9539559380e310e4b4524ed01b965aaf402e73ee
[occt.git] / src / ChFi3d / ChFi3d_FilBuilder.cxx
1 // Created on: 1995-04-25
2 // Created by: Modelistation
3 // Copyright (c) 1995-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 // Modified:    MPS :  (10-04-97) portage WNT pour GetFilletShape
18
19 #include <Adaptor3d_TopolTool.hxx>
20 #include <Blend_Point.hxx>
21 #include <BRepAdaptor_HCurve2d.hxx>
22 #include <BRepAdaptor_HSurface.hxx>
23 #include <BRepBlend_ConstRad.hxx>
24 #include <BRepBlend_ConstRadInv.hxx>
25 #include <BRepBlend_CurvPointRadInv.hxx>
26 #include <BRepBlend_EvolRad.hxx>
27 #include <BRepBlend_EvolRadInv.hxx>
28 #include <BRepBlend_Line.hxx>
29 #include <BRepBlend_RstRstConstRad.hxx>
30 #include <BRepBlend_RstRstEvolRad.hxx>
31 #include <BRepBlend_SurfCurvConstRadInv.hxx>
32 #include <BRepBlend_SurfCurvEvolRadInv.hxx>
33 #include <BRepBlend_SurfPointConstRadInv.hxx>
34 #include <BRepBlend_SurfPointEvolRadInv.hxx>
35 #include <BRepBlend_SurfRstConstRad.hxx>
36 #include <BRepBlend_SurfRstEvolRad.hxx>
37 #include <BRepBlend_Walking.hxx>
38 #include <ChFi3d_Builder_0.hxx>
39 #include <ChFi3d_FilBuilder.hxx>
40 #include <ChFi3d_SearchSing.hxx>
41 #include <ChFiDS_ErrorStatus.hxx>
42 #include <ChFiDS_FilSpine.hxx>
43 #include <ChFiDS_HData.hxx>
44 #include <ChFiDS_HElSpine.hxx>
45 #include <ChFiDS_ListIteratorOfListOfStripe.hxx>
46 #include <ChFiDS_ListIteratorOfRegularities.hxx>
47 #include <ChFiDS_ListOfStripe.hxx>
48 #include <ChFiDS_Regul.hxx>
49 #include <ChFiDS_SecHArray1.hxx>
50 #include <ChFiDS_Spine.hxx>
51 #include <ChFiDS_Stripe.hxx>
52 #include <ChFiDS_SurfData.hxx>
53 #include <ElSLib.hxx>
54 #include <Geom_Curve.hxx>
55 #include <GeomAdaptor_HCurve.hxx>
56 #include <gp_XY.hxx>
57 #include <Law_Composite.hxx>
58 #include <Law_Function.hxx>
59 #include <math_FunctionRoot.hxx>
60 #include <Precision.hxx>
61 #include <Standard_ConstructionError.hxx>
62 #include <Standard_Failure.hxx>
63 #include <TColStd_SequenceOfReal.hxx>
64 #include <TopoDS_Edge.hxx>
65 #include <TopoDS_Shape.hxx>
66 #include <TopoDS_Vertex.hxx>
67 #include <TopOpeBRepBuild_HBuilder.hxx>
68 #include <TopOpeBRepDS_Curve.hxx>
69 #include <TopOpeBRepDS_HDataStructure.hxx>
70 #include <TopOpeBRepDS_Surface.hxx>
71 #include <TopTools_ListIteratorOfListOfShape.hxx>
72
73 #ifdef OCCT_DEBUG
74 #include <OSD_Chronometer.hxx>
75 extern Standard_Boolean ChFi3d_GettraceCHRON();
76 extern Standard_Real  t_computedata ,t_completedata; 
77                     
78 extern void ChFi3d_InitChron(OSD_Chronometer& ch);
79 extern void ChFi3d_ResultChron(OSD_Chronometer & ch,Standard_Real& time);
80 #endif
81
82 static Standard_Real MaxRad(const Handle(ChFiDS_FilSpine)& fsp,
83         
84                             const TopoDS_Edge& E) 
85 {
86   Standard_Integer IE = fsp->Index(E);
87
88   // 1: case of constant R
89   if (fsp->IsConstant(IE))
90     return (fsp->Radius(IE));
91   else // 2,3: case of sequence ParAndRad and(or) Laws
92     return (fsp->MaxRadFromSeqAndLaws());
93
94 /*
95  Handle(ChFiDS_HElSpine) HGuide = fsp->ElSpine(IE);
96  Standard_Real la = HGuide->LastParameter(), fi = HGuide->FirstParameter();
97  Standard_Real longueur = la - fi,  temp, w;
98 //#ifndef OCCT_DEBUG
99  Standard_Real radiussect = 0.;
100 //#else
101 // Standard_Real radiussect;
102 //#endif
103  Handle(Law_Composite) lc = fsp->Law(HGuide);
104  for(Standard_Integer i = 0; i <= 5; i++){ 
105    w = fi + i*longueur*0.2;
106    temp = lc->Value(w);
107    if(temp>radiussect) radiussect = temp;
108  }
109  return  radiussect;
110 */
111 }
112
113 static void SimulParams(const Handle(ChFiDS_HElSpine)& HGuide,
114                         const Handle(ChFiDS_FilSpine)& fsp,
115                         Standard_Real&                 MaxStep,
116                         Standard_Real&                 Fleche)
117 {
118   Standard_Real la = HGuide->LastParameter(), fi = HGuide->FirstParameter();
119   Standard_Real longueur = la - fi;
120   MaxStep = longueur * 0.05;
121   Standard_Real w;
122   //gp_Pnt Pbid;
123   //gp_Vec d1,d2;
124   Standard_Real radiussect;
125   if(fsp->IsConstant()) radiussect = fsp->Radius();
126   else {
127     radiussect = 0.;
128     Handle(Law_Composite) lc = fsp->Law(HGuide);
129     for(Standard_Integer i = 0; i <= 5; i++){ 
130       w = fi + i*longueur*0.2;
131       Standard_Real temp = lc->Value(w);
132       if(temp>radiussect) radiussect = temp;
133     }
134   }
135   Fleche = radiussect * 0.05;
136 }
137
138 //=======================================================================
139 //function : ChFi3d_FilBuilder
140 //purpose  : 
141 //=======================================================================
142
143 ChFi3d_FilBuilder::ChFi3d_FilBuilder(const TopoDS_Shape& S,
144                                      const ChFi3d_FilletShape FShape,
145                                      const Standard_Real Ta):
146                                      ChFi3d_Builder(S, Ta)
147 {
148   SetFilletShape(FShape);
149 }
150
151 //=======================================================================
152 //function : SetFilletShape
153 //purpose  : 
154 //=======================================================================
155
156 void ChFi3d_FilBuilder::SetFilletShape(const ChFi3d_FilletShape FShape)
157 {
158   switch (FShape) {
159   case ChFi3d_Rational:
160     myShape = BlendFunc_Rational;
161     break;
162   case ChFi3d_QuasiAngular:
163     myShape = BlendFunc_QuasiAngular;
164     break;
165   case ChFi3d_Polynomial:
166     myShape = BlendFunc_Polynomial;
167     break;
168   }
169 }
170
171 //=======================================================================
172 //function : GetFilletShape
173 //purpose  : 
174 //=======================================================================
175
176 ChFi3d_FilletShape ChFi3d_FilBuilder::GetFilletShape() const
177 {
178   ChFi3d_FilletShape filshape = ChFi3d_Rational; //  need to set default value
179   switch (myShape) {
180   case BlendFunc_Rational:
181     filshape= ChFi3d_Rational;
182     break;
183   case BlendFunc_QuasiAngular:
184     filshape= ChFi3d_QuasiAngular;
185     break;
186   case BlendFunc_Polynomial:
187     filshape= ChFi3d_Polynomial;
188     break;
189   default:
190     break;
191   }
192   return filshape;
193 }
194
195 //=======================================================================
196 //function : Add
197 //purpose  : 
198 //=======================================================================
199
200 void  ChFi3d_FilBuilder::Add(const TopoDS_Edge& E)
201 {
202   if(!Contains(E) && myEFMap.Contains(E)){
203     Handle(ChFiDS_Stripe) Stripe = new ChFiDS_Stripe();
204     Handle(ChFiDS_Spine)& Sp = Stripe->ChangeSpine();
205     Sp = new ChFiDS_FilSpine(tolesp);
206     Handle(ChFiDS_FilSpine) Spine = Handle(ChFiDS_FilSpine)::DownCast(Sp);
207
208     TopoDS_Edge E_wnt = E;
209     E_wnt.Orientation(TopAbs_FORWARD);
210     Spine->SetEdges(E_wnt);
211     if(PerformElement(Spine)){
212       PerformExtremity(Spine);
213       Spine->Load();
214       myListStripe.Append(Stripe);
215     }
216   }
217 }
218
219 //=======================================================================
220 //function : Add
221 //purpose  : 
222 //=======================================================================
223
224 void  ChFi3d_FilBuilder::Add(const Standard_Real Radius, const TopoDS_Edge& E)
225 {
226   Add(E);
227   Standard_Integer IC = Contains(E);
228   if (IC)
229     SetRadius( Radius, IC, E );
230 }
231
232 //=======================================================================
233 //function : SetRadius
234 //purpose  : 
235 //=======================================================================
236
237 void  ChFi3d_FilBuilder::SetRadius(const Handle(Law_Function)& C, 
238                                    const Standard_Integer IC,
239                                    const Standard_Integer IinC)
240 {
241   if(IC <= NbElements()) {
242     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
243     fsp->SetRadius(C, IinC);
244   }
245 }
246
247 //=======================================================================
248 //function : IsConstant
249 //purpose  : 
250 //=======================================================================
251
252 Standard_Boolean ChFi3d_FilBuilder::IsConstant(const Standard_Integer IC)
253 {
254   if(IC <= NbElements()) {
255     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
256     return fsp->IsConstant();
257   }
258   return 0;
259 }
260
261 //=======================================================================
262 //function : Radius
263 //purpose  : 
264 //=======================================================================
265
266 Standard_Real ChFi3d_FilBuilder::Radius(const Standard_Integer IC)
267 {
268   if(IC <= NbElements()) {
269     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
270     return fsp->Radius();
271   }
272   return -1.;
273 }
274
275 //=======================================================================
276 //function : ResetContour
277 //purpose  : 
278 //=======================================================================
279
280 void  ChFi3d_FilBuilder::ResetContour(const Standard_Integer IC)
281 {
282   if(IC <= NbElements()) {
283     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
284     fsp->Reset(Standard_True);
285   }
286 }
287
288 //=======================================================================
289 //function : SetRadius
290 //purpose  : 
291 //=======================================================================
292
293 void  ChFi3d_FilBuilder::SetRadius(const Standard_Real    Radius, 
294                                    const Standard_Integer IC,
295                                    const TopoDS_Edge&     E)
296 {
297   if(IC <= NbElements()) {
298     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
299     fsp->SetRadius(Radius, E);
300   }
301 }
302
303 //=======================================================================
304 //function : UnSet
305 //purpose  : 
306 //=======================================================================
307
308 void  ChFi3d_FilBuilder::UnSet(const Standard_Integer IC,
309                                const TopoDS_Edge&     E)
310 {
311   if(IC <= NbElements()) {
312     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
313     fsp->UnSetRadius(E);
314   }
315 }
316
317 //=======================================================================
318 //function : SetRadius
319 //purpose  : 
320 //=======================================================================
321
322 void  ChFi3d_FilBuilder::SetRadius(const Standard_Real    Radius, 
323                                    const Standard_Integer IC,
324                                    const TopoDS_Vertex&   V)
325 {
326   if(IC <= NbElements()) {
327     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
328     fsp->SetRadius(Radius, V);
329   }
330 }
331
332 //=======================================================================
333 //function : UnSet
334 //purpose  : 
335 //=======================================================================
336
337 void  ChFi3d_FilBuilder::UnSet(const Standard_Integer IC,
338                                const TopoDS_Vertex&   V)
339 {
340   if(IC <= NbElements()) {
341     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
342     fsp->UnSetRadius(V);
343   }
344 }
345
346 //=======================================================================
347 //function : SetRadius
348 //purpose  : 
349 //=======================================================================
350
351 void  ChFi3d_FilBuilder::SetRadius(const gp_XY&           UandR, 
352                                    const Standard_Integer IC,
353                                    const Standard_Integer IinC)
354 {
355   if(IC <= NbElements()) {
356     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
357     fsp->SetRadius( UandR, IinC );
358   }
359 }
360
361 //=======================================================================
362 //function : IsConstant
363 //purpose  : 
364 //=======================================================================
365
366 Standard_Boolean ChFi3d_FilBuilder::IsConstant(const Standard_Integer IC,
367                                                const TopoDS_Edge&     E)
368 {
369   if(IC <= NbElements()) {
370     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
371     return fsp->IsConstant(fsp->Index(E));
372   }
373   return 0;
374 }
375
376 //=======================================================================
377 //function : Radius
378 //purpose  : 
379 //=======================================================================
380
381 Standard_Real ChFi3d_FilBuilder::Radius(const Standard_Integer IC,
382                                         const TopoDS_Edge&     E)
383 {
384   if(IC <= NbElements()) {
385     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
386     return fsp->Radius(E);
387   }
388   return -1.;
389 }
390
391 //=======================================================================
392 //function : GetBounds
393 //purpose  : 
394 //=======================================================================
395
396 Standard_Boolean ChFi3d_FilBuilder::GetBounds(const Standard_Integer IC,
397                                               const TopoDS_Edge&     E,
398                                               Standard_Real&         F,
399                                               Standard_Real&         L)
400 {
401   if(IC <= NbElements()) {
402     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
403     Handle(Law_Function)& loi = fsp->ChangeLaw(E);
404     if(!loi.IsNull()){
405       loi->Bounds(F,L);
406       return Standard_True;
407     }
408   }
409   return Standard_False;
410 }
411
412 //=======================================================================
413 //function : GetLaw
414 //purpose  : 
415 //=======================================================================
416
417 Handle(Law_Function) ChFi3d_FilBuilder::GetLaw(const Standard_Integer IC,
418                                                const TopoDS_Edge&     E)
419 {
420   if(IC <= NbElements()) {
421     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
422     return fsp->ChangeLaw(E);
423   }
424   return Handle(Law_Function)();
425 }
426
427 //=======================================================================
428 //function : SetLaw
429 //purpose  : 
430 //=======================================================================
431
432 void ChFi3d_FilBuilder::SetLaw(const Standard_Integer      IC,
433                                const TopoDS_Edge&          E,
434                                const Handle(Law_Function)& L)
435 {
436   // Check if it is necessary to check borders!
437   if(IC <= NbElements()) {
438     Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Value(IC));
439     fsp->ChangeLaw(E) = L;
440   }
441 }
442
443 //=======================================================================
444 //function : Simulate
445 //purpose  : 
446 //=======================================================================
447
448 void ChFi3d_FilBuilder::Simulate (const Standard_Integer IC)
449 {
450 #ifdef OCCT_DEBUG
451   if(ChFi3d_GettraceCHRON()){
452     simul.Reset();elspine.Reset();chemine.Reset();
453     simul.Start();
454   }
455 #endif
456   ChFiDS_ListIteratorOfListOfStripe itel;
457   Standard_Integer i = 1;
458   for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
459     if(i == IC){
460       PerformSetOfSurf(itel.Value(), Standard_True);
461       break;
462     }
463   }
464 #ifdef OCCT_DEBUG
465   if(ChFi3d_GettraceCHRON()){
466     simul.Stop();
467     cout<<"Total simulation time : ";
468     simul.Show();
469     cout<<"Spine construction time : ";
470     elspine.Show();
471     cout<<"and process time : ";
472     chemine.Show();
473   }
474 #endif
475 }
476
477 //=======================================================================
478 //function : NbSurf
479 //purpose  : 
480 //=======================================================================
481
482 Standard_Integer ChFi3d_FilBuilder::NbSurf (const Standard_Integer IC) const 
483 {
484   ChFiDS_ListIteratorOfListOfStripe itel;
485   Standard_Integer i = 1;
486   for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
487     if(i == IC){
488       return itel.Value()->SetOfSurfData()->Length();
489     }
490   }
491   return 0;
492 }
493
494 //=======================================================================
495 //function : Sect
496 //purpose  : 
497 //=======================================================================
498
499 Handle(ChFiDS_SecHArray1) ChFi3d_FilBuilder::Sect (const Standard_Integer IC,
500                                                    const Standard_Integer IS) const 
501 {
502   ChFiDS_ListIteratorOfListOfStripe itel;
503   Standard_Integer i = 1;
504   Handle(ChFiDS_SecHArray1) res;
505   for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
506     if(i == IC){
507       Handle(MMgt_TShared) bid = itel.Value()->SetOfSurfData()->Value(IS)->Simul();
508       res = Handle(ChFiDS_SecHArray1)::DownCast(bid);
509       return res;
510     }
511   }
512   return Handle(ChFiDS_SecHArray1)();
513 }
514
515 //=======================================================================
516 //function : SimulKPart
517 //purpose  : 
518 //=======================================================================
519
520 void  ChFi3d_FilBuilder::SimulKPart(const Handle(ChFiDS_SurfData)& SD) const 
521 {
522   TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
523   Handle(Geom_Surface) S = DStr.Surface(SD->Surf()).Surface();
524   gp_Pnt2d p1f = SD->InterferenceOnS1().PCurveOnSurf()->
525     Value(SD->InterferenceOnS1().FirstParameter());
526   gp_Pnt2d p1l = SD->InterferenceOnS1().PCurveOnSurf()->
527     Value(SD->InterferenceOnS1().LastParameter());
528   gp_Pnt2d p2f = SD->InterferenceOnS2().PCurveOnSurf()->
529     Value(SD->InterferenceOnS2().FirstParameter());
530   gp_Pnt2d p2l = SD->InterferenceOnS2().PCurveOnSurf()->
531     Value(SD->InterferenceOnS2().LastParameter());
532   GeomAdaptor_Surface AS(S);
533   Handle(ChFiDS_SecHArray1) sec;
534   Standard_Real u1,v1,u2,v2;
535   GeomAbs_SurfaceType typ = AS.GetType();
536   switch (typ){
537   case GeomAbs_Cylinder: 
538     {
539       u1 = p1f.X();
540       u2 = p2f.X();
541       v1 = Max(p1f.Y(),p2f.Y());
542       v2 = Min(p1l.Y(),p2l.Y());
543       sec = new ChFiDS_SecHArray1(1,2);
544       gp_Cylinder Cy = AS.Cylinder();
545       ChFiDS_CircSection& sec1 = sec->ChangeValue(1);
546       ChFiDS_CircSection& sec2 = sec->ChangeValue(2);
547       sec1.Set(ElSLib::CylinderVIso(Cy.Position(), Cy.Radius(), v1), u1, u2);  
548       sec2.Set(ElSLib::CylinderVIso(Cy.Position(), Cy.Radius(), v2), u1, u2);  
549     }
550     break;
551   case GeomAbs_Torus:
552     {
553       v1 = p1f.Y();
554       v2 = p2f.Y();
555       u1 = Max(p1f.X(),p2f.X());
556       u2 = Min(p1l.X(),p2l.X());
557       Standard_Real ang = (u2-u1);
558       gp_Torus To = AS.Torus();
559       Standard_Real majr = To.MajorRadius(), minr = To.MinorRadius();
560       Standard_Integer n = (Standard_Integer) (36.*ang/M_PI + 1);
561       if(n<2) n = 2;
562       sec = new ChFiDS_SecHArray1(1, n);
563       for (Standard_Integer i = 1; i <= n; i++) {
564         ChFiDS_CircSection& isec = sec->ChangeValue(i);
565         Standard_Real u = u1 + (i - 1)*(u2 - u1)/(n-1);
566         isec.Set(ElSLib::TorusUIso(To.Position(), majr, minr, u), v1, v2);  
567       }
568     }
569     break;
570   case GeomAbs_Sphere:
571     {
572       v1 = p1f.Y();
573       v2 = p2f.Y();
574       u1 = Max(p1f.X(),p2f.X());
575       u2 = Min(p1l.X(),p2l.X());
576       Standard_Real ang = (u2-u1);
577       gp_Sphere Sp = AS.Sphere();
578       Standard_Real rad = Sp.Radius();
579       Standard_Integer n = (Standard_Integer) (36.*ang/M_PI + 1);
580       if(n<2) n = 2;
581       sec = new ChFiDS_SecHArray1(1, n);
582       for (Standard_Integer i = 1; i <= n; i++) {
583         ChFiDS_CircSection& isec = sec->ChangeValue(i);
584         Standard_Real u = u1 + (i - 1)*(u2 - u1)/(n-1);
585         isec.Set(ElSLib::SphereUIso(Sp.Position(), rad, u), v1, v2);  
586       }
587     }
588     break;
589   default:
590     break;
591   }
592   SD->SetSimul(sec);
593 }
594
595
596 //=======================================================================
597 //function : SimulSurf
598 //purpose  : 
599 //=======================================================================
600
601 Standard_Boolean  
602 ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
603                              const Handle(ChFiDS_HElSpine)&      HGuide,
604                              const Handle(ChFiDS_Spine)&         Spine,
605                              const Standard_Integer              Choix,
606                              const Handle(BRepAdaptor_HSurface)& S1,
607                              const Handle(Adaptor3d_TopolTool)&    I1,
608                              const Handle(BRepAdaptor_HSurface)& S2,
609                              const Handle(Adaptor3d_TopolTool)&    I2,
610                              const Standard_Real                 TolGuide,
611                              Standard_Real&                      First,
612                              Standard_Real&                      Last,
613                              const Standard_Boolean              Inside,
614                              const Standard_Boolean              Appro,
615                              const Standard_Boolean              Forward,
616                              const Standard_Boolean              RecOnS1,
617                              const Standard_Boolean              RecOnS2,
618                              const math_Vector&                  Soldep,
619                              Standard_Boolean&                   intf,
620                              Standard_Boolean&                   intl)
621 {
622   Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
623   if(fsp.IsNull()) Standard_ConstructionError::Raise
624     ("SimulSurf : this is not the spine of the fillet");
625   Handle(BRepBlend_Line) lin;
626 #ifdef OCCT_DEBUG
627 //  TopAbs_Orientation Or = S1->ChangeSurface().Face().Orientation();
628 #endif
629   // Flexible parameters!!!
630   Standard_Real locfleche, MaxStep;
631   SimulParams(HGuide,fsp,MaxStep,locfleche);
632   Handle(ChFiDS_SecHArray1) sec;
633   gp_Pnt2d pf1,pl1,pf2,pl2;
634
635   Standard_Real PFirst = First;
636   if(intf) First = fsp->FirstParameter(1);
637   if(intl) Last = fsp->LastParameter(fsp->NbEdges());
638   if (fsp->IsConstant()) {
639     BRepBlend_ConstRad Func(S1,S2,HGuide);
640     BRepBlend_ConstRadInv FInv(S1,S2,HGuide);
641     Func.Set(fsp->Radius(),Choix);
642     FInv.Set(fsp->Radius(),Choix);
643     Func.Set(myShape);
644     done = SimulData(Data,HGuide,lin,S1,I1 ,
645                      S2,I2,Func,FInv,PFirst,MaxStep,locfleche,
646                      TolGuide,First,Last,Inside,Appro,Forward,
647                      Soldep,4,RecOnS1,RecOnS2);
648     if(!done) return Standard_False;
649     Standard_Integer nbp = lin->NbPoints();
650     sec = new ChFiDS_SecHArray1(1,nbp);
651     for(Standard_Integer i = 1; i <= nbp; i++){
652       ChFiDS_CircSection& isec = sec->ChangeValue(i);
653       Standard_Real u1,v1,u2,v2,w,p1,p2;
654       gp_Circ ci;
655       const Blend_Point& p = lin->Point(i);
656       p.ParametersOnS1(u1,v1);
657       p.ParametersOnS2(u2,v2);
658       w = p.Parameter();
659       Func.Section(w,u1,v1,u2,v2,p1,p2,ci);
660       isec.Set(ci,p1,p2);
661       if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);} 
662       if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);} 
663     }
664   }
665   else{
666     BRepBlend_EvolRad Func(S1,S2,HGuide,fsp->Law(HGuide));
667     BRepBlend_EvolRadInv FInv(S1,S2,HGuide,fsp->Law(HGuide));
668     Func.Set(Choix);
669     FInv.Set(Choix);
670     Func.Set(myShape);
671     done = SimulData(Data,HGuide,lin,S1,I1 ,
672                      S2,I2,Func,FInv,PFirst,MaxStep,locfleche,
673                      TolGuide,First,Last,Inside,Appro,Forward,
674                      Soldep,4,RecOnS1,RecOnS2);
675     if(!done) return Standard_False;
676     Standard_Integer nbp = lin->NbPoints();
677     sec = new ChFiDS_SecHArray1(1,nbp);
678     for(Standard_Integer i = 1; i <= nbp; i++){
679       ChFiDS_CircSection& isec = sec->ChangeValue(i);
680       Standard_Real u1,v1,u2,v2,w,p1,p2;
681       gp_Circ ci;
682       const Blend_Point& p = lin->Point(i);
683       p.ParametersOnS1(u1,v1);
684       p.ParametersOnS2(u2,v2);
685       w = p.Parameter();
686       Func.Section(w,u1,v1,u2,v2,p1,p2,ci);
687       isec.Set(ci,p1,p2);
688       if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);} 
689       if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);} 
690     }
691   }
692   Data->SetSimul(sec);
693   Data->Set2dPoints(pf1,pl1,pf2,pl2);
694   ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
695                         Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
696   ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
697                         Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
698   ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
699                         Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
700   ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
701                         Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
702   Standard_Boolean reverse = (!Forward || Inside);
703   if(intf && reverse){
704     Standard_Boolean ok = 0;
705     const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
706     if(cp1.IsOnArc()){
707       TopoDS_Face F1 = S1->ChangeSurface().Face();
708       TopoDS_Face bid;
709       ok = intf = !SearchFace(Spine,cp1,F1,bid);
710     }
711     const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
712     if(cp2.IsOnArc() && !ok){
713       TopoDS_Face F2 = S2->ChangeSurface().Face();
714       TopoDS_Face bid;
715       intf = !SearchFace(Spine,cp2,F2,bid);
716     }
717   }
718   if(intl){
719     Standard_Boolean ok = 0;
720     const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
721     if(cp1.IsOnArc()){
722       TopoDS_Face F1 = S1->ChangeSurface().Face();
723       TopoDS_Face bid;
724       ok = intl = !SearchFace(Spine,cp1,F1,bid);
725     }
726     const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
727     if(cp2.IsOnArc() && !ok){
728       TopoDS_Face F2 = S2->ChangeSurface().Face();
729       TopoDS_Face bid;
730       intl = !SearchFace(Spine,cp2,F2,bid);
731     }
732   }
733   return Standard_True;
734 }
735
736 //=======================================================================
737 //function : SimulSurf
738 //purpose  : 
739 //=======================================================================
740
741 void  ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
742                                    const Handle(ChFiDS_HElSpine)&      HGuide,
743                                    const Handle(ChFiDS_Spine)&         Spine,
744                                    const Standard_Integer              Choix,
745                                    const Handle(BRepAdaptor_HSurface)& HS1,
746                                    const Handle(Adaptor3d_TopolTool)&    I1,
747                                    const Handle(BRepAdaptor_HCurve2d)& PC1,
748                                    const Handle(BRepAdaptor_HSurface)& HSref1,
749                                    const Handle(BRepAdaptor_HCurve2d)& PCref1,
750                                    Standard_Boolean&                   Decroch1,
751                                    const Handle(BRepAdaptor_HSurface)& HS2,
752                                    const Handle(Adaptor3d_TopolTool)&    I2,
753                                    const TopAbs_Orientation            Or2,
754                                    const Standard_Real                 /*Fleche*/,
755                                    const Standard_Real                 TolGuide,
756                                    Standard_Real&                      First,
757                                    Standard_Real&                      Last,
758                                    const Standard_Boolean              Inside,
759                                    const Standard_Boolean              Appro,
760                                    const Standard_Boolean              Forward,
761                                    const Standard_Boolean              RecP,
762                                    const Standard_Boolean              RecS,
763                                    const Standard_Boolean              RecRst,
764                                    const math_Vector&                  Soldep)
765 {
766   Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
767   if(fsp.IsNull()) Standard_ConstructionError::Raise
768     ("PerformSurf : this is not the spine of the fillet");
769   Handle(BRepBlend_Line) lin;
770   
771   // Flexible parameters!
772   Standard_Real locfleche, MaxStep;
773   SimulParams(HGuide,fsp,MaxStep,locfleche);
774   Handle(ChFiDS_SecHArray1) sec;
775   gp_Pnt2d pf,pl,ppcf,ppcl;
776   
777   Standard_Real PFirst = First;
778   if(fsp->IsConstant()){
779     BRepBlend_SurfRstConstRad func(HS2,HS1,PC1,HGuide);
780     func.Set(HSref1,PCref1);
781     Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
782     HC->ChangeCurve().Load(PC1, HS1);
783     BRepBlend_SurfCurvConstRadInv finvc(HS2,HC,HGuide);
784     BRepBlend_SurfPointConstRadInv finvp(HS2,HGuide);
785     BRepBlend_ConstRadInv finv(HS2,HSref1,HGuide);
786     finv.Set(Standard_False,PCref1);
787     
788     Standard_Real rad = fsp->Radius();
789     Standard_Integer petitchoix = 1;
790     if(Or2 == TopAbs_REVERSED) petitchoix = 3;
791     if(Choix%2 == 0) petitchoix++;
792     finv.Set(rad,Choix);
793     finvc.Set(rad,petitchoix);
794     finvp.Set(rad,petitchoix);
795     func.Set(rad,petitchoix);
796     func.Set(myShape);
797     
798     done = SimulData(Data,HGuide,lin,HS2,I2,HS1,PC1,I1,Decroch1,
799                      func,finv,finvp,finvc,
800                      PFirst,MaxStep,locfleche,TolGuide,First,Last,
801                      Soldep,4,Inside,Appro,Forward,RecP,RecS,RecRst);
802     if(!done) {
803       Standard_Failure::Raise("SimulSurf : Failed process!");
804     }
805     Standard_Integer nbp = lin->NbPoints();
806     sec = new ChFiDS_SecHArray1(1,nbp);
807     for(Standard_Integer i = 1; i <= nbp; i++){
808       ChFiDS_CircSection& isec = sec->ChangeValue(i);
809       Standard_Real u,v,w,param,p1,p2;
810       gp_Circ ci;
811       const Blend_Point& p = lin->Point(i);
812       p.ParametersOnS(u,v);
813       w = p.ParameterOnC();
814       param = p.Parameter();
815       func.Section(param,u,v,w,p1,p2,ci);
816       isec.Set(ci,p1,p2);
817       if(i == 1) {pf.SetCoord(u,v);p.ParametersOnS2(u,v);ppcf.SetCoord(u,v);} 
818       if(i == nbp) {pl.SetCoord(u,v);p.ParametersOnS2(u,v);ppcl.SetCoord(u,v);} 
819     }
820   }
821   else {
822     BRepBlend_SurfRstEvolRad func(HS2,HS1,PC1,HGuide,fsp->Law(HGuide));
823     Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
824     HC->ChangeCurve().Load(PC1, HS1);
825     BRepBlend_SurfCurvEvolRadInv finvc(HS2,HC,HGuide,fsp->Law(HGuide));
826     BRepBlend_SurfPointEvolRadInv finvp(HS2,HGuide,fsp->Law(HGuide));
827     BRepBlend_EvolRadInv finv(HS2,HSref1,HGuide,fsp->Law(HGuide));
828     finv.Set(Standard_False,PCref1);
829     Standard_Integer petitchoix = 1;
830     if(Or2 == TopAbs_REVERSED) petitchoix = 3;
831     if(Choix%2 == 0) petitchoix++;
832     finv.Set(Choix);
833     finvc.Set(petitchoix);
834     finvp.Set(petitchoix);
835     func.Set(petitchoix);
836     func.Set(myShape);
837     done = SimulData(Data,HGuide,lin,HS2,I2,HS1,PC1,I1,Decroch1,
838                      func,finv,finvp,finvc,
839                      PFirst,MaxStep,locfleche,TolGuide,First,Last,
840                      Soldep,4,Inside,Appro,Forward,RecP,RecS,RecRst);
841     if(!done) Standard_Failure::Raise("SimulSurf : Fail !");
842     Standard_Integer nbp = lin->NbPoints();
843     sec = new ChFiDS_SecHArray1(1,nbp);
844     for(Standard_Integer i = 1; i <= nbp; i++){
845       ChFiDS_CircSection& isec = sec->ChangeValue(i);
846       Standard_Real u,v,w,param,p1,p2;
847       gp_Circ ci;
848       const Blend_Point& p = lin->Point(i);
849       p.ParametersOnS(u,v);
850       w = p.ParameterOnC();
851       param = p.Parameter();
852       func.Section(param,u,v,w,p1,p2,ci);
853       isec.Set(ci,p1,p2);
854       if(i == 1) {pf.SetCoord(u,v);p.ParametersOnS2(u,v);ppcf.SetCoord(u,v);} 
855       if(i == nbp) {pl.SetCoord(u,v);p.ParametersOnS2(u,v);ppcl.SetCoord(u,v);} 
856     }
857   }
858   Data->SetSimul(sec);
859 //  gp_Pnt2d pbid;
860   Data->Set2dPoints(ppcf,ppcl,pf,pl);
861   ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
862                         Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
863   ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
864                         Standard_False,Data->ChangeVertexLastOnS2(),tolesp);
865   ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
866                         Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
867   ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
868                         Standard_False, Data->ChangeVertexLastOnS1(),tolesp);
869 }
870
871 //=======================================================================
872 //function : SimulSurf
873 //purpose  : 
874 //=======================================================================
875
876 void  ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
877                                    const Handle(ChFiDS_HElSpine)&      HGuide,
878                                    const Handle(ChFiDS_Spine)&         Spine,
879                                    const Standard_Integer              Choix,
880                                    const Handle(BRepAdaptor_HSurface)& HS1,
881                                    const Handle(Adaptor3d_TopolTool)&    I1,
882                                    const TopAbs_Orientation            Or1,
883                                    const Handle(BRepAdaptor_HSurface)& HS2,
884                                    const Handle(Adaptor3d_TopolTool)&    I2,
885                                    const Handle(BRepAdaptor_HCurve2d)& PC2,
886                                    const Handle(BRepAdaptor_HSurface)& HSref2,
887                                    const Handle(BRepAdaptor_HCurve2d)& PCref2,
888                                    Standard_Boolean&                   Decroch2,
889                                    const Standard_Real                 /*Arrow*/,
890                                    const Standard_Real                 TolGuide,
891                                    Standard_Real&                      First,
892                                    Standard_Real&                      Last,
893                                    const Standard_Boolean              Inside,
894                                    const Standard_Boolean              Appro,
895                                    const Standard_Boolean              Forward,
896                                    const Standard_Boolean              RecP,
897                                    const Standard_Boolean              RecS,
898                                    const Standard_Boolean              RecRst,
899                                    const math_Vector&                  Soldep)
900 {
901   Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
902   if(fsp.IsNull()) Standard_ConstructionError::Raise
903     ("PerformSurf : it is not the spine of a fillet");
904   Handle(BRepBlend_Line) lin;
905   
906   // Flexible parameters!
907   Standard_Real locfleche, MaxStep;
908   SimulParams(HGuide,fsp,MaxStep,locfleche);
909   Handle(ChFiDS_SecHArray1) sec;
910   gp_Pnt2d pf,pl,ppcf,ppcl;
911   
912   Standard_Real PFirst = First;
913   if(fsp->IsConstant()){
914     BRepBlend_SurfRstConstRad func(HS1,HS2,PC2,HGuide);
915     func.Set(HSref2,PCref2);
916     Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
917     HC->ChangeCurve().Load(PC2, HS2);
918     BRepBlend_SurfCurvConstRadInv finvc(HS1,HC,HGuide);
919     BRepBlend_SurfPointConstRadInv finvp(HS1,HGuide);
920     BRepBlend_ConstRadInv finv(HS1,HSref2,HGuide);
921     finv.Set(Standard_False,PCref2);
922     
923     Standard_Real rad = fsp->Radius();
924     Standard_Integer petitchoix = 1;
925     if(Or1 == TopAbs_REVERSED) petitchoix = 3;
926     if(Choix%2 == 0) petitchoix++;
927     finv.Set(rad,Choix);
928     finvc.Set(rad,petitchoix);
929     finvp.Set(rad,petitchoix);
930     func.Set(rad,petitchoix);
931     func.Set(myShape);
932     
933     done = SimulData(Data,HGuide,lin,HS1,I1,HS2,PC2,I2,Decroch2,
934                      func,finv,finvp,finvc,
935                      PFirst,MaxStep,locfleche,TolGuide,First,Last,
936                      Soldep,4,Inside,Appro,Forward,RecP,RecS,RecRst);
937     if(!done) Standard_Failure::Raise("SimulSurf : Failed Processing!");
938     Standard_Integer nbp = lin->NbPoints();
939     sec = new ChFiDS_SecHArray1(1,nbp);
940     for(Standard_Integer i = 1; i <= nbp; i++){
941       ChFiDS_CircSection& isec = sec->ChangeValue(i);
942       Standard_Real u,v,w,param,p1,p2;
943       gp_Circ ci;
944       const Blend_Point& p = lin->Point(i);
945       p.ParametersOnS(u,v);
946       w = p.ParameterOnC();
947       param = p.Parameter();
948       func.Section(param,u,v,w,p1,p2,ci);
949       isec.Set(ci,p1,p2);
950       if(i == 1) {pf.SetCoord(u,v);p.ParametersOnS2(u,v);ppcf.SetCoord(u,v);} 
951       if(i == nbp) {pl.SetCoord(u,v);p.ParametersOnS2(u,v);ppcl.SetCoord(u,v);} 
952     }
953   }
954   else {
955     BRepBlend_SurfRstEvolRad func(HS1,HS2,PC2,HGuide,fsp->Law(HGuide));
956     Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
957     HC->ChangeCurve().Load(PC2, HS2);
958     BRepBlend_SurfCurvEvolRadInv finvc(HS1,HC,HGuide,fsp->Law(HGuide));
959     BRepBlend_SurfPointEvolRadInv finvp(HS1,HGuide,fsp->Law(HGuide));
960     BRepBlend_EvolRadInv finv(HS1,HSref2,HGuide,fsp->Law(HGuide));
961     finv.Set(Standard_False,PCref2);
962     Standard_Integer petitchoix = 1;
963     if(Or1 == TopAbs_REVERSED) petitchoix = 3;
964     if(Choix%2 == 0) petitchoix++;
965     finv.Set(Choix);
966     finvc.Set(petitchoix);
967     finvp.Set(petitchoix);
968     func.Set(petitchoix);
969     func.Set(myShape);
970     done = SimulData(Data,HGuide,lin,HS1,I1,HS2,PC2,I2,Decroch2,
971                      func,finv,finvp,finvc,
972                      PFirst,MaxStep,locfleche,TolGuide,First,Last,
973                      Soldep,4,Inside,Appro,Forward,RecP,RecS,RecRst);
974     if(!done) Standard_Failure::Raise("SimulSurf : Fail !");
975     Standard_Integer nbp = lin->NbPoints();
976     sec = new ChFiDS_SecHArray1(1,nbp);
977     for(Standard_Integer i = 1; i <= nbp; i++){
978       ChFiDS_CircSection& isec = sec->ChangeValue(i);
979       Standard_Real u,v,w,param,p1,p2;
980       gp_Circ ci;
981       const Blend_Point& p = lin->Point(i);
982       p.ParametersOnS(u,v);
983       w = p.ParameterOnC();
984       param = p.Parameter();
985       func.Section(param,u,v,w,p1,p2,ci);
986       isec.Set(ci,p1,p2);
987       if(i == 1) {pf.SetCoord(u,v);p.ParametersOnS2(u,v);ppcf.SetCoord(u,v);} 
988       if(i == nbp) {pl.SetCoord(u,v);p.ParametersOnS2(u,v);ppcl.SetCoord(u,v);} 
989     }
990   }
991   Data->SetSimul(sec);
992   //gp_Pnt2d pbid;
993   Data->Set2dPoints(pf,pl,ppcf,ppcl);
994   ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
995                         Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
996   ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
997                         Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
998   ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
999                         Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
1000   ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
1001                         Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
1002 }
1003
1004
1005
1006 //=======================================================================
1007 //function : SimulSurf
1008 //purpose  : 
1009 //=======================================================================
1010
1011 void  ChFi3d_FilBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
1012                                    const Handle(ChFiDS_HElSpine)&      HGuide,
1013                                    const Handle(ChFiDS_Spine)&         Spine,
1014                                    const Standard_Integer              Choix,
1015                                    const Handle(BRepAdaptor_HSurface)& HS1,
1016                                    const Handle(Adaptor3d_TopolTool)&    I1,
1017                                    const Handle(BRepAdaptor_HCurve2d)& PC1,
1018                                    const Handle(BRepAdaptor_HSurface)& HSref1,
1019                                    const Handle(BRepAdaptor_HCurve2d)& PCref1,
1020                                    Standard_Boolean&                   Decroch1,
1021                                    const TopAbs_Orientation            Or1,
1022                                    const Handle(BRepAdaptor_HSurface)& HS2,
1023                                    const Handle(Adaptor3d_TopolTool)&    I2,
1024                                    const Handle(BRepAdaptor_HCurve2d)& PC2,
1025                                    const Handle(BRepAdaptor_HSurface)& HSref2,
1026                                    const Handle(BRepAdaptor_HCurve2d)& PCref2,
1027                                    Standard_Boolean&                   Decroch2,
1028                                    const TopAbs_Orientation            Or2,
1029                                    const Standard_Real                 /*Fleche*/,
1030                                    const Standard_Real                 TolGuide,
1031                                    Standard_Real&                      First,
1032                                    Standard_Real&                      Last,
1033                                    const Standard_Boolean              Inside,
1034                                    const Standard_Boolean              Appro,
1035                                    const Standard_Boolean              Forward,
1036                                    const Standard_Boolean              RecP1,
1037                                    const Standard_Boolean              RecRst1,
1038                                    const Standard_Boolean              RecP2,
1039                                    const Standard_Boolean              RecRst2,
1040                                    const math_Vector&                  Soldep)
1041 {
1042   Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1043   if(fsp.IsNull()) Standard_ConstructionError::Raise
1044     ("PerformSurf : it is not the spine of a fillet");
1045   Handle(BRepBlend_Line) lin;
1046   
1047   // Flexible parameters!
1048   Standard_Real locfleche, MaxStep;
1049   SimulParams(HGuide,fsp,MaxStep,locfleche);
1050   Handle(ChFiDS_SecHArray1) sec;
1051 //  gp_Pnt2d pf,pl;
1052
1053   Standard_Integer ch1 = 1, ch2 = 2;      
1054   Standard_Real PFirst = First;
1055
1056   if(fsp->IsConstant()){
1057     BRepBlend_RstRstConstRad func(HS1, PC1, HS2, PC2, HGuide);
1058     func.Set(HSref1, PCref1, HSref2, PCref2);
1059     Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
1060     HC1->ChangeCurve().Load(PC1, HS1);
1061     Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
1062     HC2->ChangeCurve().Load(PC2, HS2);
1063     BRepBlend_SurfCurvConstRadInv finv1(HSref1, HC2, HGuide);
1064     BRepBlend_CurvPointRadInv     finvp1(HGuide, HC2);
1065     BRepBlend_SurfCurvConstRadInv finv2(HSref2, HC1, HGuide);
1066     BRepBlend_CurvPointRadInv     finvp2(HGuide, HC1);
1067
1068     finv1.Set(PCref1);
1069     finv2.Set(PCref2);
1070
1071
1072     Standard_Real rad = fsp->Radius();
1073     if(Or1 == TopAbs_REVERSED) ch1 = 3;
1074     if(Or2 == TopAbs_REVERSED) ch2 = 3;
1075
1076     finv1.Set(rad, ch1);
1077     finvp1.Set(Choix);
1078     finv2.Set(rad, ch2);
1079     finvp2.Set(Choix);
1080     func.Set(rad, Choix);
1081     func.Set(myShape);
1082     
1083     done = SimulData(Data, HGuide, lin, HS1, PC1, I1, Decroch1, HS2, PC2, I2, Decroch2,
1084                      func, finv1, finvp1, finv2, finvp2,
1085                      PFirst, MaxStep, locfleche, TolGuide, First, Last,
1086                      Soldep, 4, Inside, Appro, Forward, RecP1, RecRst1, RecP2, RecRst2);
1087     if(!done) Standard_Failure::Raise("SimulSurf : Failed processing!");
1088     Standard_Integer nbp = lin->NbPoints();
1089     sec = new ChFiDS_SecHArray1(1,nbp);
1090     for(Standard_Integer i = 1; i <= nbp; i++){
1091       ChFiDS_CircSection& isec = sec->ChangeValue(i);
1092       Standard_Real u, v, param, p1, p2;
1093       gp_Circ ci;
1094       const Blend_Point& p = lin->Point(i);
1095       u = p.ParameterOnC1();
1096       v = p.ParameterOnC2();
1097       param = p.Parameter();
1098       func.Section(param, u, v, p1, p2, ci);
1099       isec.Set(ci, p1, p2);
1100 //      if(i == 1) {pf.SetCoord(u,v);} 
1101 //      if(i == nbp) {pl.SetCoord(u,v);} 
1102     }
1103   }
1104   else {
1105     BRepBlend_RstRstEvolRad func(HS1,PC1, HS2, PC2, HGuide, fsp->Law(HGuide));
1106     func.Set(HSref1, PCref1, HSref2, PCref2);
1107     Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
1108     HC1->ChangeCurve().Load(PC1, HS1);
1109     Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
1110     HC2->ChangeCurve().Load(PC2, HS2);
1111
1112     BRepBlend_SurfCurvEvolRadInv  finv1(HSref1, HC2, HGuide, fsp->Law(HGuide));
1113     BRepBlend_CurvPointRadInv     finvp1(HGuide, HC2);
1114     BRepBlend_SurfCurvEvolRadInv  finv2(HSref2, HC1, HGuide, fsp->Law(HGuide));
1115     BRepBlend_CurvPointRadInv     finvp2(HGuide, HC1);
1116
1117     finv1.Set(PCref1);
1118     finv2.Set(PCref2);
1119
1120     Standard_Integer ch11 = 1, ch22 = 2;    
1121
1122     if(Or1 == TopAbs_REVERSED) ch11 = 3;
1123     if(Or2 == TopAbs_REVERSED) ch22 = 3;
1124
1125
1126     finv1.Set(ch11);
1127     finvp1.Set(Choix);
1128     finv2.Set(ch22);
1129     finvp2.Set(Choix);
1130     func.Set(Choix);
1131     func.Set(myShape);
1132
1133     done = SimulData(Data, HGuide, lin, HS1, PC1, I1, Decroch1, HS2, PC2, I2, Decroch2,
1134                      func, finv1, finvp1, finv2, finvp2,
1135                      PFirst, MaxStep, locfleche, TolGuide, First, Last,
1136                      Soldep, 4, Inside, Appro, Forward, RecP1, RecRst1, RecP2, RecRst2);
1137
1138     if(!done) Standard_Failure::Raise("SimulSurf : Fail !");
1139     Standard_Integer nbp = lin->NbPoints();
1140     sec = new ChFiDS_SecHArray1(1, nbp);
1141     for(Standard_Integer i = 1; i <= nbp; i++){
1142       ChFiDS_CircSection& isec = sec->ChangeValue(i);
1143       Standard_Real u, v, param, p1, p2;
1144       gp_Circ ci;
1145       const Blend_Point& p = lin->Point(i);
1146       u = p.ParameterOnC1();
1147       v = p.ParameterOnC2();
1148       param = p.Parameter();
1149       func.Section(param, u, v, p1, p2, ci);
1150       isec.Set(ci, p1, p2);
1151 //      if(i == 1) {pf.SetCoord(u,v);} 
1152 //      if(i == nbp) {pl.SetCoord(u,v);} 
1153     }
1154   }
1155   Data->SetSimul(sec);
1156 //  gp_Pnt2d pbid;
1157 //  Data->Set2dPoints(pf,pl,pbid,pbid);
1158
1159   ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
1160                         Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
1161   ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
1162                         Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
1163   ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
1164                         Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
1165   ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
1166                         Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
1167 }
1168
1169
1170
1171
1172
1173
1174
1175 //=======================================================================
1176 //function : PerformFirstSection
1177 //purpose  : 
1178 //=======================================================================
1179
1180 Standard_Boolean ChFi3d_FilBuilder::PerformFirstSection
1181 (const Handle(ChFiDS_Spine)&         Spine,
1182  const Handle(ChFiDS_HElSpine)&      HGuide,
1183  const Standard_Integer              Choix,
1184  Handle(BRepAdaptor_HSurface)& S1,
1185  Handle(BRepAdaptor_HSurface)& S2,
1186  const Handle(Adaptor3d_TopolTool)&    I1,
1187  const Handle(Adaptor3d_TopolTool)&    I2,
1188  const Standard_Real                 Par,
1189  math_Vector&                        SolDep,
1190  TopAbs_State&                       Pos1,
1191  TopAbs_State&                       Pos2) const 
1192 {
1193   Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1194   if(fsp.IsNull()) Standard_ConstructionError::Raise
1195     ("PerformSurf : this is not the spine of a fillet");
1196   Standard_Real TolGuide = HGuide->Resolution(tolesp);
1197   if(fsp->IsConstant()){
1198     BRepBlend_ConstRad Func(S1,S2,HGuide);
1199     Func.Set(fsp->Radius(),Choix);
1200     Func.Set(myShape);
1201     BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
1202     return TheWalk.PerformFirstSection(Func,Par,SolDep,
1203                                        tolesp,TolGuide,Pos1,Pos2);
1204   }
1205   else {
1206     BRepBlend_EvolRad Func(S1,S2,HGuide,fsp->Law(HGuide));
1207     Func.Set(Choix);
1208     Func.Set(myShape);
1209     BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
1210     return TheWalk.PerformFirstSection(Func,Par,SolDep,
1211                                        tolesp,TolGuide,Pos1,Pos2);
1212   }
1213 }
1214
1215 //=======================================================================
1216 //function : PerformSurf
1217 //purpose  : 
1218 //=======================================================================
1219
1220 Standard_Boolean 
1221 ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&          SeqData,
1222                                const Handle(ChFiDS_HElSpine)&      HGuide,
1223                                const Handle(ChFiDS_Spine)&         Spine,
1224                                const Standard_Integer              Choix,
1225                                const Handle(BRepAdaptor_HSurface)& S1,
1226                                const Handle(Adaptor3d_TopolTool)&    I1,
1227                                const Handle(BRepAdaptor_HSurface)& S2,
1228                                const Handle(Adaptor3d_TopolTool)&    I2,
1229                                const Standard_Real                 MaxStep,
1230                                const Standard_Real                 Fleche,
1231                                const Standard_Real                 TolGuide,
1232                                Standard_Real&                      First,
1233                                Standard_Real&                      Last,
1234                                const Standard_Boolean              Inside,
1235                                const Standard_Boolean              Appro,
1236                                const Standard_Boolean              Forward,
1237                                const Standard_Boolean              RecOnS1,
1238                                const Standard_Boolean              RecOnS2,
1239                                const math_Vector&                  Soldep,
1240                                Standard_Boolean&                   intf,
1241                                Standard_Boolean&                   intl)
1242 {
1243 #ifdef OCCT_DEBUG
1244   OSD_Chronometer ch;
1245 #endif
1246   Handle(ChFiDS_SurfData) Data = SeqData(1);
1247   Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1248   if(fsp.IsNull()) Standard_ConstructionError::Raise
1249     ("PerformSurf : this is not the spine of a fillet");
1250   Standard_Boolean gd1,gd2,gf1,gf2, maybesingular;
1251   Handle(BRepBlend_Line) lin;
1252   TopAbs_Orientation Or = S1->ChangeSurface().Face().Orientation();
1253   Standard_Real PFirst = First;
1254   if(intf) First = fsp->FirstParameter(1);
1255   if(intl) Last = fsp->LastParameter(fsp->NbEdges());
1256   if(fsp->IsConstant()){
1257     BRepBlend_ConstRad Func(S1,S2,HGuide);
1258     BRepBlend_ConstRadInv FInv(S1,S2,HGuide);
1259     Func.Set(fsp->Radius(),Choix);
1260     FInv.Set(fsp->Radius(),Choix);
1261     Func.Set(myShape);
1262
1263 #ifdef OCCT_DEBUG
1264         ChFi3d_InitChron(ch); //init perf ComputeData
1265 #endif
1266
1267     done = ComputeData(Data,HGuide,Spine,lin,S1,I1,S2,I2,Func,FInv,
1268                        PFirst,MaxStep,Fleche,TolGuide,First,Last,
1269                        Inside,Appro,Forward,Soldep,intf,intl,
1270                        gd1,gd2,gf1,gf2,RecOnS1,RecOnS2);
1271
1272 #ifdef OCCT_DEBUG
1273         ChFi3d_ResultChron(ch , t_computedata);// result perf ComputeData
1274 #endif 
1275
1276     if(!done) return Standard_False; // recovery is possible PMN 14/05/1998
1277
1278 #ifdef OCCT_DEBUG
1279           ChFi3d_InitChron(ch);// init  perf  CompleteData
1280 #endif
1281
1282     done = CompleteData(Data,Func,lin,S1,S2,Or,gd1,gd2,gf1,gf2);
1283
1284 #ifdef OCCT_DEBUG
1285          ChFi3d_ResultChron(ch , t_completedata);// result perf CompleteData
1286 #endif 
1287
1288     if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
1289     maybesingular = (Func.GetMinimalDistance()<=100*tolapp3d);
1290   }
1291   else {
1292     BRepBlend_EvolRad Func(S1, S2, HGuide, fsp->Law(HGuide));
1293     BRepBlend_EvolRadInv FInv(S1, S2, HGuide, fsp->Law(HGuide));
1294     Func.Set(Choix);
1295     FInv.Set(Choix);
1296     Func.Set(myShape);
1297
1298 #ifdef OCCT_DEBUG
1299           ChFi3d_InitChron(ch);// init perf ComputeData
1300 #endif
1301
1302     done = ComputeData(Data,HGuide,Spine,lin,S1,I1,S2,I2,Func,FInv,
1303                        PFirst,MaxStep,Fleche,TolGuide,First,Last,
1304                        Inside,Appro,Forward,Soldep,intf,intl,
1305                        gd1,gd2,gf1,gf2,RecOnS1,RecOnS2);
1306 #ifdef OCCT_DEBUG
1307          ChFi3d_ResultChron(ch , t_computedata); //result perf ComputeData
1308 #endif 
1309
1310     if(!done) return Standard_False;
1311
1312 #ifdef OCCT_DEBUG
1313           ChFi3d_InitChron(ch);// init perf CompleteData
1314 #endif
1315
1316     done = CompleteData(Data,Func,lin,S1,S2,Or,gd1,gd2,gf1,gf2);
1317
1318 #ifdef OCCT_DEBUG
1319          ChFi3d_ResultChron(ch , t_completedata);// result perf CompleteData
1320 #endif 
1321
1322     if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
1323     maybesingular = (Func.GetMinimalDistance()<=100*tolapp3d); 
1324   }
1325   if (maybesingular) SplitSurf(SeqData, lin);
1326   return Standard_True;
1327 }
1328
1329 //=======================================================================
1330 //function : PerformSurf
1331 //purpose  : 
1332 //=======================================================================
1333
1334 void  ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&          SeqData,
1335                                      const Handle(ChFiDS_HElSpine)&      HGuide,
1336                                      const Handle(ChFiDS_Spine)&         Spine,
1337                                      const Standard_Integer              Choix,
1338                                      const Handle(BRepAdaptor_HSurface)& HS1,
1339                                      const Handle(Adaptor3d_TopolTool)&    I1,
1340                                      const Handle(BRepAdaptor_HCurve2d)& PC1,
1341                                      const Handle(BRepAdaptor_HSurface)& HSref1,
1342                                      const Handle(BRepAdaptor_HCurve2d)& PCref1,
1343                                      Standard_Boolean&                   Decroch1,
1344                                      const Handle(BRepAdaptor_HSurface)& HS2,
1345                                      const Handle(Adaptor3d_TopolTool)&    I2,
1346                                      const TopAbs_Orientation            Or2,
1347                                      const Standard_Real                 MaxStep,
1348                                      const Standard_Real                 Fleche,
1349                                      const Standard_Real                 TolGuide,
1350                                      Standard_Real&                      First,
1351                                      Standard_Real&                      Last,
1352                                      const Standard_Boolean              Inside,
1353                                      const Standard_Boolean              Appro,
1354                                      const Standard_Boolean              Forward,
1355                                      const Standard_Boolean              RecP,
1356                                      const Standard_Boolean              RecS,
1357                                      const Standard_Boolean              RecRst,
1358                                      const math_Vector&                  Soldep)
1359 {
1360   Handle(ChFiDS_SurfData)  Data = SeqData(1);
1361   Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1362   if(fsp.IsNull()) Standard_ConstructionError::Raise
1363     ("PerformSurf : this is not the spine of a fillet");
1364   Handle(BRepBlend_Line) lin;
1365   Standard_Real PFirst = First;
1366   Standard_Boolean maybesingular;
1367
1368   if(fsp->IsConstant()){
1369     BRepBlend_SurfRstConstRad func(HS2,HS1,PC1,HGuide);
1370     func.Set(HSref1,PCref1);
1371     Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
1372     HC->ChangeCurve().Load(PC1, HS1);
1373     BRepBlend_SurfCurvConstRadInv finvc(HS2,HC,HGuide);
1374     BRepBlend_SurfPointConstRadInv finvp(HS2,HGuide);
1375     BRepBlend_ConstRadInv finv(HS2,HSref1,HGuide);
1376     finv.Set(Standard_False,PCref1);
1377      
1378     Standard_Real rad = fsp->Radius();
1379     Standard_Integer petitchoix = 1;
1380     if(Or2 == TopAbs_REVERSED) petitchoix = 3;
1381     if(Choix%2 == 0) petitchoix++;
1382     finv.Set(rad,Choix);
1383     finvc.Set(rad,petitchoix);
1384     finvp.Set(rad,petitchoix);
1385     func.Set(rad,petitchoix);
1386     func.Set(myShape);
1387     
1388     done = ComputeData(Data,HGuide,lin,HS2,I2,HS1,PC1,I1,Decroch1,
1389                        func,finv,finvp,finvc,
1390                        PFirst,MaxStep,Fleche,TolGuide,First,Last,
1391                        Soldep,Inside,Appro,Forward,RecP,RecS,RecRst);
1392     if(!done) {
1393        Spine->SetErrorStatus(ChFiDS_WalkingFailure); 
1394        Standard_Failure::Raise("PerformSurf : Failed processing!");
1395     }
1396     TopAbs_Orientation Or = HS2->ChangeSurface().Face().Orientation();
1397     done = CompleteData(Data,func,lin,HS1,HS2,Or,1);
1398     if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
1399     maybesingular = (func.GetMinimalDistance()<=100*tolapp3d); 
1400   }
1401   else {
1402     BRepBlend_SurfRstEvolRad func(HS2,HS1,PC1,HGuide,fsp->Law(HGuide));
1403     func.Set(HSref1,PCref1);
1404     Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
1405     HC->ChangeCurve().Load(PC1, HS1);
1406     BRepBlend_SurfCurvEvolRadInv finvc(HS2,HC,HGuide,fsp->Law(HGuide));
1407     BRepBlend_SurfPointEvolRadInv finvp(HS2,HGuide,fsp->Law(HGuide));
1408     BRepBlend_EvolRadInv finv(HS2,HSref1,HGuide,fsp->Law(HGuide));
1409     finv.Set(Standard_False,PCref1);
1410     Standard_Integer petitchoix = 1;
1411     if(Or2 == TopAbs_REVERSED) petitchoix = 3;
1412     if(Choix%2 == 0) petitchoix++;
1413     finv.Set(Choix);
1414     finvc.Set(petitchoix);
1415     finvp.Set(petitchoix);
1416     func.Set(petitchoix);
1417     func.Set(myShape);
1418     done = ComputeData(Data,HGuide,lin,HS2,I2,HS1,PC1,I1,Decroch1,
1419                        func,finv,finvp,finvc,
1420                        PFirst,MaxStep,Fleche,TolGuide,First,Last,
1421                        Soldep,Inside,Appro,Forward,RecP,RecS,RecRst);
1422     if(!done) {
1423       Spine->SetErrorStatus(ChFiDS_WalkingFailure);
1424       Standard_Failure::Raise("PerformSurf : Failed processing!");
1425     }
1426     TopAbs_Orientation Or = HS2->ChangeSurface().Face().Orientation();
1427     done = CompleteData(Data,func,lin,HS1,HS2,Or,1);
1428     if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
1429    maybesingular = (func.GetMinimalDistance()<=100*tolapp3d); 
1430   }
1431   if (maybesingular) SplitSurf(SeqData, lin);
1432 }
1433
1434 //=======================================================================
1435 //function : PerformSurf
1436 //purpose  : 
1437 //=======================================================================
1438
1439 void  ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&          SeqData,
1440                                      const Handle(ChFiDS_HElSpine)&      HGuide,
1441                                      const Handle(ChFiDS_Spine)&         Spine,
1442                                      const Standard_Integer              Choix,
1443                                      const Handle(BRepAdaptor_HSurface)& HS1,
1444                                      const Handle(Adaptor3d_TopolTool)&    I1,
1445                                      const TopAbs_Orientation            Or1,
1446                                      const Handle(BRepAdaptor_HSurface)& HS2,
1447                                      const Handle(Adaptor3d_TopolTool)&    I2,
1448                                      const Handle(BRepAdaptor_HCurve2d)& PC2,
1449                                      const Handle(BRepAdaptor_HSurface)& HSref2,
1450                                      const Handle(BRepAdaptor_HCurve2d)& PCref2,
1451                                      Standard_Boolean&                   Decroch2,
1452                                      const Standard_Real                 MaxStep,
1453                                      const Standard_Real                 Fleche,
1454                                      const Standard_Real                 TolGuide,
1455                                      Standard_Real&                      First,
1456                                      Standard_Real&                      Last,
1457                                      const Standard_Boolean              Inside,
1458                                      const Standard_Boolean              Appro,
1459                                      const Standard_Boolean              Forward,
1460                                      const Standard_Boolean              RecP,
1461                                      const Standard_Boolean              RecS,
1462                                      const Standard_Boolean              RecRst,
1463                                      const math_Vector&                  Soldep)
1464 {
1465   Handle(ChFiDS_SurfData) Data = SeqData(1);;
1466   Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1467   if(fsp.IsNull()) Standard_ConstructionError::Raise
1468     ("PerformSurf : this is not the spine of a fillet");
1469   Handle(BRepBlend_Line) lin;
1470   Standard_Real PFirst = First;
1471   Standard_Boolean maybesingular;
1472
1473   if(fsp->IsConstant()){
1474     BRepBlend_SurfRstConstRad func(HS1,HS2,PC2,HGuide);
1475     func.Set(HSref2,PCref2);
1476     Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
1477     HC->ChangeCurve().Load(PC2, HS2);
1478     BRepBlend_SurfCurvConstRadInv finvc(HS1,HC,HGuide);
1479     BRepBlend_SurfPointConstRadInv finvp(HS1,HGuide);
1480     BRepBlend_ConstRadInv finv(HS1,HSref2,HGuide);
1481     finv.Set(Standard_False,PCref2);
1482     
1483     Standard_Real rad = fsp->Radius();
1484     Standard_Integer petitchoix = 1;
1485     if(Or1 == TopAbs_REVERSED) petitchoix = 3;
1486     if(Choix%2 == 0) petitchoix++;
1487     finv.Set(rad,Choix);
1488     finvc.Set(rad,petitchoix);
1489     finvp.Set(rad,petitchoix);
1490     func.Set(rad,petitchoix);
1491     func.Set(myShape);
1492     
1493     done = ComputeData(Data,HGuide,lin,HS1,I1,HS2,PC2,I2,Decroch2,
1494                        func,finv,finvp,finvc,
1495                        PFirst,MaxStep,Fleche,TolGuide,First,Last,
1496                        Soldep,Inside,Appro,Forward,RecP,RecS,RecRst);
1497     if(!done) {
1498       Spine->SetErrorStatus(ChFiDS_WalkingFailure);
1499       Standard_Failure::Raise("PerformSurf : Failed processing!");
1500     }
1501     TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
1502     done = CompleteData(Data,func,lin,HS1,HS2,Or,0);
1503     if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
1504     maybesingular = (func.GetMinimalDistance()<=100*tolapp3d); 
1505   }
1506   else {
1507     BRepBlend_SurfRstEvolRad func(HS1,HS2,PC2,HGuide,fsp->Law(HGuide));
1508     func.Set(HSref2,PCref2);
1509     Handle(Adaptor3d_HCurveOnSurface) HC = new Adaptor3d_HCurveOnSurface();
1510     HC->ChangeCurve().Load(PC2, HS2);
1511     BRepBlend_SurfCurvEvolRadInv finvc(HS1,HC,HGuide,fsp->Law(HGuide));
1512     BRepBlend_SurfPointEvolRadInv finvp(HS1,HGuide,fsp->Law(HGuide));
1513     BRepBlend_EvolRadInv finv(HS1,HSref2,HGuide,fsp->Law(HGuide));
1514     finv.Set(Standard_False,PCref2);
1515     Standard_Integer petitchoix = 1;
1516     if(Or1 == TopAbs_REVERSED) petitchoix = 3;
1517     if(Choix%2 == 0) petitchoix++;
1518     finv.Set(Choix);
1519     finvc.Set(petitchoix);
1520     finvp.Set(petitchoix);
1521     func.Set(petitchoix);
1522     func.Set(myShape);
1523
1524     done = ComputeData(Data,HGuide,lin,HS1,I1,HS2,PC2,I2,Decroch2,
1525                        func,finv,finvp,finvc,
1526                        PFirst,MaxStep,Fleche,TolGuide,First,Last,
1527                        Soldep,Inside,Appro,Forward,RecP,RecS,RecRst);
1528     if(!done) {
1529       Spine->SetErrorStatus(ChFiDS_WalkingFailure);
1530       Standard_Failure::Raise("PerformSurf : Failed processing!");
1531     }
1532     TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
1533     done = CompleteData(Data,func,lin,HS1,HS2,Or,0);
1534     if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
1535     maybesingular = (func.GetMinimalDistance()<=100*tolapp3d); 
1536   }
1537   if (maybesingular) SplitSurf(SeqData, lin); 
1538 }
1539
1540
1541
1542
1543
1544
1545 //=======================================================================
1546 //function : PerformSurf
1547 //purpose  : 
1548 //=======================================================================
1549
1550 void  ChFi3d_FilBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&          SeqData,
1551                                      const Handle(ChFiDS_HElSpine)&      HGuide,
1552                                      const Handle(ChFiDS_Spine)&         Spine,
1553                                      const Standard_Integer              Choix,
1554                                      const Handle(BRepAdaptor_HSurface)& HS1,
1555                                      const Handle(Adaptor3d_TopolTool)&    I1,
1556                                      const Handle(BRepAdaptor_HCurve2d)& PC1,
1557                                      const Handle(BRepAdaptor_HSurface)& HSref1,
1558                                      const Handle(BRepAdaptor_HCurve2d)& PCref1,
1559                                      Standard_Boolean&                   Decroch1,
1560                                      const TopAbs_Orientation            Or1,
1561                                      const Handle(BRepAdaptor_HSurface)& HS2,
1562                                      const Handle(Adaptor3d_TopolTool)&    I2,
1563                                      const Handle(BRepAdaptor_HCurve2d)& PC2,
1564                                      const Handle(BRepAdaptor_HSurface)& HSref2,
1565                                      const Handle(BRepAdaptor_HCurve2d)& PCref2,
1566                                      Standard_Boolean&                   Decroch2,
1567                                      const TopAbs_Orientation            Or2,
1568                                      const Standard_Real                 MaxStep,
1569                                      const Standard_Real                 Fleche,
1570                                      const Standard_Real                 TolGuide,
1571                                      Standard_Real&                      First,
1572                                      Standard_Real&                      Last,
1573                                      const Standard_Boolean              Inside,
1574                                      const Standard_Boolean              Appro,
1575                                      const Standard_Boolean              Forward,
1576                                      const Standard_Boolean              RecP1,
1577                                      const Standard_Boolean              RecRst1,
1578                                      const Standard_Boolean              RecP2,
1579                                      const Standard_Boolean              RecRst2,
1580                                      const math_Vector&                  Soldep)
1581 {
1582   Handle(ChFiDS_SurfData) Data = SeqData(1);;
1583   Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1584   if(fsp.IsNull()) Standard_ConstructionError::Raise
1585     ("PerformSurf : this is not the spine of a fillet");
1586   Handle(BRepBlend_Line) lin;
1587   Standard_Real PFirst = First;
1588   Standard_Boolean maybesingular;
1589
1590   if(fsp->IsConstant()){
1591     BRepBlend_RstRstConstRad func(HS1, PC1, HS2, PC2, HGuide);
1592     func.Set(HSref1, PCref1, HSref2, PCref2);
1593     Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
1594     HC1->ChangeCurve().Load(PC1, HS1);
1595     Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
1596     HC2->ChangeCurve().Load(PC2, HS2);
1597     BRepBlend_SurfCurvConstRadInv finv1(HSref1, HC2, HGuide);
1598     BRepBlend_CurvPointRadInv     finvp1(HGuide, HC2);
1599     BRepBlend_SurfCurvConstRadInv finv2(HSref2, HC1, HGuide);
1600     BRepBlend_CurvPointRadInv     finvp2(HGuide, HC1);
1601
1602     finv1.Set(PCref1);
1603     finv2.Set(PCref2);
1604
1605     Standard_Integer ch1 = 1, ch2 = 2;    
1606     Standard_Real rad = fsp->Radius();
1607     if(Or1 == TopAbs_REVERSED) ch1 = 3;
1608     if(Or2 == TopAbs_REVERSED) ch2 = 3;
1609
1610     finv1.Set(rad, ch1);
1611     finvp1.Set(Choix);
1612     finv2.Set(rad, ch2);
1613     finvp2.Set(Choix);
1614     func.Set(rad, Choix);
1615     func.Set(myShape);
1616     
1617     done = ComputeData(Data, HGuide, lin, HS1, PC1, I1, Decroch1, HS2, PC2, I2, Decroch2,
1618                        func, finv1, finvp1, finv2, finvp2,
1619                        PFirst, MaxStep, Fleche, TolGuide, First, Last,
1620                        Soldep, Inside, Appro, Forward, RecP1, RecRst1, RecP2, RecRst2);
1621     if(!done) {
1622        Spine->SetErrorStatus(ChFiDS_WalkingFailure);
1623        Standard_Failure::Raise("PerformSurf : Failed processing!");
1624     }
1625     TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
1626     done = CompleteData(Data, func, lin, HS1, HS2, Or);
1627     if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
1628     maybesingular = (func.GetMinimalDistance()<=100*tolapp3d); 
1629   }
1630   else {
1631     BRepBlend_RstRstEvolRad func(HS1,PC1, HS2, PC2, HGuide, fsp->Law(HGuide));
1632     func.Set(HSref1, PCref1, HSref2, PCref2);
1633     Handle(Adaptor3d_HCurveOnSurface) HC1 = new Adaptor3d_HCurveOnSurface();
1634     HC1->ChangeCurve().Load(PC1, HS1);
1635     Handle(Adaptor3d_HCurveOnSurface) HC2 = new Adaptor3d_HCurveOnSurface();
1636     HC2->ChangeCurve().Load(PC2, HS2);
1637
1638     BRepBlend_SurfCurvEvolRadInv finv1(HSref1, HC2, HGuide, fsp->Law(HGuide));
1639     BRepBlend_CurvPointRadInv     finvp1(HGuide, HC2);
1640     BRepBlend_SurfCurvEvolRadInv  finv2(HSref2, HC1, HGuide, fsp->Law(HGuide));
1641     BRepBlend_CurvPointRadInv     finvp2(HGuide, HC1);
1642
1643     finv1.Set(PCref1);
1644     finv2.Set(PCref2);
1645
1646     Standard_Integer ch1 = 1, ch2 = 2;    
1647
1648     if(Or1 == TopAbs_REVERSED) ch1 = 3;
1649     if(Or2 == TopAbs_REVERSED) ch2 = 3;
1650
1651
1652     finv1.Set(ch1);
1653     finvp1.Set(Choix);
1654     finv2.Set(ch2);
1655     finvp2.Set(Choix);
1656     func.Set(Choix);
1657     func.Set(myShape);
1658     
1659     done = ComputeData(Data, HGuide, lin, HS1, PC1,  I1, Decroch1, HS2, PC2,I2, Decroch2,
1660                        func, finv1, finvp1, finv2, finvp2,
1661                        PFirst, MaxStep, Fleche, TolGuide, First, Last,
1662                        Soldep, Inside, Appro, Forward, RecP1, RecRst1, RecP2, RecRst2);
1663
1664     if(!done) {
1665       Spine->SetErrorStatus(ChFiDS_WalkingFailure);
1666       Standard_Failure::Raise("PerformSurf : Failed processing!");
1667     }
1668     TopAbs_Orientation Or = HS1->ChangeSurface().Face().Orientation();
1669     done = CompleteData(Data, func, lin, HS1, HS2, Or);
1670     if(!done) Standard_Failure::Raise("PerformSurf : Failed approximation!");
1671     maybesingular = (func.GetMinimalDistance()<=100*tolapp3d); 
1672
1673
1674   }
1675   if (maybesingular) SplitSurf(SeqData, lin); 
1676 }
1677
1678
1679
1680
1681 //=======================================================================
1682 //function : SplitSurf
1683 //purpose  : 
1684 //=======================================================================
1685
1686 void ChFi3d_FilBuilder::SplitSurf(ChFiDS_SequenceOfSurfData&    SeqData,
1687                                   const Handle(BRepBlend_Line)& Line)
1688 {
1689   Standard_Integer ii, Nbpnt=Line->NbPoints();
1690   if (Nbpnt <3) return;
1691   Standard_Real UFirst,ULast,VFirst,VLast;
1692   TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
1693   Standard_Integer ISurf;
1694   Handle(ChFiDS_SurfData) ref =  SeqData(1);
1695   Blend_Point P; 
1696
1697   ISurf= ref->Surf(); 
1698   Handle(Geom_Surface) Surf = DStr.Surface(ISurf).Surface();
1699   Surf->Bounds(UFirst,ULast,VFirst,VLast);
1700   Handle(Geom_Curve) Courbe1 = Surf->UIso(UFirst);
1701   Handle(Geom_Curve) Courbe2 = Surf->UIso(ULast);
1702   ChFi3d_SearchSing Fonc(Courbe1, Courbe2);
1703
1704   TColStd_SequenceOfReal LesVi;
1705   Standard_Real precedant, suivant, courant;
1706   Standard_Real a, b, c;
1707   
1708   // (1) Finds vi so that iso v=vi is punctual
1709   VFirst = Min( ref->InterferenceOnS1().FirstParameter(),
1710                 ref->InterferenceOnS2().FirstParameter() );
1711   VLast  = Max( ref->InterferenceOnS1().LastParameter(),
1712                 ref->InterferenceOnS2().LastParameter() );
1713
1714   // (1.1) Finds the first point inside
1715   for (ii=1; ii<=Nbpnt && Line->Point(ii).Parameter()<VFirst; ii++) {}
1716   if (ii==1) ii++;
1717   P =  Line->Point(ii);
1718   b = P.Parameter();
1719   courant = P.PointOnS1().Distance(P.PointOnS2());
1720   P = Line->Point(ii-1);
1721   a = P.Parameter();    
1722   precedant = P.PointOnS1().Distance(P.PointOnS2());
1723   ii ++;
1724
1725   // (1.2) Find a minimum by "points"
1726   for ( ; ii<=Nbpnt && Line->Point(ii).Parameter()<=VLast; ii++) {
1727     for (;ii<=Nbpnt && 
1728          Line->Point(ii).Parameter()<VLast &&
1729          Line->Point(ii).Parameter()-b<Precision::PConfusion(); ii++) {}
1730
1731     const Blend_Point& pnt =  Line->Point(ii);
1732     c = pnt.Parameter();    
1733     suivant = pnt.PointOnS1().Distance(pnt.PointOnS2());
1734     if ( (courant <  precedant) && (courant < suivant) ) {
1735       // (1.3) Find the exact minimum
1736       math_FunctionRoot Resol(Fonc, (a+c)/2,
1737                               tol2d,//Surf->VResolution(toleps), 
1738                               a, c,
1739                               50);
1740       if (Resol.IsDone()) {
1741         Standard_Real Val, racine=Resol.Root();
1742         
1743         Fonc.Value(Resol.Root(), Val);
1744         if (Val< tolapp3d) { 
1745           // the solution (avoiding the risks of confusion)
1746           if (LesVi.Length()==0) {
1747             if ( (racine > VFirst+tol2d) &&
1748                  (racine < VLast -tol2d) ) {
1749                    LesVi.Append(racine);
1750                  }
1751           }
1752           else {
1753             if ( (racine > LesVi(LesVi.Length()) + tol2d) &&
1754                  (racine < VLast-tol2d) ) {
1755                    LesVi.Append(racine);
1756                  }
1757           }
1758         }
1759       }
1760       else {
1761 # if CHFI3D_DEB
1762         cout << "Failed calculation of the minimum length" << endl;
1763 # endif
1764       }
1765     }
1766     // update if non duplication
1767     a = b;
1768     precedant = courant;
1769     b = c;
1770     courant = suivant;
1771   }
1772
1773   // (2) Update of the sequence of SurfData
1774   if (LesVi.Length()>0) {
1775     TopOpeBRepDS_DataStructure& DStru = myDS->ChangeDS();
1776     Handle(ChFiDS_SurfData) SD;
1777     TopOpeBRepDS_Surface S;
1778     TopOpeBRepDS_Curve C1, C2;
1779     Standard_Real T, VertexTol;
1780     gp_Pnt P3d, P1, P2;
1781     ChFiDS_CommonPoint LePoint;
1782     for (ii=1 ; ii<=LesVi.Length(); ii++) {
1783
1784       T = LesVi(ii);
1785       // (2.0) copy and insertion
1786       SD = new (ChFiDS_SurfData);
1787       SD->Copy(ref);
1788       SeqData.InsertBefore(ii, SD);
1789       S = DStru.Surface(ref->Surf());
1790       SD->ChangeSurf(DStru.AddSurface(S));
1791       C1 = DStru.Curve(SD->InterferenceOnS1().LineIndex());
1792       SD->ChangeInterferenceOnS1().SetLineIndex( DStru.AddCurve(C1));
1793       C2 = DStru.Curve(SD->InterferenceOnS2().LineIndex());
1794       SD->ChangeInterferenceOnS2().SetLineIndex(DStru.AddCurve(C2));
1795
1796       // (2.1) Modification of common Point
1797       SD-> ChangeVertexLastOnS1().Reset();
1798       SD-> ChangeVertexLastOnS2().Reset();
1799       ref->ChangeVertexFirstOnS1().Reset();
1800       ref->ChangeVertexFirstOnS2().Reset();
1801       Courbe1->D0(T, P1);
1802       Courbe2->D0(T, P2);
1803       P3d.SetXYZ((P1.XYZ()+ P2.XYZ())/2);
1804       VertexTol = P1.Distance(P2);
1805       VertexTol += Max(C1.Tolerance(), C2.Tolerance());
1806
1807       SD->ChangeVertexLastOnS1().SetPoint(P3d);
1808       SD->ChangeVertexLastOnS2().SetPoint(P3d);
1809       ref->ChangeVertexFirstOnS1().SetPoint(P3d);
1810       ref->ChangeVertexFirstOnS2().SetPoint(P3d);
1811       SD->ChangeVertexLastOnS1().SetTolerance(VertexTol);
1812       SD->ChangeVertexLastOnS2().SetTolerance(VertexTol);
1813       ref->ChangeVertexFirstOnS1().SetTolerance(VertexTol);
1814       ref->ChangeVertexFirstOnS2().SetTolerance(VertexTol);     
1815
1816       // (2.2) Modification of interferences
1817       SD->ChangeInterferenceOnS1().SetLastParameter(T);
1818       SD->ChangeInterferenceOnS2().SetLastParameter(T);
1819       ref->ChangeInterferenceOnS1().SetFirstParameter(T);
1820       ref->ChangeInterferenceOnS2().SetFirstParameter(T);
1821
1822       // Parameters on ElSpine
1823       SD->LastSpineParam(T);
1824       ref->FirstSpineParam(T);
1825     }
1826   }
1827 }
1828
1829 //=======================================================================
1830 //function : ExtentOneCorner
1831 //purpose  : 
1832 //=======================================================================
1833
1834 void ChFi3d_FilBuilder::ExtentOneCorner(const TopoDS_Vertex& V,
1835                                         const Handle(ChFiDS_Stripe)& S)
1836 {
1837   // review by using the data at end of fillets (point, radius, normal
1838   // to the faces and tangents of the guideline).
1839   Standard_Integer      Sens = 0;
1840   Standard_Real         Coeff = 0.5;
1841   Handle(ChFiDS_Spine)  Spine = S->Spine();
1842   ChFi3d_IndexOfSurfData(V,S,Sens);
1843   Standard_Real dU = Spine->LastParameter(Spine->NbEdges());
1844   if (Spine->IsTangencyExtremity((Sens == 1))) 
1845     return; //No extension in the queue
1846
1847   if (Spine->Status((Sens == 1)) == ChFiDS_FreeBoundary) {
1848     Coeff *= 2; // It is necessary to go to the end and to evaluate the length
1849   }
1850
1851   if (Sens == 1) {
1852     Spine->SetFirstParameter(-dU*Coeff);
1853     Spine->SetFirstTgt(0.);
1854   }
1855   else{
1856     Spine->SetLastParameter(dU*(1.+Coeff));
1857     Spine->SetLastTgt(dU);
1858   }
1859 }
1860
1861 //=======================================================================
1862 //function : ExtentTwoCorner
1863 //purpose  : 
1864 //=======================================================================
1865
1866 void ChFi3d_FilBuilder::ExtentTwoCorner(const TopoDS_Vertex& V,
1867                                         const ChFiDS_ListOfStripe& LS)
1868 {
1869   // Review by using the data at end of fillets (point, radius, normal
1870   // to faces and tangents to the guideline.
1871   Standard_Integer Sens;
1872   Standard_Real    Coeff = 0.3, Eval=0.0, dU, rad;
1873   ChFiDS_ListIteratorOfListOfStripe itel(LS);
1874   Standard_Boolean FF = Standard_True;
1875   Handle(ChFiDS_Stripe) Stripe;
1876   Handle(ChFiDS_Spine)  Spine;
1877
1878   // A value of symetric extension is calculated
1879   for ( ; itel.More(); itel.Next()) {    
1880    Stripe = itel.Value();
1881    Spine = Stripe->Spine();
1882    dU = Spine->LastParameter(Spine->NbEdges())*Coeff;
1883    Handle(ChFiDS_FilSpine) fsp = Handle(ChFiDS_FilSpine)::DownCast(Spine);
1884    if (fsp->IsConstant()) 
1885      rad =  fsp->Radius();
1886    else
1887      {
1888        TopoDS_Edge E = ChFi3d_EdgeFromV1( V, itel.Value(), Sens);
1889        rad = MaxRad( fsp, E );
1890        /*
1891        IE = ChFi3d_IndexOfSurfData(V,itel.Value(),Sens);
1892        rad = MaxRad(fsp, IE);
1893        */
1894      }
1895    rad *= 1.5;
1896    if (rad > dU) dU = rad;
1897    if (dU > Eval) Eval = dU;
1898  }
1899
1900   // One applies
1901   for (itel.Initialize(LS) ; itel.More(); itel.Next()) {    
1902     ChFi3d_IndexOfSurfData(V,itel.Value(),Sens);
1903     if (!FF && Stripe == itel.Value()) Sens = -Sens;
1904     Stripe = itel.Value();
1905     Spine = Stripe->Spine();
1906     if (! Spine->IsTangencyExtremity((Sens == 1))) { //No extension on queue
1907       if (Sens == 1){ 
1908         Spine->SetFirstParameter(-Eval);
1909         Spine->SetFirstTgt(0.);
1910       }
1911       else{
1912         dU = Spine->LastParameter(Spine->NbEdges());
1913         Spine->SetLastParameter(dU+Eval);
1914         Spine->SetLastTgt(dU);
1915       }
1916       FF = Standard_False;
1917     }
1918   }
1919 }
1920
1921
1922 //=======================================================================
1923 //function : ExtentThreeCorner
1924 //purpose  : 
1925 //=======================================================================
1926
1927 void ChFi3d_FilBuilder::ExtentThreeCorner(const TopoDS_Vertex& V,
1928                                           const ChFiDS_ListOfStripe& LS)
1929 {
1930   // Review by using the data at end of fillets (point, radius, normal
1931   // to faces and tangents to the guideline.
1932   Standard_Integer Sens = 0;
1933   Standard_Real    Coeff = 0.1;
1934   ChFiDS_ListOfStripe check;
1935 //  Standard_Boolean FF = Standard_True;
1936   for(ChFiDS_ListIteratorOfListOfStripe itel(LS); itel.More(); itel.Next()) {    
1937     Handle(ChFiDS_Stripe) Stripe = itel.Value(); 
1938     ChFi3d_IndexOfSurfData(V,Stripe,Sens);
1939     for(ChFiDS_ListIteratorOfListOfStripe ich(check); ich.More(); ich.Next()){
1940       if(Stripe == ich.Value()){
1941         Sens = -Sens;
1942         break;
1943       }
1944     }
1945     Handle(ChFiDS_Spine) Spine = Stripe->Spine();
1946     if (Spine->IsTangencyExtremity((Sens == 1))) return; //No extension on queue
1947     Standard_Real dU = Spine->LastParameter(Spine->NbEdges());
1948     if (Sens == 1){ 
1949       Spine->SetFirstParameter(-dU*Coeff);
1950       Spine->SetFirstTgt(0.);
1951     }
1952     else{
1953       Spine->SetLastParameter(dU*(1.+Coeff));
1954       Spine->SetLastTgt(dU);
1955     }
1956     check.Append(Stripe);
1957   }
1958 }
1959
1960
1961 //=======================================================================
1962 //function : SetRegul
1963 //purpose  : 
1964 //=======================================================================
1965
1966 void ChFi3d_FilBuilder::SetRegul()
1967
1968 {
1969   ChFiDS_ListIteratorOfRegularities it;
1970   TopTools_ListIteratorOfListOfShape itc;
1971   TopTools_ListIteratorOfListOfShape its1;
1972   TopTools_ListIteratorOfListOfShape its2;
1973   BRep_Builder B;
1974   for (it.Initialize(myRegul); it.More(); it.Next()){
1975     const ChFiDS_Regul& reg = it.Value();
1976     itc.Initialize(myCoup->NewEdges(reg.Curve()));
1977     if(itc.More()){
1978       TopoDS_Edge E = TopoDS::Edge(itc.Value());
1979       if(reg.IsSurface1()) its1.Initialize(myCoup->NewFaces(reg.S1()));
1980       else its1.Initialize(myCoup->Merged(myDS->Shape(reg.S1()),TopAbs_IN));
1981       if(reg.IsSurface2()) its2.Initialize(myCoup->NewFaces(reg.S2()));
1982       else its2.Initialize(myCoup->Merged(myDS->Shape(reg.S2()),TopAbs_IN));
1983       if(its1.More() && its2.More()){
1984         TopoDS_Face F1 = TopoDS::Face(its1.Value());
1985         TopoDS_Face F2 = TopoDS::Face(its2.Value());
1986         GeomAbs_Shape cont = ChFi3d_evalconti(E,F1,F2);
1987         B.Continuity(E,F1,F2,cont);
1988       }
1989     }
1990   }
1991 }