0027772: Foundation Classes - define Standard_Boolean using C++ type "bool" instead...
[occt.git] / src / ChFi3d / ChFi3d_ChBuilder.cxx
1 // Created on: 1995-04-26
2 // Created by: Flore Lantheaume
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
18 #include <Adaptor3d_TopolTool.hxx>
19 #include <Blend_Point.hxx>
20 #include <BlendFunc_SectionShape.hxx>
21 #include <BRepAdaptor_Curve2d.hxx>
22 #include <BRepAdaptor_HCurve2d.hxx>
23 #include <BRepAdaptor_HSurface.hxx>
24 #include <BRepAdaptor_Surface.hxx>
25 #include <BRepBlend_Chamfer.hxx>
26 #include <BRepBlend_ChamfInv.hxx>
27 #include <BRepBlend_ChAsym.hxx>
28 #include <BRepBlend_ChAsymInv.hxx>
29 #include <BRepBlend_Line.hxx>
30 #include <BRepBlend_Walking.hxx>
31 #include <BRepTools.hxx>
32 #include <ChFi3d.hxx>
33 #include <ChFi3d_Builder_0.hxx>
34 #include <ChFi3d_ChBuilder.hxx>
35 #include <ChFiDS_ChamfSpine.hxx>
36 #include <ChFiDS_CircSection.hxx>
37 #include <ChFiDS_HData.hxx>
38 #include <ChFiDS_HElSpine.hxx>
39 #include <ChFiDS_ListIteratorOfListOfStripe.hxx>
40 #include <ChFiDS_ListIteratorOfRegularities.hxx>
41 #include <ChFiDS_ListOfStripe.hxx>
42 #include <ChFiDS_Regul.hxx>
43 #include <ChFiDS_SecHArray1.hxx>
44 #include <ChFiDS_Spine.hxx>
45 #include <ChFiDS_Stripe.hxx>
46 #include <ChFiDS_SurfData.hxx>
47 #include <ElSLib.hxx>
48 #include <Extrema_GenLocateExtPS.hxx>
49 #include <GeomAdaptor_HCurve.hxx>
50 #include <Standard_ConstructionError.hxx>
51 #include <Standard_DomainError.hxx>
52 #include <Standard_NotImplemented.hxx>
53 #include <TopAbs.hxx>
54 #include <TopoDS_Edge.hxx>
55 #include <TopoDS_Face.hxx>
56 #include <TopoDS_Shape.hxx>
57 #include <TopoDS_Vertex.hxx>
58 #include <TopOpeBRepBuild_HBuilder.hxx>
59 #include <TopOpeBRepDS_HDataStructure.hxx>
60 #include <TopTools_ListIteratorOfListOfShape.hxx>
61
62 #ifdef OCCT_DEBUG
63 extern Standard_Boolean ChFi3d_GettraceCHRON();
64 #endif
65
66 //=======================================================================
67 //function : SearchCommonFaces
68 //purpose  : search the 2 common faces <F1> and <F2> of the edge <E>
69 //           uses the EFMap and take the 2 first good faces 
70 //=======================================================================
71
72 void SearchCommonFaces(const ChFiDS_Map& EFMap, 
73                        const TopoDS_Edge& E,
74                        TopoDS_Face& F1,
75                        TopoDS_Face& F2)
76 {
77   TopoDS_Face Fc;
78   TopTools_ListIteratorOfListOfShape It;
79   
80   F1.Nullify();
81   F2.Nullify();
82   for ( It.Initialize(EFMap(E)); It.More(); It.Next() ) {
83     Fc = TopoDS::Face(It.Value());
84     if ( F1.IsNull() )
85       F1 = Fc;
86     else if ( !Fc.IsSame(F1) ) {
87       F2 = Fc;
88       break;
89     }
90   }
91
92   if (!F1.IsNull() && F2.IsNull() && BRepTools::IsReallyClosed( E, F1 ))
93     F2 = F1;
94 }
95
96 //=======================================================================
97 //function : ExtentSpinesOnCommonFace
98 //purpose  : Extend spines of two chamfers by distance dis1,dis2
99 //           on their common face
100 //           Two guide lines Spine1 and Spine2 cross in V
101 //           isfirst(i) = False if Spine(i) is oriented to V (i = 1,2)
102 //=======================================================================
103
104 void ExtentSpineOnCommonFace(Handle(ChFiDS_Spine)&  Spine1,
105                              Handle(ChFiDS_Spine)&  Spine2,
106                              const TopoDS_Vertex&   V,
107                              const Standard_Real    dis1,
108                              const Standard_Real    dis2,
109                              const Standard_Boolean isfirst1,
110                              const Standard_Boolean isfirst2)
111 {                 
112   Standard_Real tolesp = 1.e-7;
113
114     // alpha, the opening angle between two 
115     // tangents of two guidelines in V is found
116     Standard_Real tga1,tga2;
117     Standard_Real d1plus = 0., d2plus = 0.;
118
119     gp_Pnt tmp;
120     gp_Vec tg1, tg2;
121     Spine1->D1(Spine1->Absc(V),tmp,tg1);
122     Spine2->D1(Spine2->Absc(V),tmp,tg2);
123     tg1.Normalize();
124     tg2.Normalize();
125     if (isfirst1)  
126       tg1.Reverse();
127     if (isfirst2)  
128       tg2.Reverse();
129
130     Standard_Real cosalpha,sinalpha;   
131     cosalpha = tg1.Dot(tg2);
132     sinalpha = sqrt(1-cosalpha*cosalpha);
133     
134     //a1+a2 = alpha
135     Standard_Real temp;
136     temp = cosalpha+dis2/dis1;
137     if( Abs(temp) > tolesp ){
138       tga1 = sinalpha/temp;
139       d1plus = dis1/tga1;
140     }
141     temp = cosalpha+dis1/dis2;
142     if( Abs(temp) > tolesp ){
143       tga2 = sinalpha/temp;
144       d2plus = dis2/tga2;
145     }
146
147     //extension by the calculated distance
148     if (d1plus > 0.) {
149       d1plus *= 3.;
150       if (isfirst1){
151         Spine1->SetFirstParameter(-d1plus);
152         Spine1->SetFirstTgt(0.);
153       }
154       else{
155         Standard_Real param = Spine1->LastParameter(Spine1->NbEdges());
156         Spine1->SetLastParameter(d1plus+param);
157         Spine1->SetLastTgt(param);
158       }
159     }
160     if (d2plus > 0.) {
161       d2plus *= 1.5;
162       if (isfirst2){
163         Spine2->SetFirstParameter(-d2plus);
164         Spine2->SetFirstTgt(0.);
165       }
166       else{
167         Standard_Real param = Spine2->LastParameter(Spine2->NbEdges());
168         Spine2->SetLastParameter(d2plus+param);
169         Spine2->SetLastTgt(param);
170       }
171     }
172 }
173
174 //=======================================================================
175 //function : ChFi3d_ChBuilder
176 //purpose  : 
177 //=======================================================================
178
179 ChFi3d_ChBuilder::ChFi3d_ChBuilder(const TopoDS_Shape& S,
180                                    const Standard_Real Ta) : 
181                                           ChFi3d_Builder(S, Ta)
182 {
183 }
184
185
186 //=======================================================================
187 //function : Add
188 //purpose  : create a new stripe with a spine containing the edge <E>
189 //           add on the spine the tangential edges to <E>
190 //=======================================================================
191
192 void  ChFi3d_ChBuilder::Add(const TopoDS_Edge& E)
193 {
194
195   if(!Contains(E) && myEFMap.Contains(E)){
196     Handle(ChFiDS_Stripe) Stripe = new ChFiDS_Stripe();
197     Handle(ChFiDS_Spine)& Sp = Stripe->ChangeSpine();
198     Sp = new ChFiDS_ChamfSpine(tolesp);
199     Handle(ChFiDS_ChamfSpine) Spine = Handle(ChFiDS_ChamfSpine)::DownCast(Sp);
200
201     TopoDS_Edge E_wnt = E;
202     E_wnt.Orientation(TopAbs_FORWARD);
203     Spine->SetEdges(E_wnt);
204     if(PerformElement(Spine)){
205       PerformExtremity(Spine);
206       Spine->Load();
207       myListStripe.Append(Stripe);
208     }
209   }
210 }
211
212
213 //=======================================================================
214 //function : Add
215 //purpose  : create a new stripe with a ChamfSpine containing the edge <E>
216 //           with the distance <Dis>   on the face <F> 
217 //           . Add the tangential edges continuous to E in the spine
218 //           
219 //=======================================================================
220
221 void  ChFi3d_ChBuilder::Add(const Standard_Real Dis,
222                             const TopoDS_Edge& E,
223                             const TopoDS_Face& F)
224 {
225   if (!Contains(E)  && myEFMap.Contains(E)) {
226      
227     // Take the 2 common faces of the egde <E>
228     TopoDS_Face F1,F2;
229     SearchCommonFaces(myEFMap,E,F1,F2);
230
231     if (! F1.IsSame(F) && F2.IsSame(F) ) {
232       F2 = F1;
233       F1 = F;
234     }
235
236     if ( F1.IsSame(F)) {
237       TopoDS_Edge E_wnt = E;
238       E_wnt.Orientation(TopAbs_FORWARD);
239       BRepAdaptor_Surface Sb1,Sb2;
240       Sb1.Initialize(F1);
241       Sb2.Initialize(F2);
242       TopAbs_Orientation Or1,Or2;
243       ChFi3d::ConcaveSide(Sb1,Sb2,E_wnt,Or1,Or2); 
244       Handle(ChFiDS_Stripe) Stripe = new ChFiDS_Stripe();
245       Handle(ChFiDS_Spine)& Sp = Stripe->ChangeSpine();
246       Sp = new ChFiDS_ChamfSpine(tolesp);
247       Handle(ChFiDS_ChamfSpine) 
248         Spine = Handle(ChFiDS_ChamfSpine)::DownCast(Sp);
249
250       Spine->SetEdges(E_wnt);
251       if(PerformElement(Spine)){
252         Spine->Load();
253         myListStripe.Append(Stripe);
254         
255         Spine->SetDist(Dis);
256
257         PerformExtremity(Spine);
258       }
259     }
260   }
261 }
262
263
264 //=======================================================================
265 //function : SetDist
266 //purpose  : set the distances <Dis>of the contour of 
267 //           index IC
268 //=======================================================================
269
270 void  ChFi3d_ChBuilder::SetDist(const Standard_Real    Dis,
271                                 const Standard_Integer IC,
272                                 const TopoDS_Face&     F)
273 {
274
275   if(IC <= NbElements()) {
276     Handle(ChFiDS_ChamfSpine) csp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
277
278     // Search the first edge which has a common face equal to F
279     TopoDS_Face F1,F2,FirstF1,FirstF2;
280     //TopAbs_Orientation Or1,Or2;
281     //Standard_Integer Choix, ChoixConge;
282     BRepAdaptor_Surface Sb1,Sb2;
283     Standard_Integer i = 1;
284     Standard_Boolean Found = Standard_False;
285     while ( (i <= csp->NbEdges()) && (!Found) ) {
286       SearchCommonFaces(myEFMap,csp->Edges(i),F1,F2);
287       if ( i == 1) {
288         FirstF1 = F1;
289         FirstF2 = F2;
290       }
291       Found = ( F1.IsSame(F) || F2.IsSame(F) );
292       i++;
293     }
294
295     if (Found) {
296       if ( F2.IsSame(F) ) {
297         F2 = F1;
298         F1 = F;
299       }
300       csp->SetDist(Dis);
301
302     }
303     else
304       Standard_DomainError::Raise("the face is not common to any of edges of the contour");
305
306   }
307 }
308
309
310 //=======================================================================
311 //function : GetDist
312 //purpose  : 
313 //=======================================================================
314
315 void ChFi3d_ChBuilder::GetDist(const Standard_Integer  IC,
316                                Standard_Real&          Dis) const
317 {
318     Handle(ChFiDS_ChamfSpine) chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
319     chsp->GetDist(Dis);
320
321 }
322
323
324 //=======================================================================
325 //function : Add
326 //purpose  : create a new stripe with a ChAsymSpine containing the edge <E>
327 //           with the distance <Dis> and the angle Angle  on the face <F> 
328 //           . Add the tangential edges continuous to E in the spine
329 //           
330 //=======================================================================
331
332 void  ChFi3d_ChBuilder::Add(const Standard_Real Dis1,
333                             const Standard_Real Dis2,
334                             const TopoDS_Edge& E,
335                             const TopoDS_Face& F)
336 {
337   if (!Contains(E)  && myEFMap.Contains(E)) {
338      
339     // Take the 2 common faces of the egde <E>
340     TopoDS_Face F1,F2;
341     SearchCommonFaces(myEFMap,E,F1,F2);
342
343     if (! F1.IsSame(F) && F2.IsSame(F) ) {
344       F2 = F1;
345       F1 = F;
346     }
347
348     if ( F1.IsSame(F)) {
349       TopoDS_Edge E_wnt = E;
350       E_wnt.Orientation(TopAbs_FORWARD);
351       BRepAdaptor_Surface Sb1,Sb2;
352       Sb1.Initialize(F1);
353       Sb2.Initialize(F2);
354       TopAbs_Orientation Or1,Or2;
355       Standard_Integer Choix = ChFi3d::ConcaveSide(Sb1,Sb2,E_wnt,Or1,Or2); 
356
357       Handle(ChFiDS_Stripe) Stripe = new ChFiDS_Stripe();
358       Handle(ChFiDS_Spine)& Sp = Stripe->ChangeSpine();
359       Sp = new ChFiDS_ChamfSpine(tolesp);
360       Handle(ChFiDS_ChamfSpine) 
361         Spine = Handle(ChFiDS_ChamfSpine)::DownCast(Sp);
362
363       Spine->SetEdges(E_wnt);
364       if(PerformElement(Spine)){
365         Spine->Load();
366         myListStripe.Append(Stripe);
367         
368         Standard_Integer ChoixConge;
369         SearchCommonFaces(myEFMap,Spine->Edges(1),F1,F2);
370         Sb1.Initialize(F1);
371         Sb2.Initialize(F2);
372         ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,
373                                          Spine->Edges(1),
374                                          Or1,Or2);
375
376
377         // compare the 2 computed choices to know how to set the 
378         // distances of the Spine according to the choice done 
379         // on the added edge <e>
380         if ( ChoixConge%2 != Choix%2 )
381           Spine->SetDists(Dis2, Dis1);
382         else Spine->SetDists(Dis1, Dis2);
383
384         PerformExtremity(Spine);
385       }
386     }
387   }
388 }
389
390
391 //=======================================================================
392 //function : SetDists
393 //purpose  : set the distances <Dis1> and <Dis2> of the contour of 
394 //           index IC
395 //=======================================================================
396
397 void  ChFi3d_ChBuilder::SetDists(const Standard_Real    Dis1,
398                                  const Standard_Real    Dis2,
399                                  const Standard_Integer IC,
400                                  const TopoDS_Face&     F)
401 {
402
403   if(IC <= NbElements()) {
404     Handle(ChFiDS_ChamfSpine) csp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
405
406     // Search the first edge which has a common face equal to F
407     TopoDS_Face F1,F2,FirstF1,FirstF2;
408     TopAbs_Orientation Or1,Or2;
409     Standard_Integer Choix, ChoixConge;
410     BRepAdaptor_Surface Sb1,Sb2;
411     Standard_Integer i = 1;
412     Standard_Boolean Found = Standard_False;
413     while ( (i <= csp->NbEdges()) && (!Found) ) {
414       SearchCommonFaces(myEFMap,csp->Edges(i),F1,F2);
415       if ( i == 1) {
416         FirstF1 = F1;
417         FirstF2 = F2;
418       }
419       Found = ( F1.IsSame(F) || F2.IsSame(F) );
420       i++;
421     }
422
423     if (Found) {
424       if ( F2.IsSame(F) ) {
425         F2 = F1;
426         F1 = F;
427       }
428       Sb1.Initialize(F1);
429       Sb2.Initialize(F2);
430       Choix = ChFi3d::ConcaveSide(Sb1,Sb2,
431                                   csp->Edges(i-1),
432                                   Or1,Or2);
433       Sb1.Initialize(FirstF1);
434       Sb2.Initialize(FirstF2);
435       ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,
436                                        csp->Edges(1),
437                                        Or1,Or2);
438       if ( ChoixConge%2 != Choix%2 )
439         csp->SetDists(Dis2,Dis1);
440       else csp->SetDists(Dis1,Dis2);
441     }
442     else
443       Standard_DomainError::Raise("the face is not common to any of edges of the contour");
444
445   }
446 }
447
448
449 //=======================================================================
450 //function : Dists
451 //purpose  : 
452 //=======================================================================
453
454 void ChFi3d_ChBuilder::Dists(const Standard_Integer  IC,
455                              Standard_Real&          dis1,
456                              Standard_Real&          dis2) const
457 {
458     Handle(ChFiDS_ChamfSpine) chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
459     Standard_Real temp1, temp2;
460     chsp->Dists(temp1,temp2);
461     dis1 = temp1;
462     dis2 = temp2;
463 }
464
465
466 //=======================================================================
467 //function : Add
468 //purpose  : create a new stripe with a ChAsymSpine containing the edge <E>
469 //           with the distance <Dis> and the angle Angle  on the face <F> 
470 //           . Add the tangential edges continuous to E in the spine
471 //           
472 //=======================================================================
473
474 void  ChFi3d_ChBuilder::AddDA(const Standard_Real Dis1,
475                               const Standard_Real Angle,
476                               const TopoDS_Edge& E,
477                               const TopoDS_Face& F)
478 {
479   if (!Contains(E)  && myEFMap.Contains(E)) {
480      
481     // Take the 2 common faces of the egde <E>
482     TopoDS_Face F1,F2;
483     SearchCommonFaces(myEFMap,E,F1,F2);
484  
485     if (! F1.IsSame(F) && F2.IsSame(F) ) {
486       F2 = F1;
487       F1 = F;
488     }
489
490     if ( F1.IsSame(F)) {
491       TopoDS_Edge E_wnt = E;
492       E_wnt.Orientation(TopAbs_FORWARD);
493       BRepAdaptor_Surface Sb1,Sb2;
494       Sb1.Initialize(F1);
495       Sb2.Initialize(F2);
496       TopAbs_Orientation Or1,Or2;
497       Standard_Integer Choix = ChFi3d::ConcaveSide(Sb1,Sb2,E_wnt,Or1,Or2); 
498
499       Handle(ChFiDS_Stripe) Stripe = new ChFiDS_Stripe();
500       Handle(ChFiDS_Spine)& Sp = Stripe->ChangeSpine();
501       Sp = new ChFiDS_ChamfSpine(tolesp);
502       Handle(ChFiDS_ChamfSpine) 
503         Spine = Handle(ChFiDS_ChamfSpine)::DownCast(Sp);
504
505       Spine->SetEdges(E_wnt);
506       if(PerformElement(Spine)){
507         Spine->Load();
508         myListStripe.Append(Stripe);
509         
510         Standard_Integer ChoixConge;
511         SearchCommonFaces(myEFMap,Spine->Edges(1),F1,F2);
512         Sb1.Initialize(F1);
513         Sb2.Initialize(F2);
514         ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,
515                                          Spine->Edges(1),
516                                          Or1,Or2);
517
518         // compare the 2 computed choices to know how to set the 
519         // distances of the Spine according to the choice done 
520         // on the added edge <e>
521         if ( ChoixConge%2 != Choix%2 ) {
522           Spine->SetDistAngle(Dis1, Angle, Standard_False);
523         }
524         else { 
525           Spine->SetDistAngle(Dis1, Angle, Standard_True);
526         }
527         
528         PerformExtremity(Spine);
529       }
530     }
531   }
532 }
533
534
535 //=======================================================================
536 //function : SetDistAngle
537 //purpose  : set the distances <Dis> and <Angle> of the contour of 
538 //           index IC
539 //=======================================================================
540
541 void  ChFi3d_ChBuilder::SetDistAngle(const Standard_Real    Dis,
542                                      const Standard_Real    Angle,
543                                      const Standard_Integer IC,
544                                      const TopoDS_Face&     F)
545 {
546
547   if(IC <= NbElements()) {
548     Handle(ChFiDS_ChamfSpine) csp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
549
550     // Search the first edge which has a common face equal to F
551     TopoDS_Face F1,F2,FirstF1,FirstF2;
552     TopAbs_Orientation Or1,Or2;
553     Standard_Integer Choix, ChoixConge;
554     BRepAdaptor_Surface Sb1,Sb2;
555     Standard_Integer i = 1;
556     Standard_Boolean Found = Standard_False;
557 //    Standard_Boolean DisOnF1 = Standard_True;
558
559     while ( (i <= csp->NbEdges()) && (!Found) ) {
560       SearchCommonFaces(myEFMap,csp->Edges(i),F1,F2);
561       if ( i == 1) {
562         FirstF1 = F1;
563         FirstF2 = F2;
564       }
565       Found = ( F1.IsSame(F) || F2.IsSame(F) );
566       i++;
567     }
568
569     if (Found) {
570       if ( F2.IsSame(F) ) {
571         F2 = F1;
572         F1 = F;
573       }
574       Sb1.Initialize(F1);
575       Sb2.Initialize(F2);
576       Choix = ChFi3d::ConcaveSide(Sb1,Sb2,
577                                   csp->Edges(i-1),
578                                   Or1,Or2);
579       Sb1.Initialize(FirstF1);
580       Sb2.Initialize(FirstF2);
581       ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,
582                                        csp->Edges(1),
583                                        Or1,Or2);
584       if ( ChoixConge%2 != Choix%2 ) {
585         csp->SetDistAngle(Dis, Angle, Standard_False);
586       }
587       else {
588         csp->SetDistAngle(Dis, Angle, Standard_True);
589       }
590     }
591     else
592       Standard_DomainError::Raise("the face is not common to any edges of the contour");
593
594   }
595 }
596
597
598 //=======================================================================
599 //function : GetDistAngle
600 //purpose  : 
601 //=======================================================================
602
603 void ChFi3d_ChBuilder::GetDistAngle(const Standard_Integer  IC,
604                                     Standard_Real&          Dis,
605                                     Standard_Real&          Angle,
606                                     Standard_Boolean&       DisOnFace1) const
607 {
608     Handle(ChFiDS_ChamfSpine) chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
609
610     chsp->GetDistAngle(Dis, Angle, DisOnFace1);
611 }
612
613 //=======================================================================
614 //function : IsChamfer
615 //purpose  : 
616 //=======================================================================
617 ChFiDS_ChamfMethod ChFi3d_ChBuilder::IsChamfer(const Standard_Integer  IC) const
618 {
619   Handle(ChFiDS_ChamfSpine) chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
620     
621   ChFiDS_ChamfMethod ret = chsp->IsChamfer();
622
623   return ret;
624
625 }
626
627 //=======================================================================
628 //function : ResetContour
629 //purpose  : 
630 //=======================================================================
631
632 void  ChFi3d_ChBuilder::ResetContour(const Standard_Integer IC)
633 {
634   if(IC <= NbElements()) {
635     Handle(ChFiDS_ChamfSpine) chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Value(IC));
636     chsp->Reset(Standard_True);
637   }
638 }
639
640 //--------------------------------AJOUT----------------------------------
641 //=======================================================================
642 //function : Simulate
643 //purpose  : 
644 //=======================================================================
645
646 void ChFi3d_ChBuilder::Simulate (const Standard_Integer IC)
647 {
648 #ifdef OCCT_DEBUG
649   if(ChFi3d_GettraceCHRON()){
650     simul.Reset();elspine.Reset();chemine.Reset();
651     simul.Start();
652   }
653 #endif
654   ChFiDS_ListIteratorOfListOfStripe itel;
655   Standard_Integer i = 1;
656   for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
657     if(i == IC){
658       PerformSetOfSurf(itel.Value(), Standard_True);
659       break;
660     }
661   }
662 #ifdef OCCT_DEBUG
663   if(ChFi3d_GettraceCHRON()){
664     simul.Stop();
665     cout<<"Total simulation time : ";
666     simul.Show();
667     cout<<"Spine construction time : ";
668     elspine.Show();
669     cout<<"and progression time : ";
670     chemine.Show();
671   }
672 #endif
673 }
674
675 //---------------------------AJOUT---------------------------------------
676 //=======================================================================
677 //function : NbSurf
678 //purpose  : 
679 //=======================================================================
680
681 Standard_Integer ChFi3d_ChBuilder::NbSurf (const Standard_Integer IC) const 
682 {
683   ChFiDS_ListIteratorOfListOfStripe itel;
684   Standard_Integer i = 1;
685   for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
686     if(i == IC){
687       return itel.Value()->SetOfSurfData()->Length();
688     }
689   }
690   return 0;
691 }
692
693
694 //--------------------------AJOUT---------------------------------------
695 //=======================================================================
696 //function : Sect
697 //purpose  : 
698 //=======================================================================
699
700 Handle(ChFiDS_SecHArray1) ChFi3d_ChBuilder::Sect (const Standard_Integer IC,
701                                                   const Standard_Integer IS) const 
702 {
703   ChFiDS_ListIteratorOfListOfStripe itel;
704   Standard_Integer i = 1;
705   Handle(ChFiDS_SecHArray1) res;
706   for (itel.Initialize(myListStripe);itel.More(); itel.Next(), i++) {
707     if(i == IC){
708       Handle(MMgt_TShared) bid = itel.Value()->SetOfSurfData()->Value(IS)->Simul();
709       res = Handle(ChFiDS_SecHArray1)::DownCast(bid);
710       return res;
711     }
712   }
713   return Handle(ChFiDS_SecHArray1)();
714 }
715
716
717 //-------------------MODIFS---------------------------------------------
718 //=======================================================================
719 //function : SimulKPart
720 //purpose  : Stores simulating sections in simul
721 //=======================================================================
722
723 void  ChFi3d_ChBuilder::SimulKPart(const Handle(ChFiDS_SurfData)& SD ) const 
724 {
725   TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
726   Handle(Geom_Surface) S = DStr.Surface(SD->Surf()).Surface();
727   gp_Pnt2d p1f = SD->InterferenceOnS1().PCurveOnSurf()->
728     Value(SD->InterferenceOnS1().FirstParameter());
729   gp_Pnt2d p1l = SD->InterferenceOnS1().PCurveOnSurf()->
730     Value(SD->InterferenceOnS1().LastParameter());
731   gp_Pnt2d p2f = SD->InterferenceOnS2().PCurveOnSurf()->
732     Value(SD->InterferenceOnS2().FirstParameter());
733   gp_Pnt2d p2l = SD->InterferenceOnS2().PCurveOnSurf()->
734     Value(SD->InterferenceOnS2().LastParameter());
735   GeomAdaptor_Surface AS(S);
736   Handle(ChFiDS_SecHArray1) sec;
737   Standard_Real u1,v1,u2,v2;
738   GeomAbs_SurfaceType typ = AS.GetType();
739   switch (typ){
740   case GeomAbs_Plane:
741     {
742       v1 = p1f.Y();
743       v2 = p2f.Y();
744       u1 = Max(p1f.X(),p2f.X());
745       u2 = Min(p1l.X(),p2l.X());
746       sec = new ChFiDS_SecHArray1(1,2); 
747       gp_Pln Pl = AS.Plane();
748       ChFiDS_CircSection& sec1 = sec->ChangeValue(1);
749       ChFiDS_CircSection& sec2 = sec->ChangeValue(2);
750       sec1.Set(ElSLib::PlaneUIso(Pl.Position(),u1),v1,v2);
751       sec2.Set(ElSLib::PlaneUIso(Pl.Position(),u2),v1,v2);
752     }
753     break;
754   case GeomAbs_Cone:
755     {
756       v1 = p1f.Y();
757       v2 = p2f.Y();
758       u1 = Max(p1f.X(),p2f.X());
759       u2 = Min(p1l.X(),p2l.X());
760       Standard_Real ang = (u2-u1);
761       gp_Cone Co = AS.Cone();
762       Standard_Real rad = Co.RefRadius(), sang = Co.SemiAngle();
763       Standard_Integer n = (Standard_Integer) (36.*ang/M_PI + 1);
764       if(n<2) n = 2;
765       sec = new ChFiDS_SecHArray1(1, n);
766       for (Standard_Integer i = 1; i <= n; i++) {
767         ChFiDS_CircSection& isec = sec->ChangeValue(i);
768         Standard_Real u = u1 + (i - 1)*(u2 - u1)/(n-1);
769         isec.Set(ElSLib::ConeUIso(Co.Position(), rad, sang, u), v1, v2);  
770       }
771     }
772     break;
773   default:
774     break;
775   }
776   SD->SetSimul(sec);
777 }
778
779 //------------------------MODIFS---------------------------------------
780 //=======================================================================
781 //function : SimulSurf
782 //purpose  : 
783 //=======================================================================
784
785 Standard_Boolean
786 ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            Data,
787                             const Handle(ChFiDS_HElSpine)&      HGuide,
788                             const Handle(ChFiDS_Spine)&         Spine,
789                             const Standard_Integer              Choix,
790                             const Handle(BRepAdaptor_HSurface)& S1,
791                             const Handle(Adaptor3d_TopolTool)&    I1,
792                             const Handle(BRepAdaptor_HSurface)& S2,
793                             const Handle(Adaptor3d_TopolTool)&    I2,
794                             const Standard_Real                 TolGuide,
795                             Standard_Real&                      First,
796                             Standard_Real&                      Last,
797                             const Standard_Boolean              Inside,
798                             const Standard_Boolean              Appro,
799                             const Standard_Boolean              Forward,
800                             const Standard_Boolean              RecOnS1,
801                             const Standard_Boolean              RecOnS2,
802                             const math_Vector&                  Soldep,
803                             Standard_Integer&                   intf,
804                             Standard_Integer&                   intl)
805      
806 {
807   Handle(ChFiDS_ChamfSpine) 
808     chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Spine);
809   
810   if (chsp.IsNull()) 
811     Standard_ConstructionError::Raise
812       ("SimulSurf : this is not the spine of a chamfer");
813
814
815   Standard_Real radius;
816   // Flexible parameters!
817   Standard_Real la = HGuide->LastParameter(), fi = HGuide->FirstParameter();
818   Standard_Real longueur = la - fi;
819   Standard_Real MaxStep = longueur * 0.05;
820   Standard_Real radiusspine = 0, locfleche, w;
821   gp_Pnt Pbid;
822   gp_Vec d1,d2;
823   // As ElSpine is parameterized by a curvilinear quasi-abscissa,
824   // the min radius is estimated as 1/D2 max;
825   //for(Standard_Integer i = 0; i <= 20; i++){
826   Standard_Integer i;
827   for( i = 0; i <= 20; i++){ 
828     w = fi + i*MaxStep;
829     HGuide->D2(w,Pbid,d1,d2);
830     Standard_Real temp = d2.SquareMagnitude();
831     if(temp>radiusspine) radiusspine = temp;
832   }
833
834   Handle(BRepBlend_Line) lin;
835   Standard_Real PFirst = First;
836   if(intf) First = chsp->FirstParameter(1);
837   if(intl) Last = chsp->LastParameter(chsp->NbEdges());
838
839
840
841   if (chsp->IsChamfer() == ChFiDS_Sym) {
842     Standard_Real dis;
843     chsp->GetDist(dis);
844     radius = Max(dis, radiusspine);
845     locfleche = radius*1.e-2; //graphic criterion
846
847     BRepBlend_Chamfer Func(S1,S2,HGuide);
848     BRepBlend_ChamfInv FInv(S1,S2,HGuide); 
849     Func.Set(dis, dis, Choix);
850     FInv.Set(dis, dis, Choix);
851     
852     done = SimulData(Data,HGuide,lin,S1,I1,S2,I2,
853                      Func,FInv,PFirst,MaxStep,locfleche,
854                      TolGuide,First,Last,Inside,Appro,Forward,
855                      Soldep,4,RecOnS1,RecOnS2);
856
857     if ( !done ) return Standard_False;
858     Handle(ChFiDS_SecHArray1) sec;
859     gp_Pnt2d pf1,pl1,pf2,pl2;  
860     
861     Standard_Integer nbp = lin->NbPoints();
862     sec = new ChFiDS_SecHArray1(1,nbp);
863     for( i = 1; i <= nbp; i++ ){
864       ChFiDS_CircSection& isec = sec->ChangeValue(i);
865       Standard_Real u1,v1,u2,v2,ww,p1,p2;
866       gp_Lin line;
867       const Blend_Point& p = lin->Point(i);
868       p.ParametersOnS1(u1,v1);
869       p.ParametersOnS2(u2,v2);
870       ww = p.Parameter();
871       Func.Section(ww,u1,v1,u2,v2,p1,p2,line); 
872       isec.Set(line,p1,p2);
873       if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);} 
874       if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);} 
875     }
876
877     Data->SetSimul(sec);
878     Data->Set2dPoints(pf1,pl1,pf2,pl2);
879     ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
880                           Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
881     ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
882                           Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
883     ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
884                           Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
885     ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
886                           Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
887     
888     Standard_Boolean reverse = (!Forward || Inside);
889     if(intf && reverse){
890       Standard_Boolean ok = Standard_False;
891       const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
892       if(cp1.IsOnArc()){
893         TopoDS_Face F1 = S1->ChangeSurface().Face();
894         TopoDS_Face bid;
895         intf = !SearchFace(Spine,cp1,F1,bid);
896         ok = intf != 0;
897       }
898       const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
899       if(cp2.IsOnArc() && !ok){
900         TopoDS_Face F2 = S2->ChangeSurface().Face();
901         TopoDS_Face bid;
902         intf = !SearchFace(Spine,cp2,F2,bid);
903       }
904     }
905     if(intl){
906       Standard_Boolean ok = Standard_False;
907       const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
908       if(cp1.IsOnArc()){
909         TopoDS_Face F1 = S1->ChangeSurface().Face();
910         TopoDS_Face bid;
911         intl = !SearchFace(Spine,cp1,F1,bid);
912         ok = intl != 0;
913       }
914       const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
915       if(cp2.IsOnArc() && !ok){
916         TopoDS_Face F2 = S2->ChangeSurface().Face();
917         TopoDS_Face bid;
918         intl = !SearchFace(Spine,cp2,F2,bid);
919       }
920     }
921   }
922   else if (chsp->IsChamfer() == ChFiDS_TwoDist) {
923     Standard_Real dis1, dis2;
924     chsp->Dists(dis1, dis2);
925     radius = Max(dis1, dis2);
926     radius = Max(radius, radiusspine);
927     locfleche = radius*1.e-2; //graphic criterion
928
929     BRepBlend_Chamfer Func(S1,S2,HGuide);
930     BRepBlend_ChamfInv FInv(S1,S2,HGuide); 
931     Func.Set(dis1,dis2,Choix);
932     FInv.Set(dis1,dis2,Choix);
933     
934     done = SimulData(Data,HGuide,lin,S1,I1,S2,I2,
935                      Func,FInv,PFirst,MaxStep,locfleche,
936                      TolGuide,First,Last,Inside,Appro,Forward,
937                      Soldep,4,RecOnS1,RecOnS2);
938
939     if ( !done ) return Standard_False;
940     Handle(ChFiDS_SecHArray1) sec;
941     gp_Pnt2d pf1,pl1,pf2,pl2;  
942     
943     Standard_Integer nbp = lin->NbPoints();
944     sec = new ChFiDS_SecHArray1(1,nbp);
945     for( i = 1; i <= nbp; i++ ){
946       ChFiDS_CircSection& isec = sec->ChangeValue(i);
947       Standard_Real u1,v1,u2,v2,ww,p1,p2;
948       gp_Lin line;
949       const Blend_Point& p = lin->Point(i);
950       p.ParametersOnS1(u1,v1);
951       p.ParametersOnS2(u2,v2);
952       ww = p.Parameter();
953       Func.Section(ww,u1,v1,u2,v2,p1,p2,line); 
954       isec.Set(line,p1,p2);
955       if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);} 
956       if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);} 
957     }
958     
959     Data->SetSimul(sec);
960     Data->Set2dPoints(pf1,pl1,pf2,pl2);
961     ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
962                         Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
963     ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
964                           Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
965     ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
966                           Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
967     ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
968                           Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
969     
970     Standard_Boolean reverse = (!Forward || Inside);
971     if(intf && reverse){
972       Standard_Boolean ok = Standard_False;
973       const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
974       if(cp1.IsOnArc()){
975         TopoDS_Face F1 = S1->ChangeSurface().Face();
976         TopoDS_Face bid;
977         intf = !SearchFace(Spine,cp1,F1,bid);
978         ok = intf != 0;
979       }
980       const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
981       if(cp2.IsOnArc() && !ok){
982         TopoDS_Face F2 = S2->ChangeSurface().Face();
983         TopoDS_Face bid;
984         intf = !SearchFace(Spine,cp2,F2,bid);
985       }
986     }
987     if(intl){
988       Standard_Boolean ok = Standard_False;
989       const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
990       if(cp1.IsOnArc()){
991         TopoDS_Face F1 = S1->ChangeSurface().Face();
992         TopoDS_Face bid;
993         intl = !SearchFace(Spine,cp1,F1,bid);
994         ok = intl != 0;
995       }
996       const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
997       if(cp2.IsOnArc() && !ok){
998         TopoDS_Face F2 = S2->ChangeSurface().Face();
999         TopoDS_Face bid;
1000         intl = !SearchFace(Spine,cp2,F2,bid);
1001       }
1002     }
1003   }
1004   else  {
1005     Standard_Real dis, angle;
1006     Standard_Boolean disonF1;  
1007     chsp->GetDistAngle(dis, angle, disonF1);
1008     radius = Max(dis, dis * tan(angle));
1009     radius = Max(radius, radiusspine);
1010     locfleche = radius*1.e-2; //graphic criterion
1011
1012     Standard_Integer Ch = FindChoiceDistAngle(Choix, disonF1);
1013
1014     if (disonF1)  {
1015       BRepBlend_ChAsym    Func(S1,S2,HGuide);
1016       BRepBlend_ChAsymInv FInv(S1,S2,HGuide); 
1017
1018       Func.Set(dis, angle, Ch);
1019       FInv.Set(dis, angle, Ch);
1020
1021       done = SimulData(Data,HGuide,lin,S1,I1,S2,I2,
1022                        Func,FInv,PFirst,MaxStep,locfleche,
1023                        TolGuide,First,Last,Inside,Appro,Forward,
1024                        Soldep,4,RecOnS1,RecOnS2);
1025     
1026       if ( !done ) return Standard_False;
1027       Handle(ChFiDS_SecHArray1) sec;
1028       gp_Pnt2d pf1,pl1,pf2,pl2;  
1029       
1030       Standard_Integer nbp = lin->NbPoints();
1031       sec = new ChFiDS_SecHArray1(1,nbp);
1032       for( i = 1; i <= nbp; i++ ){
1033         ChFiDS_CircSection& isec = sec->ChangeValue(i);
1034         Standard_Real u1,v1,u2,v2,ww,p1,p2;
1035         gp_Lin line;
1036         const Blend_Point& p = lin->Point(i);
1037         p.ParametersOnS1(u1,v1);
1038         p.ParametersOnS2(u2,v2);
1039         ww = p.Parameter();
1040         Func.Section(ww,u1,v1,u2,v2,p1,p2,line); 
1041         isec.Set(line,p1,p2);
1042         if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);} 
1043         if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);} 
1044       }
1045     
1046       Data->SetSimul(sec);
1047       Data->Set2dPoints(pf1,pl1,pf2,pl2);
1048       ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
1049                             Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
1050       ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
1051                             Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
1052       ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
1053                             Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
1054       ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
1055                             Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
1056
1057       Standard_Boolean reverse = (!Forward || Inside);
1058       if(intf && reverse){
1059         Standard_Boolean ok = Standard_False;
1060         const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
1061         if(cp1.IsOnArc()){
1062           TopoDS_Face F1 = S1->ChangeSurface().Face();
1063           TopoDS_Face bid;
1064           intf = !SearchFace(Spine,cp1,F1,bid);
1065           ok = intf != 0;
1066         }
1067         const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
1068         if(cp2.IsOnArc() && !ok){
1069           TopoDS_Face F2 = S2->ChangeSurface().Face();
1070           TopoDS_Face bid;
1071           intf = !SearchFace(Spine,cp2,F2,bid);
1072         }
1073       }
1074       
1075       if(intl){
1076         Standard_Boolean ok = Standard_False;
1077         const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
1078         if(cp1.IsOnArc()){
1079           TopoDS_Face F1 = S1->ChangeSurface().Face();
1080           TopoDS_Face bid;
1081           intl = !SearchFace(Spine,cp1,F1,bid);
1082           ok = intl != 0;
1083         }
1084         const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
1085         if(cp2.IsOnArc() && !ok){
1086           TopoDS_Face F2 = S2->ChangeSurface().Face();
1087           TopoDS_Face bid;
1088           intl = !SearchFace(Spine,cp2,F2,bid);
1089         }
1090       }
1091     }
1092     else {
1093       BRepBlend_ChAsym    Func(S2,S1,HGuide);
1094       BRepBlend_ChAsymInv FInv(S2,S1,HGuide); 
1095
1096       Func.Set(dis, angle, Ch);
1097       FInv.Set(dis, angle, Ch);
1098
1099       Standard_Real Rtemp;
1100       Rtemp     = Soldep(1);
1101       Soldep(1) = Soldep(3);
1102       Soldep(3) = Rtemp;
1103       Rtemp     = Soldep(2);
1104       Soldep(2) = Soldep(4);
1105       Soldep(4) = Rtemp;
1106
1107       done = SimulData(Data,HGuide,lin,S2,I2,S1,I1,
1108                        Func,FInv,PFirst,MaxStep,locfleche,
1109                        TolGuide,First,Last,Inside,Appro,Forward,
1110                        Soldep,4,RecOnS2,RecOnS1);
1111     
1112       if ( !done ) return Standard_False;
1113       Handle(ChFiDS_SecHArray1) sec;
1114       gp_Pnt2d pf1,pl1,pf2,pl2;  
1115       
1116       Standard_Integer nbp = lin->NbPoints();
1117       sec = new ChFiDS_SecHArray1(1,nbp);
1118       for( i = 1; i <= nbp; i++ ){
1119         ChFiDS_CircSection& isec = sec->ChangeValue(i);
1120         Standard_Real u1,v1,u2,v2,ww,p1,p2;
1121         gp_Lin line;
1122         const Blend_Point& p = lin->Point(i);
1123         p.ParametersOnS1(u1,v1);
1124         p.ParametersOnS2(u2,v2);
1125         ww = p.Parameter();
1126         Func.Section(ww,u1,v1,u2,v2,p1,p2,line); 
1127         isec.Set(line,p1,p2);
1128         if(i == 1) {pf1.SetCoord(u1,v1); pf2.SetCoord(u2,v2);} 
1129         if(i == nbp) {pl1.SetCoord(u1,v1); pl2.SetCoord(u2,v2);} 
1130       }
1131     
1132       Data->SetSimul(sec);
1133       Data->Set2dPoints(pf1,pl1,pf2,pl2);
1134       ChFi3d_FilCommonPoint(lin->StartPointOnFirst(),lin->TransitionOnS1(),
1135                             Standard_True, Data->ChangeVertexFirstOnS1(),tolesp);
1136       ChFi3d_FilCommonPoint(lin->EndPointOnFirst(),lin->TransitionOnS1(),
1137                             Standard_False,Data->ChangeVertexLastOnS1(),tolesp);
1138       ChFi3d_FilCommonPoint(lin->StartPointOnSecond(),lin->TransitionOnS2(),
1139                             Standard_True, Data->ChangeVertexFirstOnS2(),tolesp);
1140       ChFi3d_FilCommonPoint(lin->EndPointOnSecond(),lin->TransitionOnS2(),
1141                             Standard_False, Data->ChangeVertexLastOnS2(),tolesp);
1142
1143       Standard_Boolean reverse = (!Forward || Inside);
1144       if(intf && reverse){
1145         Standard_Boolean ok = Standard_False;
1146         const ChFiDS_CommonPoint& cp1 = Data->VertexFirstOnS1();
1147         if(cp1.IsOnArc()){
1148           TopoDS_Face F1 = S1->ChangeSurface().Face();
1149           TopoDS_Face bid;
1150           intf = !SearchFace(Spine,cp1,F1,bid);
1151           ok = intf != 0;
1152         }
1153         const ChFiDS_CommonPoint& cp2 = Data->VertexFirstOnS2();
1154         if(cp2.IsOnArc() && !ok){
1155           TopoDS_Face F2 = S2->ChangeSurface().Face();
1156           TopoDS_Face bid;
1157           intf = !SearchFace(Spine,cp2,F2,bid);
1158         }
1159       }
1160       
1161       if(intl){
1162         Standard_Boolean ok = Standard_False;
1163         const ChFiDS_CommonPoint& cp1 = Data->VertexLastOnS1();
1164         if(cp1.IsOnArc()){
1165           TopoDS_Face F1 = S1->ChangeSurface().Face();
1166           TopoDS_Face bid;
1167           intl = !SearchFace(Spine,cp1,F1,bid);
1168           ok = intl != 0;
1169         }
1170         const ChFiDS_CommonPoint& cp2 = Data->VertexLastOnS2();
1171         if(cp2.IsOnArc() && !ok){
1172           TopoDS_Face F2 = S2->ChangeSurface().Face();
1173           TopoDS_Face bid;
1174           intl = !SearchFace(Spine,cp2,F2,bid);
1175         }
1176       }
1177     }
1178   }
1179   return Standard_True;
1180 }
1181
1182 void  ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            ,
1183                                 const Handle(ChFiDS_HElSpine)&      , 
1184                                 const Handle(ChFiDS_Spine)&         , 
1185                                 const Standard_Integer              ,
1186                                 const Handle(BRepAdaptor_HSurface)& ,
1187                                 const Handle(Adaptor3d_TopolTool)&    ,
1188                                 const Handle(BRepAdaptor_HCurve2d)& ,
1189                                 const Handle(BRepAdaptor_HSurface)& ,
1190                                 const Handle(BRepAdaptor_HCurve2d)& ,
1191                                 Standard_Boolean&                   ,
1192                                 const Handle(BRepAdaptor_HSurface)& ,
1193                                 const Handle(Adaptor3d_TopolTool)&    ,
1194                                 const TopAbs_Orientation            ,
1195                                 const Standard_Real                 ,
1196                                 const Standard_Real                 ,
1197                                 Standard_Real&                      ,
1198                                 Standard_Real&                      ,
1199                                 const Standard_Boolean              ,
1200                                 const Standard_Boolean              ,
1201                                 const Standard_Boolean              ,
1202                                 const Standard_Boolean              ,
1203                                 const Standard_Boolean              ,
1204                                 const Standard_Boolean              ,
1205                                 const math_Vector&                  )
1206 {
1207   Standard_Failure::Raise("SimulSurf Not Implemented");
1208 }
1209 void  ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            ,
1210                                 const Handle(ChFiDS_HElSpine)&      , 
1211                                 const Handle(ChFiDS_Spine)&         , 
1212                                 const Standard_Integer              ,
1213                                 const Handle(BRepAdaptor_HSurface)& ,
1214                                 const Handle(Adaptor3d_TopolTool)&    ,
1215                                 const TopAbs_Orientation            ,
1216                                 const Handle(BRepAdaptor_HSurface)& ,
1217                                 const Handle(Adaptor3d_TopolTool)&    ,
1218                                 const Handle(BRepAdaptor_HCurve2d)& ,
1219                                 const Handle(BRepAdaptor_HSurface)& ,
1220                                 const Handle(BRepAdaptor_HCurve2d)& ,
1221                                 Standard_Boolean&                   ,
1222                                 const Standard_Real                 ,
1223                                 const Standard_Real                 ,
1224                                 Standard_Real&                      ,
1225                                 Standard_Real&                      ,
1226                                 const Standard_Boolean              ,
1227                                 const Standard_Boolean              ,
1228                                 const Standard_Boolean              ,
1229                                 const Standard_Boolean              ,
1230                                 const Standard_Boolean              ,
1231                                 const Standard_Boolean              ,
1232                                 const math_Vector&                  )
1233 {
1234   Standard_Failure::Raise("SimulSurf Not Implemented");
1235 }
1236 void  ChFi3d_ChBuilder::SimulSurf(Handle(ChFiDS_SurfData)&            ,
1237                                 const Handle(ChFiDS_HElSpine)&      ,
1238                                 const Handle(ChFiDS_Spine)&         ,
1239                                 const Standard_Integer              ,
1240                                 const Handle(BRepAdaptor_HSurface)& ,
1241                                 const Handle(Adaptor3d_TopolTool)&    ,
1242                                 const Handle(BRepAdaptor_HCurve2d)& ,
1243                                 const Handle(BRepAdaptor_HSurface)& ,
1244                                 const Handle(BRepAdaptor_HCurve2d)& ,
1245                                 Standard_Boolean&                   ,
1246                                 const TopAbs_Orientation            ,
1247                                 const Handle(BRepAdaptor_HSurface)& ,
1248                                 const Handle(Adaptor3d_TopolTool)&    ,
1249                                 const Handle(BRepAdaptor_HCurve2d)& ,
1250                                 const Handle(BRepAdaptor_HSurface)& ,
1251                                 const Handle(BRepAdaptor_HCurve2d)& ,
1252                                 Standard_Boolean&                   ,
1253                                 const TopAbs_Orientation            ,
1254                                 const Standard_Real                 ,
1255                                 const Standard_Real                 ,
1256                                 Standard_Real&                      ,
1257                                 Standard_Real&                      ,
1258                                 const Standard_Boolean              ,
1259                                 const Standard_Boolean              ,
1260                                 const Standard_Boolean              ,
1261                                 const Standard_Boolean              ,
1262                                 const Standard_Boolean              ,
1263                                 const Standard_Boolean              ,
1264                                 const Standard_Boolean              ,
1265                                 const math_Vector&                  )
1266 {
1267   Standard_Failure::Raise("SimulSurf Not Implemented");
1268 }
1269 //------------------------MODIFS---------------------------------------
1270 //=======================================================================
1271 //function : PerformFirstSection
1272 //purpose  : to implement the first section if there is no KPart
1273 //=======================================================================
1274
1275 Standard_Boolean ChFi3d_ChBuilder::PerformFirstSection
1276 (const Handle(ChFiDS_Spine)&         Spine,
1277  const Handle(ChFiDS_HElSpine)&      HGuide,
1278  const Standard_Integer              Choix,
1279  Handle(BRepAdaptor_HSurface)&       S1,
1280  Handle(BRepAdaptor_HSurface)&       S2,
1281  const Handle(Adaptor3d_TopolTool)&    I1,
1282  const Handle(Adaptor3d_TopolTool)&    I2,
1283  const Standard_Real                 Par,
1284  math_Vector&                        SolDep,
1285  TopAbs_State&                       Pos1,
1286  TopAbs_State&                       Pos2) const 
1287 {
1288   Handle(ChFiDS_ChamfSpine) 
1289     chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Spine);
1290   
1291   if (chsp.IsNull()) 
1292     Standard_ConstructionError::Raise
1293       ("PerformSurf : this is not the spine of a chamfer");
1294
1295   Standard_Real TolGuide = HGuide->Resolution(tolesp) ;
1296
1297
1298   if (chsp->IsChamfer() == ChFiDS_Sym) {
1299     Standard_Real dis;
1300     chsp->GetDist(dis);
1301     
1302     BRepBlend_Chamfer Func(S1,S2,HGuide);
1303     Func.Set(dis,dis,Choix);
1304     BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
1305     
1306     //calculate an approximate starting solution
1307     gp_Vec TgF, TgL, tmp1, tmp2, d1gui;
1308     gp_Pnt pt1, pt2, ptgui;
1309     gp_XYZ temp;
1310     
1311     ( HGuide->Curve() ).D1(Par,ptgui,d1gui);
1312     //  ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
1313     
1314     Func.Set(Par);
1315     Func.Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
1316     
1317     Standard_Boolean rev1 = Standard_False;
1318     Standard_Boolean rev2 = Standard_False;
1319     Standard_Real    sign = (TgF.Crossed(d1gui)).Dot(TgL);
1320   
1321     if( Choix%2 == 1 )
1322       rev1 = Standard_True;
1323     else
1324       rev2 = Standard_True;
1325     
1326     if( sign < 0. ){
1327       rev1 = !rev1;
1328       rev2 = !rev2;
1329     }
1330     
1331     if( rev1 )
1332       TgF.Reverse();
1333     if( rev2 )
1334       TgL.Reverse();
1335     
1336     temp = (TgF.XYZ()).Multiplied(dis);
1337     pt1.SetXYZ( (ptgui.XYZ()).Added(temp) );
1338     temp = (TgL.XYZ()).Multiplied(dis);
1339     pt2.SetXYZ( (ptgui.XYZ()).Added(temp) );
1340     
1341     Standard_Real tol = tolesp*1.e2;
1342 //    Standard_Real u,v;
1343     Extrema_GenLocateExtPS proj1(S1->Surface(), tol, tol);
1344     proj1.Perform(pt1, SolDep(1), SolDep(2));
1345     Extrema_GenLocateExtPS proj2(S2->Surface(), tol, tol);
1346     proj2.Perform(pt2, SolDep(3), SolDep(4));
1347
1348     if( proj1.IsDone() ){
1349       (proj1.Point()).Parameter(SolDep(1),SolDep(2)); 
1350     }
1351     if( proj2.IsDone() ){
1352       (proj2.Point()).Parameter(SolDep(3),SolDep(4)); 
1353     }
1354     
1355     return TheWalk.PerformFirstSection(Func,Par,SolDep,
1356                                        tolesp,TolGuide,Pos1,Pos2);
1357   }
1358   else if (chsp->IsChamfer() == ChFiDS_TwoDist)  {
1359     Standard_Real dis1, dis2;
1360     chsp->Dists(dis1, dis2);
1361     
1362     BRepBlend_Chamfer Func(S1,S2,HGuide);
1363     Func.Set(dis1,dis2,Choix);
1364     BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
1365     
1366     //calculate an approximate starting solution
1367     gp_Vec TgF, TgL, tmp1, tmp2, d1gui;
1368     gp_Pnt pt1, pt2, ptgui;
1369     gp_XYZ temp;
1370     
1371     ( HGuide->Curve() ).D1(Par,ptgui,d1gui);
1372     //  ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
1373     
1374     Func.Set(Par);
1375     Func.Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
1376     
1377     Standard_Boolean rev1 = Standard_False;
1378     Standard_Boolean rev2 = Standard_False;
1379     Standard_Real    sign = (TgF.Crossed(d1gui)).Dot(TgL);
1380   
1381     if( Choix%2 == 1 )
1382       rev1 = Standard_True;
1383     else
1384       rev2 = Standard_True;
1385     
1386     if( sign < 0. ){
1387       rev1 = !rev1;
1388       rev2 = !rev2;
1389     }
1390     
1391     if( rev1 )
1392       TgF.Reverse();
1393     if( rev2 )
1394       TgL.Reverse();
1395     
1396     temp = (TgF.XYZ()).Multiplied(dis1);
1397     pt1.SetXYZ( (ptgui.XYZ()).Added(temp) );
1398     temp = (TgL.XYZ()).Multiplied(dis2);
1399     pt2.SetXYZ( (ptgui.XYZ()).Added(temp) );
1400     
1401     Standard_Real tol = tolesp*1.e2;
1402 //    Standard_Real u,v;
1403
1404     Extrema_GenLocateExtPS proj1(S1->Surface(), tol, tol);
1405     proj1.Perform(pt1, SolDep(1), SolDep(2));
1406     Extrema_GenLocateExtPS proj2(S2->Surface(), tol, tol);
1407     proj2.Perform(pt2, SolDep(3), SolDep(4));
1408
1409     if( proj1.IsDone() ){
1410       (proj1.Point()).Parameter(SolDep(1),SolDep(2)); 
1411     }
1412     if( proj2.IsDone() ){
1413       (proj2.Point()).Parameter(SolDep(3),SolDep(4)); 
1414     }
1415     
1416     return TheWalk.PerformFirstSection(Func,Par,SolDep,
1417                                        tolesp,TolGuide,Pos1,Pos2);
1418   }
1419   else {
1420     Standard_Real dis1, angle;
1421     Standard_Boolean disonF1; 
1422     chsp->GetDistAngle(dis1, angle, disonF1);
1423     
1424     Standard_Integer Ch = FindChoiceDistAngle(Choix, disonF1);
1425     
1426     if (disonF1)  {
1427       BRepBlend_ChAsym Func(S1,S2,HGuide);
1428       Func.Set(dis1, angle, Ch);
1429       BRepBlend_Walking TheWalk(S1,S2,I1,I2,HGuide);
1430     
1431     //calculate an approximate starting solution
1432       gp_Vec TgF, TgL, tmp1, tmp2, d1gui;
1433       gp_Pnt pt1, pt2, ptgui;
1434       gp_XYZ temp;
1435       
1436       ( HGuide->Curve() ).D1(Par,ptgui,d1gui);
1437       //  ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
1438       
1439       Func.Set(Par);
1440       Func.Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
1441       
1442       Standard_Boolean rev1 = Standard_False;
1443       Standard_Boolean rev2 = Standard_False;
1444       Standard_Real    sign = (TgF.Crossed(d1gui)).Dot(TgL);
1445       
1446       if( Ch%2 == 1 )
1447         rev1 = Standard_True;
1448       else
1449         rev2 = Standard_True;
1450       
1451       if( sign < 0. ){
1452         rev1 = !rev1;
1453         rev2 = !rev2;
1454       }
1455       
1456       if( rev1 )
1457         TgF.Reverse();
1458       if( rev2 )
1459         TgL.Reverse();
1460   
1461       temp = (TgF.XYZ()).Multiplied(dis1);
1462       pt1.SetXYZ( (ptgui.XYZ()).Added(temp) );
1463       
1464       Standard_Real dis2, tmpcos, tmpsin;
1465       tmpcos = TgF.Dot(TgL);
1466       tmpsin = sqrt(1. - tmpcos * tmpcos);  
1467       
1468       dis2   = dis1 / (tmpcos + tmpsin / tan(angle)); 
1469       
1470       temp = (TgL.XYZ()).Multiplied(dis2);
1471       pt2.SetXYZ( (ptgui.XYZ()).Added(temp) );
1472       
1473       Standard_Real tol = tolesp*1.e2;
1474 //      Standard_Real u,v;
1475       Extrema_GenLocateExtPS proj1(S1->Surface(), tol, tol);
1476       proj1.Perform(pt1, SolDep(1), SolDep(2));
1477       Extrema_GenLocateExtPS proj2(S2->Surface(), tol, tol);
1478       proj2.Perform(pt2, SolDep(3), SolDep(4));
1479       if( proj1.IsDone() ){
1480         (proj1.Point()).Parameter(SolDep(1),SolDep(2)); 
1481       }
1482       if( proj2.IsDone() ){
1483         (proj2.Point()).Parameter(SolDep(3),SolDep(4)); 
1484       }
1485       
1486       return TheWalk.PerformFirstSection(Func,Par,SolDep,
1487                                          tolesp,TolGuide,Pos1,Pos2);
1488     }
1489     else {
1490       Standard_Real Rtemp;
1491       BRepBlend_ChAsym Func(S2,S1,HGuide);
1492       Func.Set(dis1, angle, Ch);
1493       BRepBlend_Walking TheWalk(S2,S1,I2,I1,HGuide);
1494     
1495     //calculate an approximate starting solution
1496       gp_Vec TgF, TgL, tmp1, tmp2, d1gui;
1497       gp_Pnt pt1, pt2, ptgui;
1498       gp_XYZ temp;
1499       
1500       ( HGuide->Curve() ).D1(Par,ptgui,d1gui);
1501       //  ptgui = (S1->Surface()).Value(SolDep(1),SolDep(2));
1502       Rtemp     = SolDep(1);
1503       SolDep(1) = SolDep(3);
1504       SolDep(3) = Rtemp;
1505       Rtemp     = SolDep(2);
1506       SolDep(2) = SolDep(4);
1507       SolDep(4) = Rtemp;      
1508       Func.Set(Par);
1509
1510       Func.Tangent(SolDep(1),SolDep(2),SolDep(3),SolDep(4),TgF,TgL,tmp1,tmp2);
1511       
1512       Standard_Boolean rev1 = Standard_False;
1513       Standard_Boolean rev2 = Standard_False;
1514       Standard_Real    sign = (TgF.Crossed(d1gui)).Dot(TgL);
1515       
1516       if( Ch%2 == 1 )
1517         rev1 = Standard_True;
1518       else
1519         rev2 = Standard_True;
1520       
1521       if( sign < 0. ){
1522         rev1 = !rev1;
1523         rev2 = !rev2;
1524       }
1525       
1526       if( rev1 )
1527         TgF.Reverse();
1528       if( rev2 )
1529         TgL.Reverse();
1530   
1531       temp = (TgF.XYZ()).Multiplied(dis1);
1532       pt1.SetXYZ( (ptgui.XYZ()).Added(temp) );
1533       
1534       Standard_Real dis2, tmpcos, tmpsin;
1535       tmpcos = TgF.Dot(TgL);
1536       tmpsin = sqrt(1. - tmpcos * tmpcos);  
1537       
1538       dis2   = dis1 / (tmpcos + tmpsin / tan(angle)); 
1539       
1540       temp = (TgL.XYZ()).Multiplied(dis2);
1541       pt2.SetXYZ( (ptgui.XYZ()).Added(temp) );
1542       
1543       Standard_Real tol = tolesp*1.e2;
1544 //      Standard_Real u,v;
1545       Extrema_GenLocateExtPS proj1(S2->Surface(), tol, tol);
1546       proj1.Perform(pt1, SolDep(1), SolDep(2));
1547       Extrema_GenLocateExtPS proj2(S1->Surface(), tol, tol);
1548       proj2.Perform(pt2, SolDep(3), SolDep(4));
1549       if( proj1.IsDone() ) {
1550         (proj1.Point()).Parameter(SolDep(1),SolDep(2)); 
1551       }
1552       if( proj2.IsDone() ){
1553         (proj2.Point()).Parameter(SolDep(3),SolDep(4)); 
1554       }
1555       
1556       Standard_Boolean RetWalk =  TheWalk.PerformFirstSection(Func,Par,SolDep,
1557                                                               tolesp,TolGuide,Pos2,Pos1);
1558       Rtemp     = SolDep(1);
1559       SolDep(1) = SolDep(3);
1560       SolDep(3) = Rtemp;
1561       Rtemp     = SolDep(2);
1562       SolDep(2) = SolDep(4);
1563       SolDep(4) = Rtemp;
1564
1565       return RetWalk;
1566     }
1567   }
1568 }
1569
1570
1571 //=======================================================================
1572 //function : PerformSurf
1573 //purpose  : 
1574 //=======================================================================
1575
1576 Standard_Boolean  
1577 ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&          SeqData,
1578                               const Handle(ChFiDS_HElSpine)&      HGuide,
1579                               const Handle(ChFiDS_Spine)&         Spine,
1580                               const Standard_Integer              Choix,
1581                               const Handle(BRepAdaptor_HSurface)& S1,
1582                               const Handle(Adaptor3d_TopolTool)&    I1,
1583                               const Handle(BRepAdaptor_HSurface)& S2,
1584                               const Handle(Adaptor3d_TopolTool)&    I2,
1585                               const Standard_Real                 MaxStep,
1586                               const Standard_Real                 Fleche,
1587                               const Standard_Real                 TolGuide,
1588                               Standard_Real&                      First,
1589                               Standard_Real&                      Last,
1590                               const Standard_Boolean              Inside,
1591                               const Standard_Boolean              Appro,
1592                               const Standard_Boolean              Forward,
1593                               const Standard_Boolean              RecOnS1,
1594                               const Standard_Boolean              RecOnS2,
1595                               const math_Vector&                  Soldep,
1596                               Standard_Integer&                   intf,
1597                               Standard_Integer&                   intl)
1598      
1599 {
1600   Handle(ChFiDS_SurfData) Data = SeqData(1);
1601   Handle(ChFiDS_ChamfSpine) 
1602     chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Spine);
1603   
1604   if (chsp.IsNull()) 
1605     Standard_ConstructionError::Raise
1606       ("PerformSurf : this is not the spine of a chamfer");
1607   
1608   Standard_Boolean gd1,gd2,gf1,gf2;
1609   Handle(BRepBlend_Line) lin;
1610   TopAbs_Orientation Or = S1->ChangeSurface().Face().Orientation();
1611   Standard_Real PFirst = First;
1612   if(intf) First = chsp->FirstParameter(1);
1613   if(intl) Last = chsp->LastParameter(chsp->NbEdges());
1614
1615   if (chsp->IsChamfer() == ChFiDS_Sym) {
1616     BRepBlend_Chamfer  Func(S1,S2,HGuide);
1617     BRepBlend_ChamfInv FInv(S1,S2,HGuide);
1618     Standard_Real dis;
1619     chsp->GetDist(dis);
1620     Func.Set(dis, dis, Choix);
1621     FInv.Set(dis, dis, Choix);
1622       
1623     done = ComputeData(Data,HGuide,Spine,lin,S1,I1,S2,I2,Func,FInv,
1624                        PFirst,MaxStep,Fleche,TolGuide,First,Last,
1625                        Inside,Appro,Forward,Soldep,intf,intl,
1626                        gd1,gd2,gf1,gf2,RecOnS1,RecOnS2);
1627     if(!done) return Standard_False; // ratrappage possible PMN 14/05/1998
1628     done = CompleteData(Data,Func,lin,S1,S2,Or,gd1,gd2,gf1,gf2);
1629     if(!done) Standard_Failure::Raise("PerformSurf : Fail of approximation!");
1630   }
1631   else if (chsp->IsChamfer() == ChFiDS_TwoDist) {
1632     BRepBlend_Chamfer  Func(S1,S2,HGuide);
1633     BRepBlend_ChamfInv FInv(S1,S2,HGuide);
1634     Standard_Real d1, d2;
1635     chsp->Dists(d1,d2);
1636     Func.Set(d1,d2,Choix);
1637     FInv.Set(d1,d2,Choix);
1638     
1639     done = ComputeData(Data,HGuide,Spine,lin,S1,I1,S2,I2,Func,FInv,
1640                        PFirst,MaxStep,Fleche,TolGuide,First,Last,
1641                        Inside,Appro,Forward,Soldep,intf,intl,
1642                        gd1,gd2,gf1,gf2,RecOnS1,RecOnS2);
1643     if(!done) return Standard_False; // ratrappage possible PMN 14/05/1998
1644     done = CompleteData(Data,Func,lin,S1,S2,Or,gd1,gd2,gf1,gf2);
1645     if(!done) Standard_Failure::Raise("PerformSurf : Fail of approximation!");
1646   }
1647   else {
1648     Standard_Real d1, angle;
1649     Standard_Boolean disonF1;
1650     chsp->GetDistAngle(d1, angle, disonF1);
1651     
1652     Standard_Integer Ch = FindChoiceDistAngle(Choix, disonF1);
1653
1654     if (disonF1) {
1655       BRepBlend_ChAsym  Func(S1,S2,HGuide);
1656       BRepBlend_ChAsymInv FInv(S1,S2,HGuide);
1657       Func.Set(d1, angle, Ch);
1658       FInv.Set(d1, angle, Ch);
1659     
1660       done = ComputeData(Data,HGuide,Spine,lin,S1,I1,S2,I2,Func,FInv,
1661                          PFirst,MaxStep,Fleche,TolGuide,First,Last,
1662                          Inside,Appro,Forward,Soldep,intf,intl,
1663                          gd1,gd2,gf1,gf2,RecOnS1,RecOnS2);
1664
1665       if(!done) return Standard_False; // ratrappage possible PMN 14/05/1998
1666       done = CompleteData(Data,Func,lin,S1,S2,Or,gd1,gd2,gf1,gf2);
1667       if(!done) Standard_Failure::Raise("PerformSurf : Fail of approximation!");
1668     }
1669     else {
1670       Standard_Real Rtemp;
1671       BRepBlend_ChAsym  Func(S2, S1, HGuide);
1672       BRepBlend_ChAsymInv FInv(S2, S1,HGuide);
1673       Func.Set(d1, angle, Ch);
1674       FInv.Set(d1, angle, Ch);
1675
1676       Rtemp     = Soldep(1);
1677       Soldep(1) = Soldep(3);
1678       Soldep(3) = Rtemp;
1679       Rtemp     = Soldep(2);
1680       Soldep(2) = Soldep(4);
1681       Soldep(4) = Rtemp;
1682
1683       TopAbs_Orientation Or2 = S2->ChangeSurface().Face().Orientation();
1684
1685       done = ComputeData(Data,HGuide,Spine,lin,S2,I2,S1,I1,Func,FInv,
1686                          PFirst,MaxStep,Fleche,TolGuide,First,Last,
1687                          Inside,Appro,Forward,Soldep,intf,intl,
1688                          gd2,gd1,gf2,gf1,RecOnS2,RecOnS1);
1689
1690       ChFiDS_CommonPoint tmp = Data->VertexFirstOnS1();
1691       Data->ChangeVertexFirstOnS1() = Data->VertexFirstOnS2();
1692       Data->ChangeVertexFirstOnS2() = tmp;
1693       tmp = Data->VertexLastOnS1();
1694       Data->ChangeVertexLastOnS1() = Data->VertexLastOnS2();
1695       Data->ChangeVertexLastOnS2() = tmp;
1696       if(!done) return Standard_False; // ratrappage possible PMN 14/05/1998
1697       done = CompleteData(Data,Func,lin,S1,S2,Or2,gd1,gd2,gf1,gf2, Standard_True);
1698       if(!done) Standard_Failure::Raise("PerformSurf : Fail of approximation!");
1699     }      
1700
1701   }
1702   return Standard_True;
1703 }
1704 void  ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&          ,
1705                                   const Handle(ChFiDS_HElSpine)&      , 
1706                                   const Handle(ChFiDS_Spine)&         , 
1707                                   const Standard_Integer              ,
1708                                   const Handle(BRepAdaptor_HSurface)& ,
1709                                   const Handle(Adaptor3d_TopolTool)&    ,
1710                                   const Handle(BRepAdaptor_HCurve2d)& ,
1711                                   const Handle(BRepAdaptor_HSurface)& ,
1712                                   const Handle(BRepAdaptor_HCurve2d)& ,
1713                                   Standard_Boolean&                   ,
1714                                   const Handle(BRepAdaptor_HSurface)& ,
1715                                   const Handle(Adaptor3d_TopolTool)&    ,
1716                                   const TopAbs_Orientation            ,
1717                                   const Standard_Real                 ,
1718                                   const Standard_Real                 ,
1719                                   const Standard_Real                 ,
1720                                   Standard_Real&                      ,
1721                                   Standard_Real&                      ,
1722                                   const Standard_Boolean              ,
1723                                   const Standard_Boolean              ,
1724                                   const Standard_Boolean              ,
1725                                   const Standard_Boolean              ,
1726                                   const Standard_Boolean              ,
1727                                   const Standard_Boolean              ,
1728                                   const math_Vector&                  )
1729 {
1730   Standard_Failure::Raise("PerformSurf Not Implemented");
1731 }
1732 void  ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&          ,
1733                                   const Handle(ChFiDS_HElSpine)&      , 
1734                                   const Handle(ChFiDS_Spine)&         , 
1735                                   const Standard_Integer              ,
1736                                   const Handle(BRepAdaptor_HSurface)& ,
1737                                   const Handle(Adaptor3d_TopolTool)&    ,
1738                                   const TopAbs_Orientation            ,
1739                                   const Handle(BRepAdaptor_HSurface)& ,
1740                                   const Handle(Adaptor3d_TopolTool)&    ,
1741                                   const Handle(BRepAdaptor_HCurve2d)& ,
1742                                   const Handle(BRepAdaptor_HSurface)& ,
1743                                   const Handle(BRepAdaptor_HCurve2d)& ,
1744                                   Standard_Boolean&                   ,
1745                                   const Standard_Real                 ,
1746                                   const Standard_Real                 ,
1747                                   const Standard_Real                 ,
1748                                   Standard_Real&                      ,
1749                                   Standard_Real&                      ,
1750                                   const Standard_Boolean              ,
1751                                   const Standard_Boolean              ,
1752                                   const Standard_Boolean              ,
1753                                   const Standard_Boolean              ,
1754                                   const Standard_Boolean              ,
1755                                   const Standard_Boolean              ,
1756                                   const math_Vector&                  )
1757 {
1758   Standard_Failure::Raise("PerformSurf Not Implemented");
1759
1760 }
1761 void  ChFi3d_ChBuilder::PerformSurf(ChFiDS_SequenceOfSurfData&          ,
1762                                   const Handle(ChFiDS_HElSpine)&      ,
1763                                   const Handle(ChFiDS_Spine)&         ,
1764                                   const Standard_Integer              ,
1765                                   const Handle(BRepAdaptor_HSurface)& ,
1766                                   const Handle(Adaptor3d_TopolTool)&    ,
1767                                   const Handle(BRepAdaptor_HCurve2d)& ,
1768                                   const Handle(BRepAdaptor_HSurface)& ,
1769                                   const Handle(BRepAdaptor_HCurve2d)& ,
1770                                   Standard_Boolean&                   ,
1771                                   const TopAbs_Orientation            ,
1772                                   const Handle(BRepAdaptor_HSurface)& ,
1773                                   const Handle(Adaptor3d_TopolTool)&    ,
1774                                   const Handle(BRepAdaptor_HCurve2d)& ,
1775                                   const Handle(BRepAdaptor_HSurface)& ,
1776                                   const Handle(BRepAdaptor_HCurve2d)& ,
1777                                   Standard_Boolean&                   ,
1778                                   const TopAbs_Orientation            ,
1779                                   const Standard_Real                 ,
1780                                   const Standard_Real                 ,
1781                                   const Standard_Real                 ,
1782                                   Standard_Real&                      ,
1783                                   Standard_Real&                      ,
1784                                   const Standard_Boolean              ,
1785                                   const Standard_Boolean              ,
1786                                   const Standard_Boolean              ,
1787                                   const Standard_Boolean              ,
1788                                   const Standard_Boolean              ,
1789                                   const Standard_Boolean              ,
1790                                   const Standard_Boolean              ,
1791                                   const math_Vector&                  )
1792 {
1793   Standard_Failure::Raise("PerformSurf Not Implemented");
1794
1795 }
1796 //=======================================================================
1797 //function : ExtentOneCorner
1798 //purpose  : extends the spine of the stripe S on the side of the vertex V
1799 // PMN : 28/11/97 : Reproduces the code of fillets, and it seems to work better...
1800 //=======================================================================
1801
1802 void ChFi3d_ChBuilder::ExtentOneCorner(const TopoDS_Vertex&          V,
1803                                        const Handle(ChFiDS_Stripe)&  S)
1804 {
1805   Standard_Integer      Sens = 0;
1806   Standard_Real         Coeff = 0.5;
1807   Handle(ChFiDS_Spine)  Spine = S->Spine();
1808   ChFi3d_IndexOfSurfData(V,S,Sens);
1809   if (Spine->IsTangencyExtremity((Sens == 1))) return; //No extension on queue
1810   Standard_Real dU = Spine->LastParameter(Spine->NbEdges());
1811   if (Sens == 1) {
1812     Spine->SetFirstParameter(-dU*Coeff);
1813     Spine->SetFirstTgt(0.);
1814   }
1815   else {
1816     Spine->SetLastParameter(dU*(1.+Coeff));
1817     Spine->SetLastTgt(dU);
1818   }
1819 /*
1820   Standard_Integer Sens;
1821   Standard_Boolean isfirst;
1822   Standard_Integer Iedge = 1;
1823   Standard_Real d1, d2;
1824
1825   Handle(ChFiDS_Spine) Spine = S->Spine();
1826   Handle(ChFiDS_ChamfSpine)
1827       chsp = Handle(ChFiDS_ChamfSpine)::DownCast(Spine);
1828   chsp->Dists(d1,d2); 
1829   Standard_Integer IE = ChFi3d_IndexOfSurfData(V,S,Sens);
1830   isfirst = (Sens == 1);
1831   if (!isfirst)  
1832     Iedge = Spine->NbEdges();
1833  
1834   TopTools_ListIteratorOfListOfShape It, Jt;
1835   TopoDS_Edge E1, E2, Ec;
1836   TopoDS_Face F1, F2, Fc;
1837   TopoDS_Edge EdgeSp = Spine->Edges(Iedge);
1838
1839   ConexFaces(Spine,Iedge,F1,F2);
1840
1841   for (Jt.Initialize(myVEMap(V));Jt.More();Jt.Next()) {
1842     Ec = TopoDS::Edge(Jt.Value());
1843     if (!Ec.IsSame(EdgeSp)){
1844       for (It.Initialize(myEFMap(Ec));It.More();It.Next()) {
1845         Fc = TopoDS::Face(It.Value());
1846         if (Fc.IsSame(F1))
1847           E1 = Ec;
1848         else if (Fc.IsSame(F2))
1849           E2 = Ec;
1850       } 
1851     }
1852   }
1853
1854   gp_Vec tg1, tg2, tgsp;
1855   gp_Pnt tmp, ptgui;
1856   Spine->D1(Spine->Absc(V),ptgui,tgsp);
1857   if (isfirst)
1858     tgsp.Reverse();
1859
1860   // tg1
1861   BRepAdaptor_Curve curv;
1862   curv.Initialize(E1);
1863   curv.D1(curv.FirstParameter(),tmp,tg1); //pour eviter les projections
1864   tg1.Reverse();
1865     // pbm d'erreurs d'approx : baisser la tolerance
1866   if( !tmp.IsEqual(ptgui,tolesp*1.e2) )
1867     curv.D1(curv.LastParameter(),tmp,tg1);
1868
1869   // tg2
1870   curv.Initialize(E2);
1871   curv.D1(curv.FirstParameter(),tmp,tg2);
1872   tg2.Reverse();
1873   if( !tmp.IsEqual(ptgui,tolesp*1.e2) )
1874     curv.D1(curv.LastParameter(),tmp,tg2);
1875
1876   // calcul de dspine
1877   Standard_Real dspine;
1878   Standard_Real d1plus = 0.;
1879   Standard_Real d2plus = 0.;
1880
1881   Standard_Real sinalpha = tg1.Dot(tgsp);
1882   if (sinalpha < 0.){
1883     Standard_Real cosalpha = Sqrt(1 - sinalpha*sinalpha);
1884     d1plus = -d1*sinalpha/cosalpha;
1885   }
1886   sinalpha = tg2.Dot(tgsp);
1887   if (sinalpha < 0.){
1888     Standard_Real cosalpha = Sqrt(1 - sinalpha*sinalpha);
1889     d2plus = -d2*sinalpha/cosalpha;
1890   }
1891   dspine = d1plus;
1892   if (d2plus > d1plus)
1893     dspine = d2plus;
1894
1895   dspine *=1.5;
1896
1897   // ExtentOneCorner
1898   if (isfirst) {
1899     Spine->SetFirstParameter(-dspine);
1900     Spine->SetFirstTgt(0.);
1901   }
1902   else{
1903     Standard_Real param = Spine->LastParameter(Spine->NbEdges());
1904     Spine->SetLastParameter(param+dspine);
1905     Spine->SetLastTgt(param);
1906   } */
1907 }
1908
1909
1910
1911 //=======================================================================
1912 //function : ExtentTwoCorner
1913 //purpose  : extends the spines of the stripes contained in the list LS,
1914 //           on the side of the vertex V
1915 //=======================================================================
1916
1917
1918 void ChFi3d_ChBuilder::ExtentTwoCorner(const TopoDS_Vertex&        V,
1919                                        const ChFiDS_ListOfStripe&  LS)
1920 {
1921   Standard_Integer Sens = 0;
1922   ChFiDS_ListIteratorOfListOfStripe itel(LS);
1923   Standard_Boolean FF = Standard_True;
1924   Standard_Boolean isfirst[2];
1925   Standard_Integer Iedge[2];
1926   Iedge[0] = 1;
1927   Iedge[1] = 1;
1928   Handle(ChFiDS_Stripe) Stripe[2];
1929   Handle(ChFiDS_Spine) Spine[2];
1930
1931   Standard_Integer i = 0;
1932   for (; itel.More(); itel.Next(),i++) {    
1933   ChFi3d_IndexOfSurfData(V,itel.Value(),Sens);
1934     if (!FF)
1935       if ( Stripe[1] == itel.Value())
1936         Sens = -Sens; 
1937     
1938     Stripe[i] = itel.Value();
1939     isfirst[i] = (Sens == 1);
1940     Spine[i] = Stripe[i]->Spine();
1941     if( !isfirst[i] )
1942       Iedge[i] = Spine[i]->NbEdges();
1943     FF = Standard_False;
1944   }
1945
1946
1947   Handle(ChFiDS_ChamfSpine) chsp[2];
1948   Standard_Real d[4], dis[2] = { 0.0, 0.0 };
1949   Standard_Integer j;
1950   TopoDS_Face F[4];
1951   Standard_Real tmpang, tmd;
1952   Standard_Boolean disonF1;
1953
1954
1955   for (i=0, j=0; i<2; i++, j += 2) {
1956     chsp[i] = Handle(ChFiDS_ChamfSpine)::DownCast(Spine[i]);
1957     ConexFaces(Spine[i],Iedge[i],F[j],F[j+1]);
1958
1959     if (chsp[i]->IsChamfer() == ChFiDS_Sym) {
1960       chsp[i]->GetDist(d[j]);
1961       d[j+1] = d[j]; 
1962     }
1963     else if (chsp[i]->IsChamfer() == ChFiDS_TwoDist) {
1964       chsp[i]->Dists(d[j],d[j+1]); 
1965     }
1966     else {
1967       chsp[i]->GetDistAngle(tmd, tmpang, disonF1);
1968       // an approximate calculation of distance 2 is done
1969       if (disonF1) {
1970         d[j]   = tmd;
1971         d[j+1] = tmd * tan(tmpang); 
1972       }
1973       else
1974       {
1975         d[j]   = tmd * tan(tmpang);
1976         d[j+1] = tmd;
1977       }
1978     }
1979
1980   }
1981
1982   Standard_Boolean notfound = Standard_True;
1983   i = 0; 
1984   while (notfound && (i<2)) {
1985     j = 0;
1986     while (notfound && (j<2)) {
1987       if (F[i].IsSame(F[j+2])) {
1988         dis[0] = d[i];
1989 //      dOnArc[0] = d[(i+1)%2];
1990
1991         dis[1] = d[j + 2];
1992 //      dOnArc[1] = d[(j+1)%2 + 2];
1993         notfound = Standard_False;
1994       }
1995       j++;
1996     }
1997     i++;
1998   }
1999   // ExtentTwoCorner
2000
2001   ChFiDS_State State[2];
2002
2003   for (i=0; i<2; i++) {
2004     if (isfirst[i])
2005       State[i] = Spine[i]->FirstStatus();
2006     else
2007       State[i] = Spine[i]->LastStatus();
2008  }
2009   
2010   if (State[0] == ChFiDS_AllSame ){
2011 /*      
2012    // The greatest intersection of the chamfer is found (on the incident edge)
2013     // with the face at end
2014     i = 0;
2015     j = 1;
2016     if(dOnArc[j] > dOnArc[i]) {
2017       Standard_Integer temp = i;
2018       i = j;
2019       j = temp;
2020     }
2021     ExtentOneCorner( V, Stripe[i] ); */
2022
2023     // it is necessary that two chamfers touch the face at end 
2024     for (j=0; j<2; j++)
2025       ExtentOneCorner( V, Stripe[j] ); 
2026   }
2027   else if ((State[0] == ChFiDS_OnSame) && (State[1] == ChFiDS_OnSame)) {
2028
2029     ExtentSpineOnCommonFace(Spine[0],Spine[1],V,dis[0],dis[1],
2030                             isfirst[0],isfirst[1]);
2031   }
2032
2033 }
2034
2035 //=======================================================================
2036 //function : ExtentThreeCorner
2037 //purpose  : 
2038 //=======================================================================
2039
2040 void ChFi3d_ChBuilder::ExtentThreeCorner(const TopoDS_Vertex& V,
2041                                          const ChFiDS_ListOfStripe& LS)
2042 {
2043   Standard_Integer Sens = 0;
2044   ChFiDS_ListOfStripe check;
2045   Standard_Boolean isfirst[3];
2046   Standard_Integer Iedge[3];
2047   Iedge[0] = 1;
2048   Iedge[1] = 1;
2049   Iedge[2] = 1;  
2050   Handle(ChFiDS_Spine) Spine[3];
2051
2052   Standard_Integer i = 0;
2053   for(ChFiDS_ListIteratorOfListOfStripe itel(LS); itel.More(); itel.Next(), i++) {    
2054     Handle(ChFiDS_Stripe) Stripe = itel.Value(); 
2055     ChFi3d_IndexOfSurfData(V,Stripe,Sens);
2056     for(ChFiDS_ListIteratorOfListOfStripe ich(check); ich.More(); ich.Next()){
2057       if(Stripe == ich.Value()){
2058         Sens = -Sens;
2059         break;
2060       }
2061     }
2062
2063     isfirst[i] = (Sens == 1);
2064     Spine[i] = Stripe->Spine();
2065     if( !isfirst[i] )
2066       Iedge[i] = Spine[i]->NbEdges();
2067
2068     check.Append(Stripe);
2069   }
2070   
2071   Standard_Real d[3][2], tmd, tmpangle;
2072   Standard_Boolean disonF1;
2073   Standard_Integer j;
2074   TopoDS_Face F[3][2];
2075
2076   Handle(ChFiDS_ChamfSpine) chsp[3];
2077
2078   for (i=0; i<3; i++) {
2079     chsp[i] = Handle(ChFiDS_ChamfSpine)::DownCast(Spine[i]);
2080     ConexFaces(Spine[i],Iedge[i],F[i][0],F[i][1]);
2081
2082     if (chsp[i]->IsChamfer() == ChFiDS_Sym) {
2083       chsp[i]->GetDist(d[i][0]); 
2084       d[i][1] = d[i][0];
2085     }
2086     else if (chsp[i]->IsChamfer() == ChFiDS_TwoDist) {
2087        chsp[i]->Dists(d[i][0],d[i][1]); 
2088     }
2089     else {
2090       chsp[i]->GetDistAngle(tmd, tmpangle, disonF1);
2091       // an approximate calculation of distance 2 is done
2092
2093       if (disonF1) {
2094         d[i][0] = tmd;
2095         d[i][1] = tmd * tan(tmpangle); 
2096       }
2097       else {
2098         d[i][0] = tmd * tan(tmpangle);
2099         d[i][1] = tmd;
2100       }     
2101     }
2102   }
2103
2104
2105   // dis[i][j] distance from chamfer i on the common face with 
2106   // chamfer j
2107   Standard_Real dis[3][3];
2108
2109   for (i=0; i<3; i++) {
2110 //    for (Standard_Integer ii=0; ii<3; ii++) {
2111 //      j = (i+ii)%3;
2112       j = (i+1)%3;
2113       Standard_Boolean notfound = Standard_True;
2114       Standard_Integer k, l;
2115       k = 0;
2116       while (notfound && (k<2)) {
2117         l = 0;
2118         while (notfound && (l<2)) {
2119           if (F[i][k].IsSame(F[j][l])) {
2120             dis[i][j] = d[i][k];
2121             dis[j][i] = d[j][l];
2122             notfound = Standard_False;
2123           }
2124           l++;
2125         }
2126         k++;
2127       } 
2128 //    }
2129   }
2130    
2131   //ExtentThreeCorner
2132   for (i=0; i<3; i++) {
2133     j = (i+1)%3;
2134     ExtentSpineOnCommonFace(Spine[i],Spine[j],V,dis[i][j],dis[j][i],
2135                             isfirst[i],isfirst[j]);
2136   }
2137
2138 }
2139
2140 //=======================================================================
2141 //function : SetRegul
2142 //purpose  : 
2143 //=======================================================================
2144
2145 void ChFi3d_ChBuilder::SetRegul()
2146
2147 {
2148   ChFiDS_ListIteratorOfRegularities it;
2149   TopTools_ListIteratorOfListOfShape itc;
2150   TopTools_ListIteratorOfListOfShape its1;
2151   TopTools_ListIteratorOfListOfShape its2;
2152   BRepAdaptor_Surface S;
2153   BRepAdaptor_Curve2d PC;
2154   Standard_Real u,v,t;
2155   gp_Pnt p;
2156   gp_Vec n1,n2,du,dv;
2157   BRep_Builder B;
2158   Standard_Real Seuil = M_PI/360.;
2159   Standard_Real Seuil2 = Seuil * Seuil;
2160   for (it.Initialize(myRegul); it.More(); it.Next()){
2161     const ChFiDS_Regul& reg = it.Value();
2162     itc.Initialize(myCoup->NewEdges(reg.Curve()));
2163     if(itc.More()){
2164       TopoDS_Edge E = TopoDS::Edge(itc.Value());
2165       if(reg.IsSurface1() && reg.IsSurface2()){
2166         its1.Initialize(myCoup->NewFaces(reg.S1()));
2167         its2.Initialize(myCoup->NewFaces(reg.S2()));
2168         if(its1.More() && its2.More()){
2169           TopoDS_Face F1 = TopoDS::Face(its1.Value());
2170           TopoDS_Face F2 = TopoDS::Face(its2.Value());
2171           S.Initialize(F1,Standard_False);
2172           PC.Initialize(E,F1);
2173           t = 0.5*(PC.FirstParameter() + PC.LastParameter());
2174           PC.Value(t).Coord(u,v);
2175           S.D1(u,v,p,du,dv);
2176           n1 = du.Crossed(dv);
2177
2178           S.Initialize(F2,Standard_False);
2179           PC.Initialize(E,F2);
2180           PC.Value(t).Coord(u,v);
2181           S.D1(u,v,p,du,dv);
2182           n2 = du.Crossed(dv);
2183           
2184           if(n1.SquareMagnitude() > 1.e-14 && n2.SquareMagnitude() > 1.e-14){
2185             n1.Normalize();
2186             n2.Normalize();
2187             Standard_Real sina2 = n1.Crossed(n2).SquareMagnitude();
2188             if(sina2 < Seuil2) {
2189               GeomAbs_Shape cont = ChFi3d_evalconti(E,F1,F2);
2190               B.Continuity(E,F1,F2,cont);
2191             }
2192           }
2193         }
2194       }
2195     }
2196   }
2197 }
2198
2199 //=======================================================================
2200 //function : ConexFaces
2201 //purpose  : F1, F2 are connected to edge so that F1 corresponds to distance
2202 //=======================================================================
2203
2204 void ChFi3d_ChBuilder::ConexFaces (const Handle(ChFiDS_Spine)&  Spine,
2205                                    const Standard_Integer       IEdge,
2206                                    TopoDS_Face&                 F1,
2207                                    TopoDS_Face&                 F2) const
2208 {
2209   BRepAdaptor_Surface Sb1,Sb2;
2210   TopAbs_Orientation tmp1,tmp2;
2211   Standard_Integer RC,Choix;
2212   TopoDS_Face f1,f2,ff1,ff2;
2213
2214   //calculate the reference orientation
2215   // ChFi3d_Builder::StripeOrientations is private
2216   SearchCommonFaces(myEFMap,Spine->Edges(1),ff1,ff2);
2217   ff1.Orientation(TopAbs_FORWARD);
2218   Sb1.Initialize(ff1);
2219   ff2.Orientation(TopAbs_FORWARD);
2220   Sb2.Initialize(ff2);
2221   RC = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(1),tmp1,tmp2);
2222                                   
2223   //calculate the connected faces
2224   SearchCommonFaces(myEFMap,Spine->Edges(IEdge),f1,f2);
2225   Sb1.Initialize(f1);
2226   Sb2.Initialize(f2);
2227   Choix = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(IEdge),tmp1,tmp2);
2228
2229   if (RC%2 != Choix%2) {
2230     F1 = f2;
2231     F2 = f1;
2232   }
2233   else {
2234     F1 = f1;
2235     F2 = f2;
2236   }
2237 }
2238
2239
2240 //=======================================================================
2241 //function : FindChoiceDistAngle
2242 //purpose  : F1, F2 connected to the edge so that F1 corresponds to distance
2243 //=======================================================================
2244
2245 Standard_Integer ChFi3d_ChBuilder::FindChoiceDistAngle(const Standard_Integer Choice,
2246                                                        const Standard_Boolean DisOnF1) const
2247 {
2248   Standard_Integer ch = 0;  
2249   if (!DisOnF1) {
2250
2251     switch (Choice) {
2252       case 1 : ch = 2;
2253                break;
2254       case 2 : ch = 1;
2255                break;
2256       case 3 : ch = 8;
2257                break;
2258       case 4 : ch = 7;
2259                break;
2260       case 5 : ch = 6;
2261                break;
2262       case 6 : ch = 5;
2263                break;
2264       case 7 : ch = 4;
2265                break;
2266       case 8 : ch = 3;
2267                break;
2268     }
2269
2270   }
2271   else
2272     ch = Choice;
2273  
2274   return ch;
2275 }