ff19e6a163639cde76bd777d9903b2206b6545ce
[occt.git] / src / ChFi3d / ChFi3d_Builder_2.cxx
1 // Created on: 1993-12-15
2 // Created by: Isabelle GRIGNON
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17
18 #include <Adaptor2d_HCurve2d.hxx>
19 #include <Adaptor3d_HSurface.hxx>
20 #include <Adaptor3d_TopolTool.hxx>
21 #include <AppBlend_Approx.hxx>
22 #include <Blend_CurvPointFuncInv.hxx>
23 #include <Blend_FuncInv.hxx>
24 #include <Blend_Function.hxx>
25 #include <Blend_RstRstFunction.hxx>
26 #include <Blend_SurfCurvFuncInv.hxx>
27 #include <Blend_SurfPointFuncInv.hxx>
28 #include <Blend_SurfRstFunction.hxx>
29 #include <BRep_Tool.hxx>
30 #include <BRepAdaptor_Curve.hxx>
31 #include <BRepAdaptor_HCurve.hxx>
32 #include <BRepAdaptor_HCurve2d.hxx>
33 #include <BRepAdaptor_HSurface.hxx>
34 #include <BRepAdaptor_Surface.hxx>
35 #include <BRepBlend_Line.hxx>
36 #include <BRepLib_MakeFace.hxx>
37 #include <BRepLProp_SLProps.hxx>
38 #include <BRepTools.hxx>
39 #include <BRepTools_WireExplorer.hxx>
40 #include <BRepTopAdaptor_TopolTool.hxx>
41 #include <ChFi3d.hxx>
42 #include <ChFi3d_Builder.hxx>
43 #include <ChFi3d_Builder_0.hxx>
44 #include <ChFiDS_ChamfSpine.hxx>
45 #include <ChFiDS_CommonPoint.hxx>
46 #include <ChFiDS_ElSpine.hxx>
47 #include <ChFiDS_ErrorStatus.hxx>
48 #include <ChFiDS_FaceInterference.hxx>
49 #include <ChFiDS_FilSpine.hxx>
50 #include <ChFiDS_HData.hxx>
51 #include <ChFiDS_HElSpine.hxx>
52 #include <ChFiDS_ListIteratorOfListOfHElSpine.hxx>
53 #include <ChFiDS_ListOfHElSpine.hxx>
54 #include <ChFiDS_SequenceOfSurfData.hxx>
55 #include <ChFiDS_Spine.hxx>
56 #include <ChFiDS_State.hxx>
57 #include <ChFiDS_Stripe.hxx>
58 #include <ChFiDS_SurfData.hxx>
59 #include <ChFiKPart_ComputeData.hxx>
60 #include <ElCLib.hxx>
61 #include <Extrema_ExtPC.hxx>
62 #include <Extrema_ExtPS.hxx>
63 #include <Extrema_LocateExtPC.hxx>
64 #include <Extrema_POnCurv.hxx>
65 #include <Geom2d_Curve.hxx>
66 #include <Geom_BSplineCurve.hxx>
67 #include <Geom_BSplineSurface.hxx>
68 #include <Geom_Line.hxx>
69 #include <Geom_Plane.hxx>
70 #include <Geom_Surface.hxx>
71 #include <GeomAdaptor_HCurve.hxx>
72 #include <GeomAdaptor_HSurface.hxx>
73 #include <GeomAdaptor_Surface.hxx>
74 #include <GeomAPI_ProjectPointOnCurve.hxx>
75 #include <gp_Pln.hxx>
76 #include <gp_Pnt.hxx>
77 #include <gp_Pnt2d.hxx>
78 #include <gp_Vec.hxx>
79 #include <gp_XYZ.hxx>
80 #include <math_Vector.hxx>
81 #include <Precision.hxx>
82 #include <Standard_ConstructionError.hxx>
83 #include <Standard_NoSuchObject.hxx>
84 #include <Standard_NotImplemented.hxx>
85 #include <Standard_OutOfRange.hxx>
86 #include <TColgp_Array1OfPnt.hxx>
87 #include <TColgp_Array1OfVec.hxx>
88 #include <TColStd_Array1OfInteger.hxx>
89 #include <TColStd_Array1OfReal.hxx>
90 #include <TColStd_ListOfInteger.hxx>
91 #include <TopAbs.hxx>
92 #include <TopAbs_Orientation.hxx>
93 #include <TopAbs_ShapeEnum.hxx>
94 #include <TopExp.hxx>
95 #include <TopExp_Explorer.hxx>
96 #include <TopoDS.hxx>
97 #include <TopoDS_Edge.hxx>
98 #include <TopoDS_Face.hxx>
99 #include <TopoDS_Shape.hxx>
100 #include <TopoDS_Vertex.hxx>
101 #include <TopoDS_Wire.hxx>
102 #include <TopOpeBRepBuild_HBuilder.hxx>
103 #include <TopOpeBRepDS_HDataStructure.hxx>
104 #include <TopTools_ListIteratorOfListOfShape.hxx>
105
106 #ifdef OCCT_DEBUG
107 #ifdef DRAW
108 #include <DrawTrSurf.hxx>
109 #endif
110 #include <OSD_Chronometer.hxx>
111 extern Standard_Real  t_perfsetofkpart,t_perfsetofkgen,t_makextremities,t_performsurf,t_startsol;
112 extern Standard_Boolean ChFi3d_GettraceCHRON();
113 extern void ChFi3d_InitChron(OSD_Chronometer& ch);
114 extern void ChFi3d_ResultChron(OSD_Chronometer & ch, Standard_Real& time);
115 #endif
116
117
118 //===================================================================
119 //   Definition by a plane   
120 //
121 // It is considered that P1 and P2 are points associated to commonpoints compoint1 and
122 // compoint2, while E1 and E2 are edges containing P1 and P2.
123 // The plane containing three directions D12 T1 T2  ou  D12 represente la direction formee 
124 // par les points P1 et P2, T1 la tangente de E1 en P1 et T2 la tangente de 
125 // E2 en P2 is found (if exists). 
126 // Then fillet HConge is intersected by this plane 
127 // to find associated curve 3d C3d and the curve 2d. 
128 // 
129 //====================================================================
130 static void ChFi3d_CoupeParPlan (const ChFiDS_CommonPoint & compoint1,
131                           const ChFiDS_CommonPoint & compoint2,
132                           Handle(GeomAdaptor_HSurface)& HConge,
133                           const gp_Pnt2d & UV1,
134                           const gp_Pnt2d & UV2,
135                           const Standard_Real tol3d,
136                           const Standard_Real tol2d,
137                           Handle(Geom_Curve) &C3d,
138                           Handle(Geom2d_Curve) &pcurve,
139                           Standard_Real & tolreached,
140                           Standard_Real & Pardeb,
141                           Standard_Real & Parfin,
142                           Standard_Boolean & plane)
143 { plane=Standard_True;
144   if(compoint1.IsOnArc() && compoint2.IsOnArc() ) {
145     gp_Pnt P1,P2;
146     BRepAdaptor_Curve BCurv1(compoint1.Arc());
147     BRepAdaptor_Curve BCurv2(compoint2.Arc());
148     Standard_Real parE1,parE2;
149     parE1=compoint1.ParameterOnArc();
150     parE2=compoint2.ParameterOnArc();
151     gp_Vec t1,t2;
152     BCurv1.D1(parE1,P1,t1);
153     BCurv2.D1(parE2,P2,t2);
154     gp_Dir tgt1(t1);
155     gp_Dir tgt2(t2);
156     gp_Vec v12(P2.X()-P1.X(),P2.Y()-P1.Y(),P2.Z()-P1.Z());
157     gp_Dir d12(v12); 
158     gp_Dir nor =tgt1.Crossed(d12);
159     Handle (Geom_Plane) Plan=new Geom_Plane(P1,nor);
160     Standard_Real scal;
161     scal=Abs(nor.Dot(tgt2));
162     if (scal<0.01) {
163       Handle(GeomAdaptor_HSurface) HPlan=new GeomAdaptor_HSurface(Plan);
164       Handle(Geom2d_Curve) C2dint2;
165       TColStd_Array1OfReal Pdeb(1,4),Pfin(1,4);
166       GeomAdaptor_Surface AS(Plan);
167       Extrema_ExtPS ext(P1,AS,1.e-3,1.e-3);
168       Extrema_ExtPS ext1 (P2,AS,1.e-3,1.e-3);
169       Standard_Real u1,v1;
170       ext.Point(1).Parameter(u1,v1);
171       Pdeb(1)= UV1.X();Pdeb(2) = UV1.Y();
172       Pdeb(3)= u1;Pdeb(4) =v1;
173       ext1.Point(1).Parameter(u1,v1);
174       Pfin(1)= UV2.X();Pfin(2) = UV2.Y();
175       Pfin(3)= u1;Pfin(4) = v1;
176       if (ChFi3d_ComputeCurves(HConge,HPlan,Pdeb,Pfin,C3d,
177                              pcurve,C2dint2,tol3d,tol2d,tolreached)){
178         Pardeb=C3d->FirstParameter();
179         Parfin=C3d->LastParameter();
180       }
181       else  plane=Standard_False;
182     }
183     else plane=Standard_False;
184   }
185   else   plane=Standard_False;
186 }
187 //=======================================================================
188 //function : SortieTangente
189 //purpose  : 
190 //=======================================================================
191
192 static Standard_Boolean SortieTangente(const ChFiDS_CommonPoint& CP,
193                                        const TopoDS_Face& /*F*/,
194                                        const Handle(ChFiDS_SurfData)& /*SD*/,
195                                        const Standard_Integer /*OnS*/,
196                                        const Standard_Real TolAngular)
197 {
198   if(!CP.HasVector()) return Standard_False;
199   gp_Pnt P;
200   gp_Vec Darc, Dsurf;
201   Handle(Geom_Curve) C;
202   Standard_Real Uf, Ul;
203   C = BRep_Tool::Curve(CP.Arc(),Uf,Ul);
204   C->D1(CP.ParameterOnArc(), P, Darc);
205   Dsurf = CP.Vector();
206   return Dsurf.IsParallel(Darc, TolAngular);
207 }
208
209 //=======================================================================
210 //function : BonVoisin
211 //purpose  : 
212 //=======================================================================
213
214 static Standard_Boolean BonVoisin(const gp_Pnt& Point,
215                                   Handle(BRepAdaptor_HSurface)& HS,
216                                   TopoDS_Face& F,
217                                   Handle(GeomAdaptor_HSurface)& plane, 
218                                   const TopoDS_Edge& cured,
219                                   Standard_Real& XDep,
220                                   Standard_Real& YDep,
221                                   const ChFiDS_Map& EFMap,
222                                   const Standard_Real tolesp) 
223 {
224   Standard_Boolean bonvoisin = 1;
225   Standard_Real winter, Uf, Ul;
226   gp_Pnt papp = HS->Value(XDep, YDep);
227   Standard_Real dist = RealLast();
228   Handle(BRepAdaptor_HCurve) hc = new BRepAdaptor_HCurve();
229   Handle(Geom2d_Curve) PC;
230   Standard_Boolean found = 0;
231
232   TopExp_Explorer Ex;
233   for(Ex.Init(F,TopAbs_EDGE); Ex.More(); Ex.Next()){
234     const TopoDS_Edge& ecur = TopoDS::Edge(Ex.Current());
235     if(!ecur.IsSame(cured)){
236       hc->ChangeCurve().Initialize(ecur);
237       Standard_Real tolc = hc->ChangeCurve().Resolution(tolesp);
238       if(ChFi3d_InterPlaneEdge(plane,hc,winter,1,tolc)){
239         gp_Pnt np = hc->Value(winter);
240         Standard_Real ndist = np.SquareDistance(papp);
241         if(ndist<dist){
242           TopTools_ListIteratorOfListOfShape It;
243           TopoDS_Face ff;  
244           Standard_Boolean isclosed = BRep_Tool::IsClosed(ecur, F);
245           Standard_Boolean isreallyclosed = 
246             BRepTools::IsReallyClosed(ecur, F);
247           for(It.Initialize(EFMap(ecur));It.More();It.Next()){  
248             ff = TopoDS::Face(It.Value());
249             Standard_Boolean issame = ff.IsSame(F);
250 //  Modified by Sergey KHROMOV - Fri Dec 21 17:12:48 2001 Begin
251 //          Standard_Boolean istg = 
252 //            BRep_Tool::Continuity(ecur,ff,F) != GeomAbs_C0;
253             Standard_Boolean istg = ChFi3d_isTangentFaces(ecur,ff,F);
254 //  Modified by Sergey KHROMOV - Fri Dec 21 17:12:51 2001 End
255             if((!issame || (issame && isreallyclosed)) && istg) {
256               found = 1;
257               TopoDS_Edge newe = ecur;
258               newe.Orientation(TopAbs_FORWARD);
259               dist = ndist;
260               HS->ChangeSurface().Initialize(ff);
261               if(isclosed && !isreallyclosed){
262                 TopoDS_Face fff = ff;
263                 fff.Orientation(TopAbs_FORWARD);
264                 TopExp_Explorer Ex2;
265                 for(Ex2.Init(fff,TopAbs_EDGE); 
266                     Ex2.More(); Ex2.Next()){
267                   if(newe.IsSame(Ex2.Current())){
268                     newe = TopoDS::Edge(Ex2.Current());
269                     PC = BRep_Tool::CurveOnSurface(newe,fff,Uf,Ul);
270                     break;
271                   }
272                 }
273               }
274               else PC = BRep_Tool::CurveOnSurface(newe,ff,Uf,Ul);
275               PC->Value(winter).Coord(XDep,YDep);
276               if(issame){
277                 gp_Pnt spt; gp_Vec sdu,sdv,nors;
278                 HS->D1(XDep, YDep, spt, sdu, sdv);
279                 nors = sdu.Crossed(sdv);
280                 gp_Pnt cpt; gp_Vec cd;
281                 hc->D1(winter,cpt,cd);
282                 gp_Vec vref(Point, cpt);
283                 TopoDS_Face fff = ff;
284                 fff.Orientation(TopAbs_FORWARD);
285                 if(vref.Dot(nors.Crossed(cd)) < 0.){
286                   newe.Orientation(TopAbs_REVERSED);
287                 }
288                 PC = BRep_Tool::CurveOnSurface(newe,fff,Uf,Ul);
289                 PC->Value(winter).Coord(XDep, YDep);
290               }
291               break;
292             }
293           }
294         }
295       }
296     }
297   }
298   if(!found) bonvoisin = 0;
299   return bonvoisin;
300 }
301
302 //=======================================================================
303 //function : Projection
304 //purpose  : Projects a point on a curve
305 //=======================================================================
306
307 static Standard_Boolean Projection(Extrema_ExtPC&       PExt, 
308                                    const gp_Pnt&        P,
309                                    const Adaptor3d_Curve& C,
310                                    Standard_Real&       W,
311                                    Standard_Real        Tol)
312 {
313   Standard_Real Dist2, daux2;
314   Dist2 =  C.Value(W).SquareDistance(P);
315
316   // It is checked if it is not already a solution
317   if (Dist2 < Tol * Tol) 
318     return Standard_True;
319
320   Standard_Boolean Ok = Standard_False;
321
322   // On essai une resolution initialise
323   Extrema_LocateExtPC ext(P,C,W,Tol/10);
324   if(ext.IsDone()) {
325     daux2 = C.Value(ext.Point().Parameter()).SquareDistance(P);
326     if (daux2 <Dist2 ) {
327       W = ext.Point().Parameter();
328       Dist2 = daux2;
329       Ok = Standard_True;
330       if (Dist2 < Tol * Tol) 
331         return Standard_True;
332     }  
333   }
334   
335   // Global resolution
336   PExt.Perform(P);
337   if ( PExt.IsDone() ) {
338     for (Standard_Integer ii=1; ii<= PExt.NbExt(); ii++) {
339       if (PExt.SquareDistance(ii) < Dist2) {
340         Dist2 = PExt.SquareDistance(ii);
341         W  =  PExt.Point(ii).Parameter();
342         Ok = Standard_True;
343       }
344     }
345   }
346   return Ok;
347 }
348                                    
349 //=======================================================================
350 //function : TgtKP
351 //purpose  : 
352 //=======================================================================
353
354 static void TgtKP(const Handle(ChFiDS_SurfData)& CD,
355                   const Handle(ChFiDS_Spine)&    Spine,
356                   const Standard_Integer         iedge,
357                   const Standard_Boolean         isfirst,
358                   gp_Pnt&                        ped,
359                   gp_Vec&                        ded) 
360 {
361   Standard_Real wtg = CD->InterferenceOnS1().Parameter(isfirst);
362   const BRepAdaptor_Curve& bc = Spine->CurrentElementarySpine(iedge);
363   if(Spine->Edges(iedge).Orientation() == TopAbs_FORWARD)
364     bc.D1(wtg+bc.FirstParameter(),ped,ded);
365   else{
366     bc.D1(-wtg+bc.LastParameter(),ped,ded);
367     ded.Reverse();
368   }
369   ded.Normalize();
370 }
371
372 //=======================================================================
373 //function : IsInput
374 //purpose  : Checks if a vector belongs to a Face
375 //=======================================================================
376
377 Standard_Boolean IsInput(const gp_Vec&          Vec,
378                          const TopoDS_Vertex&   Ve,
379                          const TopoDS_Face&     Fa)
380 {
381   TopExp_Explorer FaceExp(Fa, TopAbs_WIRE);
382   BRepTools_WireExplorer WireExp;
383   Standard_Integer Trouve = 0;
384   TopoDS_Wire  W;
385   TopoDS_Edge  E;
386   TopoDS_Vertex Vf, Vl;
387   gp_Vec Vec3d[2];
388   gp_Pnt Point;
389
390   // Find edges and compute 3D vectors
391   for ( ; (FaceExp.More() && (Trouve<2)); FaceExp.Next()) {
392     W = TopoDS::Wire(FaceExp.Current());
393     for (Trouve=0, WireExp.Init(W) ; 
394          WireExp.More() && (Trouve<2); WireExp.Next()) {
395       E = TopoDS::Edge(WireExp.Current());
396       TopExp::Vertices(E, Vf, Vl);
397       if (Vf.IsSame(Ve)) {
398         BRepAdaptor_Curve Cb(E);
399         Cb.D1(BRep_Tool::Parameter(Ve, E), Point, Vec3d[Trouve]);
400         Trouve++; 
401       }
402       else if (Vl.IsSame(Ve)) {
403         BRepAdaptor_Curve Cb(E);
404         Cb.D1(BRep_Tool::Parameter(Ve, E), Point, Vec3d[Trouve]);
405         Vec3d[Trouve].Reverse();
406         Trouve++; 
407       }
408     }
409   }
410   if (Trouve < 2) return Standard_False;
411   // Calculate the normal and the angles in the asssociated vector plane
412   gp_Vec Normal;
413   Normal = Vec3d[0] ^ Vec3d[1];
414   if (Normal.SquareMagnitude() < Precision::Confusion()) {//Colinear case
415     return (Vec.IsParallel(Vec3d[0],Precision::Confusion())); 
416   }
417
418   Standard_Real amin, amax;
419   amax = Vec3d[1].AngleWithRef(Vec3d[0], Normal);
420   if (amax <0) {
421     amin = amax;
422     amax = 0;  
423   }
424   else amin = 0;
425
426   // Projection of the vector
427   gp_Ax3 Axe(Point, Normal, Vec3d[0]);  
428   gp_Trsf Transf;
429   Transf.SetTransformation (Axe);
430   gp_XYZ coord = Vec.XYZ();
431   Transf.Transforms(coord);
432   coord.SetZ(0);
433   Transf.Invert();
434   Transf.Transforms(coord);
435   gp_Vec theProj(coord); 
436
437   // and finally...
438   Standard_Real Angle = theProj.AngleWithRef(Vec3d[0], Normal);
439   return ( (Angle >= amin) && (Angle<=amax));
440
441
442 //=======================================================================
443 //function : IsG1
444 //purpose  : Find a neighbor G1 by an edge
445 //=======================================================================
446
447 Standard_Boolean IsG1(const ChFiDS_Map&         TheMap,
448                       const TopoDS_Edge&        E,
449                       const TopoDS_Face&        FRef,
450                       TopoDS_Face&              FVoi) 
451 {
452   TopTools_ListIteratorOfListOfShape It;    
453   // Find a neighbor of E different from FRef (general case).
454   for(It.Initialize(TheMap(E));It.More();It.Next()) {
455     if (!TopoDS::Face(It.Value()).IsSame(FRef)) {
456       FVoi = TopoDS::Face(It.Value());
457 //  Modified by Sergey KHROMOV - Fri Dec 21 17:09:32 2001 Begin
458 //    if (BRep_Tool::Continuity(E,FRef,FVoi) != GeomAbs_C0) {
459       if (ChFi3d_isTangentFaces(E,FRef,FVoi)) {
460 //  Modified by Sergey KHROMOV - Fri Dec 21 17:09:33 2001 End
461         return Standard_True;
462       }
463     }
464   }
465   // If is was not found it is checked if E is a cutting edge,
466   // in which case FVoi = FRef is returned (less frequent case).
467   TopExp_Explorer Ex;
468   Standard_Boolean orset = Standard_False;
469   TopAbs_Orientation orient = TopAbs_FORWARD ;
470   TopoDS_Edge ed;
471   for(Ex.Init(FRef,TopAbs_EDGE); Ex.More(); Ex.Next()){
472     ed = TopoDS::Edge(Ex.Current());
473     if(ed.IsSame(E)){
474       if(!orset){ orient = ed.Orientation(); orset = Standard_True; }
475       else if(ed.Orientation() == TopAbs::Reverse(orient)){
476         FVoi = FRef;
477 //  Modified by Sergey KHROMOV - Fri Dec 21 17:15:12 2001 Begin
478 //      if (BRep_Tool::Continuity(E,FRef,FRef) >= GeomAbs_G1) {   
479         if (ChFi3d_isTangentFaces(E,FRef,FRef)) {
480 //  Modified by Sergey KHROMOV - Fri Dec 21 17:15:16 2001 End
481           return Standard_True;
482         }
483         return Standard_False;
484       }
485     }
486   }
487   return Standard_False;
488 }
489
490 //=======================================================================
491 //function : SearchFaceOnV
492 //purpose  : Finds the output face(s) of the path by a vertex
493 //           The following criteria should be followed
494 //         -1 : The face shares regular edges with FRef 
495 //              (too hard condition that should be reconsidered)
496 //         -2 : The vector starting in CommonPoint "belongs" to the face
497 //========================================================================
498 static Standard_Integer SearchFaceOnV(const ChFiDS_CommonPoint&    Pc,
499                                       const TopoDS_Face&           FRef,
500                                       const ChFiDS_Map&            VEMap,
501                                       const ChFiDS_Map&            EFMap,
502                                       TopoDS_Face&                 F1,
503                                       TopoDS_Face&                 F2)
504 {
505   // it is checked that it leaves the current face.
506   Standard_Boolean FindFace = IsInput(Pc.Vector(), Pc.Vertex(), FRef);
507   if (FindFace) {
508     FindFace = IsInput(Pc.Vector().Reversed(), Pc.Vertex(), FRef);
509   }
510   // If it does not leave, it is finished
511   if (FindFace) {
512     F1 = FRef;
513     return 1;
514   }
515   Standard_Integer Num = 0;
516   Standard_Boolean Trouve;
517   TopTools_ListIteratorOfListOfShape ItE, ItF;
518   TopoDS_Edge E;
519   TopoDS_Face FVoi;
520
521   for(ItE.Initialize(VEMap(Pc.Vertex()));
522       ItE.More() && (Num < 2); ItE.Next()) {
523     E = TopoDS::Edge(ItE.Value());
524     for(ItF.Initialize(EFMap(E)), Trouve=Standard_False;
525         ItF.More()&&(!Trouve); ItF.Next()) {
526       if (TopoDS::Face(ItF.Value()).IsSame(FRef)) {
527         Trouve = Standard_True;
528       }
529     }
530     if (Trouve) Trouve = IsG1(EFMap, E, FRef, FVoi);
531     if (Trouve) Trouve = IsInput(Pc.Vector(), Pc.Vertex(), FVoi);
532     if (Trouve) {
533       if (Num == 0) F1 = FVoi;
534       else F2 =  FVoi;
535       Num++;
536     }
537   }
538   return Num;
539 }
540
541 //=======================================================================
542 //function : ChangeTransition
543 //purpose  : Changes the transition of the second common Point, when the surface
544 //           does not cross the arc
545 //           As it is supposed that the support Faces are the same, it is enough
546 //           to examine the cas of cutting edges.
547 //========================================================================
548 static void ChangeTransition(const ChFiDS_CommonPoint&    Precedant,
549                              ChFiDS_CommonPoint&          Courant,
550                              Standard_Integer             FaceIndex,
551                              const Handle(TopOpeBRepDS_HDataStructure)& DS)
552 {
553   Standard_Boolean tochange = Standard_True;
554   Standard_Real f,l;
555   const TopoDS_Face& F = TopoDS::Face(DS->Shape(FaceIndex));
556   const TopoDS_Edge& Arc = Precedant.Arc();
557   Handle(Geom2d_Curve) PCurve1, PCurve2;
558   PCurve1 = BRep_Tool::CurveOnSurface(Arc, F, f, l);
559   TopoDS_Shape aLocalShape = Arc.Reversed();
560   PCurve2 = BRep_Tool::CurveOnSurface(TopoDS::Edge(aLocalShape), F, f, l);
561 //  PCurve2 = BRep_Tool::CurveOnSurface(TopoDS::Edge(Arc.Reversed()), F, f, l);
562   if (PCurve1 != PCurve2) { 
563     // This is a cutting edge, it is necessary to make a small Geometric test
564     gp_Vec tgarc;
565     gp_Pnt P;
566     BRepAdaptor_Curve AC(Arc);
567     AC.D1(Precedant.ParameterOnArc(), P, tgarc);
568     tochange = tgarc.IsParallel(Precedant.Vector(), Precision::Confusion());
569   }
570
571   if (tochange) 
572     Courant.SetArc(Precision::Confusion(), 
573                    Arc, 
574                    Precedant.ParameterOnArc(),
575                    TopAbs::Reverse(Precedant.TransitionOnArc()));
576
577 }
578
579 //=======================================================================
580 //function : CallPerformSurf
581 //purpose  : Encapsulates call to PerformSurf/SimulSurf
582 //========================================================================
583
584 void ChFi3d_Builder::
585 CallPerformSurf(Handle(ChFiDS_Stripe)&              Stripe,
586                 const Standard_Boolean              Simul,
587                 ChFiDS_SequenceOfSurfData&          SeqSD,
588                 Handle(ChFiDS_SurfData)&            SD,
589                 const Handle(ChFiDS_HElSpine)&      HGuide,
590                 const Handle(ChFiDS_Spine)&         Spine,
591                 const Handle(BRepAdaptor_HSurface)& HS1,
592                 const Handle(BRepAdaptor_HSurface)& HS3,
593                 const gp_Pnt2d&                     pp1,
594                 const gp_Pnt2d&                     pp3,
595                 const Handle(Adaptor3d_TopolTool)&          It1,
596                 const Handle(BRepAdaptor_HSurface)& HS2,
597                 const Handle(BRepAdaptor_HSurface)& HS4,
598                 const gp_Pnt2d&                     pp2,
599                 const gp_Pnt2d&                     pp4,
600                 const Handle(Adaptor3d_TopolTool)&          It2,
601                 const Standard_Real                 MaxStep,
602                 const Standard_Real                 Fleche,
603                 const Standard_Real                 /*TolGuide*/,
604                 Standard_Real&                      First,
605                 Standard_Real&                      Last,
606                 const Standard_Boolean              Inside,
607                 const Standard_Boolean              /*Appro*/,
608                 const Standard_Boolean              forward,
609                 const Standard_Boolean              RecOnS1,
610                 const Standard_Boolean              RecOnS2,
611                 math_Vector&                        Soldep,
612                 Standard_Boolean&                   intf,
613                 Standard_Boolean&                   intl,
614                 Handle(BRepAdaptor_HSurface)&       Surf1,
615                 Handle(BRepAdaptor_HSurface)&       Surf2) 
616 {
617 #ifdef OCCT_DEBUG
618   OSD_Chronometer ch1;
619 #endif 
620   Handle(BRepAdaptor_HSurface) HSon1, HSon2;
621   HSon1 = HS1;
622   HSon2 = HS2;
623   // Definition of the domain of path It1, It2
624   It1->Initialize((const Handle(Adaptor3d_HSurface)&)HSon1);
625   It2->Initialize((const Handle(Adaptor3d_HSurface)&)HSon2);
626
627
628   TopAbs_Orientation Or1 = HS1->ChangeSurface().Face().Orientation();
629   TopAbs_Orientation Or2 = HS2->ChangeSurface().Face().Orientation();
630   Standard_Integer Choix = 
631     ChFi3d::NextSide(Or1,Or2,
632                      Stripe->OrientationOnFace1(),
633                      Stripe->OrientationOnFace2(),
634                      Stripe->Choix());
635   Soldep(1) = pp1.X(); Soldep(2) = pp1.Y();
636   Soldep(3) = pp2.X(); Soldep(4) = pp2.Y();
637       
638   Standard_Real thef = First, thel = Last;
639   Standard_Boolean isdone;
640
641   if(Simul){
642     isdone = SimulSurf(SD,HGuide,Spine,Choix,HS1,It1,HS2,It2,tolesp,First,Last,
643                        Inside,Inside,forward,RecOnS1,RecOnS2,Soldep,intf,intl);
644   }
645   else{
646         
647 #ifdef OCCT_DEBUG
648     ChFi3d_InitChron(ch1);//initial perform for PerformSurf
649 #endif
650         
651     isdone = PerformSurf(SeqSD,HGuide,Spine,Choix,HS1,It1,HS2,It2,
652                          MaxStep,Fleche,tolesp,
653                          First,Last,Inside,Inside,forward,
654                          RecOnS1,RecOnS2,Soldep,intf,intl);
655 #ifdef OCCT_DEBUG
656     ChFi3d_ResultChron(ch1,t_performsurf);// result perf for PerformSurf   
657 #endif
658   }
659
660  // Case of error
661  if (!isdone) {
662    First = thef;
663    Last = thel;
664    Standard_Boolean reprise = Standard_False;
665    if (! HS3.IsNull()) {
666      HSon1 = HS3;
667      It1->Initialize((const Handle(Adaptor3d_HSurface)&)HS3); 
668      Or1 = HS3->ChangeSurface().Face().Orientation();
669      Soldep(1) = pp3.X(); Soldep(2) = pp3.Y();
670      reprise = Standard_True;
671    }
672    else if (! HS4.IsNull()) {
673      HSon2 = HS4;
674      It2->Initialize((const Handle(Adaptor3d_HSurface)&)HS4); 
675      Or2 = HS4->ChangeSurface().Face().Orientation();
676      Soldep(3) = pp4.X(); Soldep(4) = pp4.Y();
677      reprise = Standard_True;
678    }
679
680    if (reprise) {
681      Choix = ChFi3d::NextSide(Or1,Or2,
682                               Stripe->OrientationOnFace1(),
683                               Stripe->OrientationOnFace2(),
684                               Stripe->Choix());
685      if(Simul){
686        isdone = SimulSurf(SD,HGuide,Spine,Choix,HSon1,It1,HSon2,It2,
687                           tolesp,First,Last,
688                           Inside,Inside,forward,RecOnS1,RecOnS2,
689                           Soldep,intf,intl);
690      }
691      else{
692         
693 #ifdef OCCT_DEBUG
694        ChFi3d_InitChron(ch1);//init perf for PerformSurf
695 #endif
696         
697        isdone = PerformSurf(SeqSD,HGuide,Spine,Choix,HSon1,It1,HSon2,It2,
698                             MaxStep,Fleche,tolesp,
699                             First,Last,Inside,Inside,forward,
700                             RecOnS1,RecOnS2,Soldep,intf,intl);
701 #ifdef OCCT_DEBUG
702        ChFi3d_ResultChron(ch1,t_performsurf);// result perf for PerformSurf   
703 #endif
704      }
705    }
706  }  
707   Surf1 = HSon1;
708   Surf2 = HSon2;
709 }
710
711 //=======================================================================
712 //function : StripeOrientation
713 //purpose  : Calculates the reference orientation determining the
714 //           concave face for construction of the fillet.
715 //=======================================================================
716
717 Standard_Boolean ChFi3d_Builder::StripeOrientations
718 (const Handle(ChFiDS_Spine)& Spine,
719  TopAbs_Orientation&         Or1,
720  TopAbs_Orientation&         Or2,
721  Standard_Integer&           ChoixConge) const 
722 {
723   //TopTools_ListIteratorOfListOfShape It;
724   BRepAdaptor_Surface Sb1,Sb2;
725   TopAbs_Orientation Of1,Of2;
726   TopoDS_Face ff1,ff2;
727   ChFi3d_conexfaces(Spine->Edges(1),ff1,ff2,myEFMap);
728   Of1 = ff1.Orientation();
729   ff1.Orientation(TopAbs_FORWARD);
730   Sb1.Initialize(ff1);
731   Of2 = ff2.Orientation();
732   ff2.Orientation(TopAbs_FORWARD);
733   Sb2.Initialize(ff2);
734
735   ChoixConge = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(1),
736                                    Or1,Or2);
737   Or1 = TopAbs::Compose(Or1,Of1);
738   Or2 = TopAbs::Compose(Or2,Of2);
739   return Standard_True;
740 }
741
742
743 //=======================================================================
744 //function : ConexFaces
745 //purpose  : 
746 //=======================================================================
747
748 void ChFi3d_Builder::ConexFaces (const Handle(ChFiDS_Spine)&   Spine,
749                                  const Standard_Integer        IEdge,
750                                  const Standard_Integer        RC,      
751                                  Handle(BRepAdaptor_HSurface)& HS1,
752                                  Handle(BRepAdaptor_HSurface)& HS2) const
753 {
754   if(HS1.IsNull()) HS1 = new BRepAdaptor_HSurface ();
755   if(HS2.IsNull()) HS2 = new BRepAdaptor_HSurface ();
756   BRepAdaptor_Surface& Sb1 = HS1->ChangeSurface();
757   BRepAdaptor_Surface& Sb2 = HS2->ChangeSurface();
758
759   TopoDS_Face ff1,ff2;  
760   ChFi3d_conexfaces(Spine->Edges(IEdge),ff1,ff2,myEFMap);
761
762   Sb1.Initialize(ff1);
763   Sb2.Initialize(ff2);
764   
765   TopAbs_Orientation Or1,Or2;
766   Standard_Integer Choix = ChFi3d::ConcaveSide(Sb1,Sb2,Spine->Edges(IEdge),
767                                                Or1,Or2);  
768   if (RC%2 != Choix%2) {
769     Sb1.Initialize(ff2);
770     Sb2.Initialize(ff1);
771   }
772 }
773
774 //=======================================================================
775 //function : StartSol
776 //purpose  : Calculates a starting solution :
777 //           - one starts by parsing about ten points on the spine,
778 //           - in case of fail one finds the solution on neighbor faces;
779 //             section plane of edges of the adjacent face 
780 //             and identication of the face by connection to that edge.
781 //=======================================================================
782
783 void ChFi3d_Builder::StartSol(const Handle(ChFiDS_Stripe)&      Stripe,
784                               const Handle(ChFiDS_HElSpine)&    HGuide,
785                               Handle(BRepAdaptor_HSurface)&     HS1,
786                               Handle(BRepAdaptor_HSurface)&     HS2,
787                               Handle(BRepTopAdaptor_TopolTool)& I1,
788                               Handle(BRepTopAdaptor_TopolTool)& I2,
789                               gp_Pnt2d&                         P1,
790                               gp_Pnt2d&                         P2,
791                               Standard_Real&                    First) const 
792 {
793   Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
794   ChFiDS_ElSpine& els = HGuide->ChangeCurve();
795   Standard_Integer nbed = Spine->NbEdges();
796   Standard_Integer nbessaimax = 3*nbed;
797   if (nbessaimax < 10) nbessaimax = 10;
798   Standard_Real unsurnbessaimax = 1./nbessaimax;
799   Standard_Real wf = 0.9981 * Spine->FirstParameter(1) +
800     0.0019 * Spine->LastParameter(1);
801   Standard_Real wl = 0.9973 * Spine->LastParameter(nbed) +
802     0.0027 * Spine->FirstParameter(nbed);
803
804   Standard_Real TolE = 1.0e-7;
805   BRepAdaptor_Surface AS;  
806
807   Standard_Integer nbessai;
808   Standard_Integer iedge = 0;
809   Standard_Integer RC = Stripe->Choix();
810   gp_Vec2d derive;
811   gp_Pnt2d P2d;
812   TopoDS_Edge cured;
813   TopoDS_Face f1,f2;
814   TopAbs_Orientation Or1,Or2;
815   Standard_Integer Choix = 0;
816   math_Vector SolDep(1,4);
817   Handle(Geom2d_Curve) PC;
818   Extrema_ExtPC PExt;
819   PExt.Initialize(els, 
820                   Spine->FirstParameter(1),
821                   Spine->LastParameter(nbed),
822                   Precision::Confusion());
823   TopAbs_State Pos1,Pos2;
824   for(nbessai = 0; nbessai <= nbessaimax; nbessai++){
825     Standard_Real t = nbessai*unsurnbessaimax;
826     Standard_Real w = wf * (1. -t) + wl * t;
827     Standard_Integer ie = Spine->Index(w);
828     if(iedge != ie){
829       iedge = ie;
830       cured = Spine->Edges(iedge);
831       TolE = BRep_Tool::Tolerance(cured);
832       ConexFaces(Spine,iedge,RC,HS1,HS2);
833       f1 = HS1->ChangeSurface().Face();
834       f2 = HS2->ChangeSurface().Face();
835       Or1 = f1.Orientation();
836       Or2 = f2.Orientation();
837       Choix = ChFi3d::NextSide(Or1,Or2,
838                                Stripe->OrientationOnFace1(),
839                                Stripe->OrientationOnFace2(),
840                                RC);
841     }
842
843     Standard_Real woned,Uf,Ul, ResU, ResV;
844     Spine->Parameter(iedge,w,woned,Standard_True);
845     cured.Orientation(TopAbs_FORWARD);
846     TopoDS_Face f1forward = f1, f2forward = f2;
847     f1forward.Orientation(TopAbs_FORWARD);
848     f2forward.Orientation(TopAbs_FORWARD);
849     PC = BRep_Tool::CurveOnSurface(cured,f1forward,Uf,Ul);
850     I1->Initialize((const Handle(Adaptor3d_HSurface)&)HS1);
851     PC->D1(woned, P1, derive);
852     // There are ponts on the border, and internal points are found
853     if (derive.Magnitude() > Precision::PConfusion()) {
854       derive.Normalized();
855       derive.Rotate(M_PI/2);
856       AS.Initialize(f1);
857       ResU = AS.UResolution(TolE);
858       ResV = AS.VResolution(TolE);
859       derive *= 2*(Abs(derive.X())*ResU + Abs(derive.Y())*ResV);
860       P2d = P1.Translated(derive);
861       if (I1->Classify(P2d, Min(ResU, ResV), 0)== TopAbs_IN) {
862         P1 = P2d;
863       }
864       else {
865          P2d = P1.Translated(-derive);
866          if (I1->Classify(P2d, Min(ResU, ResV), 0)== TopAbs_IN) {
867            P1 = P2d;
868          }
869       }
870     }
871     if(f1.IsSame(f2)) cured.Orientation(TopAbs_REVERSED);
872     PC = BRep_Tool::CurveOnSurface(cured,f2forward,Uf,Ul);
873     P2 = PC->Value(woned);
874     const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
875     I2->Initialize(HSon2);
876
877     SolDep(1) = P1.X(); SolDep(2) = P1.Y();
878     SolDep(3) = P2.X(); SolDep(4) = P2.Y();
879     const BRepAdaptor_Curve& Ced = Spine->CurrentElementarySpine(iedge);
880     gp_Pnt pnt = Ced.Value(woned);
881   
882     if (Projection(PExt, pnt, els, w, tolesp) &&
883         PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
884                             I1,I2,w,SolDep,Pos1,Pos2)) {
885       P1.SetCoord(SolDep(1),SolDep(2));
886       P2.SetCoord(SolDep(3),SolDep(4));
887       First = w;
888       return;
889     }
890   }
891   // No solution was found for the faces adjacent to the trajectory.
892   // Now one tries the neighbor faces.
893   iedge = 0;
894   for(nbessai = 0; nbessai <= nbessaimax; nbessai++){
895     Standard_Real t = nbessai*unsurnbessaimax;
896     Standard_Real w = wf * (1. -t) + wl * t;
897     iedge = Spine->Index(w);
898     cured = Spine->Edges(iedge);
899     ConexFaces(Spine,iedge,RC,HS1,HS2);
900     f1 = HS1->ChangeSurface().Face();
901     f2 = HS2->ChangeSurface().Face();
902     Or1 = f1.Orientation();
903     Or2 = f2.Orientation();
904     Choix = ChFi3d::NextSide(Or1,Or2,
905                              Stripe->OrientationOnFace1(),
906                              Stripe->OrientationOnFace2(),
907                              RC);
908     Standard_Real woned,Uf,Ul;
909     Spine->Parameter(iedge,w,woned,Standard_True);
910     TopoDS_Face f1forward = f1, f2forward = f2;
911     f1forward.Orientation(TopAbs_FORWARD);
912     f2forward.Orientation(TopAbs_FORWARD);
913     PC = BRep_Tool::CurveOnSurface(cured,f1forward,Uf,Ul);
914     P1 = PC->Value(woned);
915     PC = BRep_Tool::CurveOnSurface(cured,f2forward,Uf,Ul);
916     P2 = PC->Value(woned);
917     const Handle(Adaptor3d_HSurface)& HSon1 = HS1; // to avoid ambiguity
918     const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
919     I1->Initialize(HSon1);
920     I2->Initialize(HSon2);
921     SolDep(1) = P1.X(); SolDep(2) = P1.Y();
922     SolDep(3) = P2.X(); SolDep(4) = P2.Y();
923     const BRepAdaptor_Curve& Ced = Spine->CurrentElementarySpine(iedge);
924     gp_Pnt pnt = Ced.Value(woned);
925 //    Extrema_LocateExtPC ext(pnt,els,w,1.e-8);
926 //    if(ext.IsDone()){
927 //      w = ext.Point().Parameter(); 
928     if (Projection(PExt, pnt, els, w, tolesp)) {
929       PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
930                           I1,I2,w,SolDep,Pos1,Pos2);
931       gp_Pnt P;
932       gp_Vec V;
933       HGuide->D1(w,P,V);
934       Handle(Geom_Plane) pl = new Geom_Plane(P,V);
935       Handle(GeomAdaptor_HSurface) plane = new GeomAdaptor_HSurface(pl);
936
937       Standard_Boolean bonvoisin = 1, found = 0;
938       Standard_Integer NbChangement;
939       for (NbChangement = 1; bonvoisin && (!found) && (NbChangement < 5);
940            NbChangement++) {
941         if(Pos1 != TopAbs_IN){
942           bonvoisin = BonVoisin(P, HS1, f1, plane, cured, 
943                                 SolDep(1),SolDep(2), myEFMap, tolesp); 
944         }
945         if(Pos2 != TopAbs_IN && bonvoisin){
946           bonvoisin = BonVoisin(P, HS2, f2, plane, cured, 
947                                 SolDep(3),SolDep(4), myEFMap, tolesp);
948         } 
949         if(bonvoisin){
950           f1 = HS1->ChangeSurface().Face();
951           f2 = HS2->ChangeSurface().Face();
952           Or1 = f1.Orientation();
953           Or2 = f2.Orientation();
954           Choix = ChFi3d::NextSide(Or1,Or2,
955                                    Stripe->OrientationOnFace1(),
956                                    Stripe->OrientationOnFace2(),
957                                    RC);
958           const Handle(Adaptor3d_HSurface)& HSon1new = HS1; // to avoid ambiguity
959           const Handle(Adaptor3d_HSurface)& HSon2new = HS2; // to avoid ambiguity
960           I1->Initialize(HSon1new);
961           I2->Initialize(HSon2new);
962           if(PerformFirstSection(Spine,HGuide,Choix,HS1,HS2,
963                                  I1,I2,w,SolDep,Pos1,Pos2)){
964             P1.SetCoord(SolDep(1),SolDep(2));
965             P2.SetCoord(SolDep(3),SolDep(4));
966             First = w;
967             found = Standard_True;
968           }
969         }
970       }
971       if (found) return;
972     }
973   }
974   Spine->SetErrorStatus(ChFiDS_StartsolFailure);
975   Standard_Failure::Raise("StartSol echec");
976 }
977
978 //=======================================================================
979 //function : ChFi3d_BuildPlane
980 //purpose  : 
981 //=======================================================================
982
983 static void  ChFi3d_BuildPlane (TopOpeBRepDS_DataStructure&    DStr,
984                                 Handle(BRepAdaptor_HSurface)&  HS,
985                                 gp_Pnt2d&                      pons,
986                                 const Handle(ChFiDS_SurfData)& SD,
987                                 const Standard_Boolean         isfirst,
988                                 const Standard_Integer         ons)
989 {
990   Handle(Geom2d_Curve) Hc;      
991   TopoDS_Face F = TopoDS::Face(DStr.Shape(SD->Index(ons)));
992   Standard_Real u,v;
993   gp_Pnt P;
994   //gp_Vec V1,V2;
995   
996   if (SD->Vertex(isfirst,ons).IsOnArc()){
997     Hc = BRep_Tool::CurveOnSurface
998       (SD->Vertex(isfirst,ons).Arc(),F,u,v);
999     Hc->Value(SD->Vertex(isfirst,ons).ParameterOnArc()).Coord(u,v);
1000     BRepLProp_SLProps theProp(HS->ChangeSurface(), u, v, 1, 1.e-12);
1001     if  (theProp.IsNormalDefined()) {
1002       P =  theProp.Value();
1003       Handle(Geom_Plane) Pln  = new Geom_Plane(P, theProp.Normal());
1004       TopoDS_Face        NewF = BRepLib_MakeFace(Pln, Precision::Confusion());
1005       NewF.Orientation(F.Orientation());
1006       pons.SetCoord(0.,0.);
1007       HS->ChangeSurface().Initialize(NewF);
1008       return; // everything is good !
1009     }
1010   }
1011   Standard_Failure::Raise("ChFi3d_BuildPlane : echec .");
1012 }
1013
1014 //=======================================================================
1015 //function : StartSol
1016 //purpose  : If the commonpoint is not OnArc the input face
1017 //           is returned and 2D point is updated,
1018 //           if it is OnArc
1019 //              if it is detached  the input face
1020 //              is returned and 2D point is updated,
1021 //              otherwise
1022 //                 either there is a neighbor tangent face and it is returned
1023 //                         with recalculated 2D point
1024 //                 or if there is no face 
1025 //                         if the reference arc is Vref (extremity of the spine)
1026 //                            this is the end and the input face is returned 
1027 //                         otherwise this is an obstacle and HC is updated.
1028 //=======================================================================
1029
1030 Standard_Boolean  
1031 ChFi3d_Builder::StartSol(const Handle(ChFiDS_Spine)&    Spine,
1032                          Handle(BRepAdaptor_HSurface)&  HS, // New face
1033                          gp_Pnt2d&                      pons,// " Localization
1034                          Handle(BRepAdaptor_HCurve2d)&  HC, // Representation of the obstacle
1035                          Standard_Real&                 W,
1036                          const Handle(ChFiDS_SurfData)& SD,
1037                          const Standard_Boolean         isfirst,
1038                          const Standard_Integer         ons,
1039                          Handle(BRepAdaptor_HSurface)&  HSref, // The other representation
1040                          Handle(BRepAdaptor_HCurve2d)&  HCref, // of the obstacle          
1041                          Standard_Boolean&              RecP,
1042                          Standard_Boolean&              RecS,
1043                          Standard_Boolean&              RecRst,
1044                          Standard_Boolean&              c1obstacle,
1045                          Handle(BRepAdaptor_HSurface)&  HSBis, // Face of support       
1046                          gp_Pnt2d&                      PBis,  // and its point
1047                          const Standard_Boolean         decroch,
1048                          const TopoDS_Vertex&           Vref) const 
1049 {
1050   RecRst = RecS = RecP = c1obstacle = 0;
1051   TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
1052   TopoDS_Face Fv,Fref;
1053   //gp_Pnt2d  pp1,pp2;
1054   Handle(Geom2d_Curve) pc;      
1055   Standard_Real Uf,Ul;
1056   
1057   TopoDS_Face F = TopoDS::Face(DStr.Shape(SD->Index(ons)));
1058   if(!HSref.IsNull()) Fref = HSref->ChangeSurface().Face();
1059   const ChFiDS_CommonPoint& CP = SD->Vertex(isfirst,ons);
1060   HSBis.Nullify();
1061
1062   if (CP.IsOnArc()) {
1063     Standard_Integer notons;
1064     if (ons == 1)  notons = 2;
1065     else           notons = 1;
1066     const ChFiDS_CommonPoint& CPbis = SD->Vertex(isfirst,notons);
1067     if (CPbis.IsOnArc()) { // It is checked if it is not the extension zone 
1068                   // In case CP is not at the end of surfdata and it is not necesary to take it into account
1069                   // except for separate cases (ie pointus) ...
1070       //ts and tns were earlier CP.Parameter() and CPbis.Parameter, but sometimes they had no values.
1071       Standard_Real ts=SD->Interference(ons).Parameter(isfirst), tns=SD->Interference(notons).Parameter(isfirst);
1072       Standard_Boolean isExtend;
1073       // Arbitrary test (to precise)
1074       if (isfirst) isExtend = (ts-tns > 100*tolesp); 
1075       else         isExtend = (tns-ts > 100*tolesp);
1076       if (isExtend && !CP.Point().IsEqual(CPbis.Point(), 0) ) {
1077         //  the state is preserved and False is returned (extension by the expected plane).
1078         HS->ChangeSurface().Initialize(F);
1079         pc = SD->Interference(ons).PCurveOnFace();
1080         // The 2nd point is given by its trace on the support surface
1081         RecS = Standard_False;
1082         pons = pc->Value(tns);
1083         return Standard_False;
1084       }
1085     }
1086   }  
1087   
1088   if (CP.IsVertex() && !HC.IsNull() && !decroch){
1089     //The edge is changed, the parameter is updated and
1090     //eventually the support face and(or) the reference face.
1091     TopoDS_Vertex VCP = CP.Vertex();
1092     TopoDS_Edge EHC = HC->ChangeCurve2d().Edge();
1093     //One starts by searching in Fref another edge referencing VCP.
1094     TopExp_Explorer ex1,ex2;
1095     TopoDS_Edge newedge, edgereg;
1096     TopoDS_Face bidface = Fref, facereg;
1097     bidface.Orientation(TopAbs_FORWARD);
1098     for(ex1.Init(bidface,TopAbs_EDGE); ex1.More(); ex1.Next()){
1099       const TopoDS_Edge& cured = TopoDS::Edge(ex1.Current());
1100       Standard_Boolean found = 0;
1101       if(!cured.IsSame(EHC)){
1102         for(ex2.Init(cured,TopAbs_VERTEX); ex2.More() && !found; ex2.Next()){
1103           if(ex2.Current().IsSame(VCP)){
1104             if(IsG1(myEFMap,cured,Fref,Fv)){
1105               edgereg = cured;
1106               facereg = Fv;
1107             }
1108             else found = 1;
1109           }
1110         }
1111       }
1112       if(found) {
1113         newedge = cured;
1114         break;
1115       }
1116     }
1117     if(newedge.IsNull()){
1118       //It is checked if EHC is not a closed edge.
1119       TopoDS_Vertex V1,V2;
1120       TopExp::Vertices(EHC,V1,V2);
1121       if(V1.IsSame(V2)){
1122         newedge = EHC;
1123         Standard_Real w1 = BRep_Tool::Parameter(V1,EHC);
1124         Standard_Real w2 = BRep_Tool::Parameter(V2,EHC);
1125         const ChFiDS_FaceInterference& fi = SD->Interference(ons);
1126         const Handle(Geom2d_Curve)& pcf = fi.PCurveOnFace();
1127         Standard_Real ww = fi.Parameter(isfirst);
1128         
1129         gp_Pnt2d pww;
1130         if(!pcf.IsNull()) pww = pcf->Value(ww);
1131         else pww = SD->Get2dPoints(isfirst,ons);
1132         gp_Pnt2d p1 = HC->Value(w1);
1133         gp_Pnt2d p2 = HC->Value(w2);
1134         
1135         if(p1.Distance(pww) >  p2.Distance(pww)){
1136           W = w1;
1137           pons = p1;
1138         }
1139         else {
1140           W = w2;
1141           pons = p2;
1142         }
1143         RecP = c1obstacle = 1;
1144         return 1;
1145       }
1146       else if(!edgereg.IsNull()){
1147         // the reference edge and face are changed.
1148         Fref = facereg;
1149         HSref->ChangeSurface().Initialize(Fref);
1150         for(ex1.Init(facereg,TopAbs_EDGE); ex1.More() && newedge.IsNull(); ex1.Next()){
1151           const TopoDS_Edge& cured = TopoDS::Edge(ex1.Current());
1152           if(!cured.IsSame(edgereg)){
1153             for(ex2.Init(cured,TopAbs_VERTEX); ex2.More(); ex2.Next()){
1154               if(ex2.Current().IsSame(VCP)){
1155                 if(!IsG1(myEFMap,cured,Fref,Fv)){
1156                   newedge = cured;
1157                 }
1158               }
1159             }
1160           }
1161         }
1162       }
1163     }
1164     // it is necessary to find the new support face of the fillet : 
1165     // connected to FRef along the newedge.
1166     if(newedge.IsNull()) {
1167       Standard_Failure::Raise
1168         ("StartSol : chain is not possible, new obstacle not found");
1169     }
1170     if(IsG1(myEFMap,newedge,Fref,Fv)){
1171       Standard_Failure::Raise
1172         ("StartSol : chain is not possible, config non processed");
1173     }
1174     else if(Fv.IsNull()){
1175       Standard_Failure::Raise
1176         ("StartSol : chain is not possible, new obstacle not found");
1177     }
1178     else{
1179       HS->ChangeSurface().Initialize(Fv);
1180       W = BRep_Tool::Parameter(VCP,newedge);
1181       HCref->ChangeCurve2d().Initialize(newedge,Fref);
1182       TopoDS_Face newface = Fv;
1183       newface.Orientation(TopAbs_FORWARD);
1184       TopExp_Explorer ex;
1185       for(ex.Init(newface,TopAbs_EDGE); ex.More(); ex.Next()){
1186         if(ex.Current().IsSame(newedge)){
1187           newedge = TopoDS::Edge(ex.Current());
1188           break;
1189         }
1190       }
1191       HC->ChangeCurve2d().Initialize(newedge,Fv);
1192       pons = HC->Value(W);
1193     }
1194     RecP = c1obstacle = 1;
1195     return 1;
1196   } // End of Case Vertex && Obstacle 
1197
1198   else if (CP.IsOnArc() && !HC.IsNull() && !decroch){
1199     //Nothing is changed, the parameter is only updated.
1200     W = CP.ParameterOnArc();
1201     c1obstacle = 1;
1202     return 1;
1203   }
1204   
1205   HC.Nullify();
1206   
1207   if (CP.IsOnArc()){
1208     const TopoDS_Edge& E = CP.Arc();
1209     if(decroch){
1210       HS->ChangeSurface().Initialize(Fref);
1211       W = CP.ParameterOnArc();
1212       pc = BRep_Tool::CurveOnSurface(E,Fref,Uf,Ul);
1213       pons = pc->Value(W);
1214       RecS = 1;
1215       return 1;
1216     }
1217     if (SearchFace(Spine,CP,F,Fv)){
1218       HS->ChangeSurface().Initialize(Fv);
1219       RecS = 1;
1220       if (CP.IsVertex()) { 
1221         // One goes directly by the Vertex
1222         Standard_Integer Nb;
1223         TopoDS_Face aux;
1224         // And it is checked that there are no other candidates
1225         Nb = SearchFaceOnV(CP, F, myVEMap, myEFMap, Fv, aux);
1226
1227         pons = BRep_Tool::Parameters(CP.Vertex(), Fv);
1228         HS->ChangeSurface().Initialize(Fv);
1229         if (Nb >=2) {
1230           HSBis = new (BRepAdaptor_HSurface)(aux);
1231           PBis = BRep_Tool::Parameters(CP.Vertex(), aux);
1232         }
1233         return 1;
1234       }
1235       // otherwise one passes by the arc...
1236       if(!Fv.IsSame(F)){
1237         Fv.Orientation(TopAbs_FORWARD);
1238         TopoDS_Edge newedge;
1239         TopExp_Explorer ex;
1240         for(ex.Init(Fv,TopAbs_EDGE); ex.More(); ex.Next()){
1241           if(ex.Current().IsSame(E)){
1242             newedge = TopoDS::Edge(ex.Current());
1243             break;
1244           }
1245         }
1246         //gp_Vec Varc, VSurf;
1247         // In cas of Tangent output, the current face becomes the support face
1248         if (SortieTangente(CP, F, SD, ons, 0.1)) { 
1249           pc = BRep_Tool::CurveOnSurface(CP.Arc(),F,Uf,Ul);
1250           HSBis = new (BRepAdaptor_HSurface)(F);
1251           PBis = pc->Value(CP.ParameterOnArc());
1252         }
1253         
1254
1255         pc = BRep_Tool::CurveOnSurface(newedge,Fv,Uf,Ul);
1256       }
1257       else{
1258         TopoDS_Edge newedge = E;
1259         newedge.Reverse();
1260         Fv.Orientation(TopAbs_FORWARD);
1261         pc = BRep_Tool::CurveOnSurface(newedge,Fv,Uf,Ul);
1262       }
1263       pons = pc->Value(CP.ParameterOnArc());
1264       return 1;
1265     }
1266     else if(!Fv.IsNull()){    
1267       c1obstacle = 1;
1268       if(!Vref.IsNull()){
1269         TopExp_Explorer ex;
1270         for(ex.Init(E,TopAbs_VERTEX); ex.More(); ex.Next()){
1271           if(ex.Current().IsSame(Vref)){
1272             c1obstacle = 0;
1273             break;
1274           }
1275         }
1276       }
1277       if(c1obstacle){
1278         HS->ChangeSurface().Initialize(Fv);
1279         HSref->ChangeSurface().Initialize(F);
1280         W = CP.ParameterOnArc();
1281         HC = new BRepAdaptor_HCurve2d();
1282         TopoDS_Edge newedge;
1283         TopoDS_Face newface = Fv;
1284         newface.Orientation(TopAbs_FORWARD);
1285         TopExp_Explorer ex;
1286         for(ex.Init(newface,TopAbs_EDGE); ex.More(); ex.Next()){
1287           if(ex.Current().IsSame(E)){
1288             newedge = TopoDS::Edge(ex.Current());
1289             break;
1290           }
1291         }
1292         HC->ChangeCurve2d().Initialize(newedge,Fv);
1293         pons = HC->Value(W);
1294         HCref->ChangeCurve2d().Initialize(E,F);
1295         if(CP.IsVertex()) RecP = 1;
1296         else RecRst = 1;
1297         return 1;
1298       }
1299       else{
1300         HS->ChangeSurface().Initialize(F);
1301         W = CP.ParameterOnArc();
1302         pc = BRep_Tool::CurveOnSurface(E,F,Uf,Ul);
1303         pons = pc->Value(W);
1304         return Standard_False;
1305       }
1306     }
1307     else{ // there is no neighbor face, the state is preserved and False is returned.
1308       HS->ChangeSurface().Initialize(F);
1309       W = CP.ParameterOnArc();
1310       pc = BRep_Tool::CurveOnSurface(E,F,Uf,Ul);
1311       pons = pc->Value(W);
1312       return Standard_False;
1313     }
1314   }
1315   else{
1316     HS->ChangeSurface().Initialize(F);
1317     const ChFiDS_FaceInterference& FI = SD->Interference(ons);
1318     if(FI.PCurveOnFace().IsNull()) pons = SD->Get2dPoints(isfirst,ons);
1319     else pons = FI.PCurveOnFace()->Value(FI.Parameter(isfirst));
1320   }
1321   return Standard_True;
1322 }
1323
1324 //=======================================================================
1325 //function : SearchFace
1326 //purpose  : 
1327 //=======================================================================
1328
1329 Standard_Boolean  ChFi3d_Builder::SearchFace
1330                  (const Handle(ChFiDS_Spine)&  Spine,
1331                   const ChFiDS_CommonPoint&    Pc,
1332                   const TopoDS_Face&           FRef,
1333                   TopoDS_Face&                 FVoi) const
1334 {
1335   Standard_Boolean Trouve = Standard_False;
1336   if (! Pc.IsOnArc()) return Standard_False;
1337   FVoi.Nullify();
1338   TopoDS_Edge E;
1339   if (Pc.IsVertex()){
1340     // attention it is necessary to analyze all faces that turn around of the vertex
1341 #ifdef OCCT_DEBUG
1342     cout<<"Commonpoint on vertex, the process hangs up"<<endl;
1343 #endif
1344     if (Pc.HasVector()) { //General processing
1345       TopoDS_Face Fbis;
1346       Standard_Integer nb_faces;
1347       nb_faces = SearchFaceOnV(Pc,  FRef, myVEMap, myEFMap, FVoi, Fbis);
1348       return ( nb_faces > 0);
1349     }
1350     else { // Processing using the spine
1351       Standard_Boolean  FindFace=Standard_False;
1352       gp_Pnt Point;
1353       gp_Vec VecSpine;
1354       Spine->D1(Pc.Parameter(), Point, VecSpine);
1355     
1356       // It is checked if one leaves from the current face.
1357       FindFace = IsInput(VecSpine, Pc.Vertex(), FRef);
1358       if (FindFace) {
1359         VecSpine.Reverse();
1360         FindFace = IsInput(VecSpine, Pc.Vertex(), FRef);
1361       }
1362       // If one does not leave, it is ended
1363       if (FindFace) {
1364         FVoi = FRef;
1365         return Standard_True;
1366       }
1367     
1368       // Otherwise one finds the next among shared Faces 
1369       // by a common edge G1
1370       TopTools_ListIteratorOfListOfShape ItE, ItF;
1371       for(ItE.Initialize(myVEMap(Pc.Vertex()));
1372           ItE.More() && (!FindFace); ItE.Next()) {
1373         E = TopoDS::Edge(ItE.Value());
1374         Trouve=Standard_False;
1375         for(ItF.Initialize(myEFMap(E));//, Trouve=Standard_False;           15.11.99 SVV
1376             ItF.More()&&(!Trouve); ItF.Next()) {
1377           if (TopoDS::Face(ItF.Value()).IsSame(FRef)) {
1378             Trouve = Standard_True;
1379           }
1380         }
1381         if (Trouve) FindFace = IsG1(myEFMap, E, FRef, FVoi);
1382         if (FindFace) { 
1383           FindFace = Standard_False;
1384           if (Spine.IsNull()) {
1385             //La Spine peut etre nulle (ThreeCorner)
1386 #ifdef OCCT_DEBUG
1387             cout << "FindFace sur vertex avec spine nulle! QUEZAKO ?" << endl;
1388 #endif
1389             return Standard_False;
1390           }
1391         
1392           // It is checked if the selected face actually possesses edges of the spine
1393           // containing the vertex on its front
1394           // This processing should go only if the Vertex belongs to the spine
1395           // This is a single case, for other vertexes it is required to do other things
1396           Trouve=Standard_False;
1397           for (Standard_Integer IE=1;//, Trouve=Standard_False;                   15.11.99  SVV
1398                (IE<=Spine->NbEdges()) && (!Trouve); IE++) {
1399             E = Spine->Edges(IE);
1400             if (  (TopExp::FirstVertex(E).IsSame(Pc.Vertex())) 
1401                 ||(TopExp::LastVertex(E) .IsSame(Pc.Vertex())) ) {
1402               for(ItF.Initialize(myEFMap(E)), Trouve=Standard_False;
1403                   ItF.More()&&(!Trouve); ItF.Next()) {
1404                 if (TopoDS::Face(ItF.Value()).IsSame(FVoi)) {
1405                   Trouve = Standard_True;
1406                 }
1407               }
1408             }
1409           } 
1410           FindFace = Trouve;
1411         }
1412       }
1413     }
1414   }
1415   else {
1416     return IsG1(myEFMap, Pc.Arc(), FRef, FVoi);
1417   }
1418   return Standard_False;
1419 }
1420
1421
1422 //=======================================================================
1423 //function : ChFi3d_SingularExtremity
1424 //purpose  : load the vertex in the DS and calculate the pcurve 
1425 //           for an extremity in case of singular freeboundary 
1426 //           or periodic and singular at the cut.
1427 //=======================================================================
1428 static void ChFi3d_SingularExtremity( Handle(ChFiDS_Stripe)&     stripe,
1429                                      TopOpeBRepDS_DataStructure& DStr,
1430                                      const TopoDS_Vertex&        Vtx,      
1431                                      const Standard_Real         tol3d,
1432                                      const Standard_Real         tol2d)
1433 {
1434   Handle(ChFiDS_SurfData) Fd;
1435   Standard_Real tolreached;
1436   Standard_Real Pardeb, Parfin; 
1437   gp_Pnt2d VOnS1, VOnS2;
1438   Handle(Geom_Curve) C3d;
1439   Handle(Geom2d_Curve) PCurv;
1440   TopOpeBRepDS_Curve Crv;
1441   // SurfData and its CommonPoints,
1442   Standard_Integer Ivtx, Icurv;
1443   Standard_Boolean isfirst;
1444   
1445   if  (stripe->Spine()->IsPeriodic()) {
1446      isfirst = Standard_True;
1447      Fd = stripe->SetOfSurfData()->Sequence().First();
1448    }
1449   else {
1450     Standard_Integer sens;
1451     Standard_Integer num = ChFi3d_IndexOfSurfData(Vtx,stripe,sens);
1452     Fd =  stripe->SetOfSurfData()->Sequence().Value(num);
1453     isfirst = (sens == 1);
1454   }
1455  
1456   const ChFiDS_CommonPoint& CV1 = Fd->Vertex(isfirst,1);
1457   const ChFiDS_CommonPoint& CV2 = Fd->Vertex(isfirst,2);
1458   // Is it always degenerated ?
1459   if ( CV1.Point().IsEqual( CV2.Point(), 0) ) { 
1460     Ivtx = ChFi3d_IndexPointInDS(CV1, DStr);
1461     if (isfirst) {
1462       VOnS1 = Fd->InterferenceOnS1().PCurveOnSurf()->
1463                    Value(Fd->InterferenceOnS1().FirstParameter());
1464       VOnS2 = Fd->InterferenceOnS2().PCurveOnSurf()->
1465                      Value(Fd->InterferenceOnS2().FirstParameter());
1466     }
1467     else {
1468       VOnS1 = Fd->InterferenceOnS1().PCurveOnSurf()->
1469                     Value(Fd->InterferenceOnS1().LastParameter());
1470       VOnS2 = Fd->InterferenceOnS2().PCurveOnSurf()->
1471                     Value(Fd->InterferenceOnS2().LastParameter());
1472     }
1473       
1474     ChFi3d_ComputeArete(CV1, VOnS1,
1475                         CV2, VOnS2,
1476                         DStr.Surface(Fd->Surf()).Surface(),
1477                         C3d, PCurv,
1478                         Pardeb,Parfin, tol3d, tol2d, tolreached,0);
1479     Crv = TopOpeBRepDS_Curve(C3d,tolreached);
1480     Icurv = DStr.AddCurve(Crv);
1481
1482     stripe->SetCurve(Icurv, isfirst);
1483     stripe->SetParameters(isfirst, Pardeb,Parfin);
1484     stripe->ChangePCurve(isfirst) = PCurv;
1485     stripe->SetIndexPoint(Ivtx, isfirst, 1);
1486     stripe->SetIndexPoint(Ivtx, isfirst, 2);
1487
1488     if (stripe->Spine()->IsPeriodic()) { 
1489       // periodic case : The operation is renewed
1490       // the curve 3d is not shared.
1491       // 2 degenerated edges coinciding in 3d
1492       isfirst = Standard_False;
1493       Fd = stripe->SetOfSurfData()->Sequence().Last();
1494       VOnS1 = Fd->InterferenceOnS1().PCurveOnSurf()->
1495               Value(Fd->InterferenceOnS1().LastParameter());
1496       VOnS2 = Fd->InterferenceOnS2().PCurveOnSurf()->
1497               Value(Fd->InterferenceOnS2().LastParameter());
1498
1499       ChFi3d_ComputeArete(CV1, VOnS1,
1500                           CV2, VOnS2,
1501                           DStr.Surface(Fd->Surf()).Surface(),
1502                           C3d, PCurv,
1503                           Pardeb,Parfin, tol3d, tol2d, tolreached,0);
1504       Crv = TopOpeBRepDS_Curve(C3d,tolreached);
1505       Icurv = DStr.AddCurve(Crv);
1506
1507       stripe->SetCurve(Icurv, isfirst);
1508       stripe->SetParameters(isfirst, Pardeb,Parfin);
1509       stripe->ChangePCurve(isfirst) = PCurv;
1510       stripe->SetIndexPoint(Ivtx, isfirst, 1);
1511       stripe->SetIndexPoint(Ivtx, isfirst, 2);    
1512     }
1513   }
1514 }
1515
1516 //=======================================================================
1517 //function : ChFi3d_MakeExtremities
1518 //purpose  : calculate Curves3d and pcurves of extremities in
1519 //           periodic and freeboundary cases.
1520 //=======================================================================
1521 static Standard_Boolean IsFree(const TopoDS_Shape& E,
1522                                const ChFiDS_Map&   EFMap)
1523 {
1524   if(!EFMap.Contains(E)) return 0;
1525   TopTools_ListIteratorOfListOfShape It;
1526   TopoDS_Shape Fref;
1527   for(It.Initialize(EFMap(E)); It.More(); It.Next()){
1528     if(Fref.IsNull()) Fref = It.Value();
1529     else if(!Fref.IsSame(It.Value())) return 0;
1530   }
1531   return 1;
1532 }
1533
1534 static void ChFi3d_MakeExtremities(Handle(ChFiDS_Stripe)&      Stripe,
1535                                    TopOpeBRepDS_DataStructure& DStr,
1536                                    const ChFiDS_Map&           EFMap,
1537                                    const Standard_Real         tol3d,
1538                                    const Standard_Real         tol2d)
1539 {
1540   Handle(ChFiDS_Spine)& sp = Stripe->ChangeSpine();
1541   Standard_Real Pardeb,Parfin;
1542   Handle(Geom_Curve) C3d;
1543   Standard_Real tolreached;
1544   if(sp->IsPeriodic()){
1545     Bnd_Box b1,b2;
1546     const Handle(ChFiDS_SurfData)& 
1547       SDF = Stripe->SetOfSurfData()->Sequence().First();
1548     const ChFiDS_CommonPoint& CV1 = SDF->VertexFirstOnS1();
1549     const ChFiDS_CommonPoint& CV2 = SDF->VertexFirstOnS2();
1550     if ( !CV1.Point().IsEqual(CV2.Point(), 0) ) { 
1551       ChFi3d_ComputeArete(CV1,
1552                           SDF->InterferenceOnS1().PCurveOnSurf()->
1553                           Value(SDF->InterferenceOnS1().FirstParameter()),
1554                           CV2,
1555                           SDF->InterferenceOnS2().PCurveOnSurf()-> 
1556                           Value(SDF->InterferenceOnS2().FirstParameter()),
1557                           DStr.Surface(SDF->Surf()).Surface(),C3d,
1558                           Stripe->ChangeFirstPCurve(),Pardeb,Parfin,
1559                           tol3d,tol2d,tolreached,0);
1560       TopOpeBRepDS_Curve Crv(C3d,tolreached);
1561       Stripe->ChangeFirstCurve(DStr.AddCurve(Crv));
1562       Stripe->ChangeFirstParameters(Pardeb,Parfin);
1563       Stripe->ChangeIndexFirstPointOnS1
1564         (ChFi3d_IndexPointInDS(SDF->VertexFirstOnS1(),DStr));
1565       Stripe->ChangeIndexFirstPointOnS2
1566         (ChFi3d_IndexPointInDS(SDF->VertexFirstOnS2(),DStr));
1567       Standard_Integer ICurv = Stripe->FirstCurve();
1568       Stripe->ChangeLastParameters(Pardeb,Parfin);
1569       Stripe->ChangeLastCurve(ICurv);
1570       Stripe->ChangeIndexLastPointOnS1(Stripe->IndexFirstPointOnS1());
1571       Stripe->ChangeIndexLastPointOnS2(Stripe->IndexFirstPointOnS2());
1572       
1573       const Handle(ChFiDS_SurfData)& 
1574         SDL = Stripe->SetOfSurfData()->Sequence().Last();
1575       
1576       
1577       ChFi3d_ComputePCurv(C3d,
1578                           SDL->InterferenceOnS1().PCurveOnSurf()->
1579                           Value(SDL->InterferenceOnS1().LastParameter()),
1580                           SDL->InterferenceOnS2().PCurveOnSurf()->
1581                           Value(SDL->InterferenceOnS2().LastParameter()),
1582                           Stripe->ChangeLastPCurve(),
1583                           DStr.Surface(SDL->Surf()).Surface(),
1584                           Pardeb,Parfin,tol3d,tolreached);
1585       Standard_Real oldtol = DStr.ChangeCurve(ICurv).Tolerance();
1586       DStr.ChangeCurve(ICurv).Tolerance(Max(oldtol,tolreached));
1587       if(CV1.IsOnArc()){
1588         ChFi3d_EnlargeBox(CV1.Arc(),EFMap(CV1.Arc()),CV1.ParameterOnArc(),b1);
1589       }
1590       
1591       if(CV2.IsOnArc()){
1592         ChFi3d_EnlargeBox(CV2.Arc(),EFMap(CV2.Arc()),CV2.ParameterOnArc(),b2);
1593       }
1594       ChFi3d_EnlargeBox(DStr,Stripe,SDF,b1,b2,1);
1595       ChFi3d_EnlargeBox(DStr,Stripe,SDL,b1,b2,0);
1596       if (!CV1.IsVertex())
1597         ChFi3d_SetPointTolerance(DStr,b1,Stripe->IndexFirstPointOnS1());
1598       if (!CV2.IsVertex())
1599         ChFi3d_SetPointTolerance(DStr,b2,Stripe->IndexFirstPointOnS2());
1600     }
1601     else {
1602       // Case of the single extremity
1603       if (CV1.IsVertex()) { 
1604         ChFi3d_SingularExtremity(Stripe, DStr, CV1.Vertex(), tol3d, tol2d);
1605       }
1606 # if CHFI3D_DEB
1607       else { cout << "MakeExtremities : Singularity out of Vertex !!" << endl; }
1608 # endif
1609     }
1610     return;
1611   }  
1612   
1613   const Handle(ChFiDS_SurfData)& 
1614     SDdeb = Stripe->SetOfSurfData()->Sequence().First();
1615     
1616   const ChFiDS_CommonPoint& cpdeb1 = SDdeb->VertexFirstOnS1();
1617   const ChFiDS_CommonPoint& cpdeb2 = SDdeb->VertexFirstOnS2();
1618   Standard_Boolean freedeb = sp->FirstStatus() == ChFiDS_FreeBoundary;
1619   if(!freedeb && cpdeb1.IsOnArc() && cpdeb2.IsOnArc()){
1620     freedeb = (IsFree(cpdeb1.Arc(),EFMap) && IsFree(cpdeb2.Arc(),EFMap));
1621   }
1622   if(freedeb){
1623     sp->SetFirstStatus(ChFiDS_FreeBoundary);
1624     Bnd_Box b1,b2;
1625     if ( !cpdeb1.Point().IsEqual(cpdeb2.Point(), 0) ) { 
1626       Standard_Boolean plane;  
1627       gp_Pnt2d UV1,UV2;
1628       UV1=SDdeb->InterferenceOnS1().PCurveOnSurf()->
1629                           Value(SDdeb->InterferenceOnS1().FirstParameter());     
1630       UV2=SDdeb->InterferenceOnS2().PCurveOnSurf()->
1631                           Value(SDdeb->InterferenceOnS2().FirstParameter());
1632 // The intersection of the fillet by a plane is attempted
1633
1634       Handle(GeomAdaptor_HSurface) HConge=ChFi3d_BoundSurf(DStr,SDdeb,1,2);
1635       ChFi3d_CoupeParPlan(cpdeb1,cpdeb2,HConge,UV1,UV2,
1636                           tol3d,tol2d,C3d,Stripe->ChangeFirstPCurve(),tolreached,
1637                           Pardeb,Parfin,plane);  
1638       if (!plane) 
1639       ChFi3d_ComputeArete(cpdeb1,
1640                           SDdeb->InterferenceOnS1().PCurveOnSurf()->
1641                           Value(SDdeb->InterferenceOnS1().FirstParameter()),
1642                           cpdeb2,
1643                           SDdeb->InterferenceOnS2().PCurveOnSurf()-> 
1644                           Value(SDdeb->InterferenceOnS2().FirstParameter()),
1645                           DStr.Surface(SDdeb->Surf()).Surface(),C3d,
1646                           Stripe->ChangeFirstPCurve(),Pardeb,Parfin,
1647                           tol3d,tol2d,tolreached,0);
1648       TopOpeBRepDS_Curve Crv(C3d,tolreached);
1649       Stripe->ChangeFirstCurve(DStr.AddCurve(Crv));
1650       Stripe->ChangeFirstParameters(Pardeb,Parfin);
1651       Stripe->ChangeIndexFirstPointOnS1
1652         (ChFi3d_IndexPointInDS(SDdeb->VertexFirstOnS1(),DStr));
1653       Stripe->ChangeIndexFirstPointOnS2
1654         (ChFi3d_IndexPointInDS(SDdeb->VertexFirstOnS2(),DStr));
1655       if(cpdeb1.IsOnArc()){
1656         ChFi3d_EnlargeBox(cpdeb1.Arc(),EFMap(cpdeb1.Arc()),cpdeb1.ParameterOnArc(),b1);
1657       }
1658       if(cpdeb2.IsOnArc()){
1659         ChFi3d_EnlargeBox(cpdeb2.Arc(),EFMap(cpdeb2.Arc()),cpdeb2.ParameterOnArc(),b2);
1660       }
1661       ChFi3d_EnlargeBox(DStr,Stripe,SDdeb,b1,b2,1);
1662       if (!cpdeb1.IsVertex())
1663         ChFi3d_SetPointTolerance(DStr,b1,Stripe->IndexFirstPointOnS1());
1664       if (!cpdeb2.IsVertex())
1665         ChFi3d_SetPointTolerance(DStr,b2,Stripe->IndexFirstPointOnS2());
1666     }
1667     else { // Case of a singular extremity
1668       if (cpdeb1.IsVertex()) { 
1669         ChFi3d_SingularExtremity(Stripe, DStr, cpdeb1.Vertex(), tol3d, tol2d);
1670       }
1671 # if CHFI3D_DEB
1672       else { cout << "MakeExtremities : Singularity out of Vertex !!" << endl; }
1673 # endif
1674     }
1675   }
1676   const Handle(ChFiDS_SurfData)& 
1677     SDfin = Stripe->SetOfSurfData()->Sequence().Last();
1678   const ChFiDS_CommonPoint& cpfin1 = SDfin->VertexLastOnS1();
1679   const ChFiDS_CommonPoint& cpfin2 = SDfin->VertexLastOnS2();
1680   Standard_Boolean freefin = sp->LastStatus() == ChFiDS_FreeBoundary;
1681   if(!freefin && cpfin1.IsOnArc() && cpfin2.IsOnArc()){
1682     freefin = (IsFree(cpfin1.Arc(),EFMap) && IsFree(cpfin2.Arc(),EFMap));
1683   }
1684   if(freefin){
1685     sp->SetLastStatus(ChFiDS_FreeBoundary);
1686     Bnd_Box b1,b2;
1687     if ( !cpfin1.Point().IsEqual(cpfin2.Point(), 0) ) { 
1688       Standard_Boolean plane;
1689       gp_Pnt2d UV1,UV2;
1690       UV1=SDfin->InterferenceOnS1().PCurveOnSurf()->
1691                           Value(SDfin->InterferenceOnS1().LastParameter());     
1692       UV2=SDfin->InterferenceOnS2().PCurveOnSurf()->
1693                           Value(SDfin->InterferenceOnS2().LastParameter());
1694 // Intersection of the fillet by a plane is attempted
1695
1696       Handle(GeomAdaptor_HSurface) HConge=ChFi3d_BoundSurf(DStr,SDfin,1,2);
1697       ChFi3d_CoupeParPlan(cpfin1,cpfin2,HConge,UV1,UV2,
1698                           tol3d,tol2d,C3d,Stripe->ChangeLastPCurve(),tolreached,
1699                           Pardeb,Parfin,plane);      
1700       if (!plane)   
1701       ChFi3d_ComputeArete(cpfin1,
1702                           SDfin->InterferenceOnS1().PCurveOnSurf()->
1703                           Value(SDfin->InterferenceOnS1().LastParameter()),
1704                           cpfin2,
1705                           SDfin->InterferenceOnS2().PCurveOnSurf()-> 
1706                           Value(SDfin->InterferenceOnS2().LastParameter()),
1707                           DStr.Surface(SDfin->Surf()).Surface(),C3d,
1708                           Stripe->ChangeLastPCurve(),Pardeb,Parfin,
1709                           tol3d,tol2d,tolreached,0);
1710       TopOpeBRepDS_Curve Crv(C3d,tolreached);
1711       Stripe->ChangeLastCurve(DStr.AddCurve(Crv));
1712       Stripe->ChangeLastParameters(Pardeb,Parfin);
1713       Stripe->ChangeIndexLastPointOnS1
1714         (ChFi3d_IndexPointInDS(SDfin->VertexLastOnS1(),DStr));
1715       Stripe->ChangeIndexLastPointOnS2
1716         (ChFi3d_IndexPointInDS(SDfin->VertexLastOnS2(),DStr));
1717       if(cpfin1.IsOnArc()){
1718         ChFi3d_EnlargeBox(cpfin1.Arc(),EFMap(cpfin1.Arc()),cpfin1.ParameterOnArc(),b1);
1719       }
1720       if(cpfin2.IsOnArc()){
1721         ChFi3d_EnlargeBox(cpfin2.Arc(),EFMap(cpfin2.Arc()),cpfin2.ParameterOnArc(),b2);
1722       }
1723       ChFi3d_EnlargeBox(DStr,Stripe,SDfin,b1,b2,0);
1724       if (!cpfin1.IsVertex())
1725         ChFi3d_SetPointTolerance(DStr,b1,Stripe->IndexLastPointOnS1());
1726       if (!cpfin2.IsVertex())
1727         ChFi3d_SetPointTolerance(DStr,b2,Stripe->IndexLastPointOnS2());
1728     }
1729     else { // Case of the single extremity
1730       if (cpfin1.IsVertex()) { 
1731         ChFi3d_SingularExtremity(Stripe, DStr, cpfin1.Vertex(), tol3d, tol2d);
1732       }
1733 # if CHFI3D_DEB
1734       else { cout << "MakeExtremities : Singularity out of Vertex !!" << endl; }
1735 # endif
1736     }
1737   }
1738 }
1739
1740 //=======================================================================
1741 //function : ChFi3d_Purge
1742 //purpose  : 
1743 //=======================================================================
1744
1745 static void ChFi3d_Purge (Handle(ChFiDS_Stripe)&    Stripe,
1746                           Handle(ChFiDS_SurfData)&  SD,
1747                           const ChFiDS_CommonPoint& VRef,
1748                           const Standard_Boolean    isfirst,
1749                           const Standard_Integer    ons,
1750                           Standard_Boolean&         intf,
1751                           Standard_Boolean&         intl)
1752 {
1753   if (isfirst) intf = 1; else intl = 1; // End.
1754   Standard_Integer opp = 3-ons;
1755   if (!SD->Vertex(isfirst,opp).IsOnArc() || 
1756       SD->TwistOnS1() || SD->TwistOnS2() ) {
1757 #ifdef OCCT_DEBUG
1758     cout<<"ChFi3d_Purge : No output on extension."<<endl;
1759 #endif
1760     ChFiDS_SequenceOfSurfData& Seq = 
1761       Stripe->ChangeSetOfSurfData()->ChangeSequence();
1762     if(isfirst) Seq.Remove(1);
1763     else Seq.Remove(Seq.Length());
1764     return;
1765   }
1766   if (ons == 1) SD->ChangeIndexOfS1(0);
1767   else          SD->ChangeIndexOfS2(0);
1768   
1769   SD->ChangeVertex(!isfirst,ons) = VRef;
1770   SD->ChangeVertex(isfirst,ons)  = VRef;
1771   
1772   ChFiDS_FaceInterference& fi = SD->ChangeInterference(ons);
1773   if(isfirst) fi.SetFirstParameter(fi.LastParameter());
1774   else fi.SetLastParameter(fi.FirstParameter());
1775   fi.SetLineIndex(0);
1776 }
1777
1778 //=======================================================================
1779 //function : InsertAfter
1780 //purpose  : insert Item after ref in Seq. If ref is null, the item is
1781 //           inserted at the beginning.
1782 //=======================================================================
1783
1784 static void InsertAfter (Handle(ChFiDS_Stripe)&   Stripe,
1785                          Handle(ChFiDS_SurfData)& Ref,
1786                          Handle(ChFiDS_SurfData)& Item)
1787 {
1788   if (Ref == Item) 
1789     Standard_Failure::Raise("InsertAfter : twice the same surfdata.");
1790   
1791   ChFiDS_SequenceOfSurfData& Seq = 
1792     Stripe->ChangeSetOfSurfData()->ChangeSequence();
1793   
1794   if (Seq.IsEmpty() || Ref.IsNull()) {
1795     Seq.Prepend(Item);
1796   }
1797   for (Standard_Integer i = 1; i <= Seq.Length(); i++) {
1798     if (Seq.Value(i) == Ref) {
1799       Seq.InsertAfter(i,Item);
1800       break;
1801     }
1802   }
1803 }
1804
1805 //=======================================================================
1806 //function : RemoveSD
1807 //purpose  : 
1808 //=======================================================================
1809
1810 static void RemoveSD (Handle(ChFiDS_Stripe)&   Stripe,
1811                       Handle(ChFiDS_SurfData)& Prev,
1812                       Handle(ChFiDS_SurfData)& Next)
1813 {
1814   ChFiDS_SequenceOfSurfData& Seq = 
1815     Stripe->ChangeSetOfSurfData()->ChangeSequence();
1816   if(Seq.IsEmpty()) return;
1817   Standard_Integer iprev = 0, inext = 0;
1818   for (Standard_Integer i = 1; i <= Seq.Length(); i++) {
1819     if (Seq.Value(i) == Prev) iprev = i + 1;
1820     if (Seq.Value(i) == Next) { inext = i - 1; break; }
1821   }
1822   if(Prev.IsNull()) iprev = 1;
1823   if(Next.IsNull()) inext = Seq.Length();
1824   if(iprev <= inext) Seq.Remove(iprev,inext);
1825 }
1826
1827 //=======================================================================
1828 //function : InsertBefore
1829 //purpose  : Insert item before ref in Seq. If ref is null, the item is
1830 //           inserted in the queue.
1831 //=======================================================================
1832
1833 static void InsertBefore (Handle(ChFiDS_Stripe)&   Stripe,
1834                           Handle(ChFiDS_SurfData)& Ref,
1835                           Handle(ChFiDS_SurfData)& Item)
1836 {
1837   if (Ref == Item) 
1838     Standard_Failure::Raise("InsertBefore : twice the same surfdata.");
1839   
1840   ChFiDS_SequenceOfSurfData& Seq = 
1841     Stripe->ChangeSetOfSurfData()->ChangeSequence();
1842   
1843   if (Seq.IsEmpty() || Ref.IsNull()) {
1844     Seq.Append(Item);
1845   }
1846   for (Standard_Integer i = 1; i <= Seq.Length(); i++) {
1847     if (Seq.Value(i) == Ref) {
1848       Seq.InsertBefore(i,Item);
1849       break;
1850     }
1851   }
1852 }
1853
1854
1855 //=======================================================================
1856 //function : PerformSetOfSurfOnElSpine
1857 //purpose  : 
1858 //=======================================================================
1859
1860 void ChFi3d_Builder::PerformSetOfSurfOnElSpine
1861 (const Handle(ChFiDS_HElSpine)&    HGuide,
1862  Handle(ChFiDS_Stripe)&            Stripe,
1863  Handle(BRepTopAdaptor_TopolTool)& It1,
1864  Handle(BRepTopAdaptor_TopolTool)& It2,
1865  const Standard_Boolean            Simul)
1866
1867 #ifdef OCCT_DEBUG
1868   OSD_Chronometer ch1;
1869 #endif 
1870   
1871   ChFiDS_ElSpine& Guide = HGuide->ChangeCurve();
1872   Standard_Real wf = Guide.FirstParameter();
1873   Standard_Real wl = Guide.LastParameter();
1874   Standard_Real locfleche = (wl - wf) * fleche;
1875   Standard_Real wfsav = wf, wlsav = wl;
1876   if (!Guide.IsPeriodic())
1877   {
1878     //Now the ElSpine is artificially extended to help rsnld.
1879     Standard_Real prab = 0.01;
1880     Guide.FirstParameter(wf-prab*(wl-wf));
1881     Guide.LastParameter (wl+prab*(wl-wf));
1882   }
1883   Handle(ChFiDS_Spine)&  Spine = Stripe->ChangeSpine();
1884   Standard_Integer ii, nbed = Spine->NbEdges();
1885   Standard_Real lastedlastp = Spine->LastParameter(nbed);
1886   
1887   TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
1888   
1889   Handle(ChFiDS_SurfData) ref = Guide.Previous();
1890   Handle(ChFiDS_SurfData) refbis, SD;
1891   Handle(ChFiDS_SurfData) raf = Guide.Next();
1892   RemoveSD(Stripe,ref,raf);
1893   
1894   Handle(BRepAdaptor_HSurface) HS1 = new BRepAdaptor_HSurface();
1895   Handle(BRepAdaptor_HSurface) HS2 = new BRepAdaptor_HSurface();
1896   Handle(BRepAdaptor_HSurface) HS3, HS4;
1897   Handle(BRepAdaptor_HSurface) HSref1 = new BRepAdaptor_HSurface();
1898   Handle(BRepAdaptor_HSurface) HSref2 = new BRepAdaptor_HSurface();
1899   Handle(BRepAdaptor_HCurve2d) HC1,HC2;
1900   Handle(BRepAdaptor_HCurve2d) HCref1 = new BRepAdaptor_HCurve2d();
1901   Handle(BRepAdaptor_HCurve2d) HCref2 = new BRepAdaptor_HCurve2d();
1902   Standard_Boolean decroch1 = Standard_False, decroch2 = Standard_False;
1903   Standard_Boolean RecP1 = Standard_False, RecS1 = Standard_False, RecRst1 = Standard_False, obstacleon1 = Standard_False;
1904   Standard_Boolean RecP2 = Standard_False, RecS2 = Standard_False, RecRst2 = Standard_False, obstacleon2 = Standard_False;
1905   gp_Pnt2d pp1,pp2,pp3,pp4;
1906   Standard_Real w1 = 0.,w2 = 0.;
1907   math_Vector Soldep(1,4);
1908   math_Vector SoldepCS(1,3);
1909   math_Vector SoldepCC(1,2);
1910   
1911   // Restore a neighboring KPart.
1912   // If no neighbor calculation start point. 
1913   Standard_Boolean forward = Standard_True;
1914   Standard_Boolean Inside  = Standard_False;
1915   Standard_Real    First   = wf;
1916   Standard_Real    Last    = wl;
1917   Standard_Boolean Ok1 = 1,Ok2 = 1;
1918   // Restore the next KPart if it exists
1919   TopoDS_Vertex Vref;
1920   if(ref.IsNull() && raf.IsNull()){
1921     //sinon solution approchee.
1922     Inside = Standard_True;
1923     
1924 #ifdef OCCT_DEBUG
1925     ChFi3d_InitChron(ch1);// init perf for StartSol 
1926 #endif
1927     
1928     StartSol(Stripe,HGuide,HS1,HS2,It1,It2,pp1,pp2,First);
1929     
1930 #ifdef OCCT_DEBUG
1931     ChFi3d_ResultChron(ch1,t_startsol); // result perf for StartSol  
1932 #endif 
1933     
1934     Last = wf;
1935     if(Guide.IsPeriodic()) {
1936       Last = First - Guide.Period();
1937       Guide.SaveFirstParameter();
1938       Guide.FirstParameter(Last);
1939       Guide.SaveLastParameter();
1940       Guide.LastParameter (First * 1.1);//Extension to help rsnld.
1941     }
1942   }
1943   else{
1944     if(!Spine->IsPeriodic() && (wl - lastedlastp > -tolesp)){ 
1945       Vref = Spine->LastVertex(); 
1946     }
1947     if (ref.IsNull()) {
1948       if(!Spine->IsPeriodic() && (wf < tolesp)){ 
1949         Vref = Spine->FirstVertex(); 
1950       }
1951       ref = raf;
1952       forward = Standard_False;
1953       First = wl; Last = Guide.FirstParameter();
1954     }
1955     
1956 #ifdef OCCT_DEBUG
1957     ChFi3d_InitChron(ch1);// init perf for startsol 
1958 #endif
1959     
1960     
1961     Ok1 = StartSol(Spine,HS1,pp1,HC1,w1,ref,!forward,1,
1962                    HSref1,HCref1,RecP1,RecS1,RecRst1,obstacleon1,
1963                    HS3,pp3,decroch1,Vref);
1964     Ok2 = StartSol(Spine,HS2,pp2,HC2,w2,ref,!forward,2,
1965                    HSref2,HCref2, RecP2,RecS2,RecRst2,obstacleon2,
1966                    HS4,pp4,decroch2,Vref);
1967     HC1.Nullify(); 
1968     HC2.Nullify();
1969     
1970 #ifdef OCCT_DEBUG
1971     ChFi3d_ResultChron(ch1,t_startsol); // result perf for startsol  
1972 #endif
1973     
1974     
1975     if(Ok1 == 1 && Ok2 == 1) {
1976       if(forward) Guide.FirstParameter(wf);
1977       else Guide.LastParameter(wl);
1978     }
1979   }
1980   Standard_Boolean      fini     = Standard_False;
1981   Standard_Boolean      complete = Inside;
1982   if(!Guide.IsPeriodic()){
1983     Standard_Integer indf = Spine->Index(wf);
1984     Standard_Integer indl = Spine->Index(wl,0);
1985     if(Spine->IsPeriodic() && (indl < indf)) indl += nbed;
1986     nbed = indl-indf+1;
1987   }
1988   // No Max at the touch : 20 points by edge at average without  
1989   // counting the extensions.
1990
1991   Standard_Real bidf = wf, bidl = wl;
1992   if(!Spine->IsPeriodic()) {
1993     bidf = Max(0.,wf);
1994     bidl = Min(wl,Spine->LastParameter(Spine->NbEdges()));
1995     // PMN 20/07/98 : Attention in case if there is only extension
1996     if  ((bidl-bidf) < 0.01 * Spine->LastParameter(Spine->NbEdges())) {
1997        bidf = wf;
1998        bidl = wl;
1999     }   
2000   }
2001   Standard_Real         MaxStep  = (bidl-bidf)*0.05/nbed;
2002   Standard_Real         Firstsov = 0.;
2003   Standard_Boolean      intf = 0, intl = 0;
2004   while(!fini){
2005     // are these the ends (no extension on periodic).
2006     Ok1 = 1,Ok2 = 1;
2007     if(!Spine->IsPeriodic()){
2008       if(wf < tolesp && (complete == Inside)){
2009         if(Spine->FirstStatus() == ChFiDS_OnSame) intf = 2;
2010         else intf = 1;
2011       }
2012       if(Spine->IsTangencyExtremity(Standard_True)){
2013         intf = 4;
2014         Guide.FirstParameter(wfsav);
2015       }
2016       if(wl - lastedlastp > -tolesp){
2017         if(Spine->LastStatus() == ChFiDS_OnSame) intl = 2;
2018         else intl = 1;
2019       }
2020       if(Spine->IsTangencyExtremity(Standard_False)){
2021         intl = 4;
2022         Guide.LastParameter(wlsav);
2023       }
2024     }
2025     if(intf && !forward) Vref = Spine->FirstVertex();
2026     if(intl && forward) Vref = Spine->LastVertex();
2027     if(!ref.IsNull()){
2028       
2029 #ifdef OCCT_DEBUG
2030       ChFi3d_InitChron(ch1);// init perf for StartSol 
2031 #endif
2032       
2033       Ok1 = StartSol(Spine,HS1,pp1,HC1,w1,ref,!forward,1,
2034                      HSref1,HCref1, RecP1,RecS1,RecRst1,obstacleon1,
2035                      HS3,pp3,decroch1,Vref);
2036       Ok2 = StartSol(Spine,HS2,pp2,HC2,w2,ref,!forward,2,
2037                      HSref2,HCref2, RecP2,RecS2,RecRst2,obstacleon2,
2038                      HS4,pp4,decroch2,Vref);
2039       
2040 #ifdef OCCT_DEBUG
2041       ChFi3d_ResultChron(ch1,t_startsol); // result perf for StartSol  
2042 #endif 
2043       
2044     }
2045     
2046     // No more connected faces. Construction of the tangent plane to continue the path 
2047     // till the output on the other face.
2048     if ((!Ok1 && HC1.IsNull()) || (!Ok2 && HC2.IsNull())) {
2049       if ((intf && !forward) || (intl && forward)) {
2050         if (!Ok1) ChFi3d_BuildPlane (DStr,HS1,pp1,ref,!forward,1);
2051         if (!Ok2) ChFi3d_BuildPlane (DStr,HS2,pp2,ref,!forward,2);      
2052         if(intf) intf = 5;
2053         else if(intl) intl = 5;
2054         if(forward) Guide.FirstParameter(wf);
2055         else Guide.LastParameter(wl);
2056       }
2057       else Standard_Failure::Raise("PerformSetOfSurfOnElSpine : Chaining is impossible.");
2058     }
2059     
2060     // Definition of the domain of patch It1, It2
2061     const Handle(Adaptor3d_HSurface)& HSon1 = HS1; // to avoid ambiguity
2062     const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
2063     It1->Initialize(HSon1);
2064     It2->Initialize(HSon2);
2065     
2066     // Calculate one (several if singularity) SurfaData
2067     SD = new ChFiDS_SurfData();
2068     ChFiDS_SequenceOfSurfData SeqSD;
2069     SeqSD.Append(SD);
2070     
2071     if(obstacleon1 && obstacleon2){
2072       TopAbs_Orientation Or1 = HSref1->ChangeSurface().Face().Orientation();
2073       TopAbs_Orientation Or2 = HSref2->ChangeSurface().Face().Orientation();
2074       Standard_Integer Choix = ChFi3d::NextSide(Or1,Or2,
2075                                                 Stripe->OrientationOnFace1(),
2076                                                 Stripe->OrientationOnFace2(),
2077                                                 Stripe->Choix());
2078
2079
2080       // Calculate the criterion of Choice edge / edge
2081       if (Choix%2 == 0) Choix = 4;
2082       else Choix = 1;
2083
2084       SoldepCC(1) = w1; SoldepCC(2) = w2;
2085       if(Simul){
2086         SimulSurf(SD,HGuide,Spine,Choix,
2087                   HS1,It1,HC1,HSref1,HCref1,decroch1,Or1,
2088                   HS2,It2,HC2,HSref2,HCref2,decroch2,Or2,
2089                   locfleche,tolesp,First,Last,Inside,Inside,forward,
2090                   RecP1,RecRst1,RecP2,RecRst2,SoldepCC);
2091       }
2092       else{
2093 #ifdef OCCT_DEBUG
2094         ChFi3d_InitChron(ch1); // init perf for PerformSurf 
2095 #endif
2096         PerformSurf(SeqSD,HGuide,Spine,Choix,
2097                     HS1,It1,HC1,HSref1,HCref1,decroch1,Or1,
2098                     HS2,It2,HC2,HSref2,HCref2,decroch2,Or2,
2099                     MaxStep,locfleche,tolesp,First,Last,Inside,Inside,forward,
2100                     RecP1,RecRst1,RecP2,RecRst2,SoldepCC);
2101 #ifdef OCCT_DEBUG
2102         ChFi3d_ResultChron(ch1,t_performsurf); //result  perf for PerformSurf 
2103 #endif 
2104       }
2105       SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2106       SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2107     }
2108     else if (obstacleon1){
2109       TopAbs_Orientation Or1 = HSref1->ChangeSurface().Face().Orientation();
2110       TopAbs_Orientation Or2 = HS2->ChangeSurface().Face().Orientation();
2111       Standard_Integer Choix = ChFi3d::NextSide(Or1,Or2,
2112                                                 Stripe->OrientationOnFace1(),
2113                                                 Stripe->OrientationOnFace2(),
2114                                                 -Stripe->Choix());
2115       if(Choix%2 == 1) Choix++;
2116       else Choix--;
2117       SoldepCS(3) = w1; SoldepCS(1) =  pp2.X(); SoldepCS(2) =  pp2.Y();
2118       if(Simul){
2119         SimulSurf(SD,HGuide,Spine,Choix,HS1,It1,HC1,HSref1,HCref1,decroch1,
2120                   HS2,It2,Or2,locfleche,tolesp,First,Last,
2121                   Inside,Inside,forward,RecP1,RecS2,RecRst1,SoldepCS);
2122       }
2123       else{
2124 #ifdef OCCT_DEBUG
2125         ChFi3d_InitChron(ch1); // init perf for PerformSurf
2126 #endif
2127         PerformSurf(SeqSD,HGuide,Spine,Choix,HS1,It1,HC1,HSref1,HCref1,decroch1,
2128                     HS2,It2,Or2,MaxStep,locfleche,tolesp,First,Last,
2129                     Inside,Inside,forward,RecP1,RecS2,RecRst1,SoldepCS);
2130 #ifdef OCCT_DEBUG
2131         ChFi3d_ResultChron(ch1,t_performsurf);//result  perf for PerformSurf  
2132 #endif 
2133       }
2134       SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2135       SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2136       decroch2 = 0;
2137     }
2138     else if (obstacleon2){
2139       TopAbs_Orientation Or1 = HS1->ChangeSurface().Face().Orientation();
2140       TopAbs_Orientation Or2 = HSref2->ChangeSurface().Face().Orientation();
2141       Standard_Integer Choix = ChFi3d::NextSide(Or1,Or2,
2142                                                 Stripe->OrientationOnFace1(),
2143                                                 Stripe->OrientationOnFace2(),
2144                                                 Stripe->Choix());
2145       SoldepCS(3) = w2; SoldepCS(1) =  pp1.X(); SoldepCS(2) =  pp1.Y();
2146       if(Simul){
2147         SimulSurf(SD,HGuide,Spine,Choix,HS1,It1,Or1,
2148                   HS2,It2,HC2,HSref2,HCref2,decroch2,locfleche,tolesp,
2149                   First,Last,Inside,Inside,forward,RecP2,RecS1,RecRst2,SoldepCS);
2150       }
2151       else{
2152 #ifdef OCCT_DEBUG
2153         ChFi3d_InitChron(ch1); // init perf for PerformSurf 
2154 #endif
2155         PerformSurf(SeqSD,HGuide,Spine,Choix,HS1,It1,Or1,
2156                     HS2,It2,HC2,HSref2,HCref2,decroch2,MaxStep,locfleche,tolesp,
2157                     First,Last,Inside,Inside,forward,RecP2,RecS1,RecRst2,SoldepCS);
2158 #ifdef OCCT_DEBUG
2159         ChFi3d_ResultChron(ch1,t_performsurf); //result  perf for PerformSurf 
2160 #endif 
2161       }
2162       SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2163       SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2164       decroch1 = 0;
2165     }
2166     else{ 
2167       const Handle(Adaptor3d_TopolTool)& aTT1 = It1; // to avoid ambiguity
2168       const Handle(Adaptor3d_TopolTool)& aTT2 = It2; // to avoid ambiguity
2169       CallPerformSurf(Stripe, Simul, SeqSD, SD,
2170                       HGuide,Spine,
2171                       HS1, HS3, pp1, pp3, aTT1,
2172                       HS2, HS4, pp2, pp4, aTT2, 
2173                       MaxStep,locfleche,tolesp,
2174                       First,Last,Inside,Inside,forward,
2175                       RecS1,RecS2,Soldep,intf,intl, 
2176                       HS1, HS2);
2177       decroch1 = decroch2 = 0;
2178     }
2179
2180     if(!done) { // Case of fail
2181       if ((!Ok1 && !obstacleon1) || (!Ok2 && !obstacleon2)) {
2182         //Fail in a part of extension is not serious
2183         //Here one stops.
2184         done = Standard_True;
2185         Inside = Standard_False;
2186         if (forward) intl = 1;
2187         else         intf = 1;
2188       }
2189       else { // Otherwise invalidation of the stripe.
2190         Spine->SetErrorStatus(ChFiDS_WalkingFailure);
2191         Standard_Failure::Raise("CallPerformSurf : Path failed!");
2192       }
2193     }
2194     
2195     else {
2196       refbis = ref;
2197       if(forward) {
2198         for (ii=1; ii<=SeqSD.Length(); ii++) {
2199           SD = SeqSD(ii);
2200           SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2201           if(obstacleon1) SD->SetIndexOfC1(DStr.AddShape(HC1->ChangeCurve2d().Edge()));
2202           SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2203           if(obstacleon2) SD->SetIndexOfC2(DStr.AddShape(HC2->ChangeCurve2d().Edge()));
2204           InsertAfter (Stripe, refbis, SD);
2205           refbis = SD;
2206         }
2207       }
2208       else {
2209         for (ii=SeqSD.Length(); ii>=1; ii--) {
2210           SD = SeqSD(ii);
2211           SD->ChangeIndexOfS1(DStr.AddShape(HS1->ChangeSurface().Face()));
2212           if(obstacleon1) SD->SetIndexOfC1(DStr.AddShape(HC1->ChangeCurve2d().Edge()));
2213           SD->ChangeIndexOfS2(DStr.AddShape(HS2->ChangeSurface().Face()));
2214           if(obstacleon2) SD->SetIndexOfC2(DStr.AddShape(HC2->ChangeCurve2d().Edge()));
2215           InsertBefore(Stripe,refbis,SD);
2216           refbis = SD;
2217         }
2218       } 
2219     
2220       if (!Ok1 && !obstacleon1) 
2221         // clean infos on the plane of extension.
2222         ChFi3d_Purge (Stripe,SD,ref->Vertex(!forward,1),!forward,1,intf,intl);
2223       
2224       if (!Ok2 && !obstacleon2) 
2225         // clean infos on the plane of extension.
2226         ChFi3d_Purge (Stripe,SD,ref->Vertex(!forward,2),!forward,2,intf,intl);
2227     
2228       // The end. The reference is changed.      
2229       ref = refbis;  
2230     }  
2231     
2232     if(Inside){// There are starting solutions for the next.
2233       Inside = Standard_False;
2234       Firstsov = First;
2235       if(Guide.IsPeriodic()) {
2236         complete = Standard_False;
2237         wf  = Guide.FirstParameter();
2238         wl  = Guide.LastParameter();
2239       }
2240     }
2241     if(forward){
2242       fini = ((wl - Last) <= 10.*tolesp || 
2243               (intl && !(obstacleon1 || obstacleon2))); //General case
2244
2245       if (!fini && Guide.IsPeriodic() && 
2246           ((wl - Last)< Guide.Period()*1.e-3)) {
2247         // It is tested if reframing of extremes is done at the same edge
2248         // Loop Condition
2249         Handle(ChFiDS_SurfData) thefirst, thelast;
2250         thefirst = Stripe->SetOfSurfData()->Sequence().First();
2251         thelast =  Stripe->SetOfSurfData()->Sequence().Last();
2252         
2253         if (thefirst->VertexFirstOnS1().IsOnArc() && 
2254             thelast->VertexLastOnS1().IsOnArc())
2255           fini = thefirst->VertexFirstOnS1().Arc().IsSame
2256             (thelast->VertexLastOnS1().Arc());
2257         if (!fini &&
2258             thefirst->VertexFirstOnS2().IsOnArc() && 
2259             thelast->VertexLastOnS2().IsOnArc())
2260           fini = thefirst->VertexFirstOnS2().Arc().IsSame
2261             (thelast->VertexLastOnS2().Arc());
2262
2263         if (fini) 
2264           return; //It is ended!
2265       }
2266
2267       if(fini && complete) {
2268         // restart in the opposite direction.
2269         ref  = Stripe->SetOfSurfData()->Sequence().First();
2270         forward = Standard_False;
2271         fini = Standard_False;
2272         First = Firstsov;
2273       }
2274       else {
2275         First = Last;
2276         Last  = wl;
2277       }
2278     }
2279     if(!forward){
2280       fini = ((First - wf) <= 10.*tolesp || 
2281               (intf && !(obstacleon1 || obstacleon2)));
2282       complete = Standard_False;
2283       Last = wf;
2284     }
2285   }
2286   // The initial state is restored
2287   if(!Guide.IsPeriodic()){
2288     Guide.FirstParameter(wfsav);
2289     Guide.LastParameter (wlsav);
2290   }
2291
2292 }
2293
2294 //=======================================================================
2295 //function : PerformSetOfKPart
2296 //purpose  : 
2297 //=======================================================================
2298
2299 void ChFi3d_Builder::PerformSetOfKPart(Handle(ChFiDS_Stripe)& Stripe,
2300                                        const Standard_Boolean Simul) 
2301 {
2302   TopOpeBRepDS_DataStructure&  DStr = myDS->ChangeDS();
2303   Handle(ChFiDS_Spine)&        Spine = Stripe->ChangeSpine();
2304   Handle(BRepAdaptor_HSurface) HS1,HS2;
2305   TopAbs_Orientation           Or1,Or2,RefOr1,RefOr2;
2306   Standard_Integer             RefChoix;
2307   
2308   // initialization of the stripe.
2309   Stripe->Reset();
2310   Handle(ChFiDS_HData)&  HData  = Stripe->ChangeSetOfSurfData();
2311   HData =  new ChFiDS_HData();
2312   ChFiDS_SequenceOfSurfData& SeqSurf = HData->ChangeSequence();
2313   
2314   StripeOrientations(Spine,RefOr1,RefOr2,RefChoix);
2315   Stripe->OrientationOnFace1(RefOr1);
2316   Stripe->OrientationOnFace2(RefOr2);
2317   Stripe->Choix(RefChoix);
2318   
2319   Handle(BRepTopAdaptor_TopolTool) It1 = new BRepTopAdaptor_TopolTool();
2320   Handle(BRepTopAdaptor_TopolTool) It2 = new BRepTopAdaptor_TopolTool();
2321   
2322   Standard_Real WFirst,WLast = 0.;
2323   gp_Vec TFirst,TLast,TEndPeriodic;
2324   gp_Pnt PFirst,PLast,PEndPeriodic;
2325   Standard_Boolean intf = 0, intl = 0;
2326   
2327   Handle(ChFiDS_HElSpine) CurrentHE = new ChFiDS_HElSpine();
2328   Spine->D1(Spine->FirstParameter(),PFirst,TFirst);
2329   CurrentHE->ChangeCurve().FirstParameter(Spine->FirstParameter());
2330   CurrentHE->ChangeCurve().SetFirstPointAndTgt(PFirst,TFirst);
2331   
2332   Standard_Boolean YaKPart = Standard_False;
2333   Standard_Integer iedgelastkpart = 0;
2334   
2335   Standard_Real WStartPeriodic = 0.;
2336   Standard_Real WEndPeriodic = Spine->LastParameter(Spine->NbEdges());
2337   Spine->D1(WEndPeriodic,PEndPeriodic,TEndPeriodic);
2338   
2339   // Construction of particular cases.
2340   
2341   for (Standard_Integer iedge = 1; iedge <= Spine->NbEdges(); iedge++){
2342     
2343     ConexFaces(Spine,iedge,RefChoix,HS1,HS2);
2344     
2345     if (ChFi3d_KParticular(Spine,iedge,HS1->ChangeSurface(),HS2->ChangeSurface())) {
2346       intf = ((iedge == 1) && !Spine->IsPeriodic());
2347       intl = ((iedge == Spine->NbEdges()) && !Spine->IsPeriodic());
2348       Or1   = HS1->ChangeSurface().Face().Orientation();
2349       Or2   = HS2->ChangeSurface().Face().Orientation();
2350       ChFi3d::NextSide(Or1,Or2,RefOr1,RefOr2,RefChoix);      
2351       const Handle(Adaptor3d_HSurface)& HSon1 = HS1; // to avoid ambiguity
2352       const Handle(Adaptor3d_HSurface)& HSon2 = HS2; // to avoid ambiguity
2353       It1->Initialize(HSon1);
2354       It2->Initialize(HSon2);
2355       
2356       Handle(ChFiDS_SurfData)   SD = new ChFiDS_SurfData();
2357       ChFiDS_SequenceOfSurfData LSD;
2358       
2359       if(!ChFiKPart_ComputeData::Compute(DStr,SD,HS1,HS2,Or1,Or2,Spine,iedge)){
2360 #ifdef OCCT_DEBUG
2361         cout<<"failed calculation KPart"<<endl;
2362 #endif
2363       }
2364       else if(!SplitKPart(SD,LSD,Spine,iedge,HS1,It1,HS2,It2,intf,intl)){
2365 #ifdef OCCT_DEBUG
2366         cout<<"failed calculation KPart"<<endl;
2367 #endif
2368         LSD.Clear();
2369       }
2370       else iedgelastkpart = iedge;
2371       if(Spine->IsPeriodic()){//debug provisory for SD that arrive in desorder.
2372         Standard_Integer nbsd = LSD.Length();
2373         Standard_Real period = Spine->Period();
2374         Standard_Real wfp = WStartPeriodic, wlp = WEndPeriodic;
2375 //  modified by NIZHNY-EAP Thu Nov 25 12:57:53 1999 ___BEGIN___
2376         if(!YaKPart && nbsd>0){
2377 //      if(!YaKPart){
2378 //  modified by NIZHNY-EAP Thu Nov 25 12:57:57 1999 ___END___
2379           Handle(ChFiDS_SurfData) firstSD = LSD.ChangeValue(1);
2380           Standard_Real wwf = firstSD->FirstSpineParam();
2381           Standard_Real wwl = firstSD->LastSpineParam();
2382           wwf = ChFi3d_InPeriod(wwf,wfp,wlp,tolesp);
2383           wwl = ChFi3d_InPeriod(wwl,wfp,wlp,tolesp);
2384           if (wwl <= wwf + tolesp) wwl += period;
2385           wfp = wwf;
2386           wlp = wfp + period;
2387         }
2388         for(Standard_Integer j = 1; j < nbsd; j++){
2389           Handle(ChFiDS_SurfData) jSD = LSD.Value(j);
2390           for(Standard_Integer k = j+1; k <= nbsd; k++){
2391             Handle(ChFiDS_SurfData) kSD = LSD.Value(k);
2392             Standard_Real jwf = jSD->FirstSpineParam();
2393             jwf = ChFi3d_InPeriod(jwf,wfp,wlp,tolesp);
2394             Standard_Real kwf = kSD->FirstSpineParam();
2395             kwf = ChFi3d_InPeriod(kwf,wfp,wlp,tolesp);
2396             if(kwf < jwf){
2397               LSD.SetValue(j,kSD);
2398               LSD.SetValue(k,jSD);
2399             }
2400           }
2401         }
2402       }
2403       TColStd_ListOfInteger li;
2404       for(Standard_Integer j = 1; j <= LSD.Length(); j++){
2405         Handle(ChFiDS_SurfData)& curSD = LSD.ChangeValue(j);
2406         if(Simul) SimulKPart(curSD);
2407         SeqSurf.Append(curSD);
2408         if(!Simul) li.Append(curSD->Surf());
2409         WFirst = LSD.Value(j)->FirstSpineParam();
2410         WLast  = LSD.Value(j)->LastSpineParam();
2411         if(Spine->IsPeriodic()){
2412           WFirst = ChFi3d_InPeriod(WFirst,WStartPeriodic,WEndPeriodic,tolesp);
2413           WLast  = ChFi3d_InPeriod(WLast ,WStartPeriodic,WEndPeriodic,tolesp);
2414           if (WLast <= WFirst + tolesp) WLast+= Spine->Period();
2415         }
2416         TgtKP(LSD.Value(j),Spine,iedge,1,PFirst,TFirst);
2417         TgtKP(LSD.Value(j),Spine,iedge,0,PLast,TLast);
2418         
2419         // Determine the sections to approximate
2420         if(!YaKPart){
2421           if(Spine->IsPeriodic()){
2422             WStartPeriodic = WFirst;
2423             WEndPeriodic = WStartPeriodic + Spine->Period();
2424             WLast = ElCLib::InPeriod(WLast,WStartPeriodic,WEndPeriodic);
2425             if (WLast <= WFirst + tolesp) WLast+= Spine->Period();
2426             PEndPeriodic = PFirst;
2427             TEndPeriodic = TFirst;
2428             Spine->SetFirstParameter(WStartPeriodic);
2429             Spine->SetLastParameter(WEndPeriodic);
2430           }
2431           else if(!intf || (iedge > 1)){
2432             // start section -> first KPart
2433             // update of extension.
2434             Spine->SetFirstTgt(Min(0.,WFirst));
2435             CurrentHE->ChangeCurve().LastParameter (WFirst);
2436             CurrentHE->ChangeCurve().SetLastPointAndTgt(PFirst,TFirst);
2437             Spine->AppendElSpine(CurrentHE);
2438             CurrentHE->ChangeCurve().ChangeNext() = LSD.Value(j);
2439             CurrentHE =  new ChFiDS_HElSpine();
2440           }
2441           CurrentHE->ChangeCurve().FirstParameter(WLast);
2442           CurrentHE->ChangeCurve().SetFirstPointAndTgt(PLast,TLast);
2443           CurrentHE->ChangeCurve().ChangePrevious() = LSD.Value(j);
2444           YaKPart = Standard_True;
2445         }
2446         else {
2447           if (WFirst - CurrentHE->FirstParameter() > tolesp) {
2448             // section between two KPart
2449             CurrentHE->ChangeCurve().LastParameter(WFirst);
2450             CurrentHE->ChangeCurve().SetLastPointAndTgt(PFirst,TFirst);
2451             Spine->AppendElSpine(CurrentHE);
2452             CurrentHE->ChangeCurve().ChangeNext() = LSD.Value(j);
2453             CurrentHE = new ChFiDS_HElSpine();
2454           }
2455           CurrentHE->ChangeCurve().FirstParameter(WLast);
2456           CurrentHE->ChangeCurve().SetFirstPointAndTgt(PLast,TLast);
2457           CurrentHE->ChangeCurve().ChangePrevious() = LSD.Value(j);
2458         }
2459       }
2460       if(!li.IsEmpty()) myEVIMap.Bind(Spine->Edges(iedge),li);
2461     }
2462   }
2463   
2464   if (!intl || (iedgelastkpart < Spine->NbEdges())) {
2465     // section last KPart(or start of the spine) -> End of the spine.
2466     // update of the extension.
2467     
2468     if(Spine->IsPeriodic()){
2469       if(WEndPeriodic - WLast > tolesp){
2470         CurrentHE->ChangeCurve().LastParameter(WEndPeriodic);
2471         CurrentHE->ChangeCurve().SetLastPointAndTgt(PEndPeriodic,TEndPeriodic);
2472         if(!YaKPart) CurrentHE->ChangeCurve().SetPeriodic(Standard_True);
2473         Spine->AppendElSpine(CurrentHE);
2474       }
2475     }
2476     else{
2477       Spine->D1(Spine->LastParameter(),PLast,TLast);
2478       Spine->SetLastTgt(Max(Spine->LastParameter(Spine->NbEdges()),
2479                             WLast));
2480       if (Spine->LastParameter() - WLast > tolesp) {
2481         CurrentHE->ChangeCurve().LastParameter(Spine->LastParameter());
2482         CurrentHE->ChangeCurve().SetLastPointAndTgt(PLast,TLast);
2483         Spine->AppendElSpine(CurrentHE);
2484       }
2485     }
2486   }
2487   
2488   ChFiDS_ListOfHElSpine& ll = Spine->ChangeElSpines();
2489   ChFiDS_ListIteratorOfListOfHElSpine ILES(ll);
2490   for ( ; ILES.More(); ILES.Next()) {
2491 #ifdef OCCT_DEBUG
2492     if(ChFi3d_GettraceCHRON()) elspine.Start();
2493 #endif
2494     ChFi3d_PerformElSpine(ILES.Value(),Spine,myConti,tolesp);
2495 #ifdef OCCT_DEBUG
2496     if(ChFi3d_GettraceCHRON()) { elspine.Stop(); }
2497 #endif
2498   }
2499   Spine->SplitDone(Standard_True);
2500 }
2501
2502 static Standard_Real ChFi3d_BoxDiag(const Bnd_Box& box)
2503 {
2504   Standard_Real a,b,c,d,e,f;
2505   box.Get(a,b,c,d,e,f); 
2506   d-=a; e-=b; f-=c; 
2507   d*=d; e*=e; f*=f;
2508   Standard_Real diag = sqrt(d + e + f);
2509   return diag;
2510 }
2511
2512 //=======================================================================
2513 //function : PerformSetOfKGen
2514 //purpose  : 
2515 //=======================================================================
2516
2517 void ChFi3d_Builder::PerformSetOfKGen(Handle(ChFiDS_Stripe)& Stripe,
2518                                       const Standard_Boolean Simul) 
2519 {
2520   Handle(BRepTopAdaptor_TopolTool) It1 = new BRepTopAdaptor_TopolTool();
2521   Handle(BRepTopAdaptor_TopolTool) It2 = new BRepTopAdaptor_TopolTool();
2522   Handle(ChFiDS_Spine)& Spine = Stripe->ChangeSpine();
2523   ChFiDS_ListOfHElSpine& ll = Spine->ChangeElSpines();
2524   ChFiDS_ListIteratorOfListOfHElSpine ILES(ll);
2525   for ( ; ILES.More(); ILES.Next()) {
2526 #ifdef OCCT_DEBUG
2527     if(ChFi3d_GettraceCHRON()) { chemine.Start(); }
2528 #endif
2529     PerformSetOfSurfOnElSpine(ILES.Value(),Stripe,It1,It2,Simul);
2530 #ifdef OCCT_DEBUG
2531     if(ChFi3d_GettraceCHRON()) chemine.Stop();
2532 #endif
2533   }
2534   if(!Simul){
2535     TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
2536     Handle(ChFiDS_HData)&  HData  = Stripe->ChangeSetOfSurfData();
2537     ChFiDS_SequenceOfSurfData& SeqSurf = HData->ChangeSequence();
2538     Standard_Integer len = SeqSurf.Length();
2539     Standard_Integer last = len, i;
2540     Standard_Boolean periodic = Spine->IsPeriodic();
2541     if(periodic) last++;
2542     // It is attempted to reprocess the squares that bore.
2543     for(i = 1; i <= len; i++){
2544       Handle(ChFiDS_SurfData)& cursd = SeqSurf.ChangeValue(i);
2545       Standard_Boolean tw1 = cursd->TwistOnS1();
2546       Standard_Boolean tw2 = cursd->TwistOnS2();
2547       Handle(ChFiDS_SurfData) prevsd, nextsd;
2548       Standard_Integer iprev = i-1;
2549       if(iprev == 0) {
2550         if(periodic) iprev = len;
2551       }
2552       Standard_Integer inext = i + 1;
2553       if(inext > len) {
2554         if(periodic) inext = 1;
2555         else inext = 0;
2556       }
2557
2558       // For the moment only the surfaces where the twist is 
2559       // detected at the path are corrected, it is necessary to control  
2560       // more subtly the ugly traces (size, curvature, inflexion... ) 
2561       if(!tw1 && !tw2) continue;
2562       
2563       // It is decided (fairly at random) if the extended surface is ready for the filling.
2564       ChFiDS_FaceInterference& intf1 = cursd->ChangeInterferenceOnS1();
2565       ChFiDS_FaceInterference& intf2 = cursd->ChangeInterferenceOnS2();
2566       Standard_Integer cursurf1 = cursd->IndexOfS1();
2567       Standard_Integer cursurf2 = cursd->IndexOfS2();
2568       ChFiDS_CommonPoint& cpd1 = cursd->ChangeVertexFirstOnS1();
2569       ChFiDS_CommonPoint& cpd2 = cursd->ChangeVertexFirstOnS2();
2570       ChFiDS_CommonPoint& cpf1 = cursd->ChangeVertexLastOnS1();
2571       ChFiDS_CommonPoint& cpf2 = cursd->ChangeVertexLastOnS2();
2572       const gp_Pnt& pd1 = cpd1.Point();
2573       const gp_Pnt& pd2 = cpd2.Point();
2574       const gp_Pnt& pf1 = cpf1.Point();
2575       const gp_Pnt& pf2 = cpf2.Point();
2576       Standard_Real ddeb = pd1.Distance(pd2);
2577       Standard_Real dfin = pf1.Distance(pf2);
2578       Standard_Real don1 = pd1.Distance(pf1);
2579       Standard_Real don2 = pd2.Distance(pf2);
2580       Standard_Boolean possibleon1 = (don1 < 2*(ddeb + dfin));
2581       Standard_Boolean possibleon2 = (don2 < 2*(ddeb + dfin));
2582       if((tw1 && !possibleon1) || (tw2 && !possibleon2)) {
2583         Spine->SetErrorStatus(ChFiDS_TwistedSurface);
2584         Standard_Failure::Raise("adjustment by reprocessing the non-written points");
2585       }
2586       
2587       // It is checked if there are presentable neighbors
2588       Standard_Boolean yaprevon1 = 0, yaprevon2 = 0;
2589       Standard_Boolean samesurfon1 = 0, samesurfon2 = 0;
2590       if(iprev){
2591         prevsd = SeqSurf.ChangeValue(iprev);
2592         yaprevon1 = !prevsd->TwistOnS1();
2593         samesurfon1 = (prevsd->IndexOfS1() == cursurf1);
2594         yaprevon2 = !prevsd->TwistOnS2();
2595         samesurfon2 = (prevsd->IndexOfS2() == cursurf2);
2596       }
2597       Standard_Boolean yanexton1 = 0, yanexton2 = 0;
2598       if(inext){
2599         nextsd = SeqSurf.ChangeValue(inext);
2600         yanexton1 = !nextsd->TwistOnS1();
2601         if(samesurfon1) samesurfon1 = (nextsd->IndexOfS1() == cursurf1);
2602         yanexton2 = !nextsd->TwistOnS2();
2603         if(samesurfon2) samesurfon2 = (nextsd->IndexOfS2() == cursurf2);
2604       }
2605       // A contour of filling is constructed
2606       Handle(Geom2d_Curve) PC1 = intf1.PCurveOnFace();
2607       Handle(Geom2d_Curve) PC2 = intf2.PCurveOnFace();
2608       Handle(BRepAdaptor_HSurface) S1 = new BRepAdaptor_HSurface();
2609       TopoDS_Face F1 = TopoDS::Face(DStr.Shape(cursurf1));
2610       S1->ChangeSurface().Initialize(F1);
2611       Handle(BRepAdaptor_HSurface) S2 = new BRepAdaptor_HSurface();
2612       TopoDS_Face F2 = TopoDS::Face(DStr.Shape(cursurf2));
2613       S2->ChangeSurface().Initialize(F2);
2614       Handle(GeomFill_Boundary) Bdeb,Bfin,Bon1,Bon2;
2615       Standard_Boolean pointuon1 = 0, pointuon2 = 0;
2616       if(tw1){
2617         if(!yaprevon1 || !yanexton1){
2618           Spine->SetErrorStatus(ChFiDS_TwistedSurface);
2619           Standard_Failure::Raise
2620             ("adjustment by reprocessing the non-written points: no neighbor");
2621         }
2622         ChFiDS_FaceInterference& previntf1 = prevsd->ChangeInterferenceOnS1();
2623         ChFiDS_FaceInterference& nextintf1 = nextsd->ChangeInterferenceOnS1();
2624         Standard_Real prevpar1 = previntf1.LastParameter();
2625         Standard_Real nextpar1 = nextintf1.FirstParameter();
2626         if(samesurfon1){
2627           // It is checked if it is possible to intersect traces of neighbors
2628           // to create a sharp end.
2629           Handle(Geom2d_Curve) pcprev1 = previntf1.PCurveOnFace();
2630           Handle(Geom2d_Curve) pcnext1 = nextintf1.PCurveOnFace();
2631           Standard_Real nprevpar1,nnextpar1;
2632           gp_Pnt2d p2d;
2633 //  Modified by Sergey KHROMOV - Wed Feb  5 12:03:17 2003 Begin
2634 //        if(ChFi3d_IntTraces(prevsd,prevpar1,nprevpar1,1,1,
2635 //                            nextsd,nextpar1,nnextpar1,1,-1,p2d)){
2636           if(ChFi3d_IntTraces(prevsd,prevpar1,nprevpar1,1,1,
2637                               nextsd,nextpar1,nnextpar1,1,-1,p2d,
2638                               Standard_False, Standard_True)){
2639 //  Modified by Sergey KHROMOV - Wed Feb  5 12:03:17 2003 End
2640             previntf1.SetLastParameter(nprevpar1);
2641             nextintf1.SetFirstParameter(nnextpar1);
2642             pointuon1 = 1;
2643             PC1.Nullify();
2644           }
2645           else{
2646             gp_Pnt2d pdeb1,pfin1;
2647             gp_Vec2d vdeb1,vfin1;
2648             pcprev1->D1(prevpar1,pdeb1,vdeb1);
2649             pcnext1->D1(nextpar1,pfin1,vfin1);
2650             Bon1 = ChFi3d_mkbound(S1,PC1,-1,pdeb1,vdeb1,1,
2651                                   pfin1,vfin1,tolesp,2.e-4);
2652           }
2653         }
2654         else{
2655           //here the base is on 3D tangents of neighbors.
2656           const Handle(Geom_Curve)& c3dprev1 = 
2657             DStr.Curve(previntf1.LineIndex()).Curve();
2658           const Handle(Geom_Curve)& c3dnext1 = 
2659             DStr.Curve(nextintf1.LineIndex()).Curve();
2660           gp_Pnt Pdeb1, Pfin1;
2661           gp_Vec Vdeb1, Vfin1;
2662           c3dprev1->D1(prevpar1,Pdeb1,Vdeb1);
2663           c3dnext1->D1(nextpar1,Pfin1,Vfin1);
2664           gp_Pnt2d pdeb1,pfin1;
2665           Standard_Real pardeb1 = intf1.FirstParameter();
2666           Standard_Real parfin1 = intf1.LastParameter();
2667           pdeb1 = PC1->Value(pardeb1);
2668           pfin1 = PC1->Value(parfin1);
2669           Bon1 = ChFi3d_mkbound(S1,PC1,-1,pdeb1,Vdeb1,1,
2670                                 pfin1,Vfin1,tolesp,2.e-4);
2671         }
2672       }
2673       else{
2674         Bon1 = ChFi3d_mkbound(S1,PC1,tolesp,2.e-4);
2675       }
2676       if(tw2){
2677         if(!yaprevon2 || !yanexton2){
2678           Standard_Failure::Raise
2679             ("adjustment by reprocessing the non-written points: no neighbor");
2680         }
2681         ChFiDS_FaceInterference& previntf2 = prevsd->ChangeInterferenceOnS2();
2682         ChFiDS_FaceInterference& nextintf2 = nextsd->ChangeInterferenceOnS2();
2683         Standard_Real prevpar2 = previntf2.LastParameter();
2684         Standard_Real nextpar2 = nextintf2.FirstParameter();
2685         if(samesurfon2){
2686           // It is checked if it is possible to intersect traces of neighbors
2687           // to create a sharp end.
2688           Handle(Geom2d_Curve) pcprev2 = previntf2.PCurveOnFace();
2689           Handle(Geom2d_Curve) pcnext2 = nextintf2.PCurveOnFace();
2690           Standard_Real nprevpar2,nnextpar2;
2691           gp_Pnt2d p2d;
2692 //  Modified by Sergey KHROMOV - Wed Feb  5 12:03:17 2003 Begin
2693 //        if(ChFi3d_IntTraces(prevsd,prevpar2,nprevpar2,2,1,
2694 //                            nextsd,nextpar2,nnextpar2,2,-1,p2d)){
2695           if(ChFi3d_IntTraces(prevsd,prevpar2,nprevpar2,2,1,
2696                               nextsd,nextpar2,nnextpar2,2,-1,p2d,
2697                               Standard_False, Standard_True)){
2698 //  Modified by Sergey KHROMOV - Wed Feb  5 12:03:17 2003 End
2699             previntf2.SetLastParameter(nprevpar2);
2700             nextintf2.SetFirstParameter(nnextpar2);
2701             pointuon2 = 1;
2702             PC2.Nullify();
2703           }
2704           else{
2705             gp_Pnt2d pdeb2,pfin2;
2706             gp_Vec2d vdeb2,vfin2;
2707             pcprev2->D1(prevpar2,pdeb2,vdeb2);
2708             pcnext2->D1(nextpar2,pfin2,vfin2);
2709             Bon2 = ChFi3d_mkbound(S2,PC2,-1,pdeb2,vdeb2,1,
2710                                   pfin2,vfin2,tolesp,2.e-4);
2711           }
2712         }
2713         else{
2714          //here the base is on 3D tangents of neighbors.
2715           const Handle(Geom_Curve)& c3dprev2 = 
2716             DStr.Curve(previntf2.LineIndex()).Curve();
2717           const Handle(Geom_Curve)& c3dnext2 = 
2718             DStr.Curve(nextintf2.LineIndex()).Curve();
2719           gp_Pnt Pdeb2, Pfin2;
2720           gp_Vec Vdeb2, Vfin2;
2721           c3dprev2->D1(prevpar2,Pdeb2,Vdeb2);
2722           c3dnext2->D1(nextpar2,Pfin2,Vfin2);
2723           gp_Pnt2d pdeb2,pfin2;
2724           Standard_Real pardeb2 = intf2.FirstParameter();
2725           Standard_Real parfin2 = intf2.LastParameter();
2726           pdeb2 = PC2->Value(pardeb2);
2727           pfin2 = PC2->Value(parfin2);
2728           Bon2 = ChFi3d_mkbound(S2,PC2,-1,pdeb2,Vdeb2,1,
2729                                 pfin2,Vfin2,tolesp,2.e-4);
2730         }
2731       }
2732       else{
2733         Bon2 = ChFi3d_mkbound(S2,PC2,tolesp,2.e-4);
2734       }
2735       // The parameters of neighbor traces are updated, so 
2736       // straight lines uv are pulled.
2737       const Handle(Geom_Surface)& 
2738         sprev = DStr.Surface(prevsd->Surf()).Surface();
2739       const Handle(Geom_Surface)& 
2740         snext = DStr.Surface(nextsd->Surf()).Surface();
2741       ChFiDS_FaceInterference& previntf1 = prevsd->ChangeInterferenceOnS1();
2742       ChFiDS_FaceInterference& nextintf1 = nextsd->ChangeInterferenceOnS1();
2743       ChFiDS_FaceInterference& previntf2 = prevsd->ChangeInterferenceOnS2();
2744       ChFiDS_FaceInterference& nextintf2 = nextsd->ChangeInterferenceOnS2();
2745       Handle(Geom2d_Curve) pcsprev1 = previntf1.PCurveOnSurf();
2746       Handle(Geom2d_Curve) pcsnext1 = nextintf1.PCurveOnSurf();
2747       Standard_Real prevpar1 = previntf1.LastParameter();
2748       Standard_Real nextpar1 = nextintf1.FirstParameter();
2749       Handle(Geom2d_Curve) pcsprev2 = previntf2.PCurveOnSurf();
2750       Handle(Geom2d_Curve) pcsnext2 = nextintf2.PCurveOnSurf();
2751       Standard_Real prevpar2 = previntf2.LastParameter();
2752       Standard_Real nextpar2 = nextintf2.FirstParameter();
2753       gp_Pnt2d pdebs1 = pcsprev1->Value(prevpar1);
2754       gp_Pnt2d pdebs2 = pcsprev2->Value(prevpar2);
2755       gp_Pnt2d pfins1 = pcsnext1->Value(nextpar1);
2756       gp_Pnt2d pfins2 = pcsnext2->Value(nextpar2);
2757       Bdeb = ChFi3d_mkbound(sprev,pdebs1,pdebs2,tolesp,2.e-4);
2758       Bfin = ChFi3d_mkbound(snext,pfins1,pfins2,tolesp,2.e-4);
2759
2760       GeomFill_ConstrainedFilling fil(11,20);
2761       if(pointuon1) fil.Init(Bon2,Bfin,Bdeb,1);
2762       else if(pointuon2) fil.Init(Bon1,Bfin,Bdeb,1);
2763       else fil.Init(Bon1,Bfin,Bon2,Bdeb,1);
2764       
2765       ChFi3d_ReparamPcurv(0.,1.,PC1);
2766       ChFi3d_ReparamPcurv(0.,1.,PC2);
2767       Handle(Geom_Surface) newsurf = fil.Surface();
2768 #ifdef OCCT_DEBUG
2769 #ifdef DRAW
2770       //POP for NT
2771       char* pops = "newsurf";
2772       DrawTrSurf::Set(pops,newsurf);
2773 #endif
2774 #endif
2775       if(pointuon1) {
2776         newsurf->VReverse(); // we return to direction 1 from  2;
2777         done = CompleteData(cursd,newsurf,S1,PC1,S2,PC2,
2778                             F2.Orientation(),0,0,0,0,0);
2779         cursd->ChangeIndexOfS1(0);
2780       }
2781       else{
2782         done = CompleteData(cursd,newsurf,S1,PC1,S2,PC2,
2783                             F1.Orientation(),1,0,0,0,0);
2784         if(pointuon2) cursd->ChangeIndexOfS2(0);
2785       }
2786       if(tw1){
2787         prevsd->ChangeVertexLastOnS1().SetPoint(cpd1.Point());
2788         nextsd->ChangeVertexFirstOnS1().SetPoint(cpf1.Point());
2789       }
2790       if(tw2){
2791         prevsd->ChangeVertexLastOnS2().SetPoint(cpd2.Point());
2792         nextsd->ChangeVertexFirstOnS2().SetPoint(cpf2.Point());
2793       }
2794     }
2795     // The tolerance of points is updated.
2796     for(i = 1; i < last; i++){
2797       Standard_Integer j = i%len + 1;
2798       Standard_Integer curs1, curs2;
2799       Standard_Integer nexts1, nexts2;
2800       Handle(ChFiDS_SurfData)& cursd = SeqSurf.ChangeValue(i);
2801       Handle(ChFiDS_SurfData)& nextsd = SeqSurf.ChangeValue(j);
2802       ChFiDS_CommonPoint& curp1 = cursd->ChangeVertexLastOnS1();
2803       ChFiDS_CommonPoint& nextp1 = nextsd->ChangeVertexFirstOnS1();
2804       if (cursd->IsOnCurve1()) curs1 = cursd->IndexOfC1();
2805       else                     curs1 = cursd->IndexOfS1();
2806       if (cursd->IsOnCurve2()) curs2 = cursd->IndexOfC2();
2807       else                     curs2 = cursd->IndexOfS2();
2808       Standard_Real tol1 = Max(curp1.Tolerance(),nextp1.Tolerance());
2809       ChFiDS_CommonPoint& curp2 = cursd->ChangeVertexLastOnS2();
2810       ChFiDS_CommonPoint& nextp2 = nextsd->ChangeVertexFirstOnS2();
2811       Standard_Real tol2 = Max(curp2.Tolerance(),nextp2.Tolerance());
2812       if (nextsd->IsOnCurve1()) nexts1 = nextsd->IndexOfC1();
2813       else                     nexts1 = nextsd->IndexOfS1();
2814       if (nextsd->IsOnCurve2()) nexts2 = nextsd->IndexOfC2();
2815       else                     nexts2 = nextsd->IndexOfS2();
2816
2817       if(!curp1.IsOnArc() && nextp1.IsOnArc()){ 
2818         curp1 = nextp1;
2819         if ( (curs1 == nexts1) && !nextsd->IsOnCurve1()) 
2820           // Case when it is not possible to pass along the border without leaving
2821           ChangeTransition(nextp1, curp1, nexts1, myDS);
2822       }
2823       else if(curp1.IsOnArc() && !nextp1.IsOnArc()) { 
2824         nextp1 = curp1;
2825         if ( (curs1 == nexts1) && !cursd->IsOnCurve1())
2826           ChangeTransition(curp1, nextp1, curs1, myDS);
2827       }
2828         
2829       if(!curp2.IsOnArc() && nextp2.IsOnArc()) {
2830         curp2 = nextp2;
2831         if ( (curs2 == nexts2) && !nextsd->IsOnCurve2()) 
2832           ChangeTransition(nextp2, curp2, curs2, myDS);
2833       }
2834       else if(curp2.IsOnArc() && !nextp2.IsOnArc()){
2835         nextp2 = curp2;
2836         if ( (curs2 == nexts2) && !cursd->IsOnCurve2()) 
2837           ChangeTransition(curp2, nextp2, curs2, myDS);
2838       }
2839
2840       curp1.SetTolerance(tol1); nextp1.SetTolerance(tol1); 
2841       curp2.SetTolerance(tol2); nextp2.SetTolerance(tol2); 
2842       
2843       Bnd_Box b1,b2;
2844       if(curp1.IsOnArc()){
2845         ChFi3d_EnlargeBox(curp1.Arc(),myEFMap(curp1.Arc()),curp1.ParameterOnArc(),b1);
2846       }
2847       if(curp2.IsOnArc()){
2848         ChFi3d_EnlargeBox(curp2.Arc(),myEFMap(curp2.Arc()),curp2.ParameterOnArc(),b2);
2849       }
2850       Handle(ChFiDS_Stripe) bidst;
2851       ChFi3d_EnlargeBox(DStr,bidst,cursd,b1,b2,0);
2852       ChFi3d_EnlargeBox(DStr,bidst,nextsd,b1,b2,1);
2853       tol1 = ChFi3d_BoxDiag(b1);
2854       tol2 = ChFi3d_BoxDiag(b2);
2855       curp1.SetTolerance(tol1); nextp1.SetTolerance(tol1); 
2856       curp2.SetTolerance(tol2); nextp2.SetTolerance(tol2); 
2857     }
2858     // The connections edge/new faces are updated.
2859     for (ILES.Initialize(ll) ; ILES.More(); ILES.Next()) {
2860       const Handle(ChFiDS_HElSpine)& curhels = ILES.Value();
2861       const ChFiDS_ElSpine& curels = curhels->ChangeCurve();
2862       Standard_Real WF = curels.FirstParameter();
2863       Standard_Real WL = curels.LastParameter();
2864       Standard_Integer IF,IL;
2865       Standard_Real nwf = WF, nwl = WL;
2866       Standard_Real period = 0.;
2867       Standard_Integer nbed = Spine->NbEdges();
2868       if(periodic){
2869         period = Spine->Period();
2870         nwf = ElCLib::InPeriod(WF,-tolesp,period-tolesp);
2871         IF = Spine->Index(nwf,1);
2872         nwl = ElCLib::InPeriod(WL,tolesp,period+tolesp);
2873         IL = Spine->Index(nwl,0);
2874         if(nwl<nwf+tolesp) IL += nbed;
2875       }
2876       else{
2877         IF = Spine->Index(WF,1);
2878         IL = Spine->Index(WL,0);
2879       }
2880       if(IF == IL) {
2881         //fast processing
2882         Standard_Integer IFloc = IF;
2883         if(periodic) IFloc = (IF - 1)%nbed + 1;
2884         const TopoDS_Edge& Ej = Spine->Edges(IFloc);
2885         for(i = 1; i <= len; i++){
2886           Handle(ChFiDS_SurfData)& cursd = SeqSurf.ChangeValue(i);
2887           Standard_Real fp = cursd->FirstSpineParam();
2888           Standard_Real lp = cursd->LastSpineParam();
2889           if(lp < WF+tolesp || fp > WL-tolesp) continue;
2890           if(!myEVIMap.IsBound(Ej)) {
2891             TColStd_ListOfInteger li;
2892             myEVIMap.Bind(Ej,li);
2893           }
2894           myEVIMap.ChangeFind(Ej).Append(cursd->Surf());
2895         }
2896       }
2897       else if(IF < IL){
2898         TColStd_Array1OfReal wv(IF,IL - 1);
2899 #ifdef OCCT_DEBUG
2900         cout<<"length of the trajectory : "<<(WL-WF)<<endl;
2901 #endif
2902         for(i = IF; i < IL; i++){
2903           Standard_Integer iloc = i;
2904           if(periodic) iloc = (i - 1)%nbed + 1;
2905           Standard_Real wi = Spine->LastParameter(iloc);
2906           if(periodic) wi = ElCLib::InPeriod(wi,WF,WF+period);
2907           gp_Pnt pv = Spine->Value(wi);
2908 #ifdef OCCT_DEBUG
2909           gp_Pnt pelsapp = curels.Value(wi);
2910           Standard_Real distinit = pv.Distance(pelsapp);
2911           cout<<"distance psp/papp : "<<distinit<<endl;
2912 #endif
2913           Extrema_LocateExtPC ext(pv,curels,wi,1.e-8);
2914           wv(i) = wi;
2915           if(ext.IsDone()){
2916             wv(i) = ext.Point().Parameter(); 
2917           }
2918           else {
2919 #ifdef OCCT_DEBUG
2920             cout<<"fail of projection vertex ElSpine!!!"<<endl;
2921 #endif
2922           }
2923         }
2924         for(i = 1; i <= len; i++){
2925           Handle(ChFiDS_SurfData)& cursd = SeqSurf.ChangeValue(i);
2926           Standard_Real fp = cursd->FirstSpineParam();
2927           Standard_Real lp = cursd->LastSpineParam();
2928           Standard_Integer j;
2929           Standard_Integer jf = 0, jl = 0;
2930           if(lp < WF+tolesp || fp > WL-tolesp) continue;
2931           for(j = IF; j < IL; j++){
2932             jf = j;
2933             if(fp < wv(j) - tolesp) break;
2934           }
2935           for(j = IF; j < IL; j++){
2936             jl = j;
2937             if(lp < wv(j) + tolesp) break;
2938           }
2939           for(j = jf; j <= jl; j++){
2940             Standard_Integer jloc = j;
2941             if(periodic) jloc = (j - 1)%nbed + 1;
2942             const TopoDS_Edge& Ej = Spine->Edges(jloc);
2943             if(!myEVIMap.IsBound(Ej)) {
2944               TColStd_ListOfInteger li;
2945               myEVIMap.Bind(Ej,li);
2946             }
2947             myEVIMap.ChangeFind(Ej).Append(cursd->Surf());
2948           }
2949         }
2950       }
2951     }
2952   }
2953 }
2954
2955 //=======================================================================
2956 //function : PerformSetOfSurf
2957 //purpose  : 
2958 //=======================================================================
2959
2960 void ChFi3d_Builder::PerformSetOfSurf(Handle(ChFiDS_Stripe)& Stripe,
2961                                       const Standard_Boolean Simul) 
2962 {
2963   TopOpeBRepDS_DataStructure& DStr = myDS->ChangeDS();
2964   
2965 #ifdef OCCT_DEBUG
2966   OSD_Chronometer ch;
2967   ChFi3d_InitChron(ch);// init perf for PerformSetOfKPart
2968 #endif
2969   
2970   const Handle(ChFiDS_Spine)& sp = Stripe->Spine();
2971   Standard_Integer SI = ChFi3d_SolidIndex(sp,DStr,myESoMap,myEShMap);
2972   Stripe->SetSolidIndex(SI);
2973   if(!sp->SplitDone()) PerformSetOfKPart(Stripe,Simul);
2974   
2975 #ifdef OCCT_DEBUG
2976   ChFi3d_ResultChron(ch ,t_perfsetofkpart); // result perf PerformSetOfKPart(
2977   ChFi3d_InitChron(ch); // init perf for  PerformSetOfKGen
2978 #endif
2979   
2980   PerformSetOfKGen(Stripe,Simul);
2981   
2982 #ifdef OCCT_DEBUG
2983   ChFi3d_ResultChron(ch, t_perfsetofkgen);//result perf PerformSetOfKGen 
2984   ChFi3d_InitChron(ch); // init perf for ChFi3d_MakeExtremities
2985 #endif
2986   
2987   if(!Simul) ChFi3d_MakeExtremities(Stripe,DStr,myEFMap,tolesp,tol2d);
2988   
2989 #ifdef OCCT_DEBUG
2990   ChFi3d_ResultChron(ch, t_makextremities); // result perf t_makextremities
2991 #endif
2992 }