f9ceecaf533a5c40448e8e196014dd6dd45a8dd8
[occt.git] / src / BRepFill / BRepFill_Sweep.cxx
1 // Created on: 1998-01-07
2 // Created by: Philippe MANGIN
3 // Copyright (c) 1998-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
5 //
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
10 //
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 //
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
20
21
22 #include <stdio.h>
23
24 #include <BRepFill_Sweep.ixx>
25
26 #include <BRepFill_SectionLaw.hxx>
27 //#include <BRepFill_TrimCorner.hxx>
28 #include <BRepFill_CurveConstraint.hxx>
29
30 #include <GeomFill_SectionLaw.hxx>
31 #include <GeomFill_LocationLaw.hxx>
32 #include <GeomFill_Sweep.hxx>
33
34 // modified by NIZHNY-MKK  Wed Oct 22 12:25:45 2003
35 #include <BRepFill_TrimShellCorner.hxx>
36
37 //#include <GeomPlate_BuildPlateSurface.hxx>
38 //#include <GeomPlate_Surface.hxx>
39 //#include <GeomPlate_PointConstraint.hxx>
40
41 #include <gp_Pnt2d.hxx>
42 #include <gp_Vec2d.hxx>
43 #include <Bnd_Box.hxx>
44
45 #include <Geom_Surface.hxx>
46 #include <Geom_SurfaceOfRevolution.hxx>
47 #include <Geom_RectangularTrimmedSurface.hxx>
48 #include <Geom_Plane.hxx>
49 #include <Geom_Curve.hxx>
50 #include <Geom_BezierCurve.hxx>
51 #include <Geom_BSplineCurve.hxx>
52 #include <Geom2d_Line.hxx>
53 #include <Geom2d_Curve.hxx>
54 #include <Geom2d_TrimmedCurve.hxx>
55 #include <GeomLib.hxx>
56 #include <GeomLib_IsPlanarSurface.hxx>
57 #include <BRepLib_FindSurface.hxx>
58 #include <GeomConvert_ApproxSurface.hxx>
59
60 #include <BRepAdaptor_HCurve.hxx>
61 #include <BRepAdaptor_HCurve2d.hxx>
62 #include <BRepAdaptor_HSurface.hxx>
63 #include <Adaptor3d_HCurveOnSurface.hxx>
64 #include <GeomAdaptor_HSurface.hxx>
65 #include <GeomAdaptor_HCurve.hxx>
66 #include <Geom2dAdaptor_HCurve.hxx>
67 #include <Approx_CurveOnSurface.hxx>
68 #include <Approx_SameParameter.hxx>
69 #include <GCPnts_AbscissaPoint.hxx>
70
71 #include <BRep_Builder.hxx>
72 #include <BRep_Tool.hxx>
73 #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
74 #include <BRep_TEdge.hxx>
75 #include <BRep_TVertex.hxx>
76 #include <BRep_CurveRepresentation.hxx>
77 #include <BRep_GCurve.hxx>
78
79 #include <BRepLib.hxx>
80 #include <BRepLib_MakeEdge.hxx>
81 #include <BRepLib_MakeFace.hxx>
82 #include <BRepLib_FaceError.hxx>
83
84 #include <TopoDS.hxx>
85 #include <TopoDS_Edge.hxx>
86 #include <TopoDS_Face.hxx>
87 #include <TopoDS_Compound.hxx>
88 #include <TopoDS_Shell.hxx>
89 #include <TopExp.hxx>
90 #include <TopExp_Explorer.hxx>
91 #include <TopAbs_Orientation.hxx>
92
93 #include <TColStd_HArray1OfInteger.hxx>
94 #include <TColStd_Array2OfInteger.hxx>
95 #include <TColStd_Array1OfReal.hxx>
96 #include <TColStd_Array2OfReal.hxx>
97 #include <TColGeom_Array2OfSurface.hxx>
98 #include <TColgp_Array1OfPnt.hxx>
99
100 #include <TopTools_Array1OfShape.hxx>
101 #include <TopTools_Array2OfShape.hxx>
102 #include <TopTools_HArray2OfShape.hxx>
103 #include <TopTools_HArray1OfShape.hxx>
104 #include <TopTools_ListIteratorOfListOfShape.hxx> 
105 #include <TopTools_ListOfShape.hxx> 
106 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
107 #include <BRepTools_WireExplorer.hxx>
108
109 #include <Standard_ConstructionError.hxx>
110 #include <Precision.hxx>
111 #include <BRepBuilderAPI_MakeWire.hxx>
112
113 #include <BRepTools_Substitution.hxx>
114 #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
115 #include <TopoDS_Iterator.hxx>
116
117 //OCC500(apo)
118 #include <BRepCheck_Edge.hxx>  
119
120 #ifdef DRAW
121 #include <Draw.hxx>
122 #include <DrawTrSurf.hxx>
123 #include <DBRep.hxx>
124 static Standard_Boolean Affich = 0;
125 #endif
126
127 //=======================================================================
128 //function : NumberOfPoles
129 //purpose  : 
130 //=======================================================================
131 static Standard_Integer NumberOfPoles(const TopoDS_Wire& W)
132 {
133   Standard_Integer NbPoints = 0;
134
135   TopoDS_Iterator iter(W);
136   for (; iter.More(); iter.Next()) 
137   {
138     BRepAdaptor_Curve c(TopoDS::Edge(iter.Value()));
139
140     Standard_Real dfUf = c.FirstParameter();
141     Standard_Real dfUl = c.LastParameter();
142     if (IsEqual(dfUf,dfUl))
143       // Degenerate
144       continue;
145
146     switch (c.GetType()) 
147     {
148     case GeomAbs_BezierCurve:
149       {
150         // Put all poles for bezier
151         Handle(Geom_BezierCurve) GC = c.Bezier();
152         Standard_Integer iNbPol = GC->NbPoles();
153         if ( iNbPol >= 2)
154           NbPoints += iNbPol;
155         break;
156       }
157     case GeomAbs_BSplineCurve:
158       {
159         // Put all poles for bspline
160         Handle(Geom_BSplineCurve) GC = c.BSpline();
161         Standard_Integer iNbPol = GC->NbPoles();
162         if ( iNbPol >= 2)
163           NbPoints += iNbPol;
164         break;
165       }
166     case GeomAbs_Line:
167       {
168         NbPoints += 2;
169         break;
170       }
171     case GeomAbs_Circle:
172     case GeomAbs_Ellipse:
173     case GeomAbs_Hyperbola:
174     case GeomAbs_Parabola:
175       {
176         NbPoints += 4;
177         break;
178       }
179     default:
180       NbPoints += 15 + c.NbIntervals(GeomAbs_C3);
181     } // switch (c.GetType()) ...
182   } // for (; iter.More(); iter.Next())
183
184   return NbPoints;
185 }
186
187 //=======================================================================
188 //function : HasPCurves
189 //purpose  : 
190 //=======================================================================
191 static Standard_Boolean HasPCurves(const TopoDS_Edge& E)
192 {
193   Standard_Boolean haspcurves = Standard_False;
194
195   BRep_ListIteratorOfListOfCurveRepresentation itcr
196     ((*((Handle(BRep_TEdge)*)&E.TShape()))->Curves());
197   for (; itcr.More(); itcr.Next())
198     {
199       const Handle(BRep_CurveRepresentation)& cr = itcr.Value();
200       if (cr->IsCurveOnSurface())
201         {
202           haspcurves = Standard_True;
203           break;
204         }
205     }
206   return haspcurves;
207 }
208
209 //=======================================================================
210 //function : Translate
211 //purpose  : Copy a column from one table to another. 
212 //=======================================================================
213 static void Translate(const Handle(TopTools_HArray2OfShape)& ArrayIn,
214                       const Standard_Integer In,
215                       Handle(TopTools_HArray2OfShape)& ArrayOut,
216                       const Standard_Integer Out)
217 {
218   Standard_Integer ii, Nb;
219   Nb =  ArrayOut->ColLength();
220   for (ii=1; ii<=Nb; ii++) {
221      ArrayOut->SetValue(ii, Out,  ArrayIn->Value(ii, In));
222   } 
223 }
224
225
226 //=======================================================================
227 //function : Box
228 //purpose  : Bounding box of a section.
229 //=======================================================================
230 static void Box(Handle(GeomFill_SectionLaw)& Sec,
231                 const Standard_Real U,
232                 Bnd_Box& Box)
233
234 {
235   Standard_Integer NbPoles, bid;
236   Box.SetVoid();
237   Sec->SectionShape(NbPoles, bid, bid);
238   TColgp_Array1OfPnt Poles(1, NbPoles);
239   TColStd_Array1OfReal W(1, NbPoles);
240   Sec->D0(U, Poles, W);
241   for (Standard_Integer ii=1; ii<=NbPoles; ii++) {
242       Box.Add(Poles(ii));
243     }  
244 }
245
246 //=======================================================================
247 //function : Couture
248 //purpose  : Check if E is an edge of sewing on S
249 //           and make the representation HadHoc
250 //=======================================================================
251 static Handle(Geom2d_Curve) Couture(const TopoDS_Edge& E, 
252                                     const Handle(Geom_Surface)& S,
253                                     const TopLoc_Location& L)
254 {
255   TopLoc_Location l = L.Predivided(E.Location());
256   Standard_Boolean Eisreversed = (E.Orientation() == TopAbs_REVERSED);
257
258   // find the representation
259   BRep_ListIteratorOfListOfCurveRepresentation itcr
260     ((*((Handle(BRep_TEdge)*)&E.TShape()))->ChangeCurves());
261
262   while (itcr.More()) {
263     Handle(BRep_CurveRepresentation)& cr = itcr.Value();
264     if (cr->IsCurveOnSurface(S,l)) {
265       Handle(BRep_GCurve)& GC = *((Handle(BRep_GCurve)*)&cr);
266       if (GC->IsCurveOnClosedSurface() && Eisreversed) 
267         return  GC->PCurve2();
268       else
269         return GC->PCurve();
270     }
271     itcr.Next();
272   }
273   Handle(Geom2d_Curve) pc;
274   pc.Nullify();
275   return pc;
276 }
277
278 //=======================================================================
279 //function : CheckSameParameter
280 //purpose  : Check a posteriori that sameparameter has worked correctly
281 //=======================================================================
282
283 static Standard_Boolean CheckSameParameter 
284 (const Handle(Adaptor3d_HCurve)&   C3d,
285  Handle(Geom2d_Curve)&           Pcurv,
286  const Handle(Adaptor3d_HSurface)& S,
287  const Standard_Real             tol3d,
288  Standard_Real&                  tolreached)
289 {
290   tolreached = 0.;
291   Standard_Real f = C3d->FirstParameter();
292   Standard_Real l = C3d->LastParameter();
293   Standard_Integer nbp = 45;
294   Standard_Real step = 1./(nbp -1);
295   for(Standard_Integer i = 0; i < nbp; i++){
296     Standard_Real t,u,v;
297     t = step * i;
298     t = (1-t) * f + t * l;
299     Pcurv->Value(t).Coord(u,v);
300     gp_Pnt pS = S->Value(u,v);
301     gp_Pnt pC = C3d->Value(t);
302     Standard_Real d2 = pS.SquareDistance(pC);
303     tolreached = Max(tolreached,d2);
304   }
305   tolreached = sqrt(tolreached);
306   if(tolreached > tol3d){
307     tolreached *= 2.;
308     return Standard_False;
309   }
310   tolreached *= 2.;
311   tolreached = Max(tolreached,Precision::Confusion());
312   return Standard_True;
313 }
314
315 //=======================================================================
316 //function : SameParameter
317 //purpose  : Encapsulation of Sameparameter
318 // Boolean informs if the pcurve was computed or not...
319 // The tolerance is always OK.
320 //=======================================================================
321
322 static Standard_Boolean SameParameter(TopoDS_Edge&    E,
323                                       Handle(Geom2d_Curve)&        Pcurv,
324                                       const Handle(Geom_Surface)&  Surf,
325                                       const Standard_Real          tol3d,
326                                       Standard_Real&               tolreached)
327 {
328   //Handle(BRepAdaptor_HCurve) C3d = new (BRepAdaptor_HCurve)(E);
329   Standard_Real f, l;
330   Handle(Geom_Curve) C3d = BRep_Tool::Curve( E, f, l );
331   GeomAdaptor_Curve GAC3d( C3d, f, l );
332   Handle(GeomAdaptor_HCurve) HC3d = new GeomAdaptor_HCurve( GAC3d );
333
334   Handle(GeomAdaptor_HSurface) S = new (GeomAdaptor_HSurface)(Surf);
335   Standard_Real ResTol;
336
337   if(CheckSameParameter( HC3d, Pcurv, S, tol3d, tolreached )) 
338     return Standard_True;
339
340   if (!HasPCurves(E))
341     {
342       Handle(Geom2dAdaptor_HCurve) HC2d = new Geom2dAdaptor_HCurve( Pcurv );
343       Approx_CurveOnSurface AppCurve(HC2d, S, HC2d->FirstParameter(), HC2d->LastParameter(),
344                                      Precision::Confusion(), GeomAbs_C1, 10, 10, Standard_True);
345       if (AppCurve.IsDone() && AppCurve.HasResult())
346         {
347           C3d = AppCurve.Curve3d();
348           tolreached = AppCurve.MaxError3d();
349           BRep_Builder B;
350           B.UpdateEdge( E, C3d, tolreached );
351           return Standard_True;
352         }
353     }
354
355   Approx_SameParameter sp( HC3d, Pcurv, S, tol3d );
356   if(sp.IsDone() && !sp.IsSameParameter()) Pcurv = sp.Curve2d();
357   else if(!sp.IsDone() && !sp.IsSameParameter()){
358 #ifdef DEB
359     cout<<"echec SameParameter"<<endl;
360 #endif  
361     return Standard_False;
362   }
363
364   ResTol = sp.TolReached();
365   if(ResTol > tolreached ){
366 #ifdef DEB
367     cout<<"SameParameter : Tolerance not reached!"<<endl;
368     cout<<"tol visee : "<<tol3d<<" tol obtained : "<<ResTol<<endl;
369 #endif  
370     return Standard_False;
371   }
372   else {
373     tolreached = 1.1*ResTol;
374     if(sp.IsDone() && !sp.IsSameParameter()) Pcurv = sp.Curve2d();
375   }
376   return Standard_True;
377 }
378
379 //=======================================================================
380 //Objet : Orientate an edge of natural restriction 
381 //      : General
382 //=======================================================================
383 static void Oriente(const Handle(Geom_Surface)& S,
384                     TopoDS_Edge& E)
385 {
386   gp_Pnt2d P;
387   gp_Vec2d D, URef(1, 0), VRef(0, 1);
388   Standard_Boolean isuiso, isfirst, isopposite;
389   Standard_Real UFirst, ULast, VFirst, VLast, f, l;
390   S->Bounds(UFirst, ULast, VFirst, VLast);
391   Handle(Geom2d_Curve) C;
392   TopLoc_Location bid;
393
394   C = BRep_Tool::CurveOnSurface(E, S, bid, f, l);
395   C->D1((f+l)/2, P, D);
396
397   isuiso = D.IsParallel(VRef, 0.1);
398   
399   if ( isuiso ) {
400     isfirst = (Abs (P.X()-UFirst) < Precision::Confusion());
401     isopposite = D.IsOpposite(VRef, 0.1);
402     E.Orientation(TopAbs_REVERSED);
403   }
404   else {
405     isfirst = (Abs (P.Y()-VFirst) < Precision::Confusion());
406     isopposite = D.IsOpposite(URef, 0.1);
407     E.Orientation(TopAbs_FORWARD);
408   }
409
410   if (!isfirst)   E.Reverse();
411   if (isopposite) E.Reverse();
412 }
413 //OCC500(apo)->
414 static void UpdateEdgeOnPlane(const TopoDS_Face& F, const TopoDS_Edge& E,
415                               const BRep_Builder& BB)
416 {
417   Standard_Real f, l;
418   Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E,F,f,l);
419   Handle(Geom_Surface) S = BRep_Tool::Surface(F);
420   TopLoc_Location Loc;
421   Standard_Real Tol = BRep_Tool::Tolerance(E);
422   BB.UpdateEdge(E, C2d, S, Loc, Tol);
423   BRepCheck_Edge Check(E);
424   Tol = Max(Tol,Check.Tolerance());
425   BB.UpdateEdge(E, Tol);
426   TopoDS_Vertex V; 
427   Tol *= 1.01;
428   V = TopExp::FirstVertex(E);
429   if(BRep_Tool::Tolerance(V) < Tol) BB.UpdateVertex(V, Tol);
430   V = TopExp::LastVertex(E);
431   if(BRep_Tool::Tolerance(V) < Tol) BB.UpdateVertex(V, Tol);
432 }
433 //<-OCC500(apo)
434 //=======================================================================
435 //Function : BuildFace
436 //Objet : Construct a Face via a surface and 4 Edges (natural borders)
437 //      : Only one Hypothesis : isos u and v are switched :
438 //        Edge1/3 are iso u (recp v)
439 //        Edge2/4 are iso v (recp u)
440 //=======================================================================
441 static void BuildFace(const Handle(Geom_Surface)& S,
442                       const TopoDS_Edge& E1,
443                       const TopoDS_Edge& E2,
444                       const TopoDS_Edge& E3,
445                       const TopoDS_Edge& E4,
446                       TopTools_DataMapOfShapeShape& EEmap,
447                       const Standard_Boolean ExchUV,
448                       const Standard_Boolean UReverse,
449                       TopoDS_Face& F)
450 {
451   Standard_Real Tol;
452 // Class BRep_Tool without fields and without Constructor :
453 //  BRep_Tool BT;
454   TopoDS_Edge e1, e2, E;
455   TopoDS_Wire WW;
456   BRep_Builder BB;
457   BRepBuilderAPI_MakeWire B;
458   TopoDS_Iterator Iter;
459   //gp_Pnt2d P;
460
461   //Is the surface planar ?
462   Standard_Real Tol1, Tol2, Tol3, Tol4;
463   Tol1 = BRep_Tool::Tolerance( E1 );
464   Tol2 = BRep_Tool::Tolerance( E2 );
465   Tol3 = BRep_Tool::Tolerance( E3 );
466   Tol4 = BRep_Tool::Tolerance( E4 );
467 //  Tol = Min( BT.Tolerance(E1), BT.Tolerance(E2));
468   Tol = Min( Tol1, Tol2 );
469 //  Tol = Min(Tol, Min(BT.Tolerance(E3),BT.Tolerance(E4)));
470   Tol = Min( Tol, Min( Tol3, Tol4 ) );
471   Standard_Boolean IsPlan = Standard_False;
472   Handle(Geom_Plane) thePlane;
473
474   if (!E1.IsSame(E3) && !E2.IsSame(E4)) //exclude cases with seam edges: they are not planar
475     {
476       GeomLib_IsPlanarSurface IsP(S, Tol);
477       if (IsP.IsPlanar())
478         {
479           IsPlan = Standard_True;
480           thePlane = new Geom_Plane( IsP.Plan() );
481         }
482       else
483         {
484           Handle(BRep_TEdge)& TE1 = *((Handle(BRep_TEdge)*)&E1.TShape());
485           Handle(BRep_TEdge)& TE2 = *((Handle(BRep_TEdge)*)&E2.TShape());
486           Handle(BRep_TEdge)& TE3 = *((Handle(BRep_TEdge)*)&E3.TShape());
487           Handle(BRep_TEdge)& TE4 = *((Handle(BRep_TEdge)*)&E4.TShape());
488           TE1->Tolerance( Precision::Confusion() );
489           TE2->Tolerance( Precision::Confusion() );
490           TE3->Tolerance( Precision::Confusion() );
491           TE4->Tolerance( Precision::Confusion() );
492           
493           TopoDS_Wire theWire = BRepLib_MakeWire( E1, E2, E3, E4 );
494           Standard_Integer NbPoints = NumberOfPoles( theWire );
495           if (NbPoints <= 100) //limitation for CPU
496             {
497               BRepLib_FindSurface FS( theWire, -1, Standard_True );
498               if (FS.Found())
499                 {
500                   IsPlan = Standard_True;
501                   thePlane = Handle(Geom_Plane)::DownCast(FS.Surface());
502                 }
503             }
504           BB.UpdateEdge( E1, Tol1 );
505           BB.UpdateEdge( E2, Tol2 );
506           BB.UpdateEdge( E3, Tol3 );
507           BB.UpdateEdge( E4, Tol4 );
508         }
509     }
510
511   // Construction of the wire
512 //  B.MakeWire(WW);
513   e1 = E1;
514   Oriente(S, e1);
515 //  if (!IsPlan || !BT.Degenerated(e1)) 
516   if (!IsPlan || !BRep_Tool::Degenerated(e1)) 
517     B.Add(e1);
518
519   e2 = E2;
520   Oriente(S, e2);  
521 //  if (!IsPlan || !BT.Degenerated(e2)) 
522   if (!IsPlan || !BRep_Tool::Degenerated(e2))
523     {
524       B.Add(e2);
525       if (!BRep_Tool::Degenerated(e2))
526         {
527           WW = B.Wire();
528           TopoDS_Shape NewEdge;
529           //take the last edge added to WW
530           for (Iter.Initialize( WW ); Iter.More(); Iter.Next())
531             NewEdge = Iter.Value();
532           if (! e2.IsSame(NewEdge))
533             EEmap.Bind( e2, NewEdge );
534         }
535     }
536
537   if (E3.IsSame(E1)) {
538     E = e1;
539     E.Reverse();
540   }
541   else {
542     E = E3;
543     Oriente(S, E);
544   }
545 //  if (!IsPlan || !BT.Degenerated(E))   
546   if (!IsPlan || !BRep_Tool::Degenerated(E))
547     {
548       B.Add(E);
549       if (!BRep_Tool::Degenerated(E))
550         {
551           WW = B.Wire();
552           TopoDS_Shape NewEdge;
553           //take the last edge added to WW
554           for (Iter.Initialize( WW ); Iter.More(); Iter.Next())
555             NewEdge = Iter.Value();
556           if (! E.IsSame(NewEdge))
557             EEmap.Bind( E, NewEdge );
558         }
559     }
560
561   if (E4.IsSame(E2)) {
562     E = e2;
563     E.Reverse();
564   }
565   else {
566     E = E4;
567     Oriente(S, E);
568   }
569 //  if (!IsPlan || !BT.Degenerated(E))  
570   if (!IsPlan || !BRep_Tool::Degenerated(E)) 
571     {
572       B.Add(E);
573       if (!BRep_Tool::Degenerated(E))
574         {
575           WW = B.Wire();
576           TopoDS_Shape NewEdge;
577           //take the last edge added to WW
578           for (Iter.Initialize( WW ); Iter.More(); Iter.Next())
579             NewEdge = Iter.Value();
580           if (! E.IsSame(NewEdge))
581             EEmap.Bind( E, NewEdge );
582         }
583     }
584
585   WW = B.Wire();
586 #if DRAW
587   if (Affich)
588     DBRep::Set("wire-on-face", WW);
589 #endif
590   
591 // Construction of the face.
592   if (IsPlan) { // Suspend representation 2d 
593     // and construct face Plane
594
595     //BRepLib_MakeFace MkF(IsP.Plan(), WW);
596     gp_Pnt aPnt;
597     gp_Vec DU, DV, NS, NP;
598     Standard_Real Ufirst, Ulast, Vfirst, Vlast;
599     S->Bounds( Ufirst, Ulast, Vfirst, Vlast );
600     S->D1( (Ufirst+Ulast)/2., (Vfirst+Vlast)/2., aPnt, DU, DV );
601     NS = DU ^ DV;
602     NP = thePlane->Pln().Axis().Direction();
603     if (NS.Dot(NP) < 0.)
604       thePlane->UReverse();
605     BRepLib_MakeFace MkF( thePlane, WW );
606     if (MkF.Error() != BRepLib_FaceDone) {
607 #if DEB
608       BRepLib_FaceError Err = MkF.Error();
609       cout << "Planar Face Error :" <<   Err << endl;
610 #endif
611     }
612     else {
613       Handle(Geom2d_Curve) NullC2d;
614       TopLoc_Location Loc;
615       BB.UpdateEdge( E1, NullC2d, S, Loc, Tol1 );
616       BB.UpdateEdge( E2, NullC2d, S, Loc, Tol2 );
617       BB.UpdateEdge( E3, NullC2d, S, Loc, Tol3 );
618       BB.UpdateEdge( E4, NullC2d, S, Loc, Tol4 );
619
620       F =  MkF.Face();
621       UpdateEdgeOnPlane(F,E1,BB);
622       UpdateEdgeOnPlane(F,E2,BB);
623       UpdateEdgeOnPlane(F,E3,BB);
624       UpdateEdgeOnPlane(F,E4,BB);
625 /*OCC500(apo)->
626       TopLoc_Location Loc;
627       Handle(Geom2d_Curve) NC;
628       NC.Nullify();
629 //      B.UpdateEdge(E1, NC, S, Loc, BT.Tolerance(E1));
630       BB.UpdateEdge(E1, NC, S, Loc, BRep_Tool::Tolerance(E1));
631 //      B.UpdateEdge(E2, NC, S, Loc, BT.Tolerance(E2));
632       BB.UpdateEdge(E2, NC, S, Loc, BRep_Tool::Tolerance(E2));
633 //      B.UpdateEdge(E3, NC, S, Loc, BT.Tolerance(E3));
634       BB.UpdateEdge(E3, NC, S, Loc, BRep_Tool::Tolerance(E3));
635 //      B.UpdateEdge(E4, NC, S, Loc, BT.Tolerance(E4));
636       BB.UpdateEdge(E4, NC, S, Loc, BRep_Tool::Tolerance(E4));
637 <-OCC500(apo)*/
638     }  
639   }
640
641   if (!IsPlan) {// Cas Standard : Ajout
642     BB.MakeFace(F, S, Precision::Confusion());
643     BB.Add(F, WW);
644   }
645
646   // Reorientation
647   if (ExchUV) F.Reverse();
648   if (UReverse) F.Reverse();
649 }
650
651
652 //=======================================================================
653 //Fonction : BuildEdge
654 //Objet : Construct non-closed Edge 
655 //=======================================================================
656 static TopoDS_Edge BuildEdge(Handle(Geom_Curve)& C3d,
657                              Handle(Geom2d_Curve)& C2d,
658                              Handle(Geom_Surface)& S,
659                              const TopoDS_Vertex& VF,
660                              const TopoDS_Vertex& VL,
661                              const Standard_Real f, 
662                              const Standard_Real l,
663                              const Standard_Real Tol3d)
664 {
665   gp_Pnt P1, P2, P;
666   Standard_Real Tol1, Tol2, Tol, d;
667 // Class BRep_Tool without fields and without Constructor :
668 //  BRep_Tool BT;
669   BRep_Builder B;
670   TopoDS_Edge E;
671
672 //  P1  = BT.Pnt(VF);
673   P1  = BRep_Tool::Pnt(VF);
674 //  Tol1 = BT.Tolerance(VF);
675   Tol1 = BRep_Tool::Tolerance(VF);
676 //  P2  = BT.Pnt(VL);
677   P2  = BRep_Tool::Pnt(VL);
678 //  Tol2 = BT.Tolerance(VF);
679   Tol2 = BRep_Tool::Tolerance(VF);
680   Tol = Max(Tol1, Tol2);
681
682   if (VF.IsSame(VL) || 
683       (P1.Distance(P2) < Tol ) ) { 
684     // Degenerated case
685     gp_Pnt2d P2d;
686     C2d->D0(f, P2d);
687     S->D0(P2d.X(), P2d.Y(), P);
688     d = P1.Distance(P);
689     if (d > Tol) Tol = d;
690     C2d->D0(l, P2d);
691     S->D0(P2d.X(), P2d.Y(), P);
692     d = P2.Distance(P);
693     if (d > Tol) Tol = d;
694
695     B.UpdateVertex(VF, Tol);
696     B.UpdateVertex(VL, Tol);
697
698     B.MakeEdge(E);
699     B.UpdateEdge(E,C2d,S,TopLoc_Location(), Tol);
700     B.Add(E,VF);
701     B.Add(E,VL);
702     B.Range(E,f,l);
703     B.Degenerated(E, Standard_True);
704
705     return E;
706   }
707
708   C3d->D0(f, P);
709   d = P1.Distance(P);
710   if (d > Tol1)
711       B.UpdateVertex(VF, d);
712
713 //  P1 = BT.Pnt(VL);
714   P1 = BRep_Tool::Pnt(VL);
715   C3d->D0(l, P);
716   d = P2.Distance(P);
717   if (d > Tol2)
718       B.UpdateVertex(VL, d); 
719
720   BRepLib_MakeEdge MkE (C3d, VF, VL, f, l);
721   if (!MkE.IsDone()) { // Error of construction !!     
722 #ifdef DRAW    
723     char name[100];
724     sprintf(name,"firstvertex_error");
725     DBRep::Set(name, VF);
726     sprintf(name,"lastvertex_error");
727     DBRep::Set(name, VL);
728     sprintf(name,"curve3d_error");
729     char* Temp = name ;
730     DrawTrSurf::Set(Temp, C3d);
731 //    DrawTrSurf::Set(name, C3d);
732     Standard_ConstructionError::Raise("BRepFill_Sweep::BuildEdge");
733 #endif
734   }
735
736   E = MkE.Edge();
737   TopLoc_Location Loc;
738   B.UpdateEdge(E, C2d, S, Loc, Tol3d);
739
740   return E;
741 }
742
743         
744 //=======================================================================
745 //Fonction : Filling
746 //Objet : Construct the faces of filling
747 //=======================================================================
748 static Standard_Boolean Filling(const TopoDS_Shape& EF,
749                                 const TopoDS_Shape& F1,
750                                 const TopoDS_Shape& EL,
751                                 const TopoDS_Shape& F2,
752                                 TopTools_DataMapOfShapeShape& EEmap,
753                                 const Standard_Real Tol,
754                                 const  gp_Ax2& Axe,
755                                 const  gp_Vec& TangentOnPart1,
756                                 TopoDS_Edge& Aux1,
757                                 TopoDS_Edge& Aux2,
758                                 TopoDS_Face& Result)
759 {
760   BRep_Builder B;
761 // Class BRep_Tool without fields and without Constructor :
762 //  BRep_Tool BT;
763 //  Standard_Integer NbInt =0;
764 //  Standard_Real Tol3d = Tol;
765   Standard_Boolean WithE3, WithE4;
766
767 // Return constraints
768   TopoDS_Vertex V1, V2, Vf, Vl;
769   TopoDS_Edge E1, E2, E3, E4;
770   E1 = TopoDS::Edge(EF);
771   E2 = TopoDS::Edge(EL);
772   
773   TopExp::Vertices(E1, Vf, Vl);
774   Vf.Orientation(TopAbs_FORWARD);
775   Vl.Orientation(TopAbs_FORWARD);
776
777   TopExp::Vertices(E2, V1, V2);
778   V1.Orientation(TopAbs_REVERSED);
779   V2.Orientation(TopAbs_REVERSED);  
780   
781   B.MakeEdge(E3);
782   B.MakeEdge(E4);
783
784   WithE3 = WithE4 = Standard_False;
785
786   if ((!Aux1.IsNull()) && (!Vf.IsSame(V1))) {
787     E3 = Aux1;
788 //    E3 = TopoDS::Edge(Aux1);
789     WithE3 = Standard_True;
790   }
791
792   if (Vf.IsSame(Vl)) {
793     E4 = E3;
794     E4.Reverse();
795     WithE4 = WithE3;
796   }
797   else if (!Aux2.IsNull() && (!Vl.IsSame(V2))) {
798     E4 = Aux2;
799 //    E4 = TopoDS::Edge(Aux2);
800     WithE4 = Standard_True;
801   }
802
803 #if DRAW
804   if (Affich) {
805     DBRep::Set("Fill_Edge1", E1);
806     DBRep::Set("Fill_Edge2", E2);
807     if (!E3.IsNull())
808       DBRep::Set("Fill_Edge3", E3);
809     if (!E4.IsNull())
810       DBRep::Set("Fill_Edge4", E4);
811   }
812 #endif
813
814 // Construction of a surface of revolution
815   Handle(Geom_Curve) Prof1, Prof2;
816   //Standard_Integer ii, jj;//, Nb;
817   Standard_Real f1, f2, l1, l2,/*d1, d2,*/ Angle;//, Eps = 1.e-9;
818 //  Prof1 = BT.Curve(E1, f1, l1);
819   Prof1 = BRep_Tool::Curve(E1, f1, l1);
820 //  Prof2 = BT.Curve(E2, f2, l2);
821   Prof2 = BRep_Tool::Curve(E2, f2, l2);
822   gp_Pnt P1, P2, P;
823   gp_Pnt2d p1, p2;
824   gp_Trsf Tf;
825   Tf.SetTransformation(Axe);
826
827 // Choose the angle of opening
828   P1 = Prof1->Value((f1+l1)/2);
829   P2 = Prof2->Value((f2+l2)/2);
830   P1.Transform(Tf);
831   P2.Transform(Tf);
832   p1.SetCoord(P1.Z(), P1.X());
833   p2.SetCoord(P2.Z(), P2.X());
834   gp_Vec2d v1(gp::Origin2d(), p1);
835   gp_Vec2d v2(gp::Origin2d(), p2);
836   if (v1.Magnitude() <= gp::Resolution() ||
837       v2.Magnitude() <= gp::Resolution())
838     return Standard_False;
839   Angle = v1.Angle(v2);
840
841   gp_Ax1 axe(Axe.Location(), Axe.YDirection());
842
843   if (Angle < 0) {
844     Angle = -Angle;
845     axe.Reverse();
846   }
847
848   Handle(Geom_SurfaceOfRevolution) Rev = 
849     new (Geom_SurfaceOfRevolution) (Prof1, axe);
850   
851   Handle(Geom_Surface) Surf = 
852     new (Geom_RectangularTrimmedSurface) (Rev, 0, Angle, f1, l1);
853
854   // Control the direction of the rotation
855   Standard_Boolean ToReverseResult = Standard_False;
856   gp_Vec d1u;
857   d1u = Surf->DN(0, (f1+l1)/2, 1, 0);
858   if (d1u.Angle(TangentOnPart1) > M_PI/2) { //Invert everything
859     ToReverseResult = Standard_True;
860     /*
861     axe.Reverse();
862     Angle = 2*M_PI - Angle;
863     Rev = new (Geom_SurfaceOfRevolution) (Prof1, axe);
864     Surf = new (Geom_RectangularTrimmedSurface) 
865            (Rev, 0, Angle, f1, l1);
866     */
867   }
868
869 #if DRAW
870   if (Affich) { 
871       char* Temp = "Surf_Init" ;
872       DrawTrSurf::Set(Temp, Surf);
873     }
874 #endif
875
876   Handle(Geom2d_Curve) C1, C2, C3, C4;
877 /*
878 // Deform the surface of revolution.
879   GeomPlate_BuildPlateSurface BPS;
880
881   Handle(BRepAdaptor_HSurface) AS;
882   Handle(BRepAdaptor_HCurve2d) AC2d;
883   Handle(Adaptor3d_HCurveOnSurface) HConS;
884 */
885   Handle(Geom2d_Line) L;
886   gp_Pnt2d P2d(0.,0.);
887
888   L = new (Geom2d_Line) (P2d, gp::DY2d());
889   C1 = new (Geom2d_TrimmedCurve) (L, f1, l1);
890
891   P2d.SetCoord(Angle,0.);
892   L = new (Geom2d_Line) (P2d, gp::DY2d());
893   C2 = new (Geom2d_TrimmedCurve) (L, f1, l1);
894  
895   // It is required to control the direction and the range.
896   C2->D0(f1, P2d);
897   Surf->D0(P2d.X(), P2d.Y(), P1);
898   C2->D0(l1, P2d);
899   Surf->D0(P2d.X(), P2d.Y(), P2);
900 //  P = BT.Pnt(V1);
901   P = BRep_Tool::Pnt(V1);
902   if (P.Distance(P2)+Tol < P.Distance(P1)) {
903     // E2 is parsed in the direction opposite to E1
904     C2->Reverse();
905     TopoDS_Vertex aux;
906     aux = V2;
907     V2 = V1;
908     V1 = aux;
909   }
910   GeomLib::SameRange(Precision::PConfusion(), C2, 
911                      C2->FirstParameter(),
912                      C2->LastParameter(),
913                      f2, l2, C3);
914   C2 = C3;
915
916   Standard_Boolean pointu_f,  pointu_l;
917 //  P1 = BT.Pnt(Vf);
918   P1 = BRep_Tool::Pnt(Vf);
919 //  P2 = BT.Pnt(V1);
920   P2 = BRep_Tool::Pnt(V1);
921 //  pointu_f = Vf.IsSame(V1) || (P1.Distance(P2) < BT.Tolerance(Vf));
922   pointu_f = Vf.IsSame(V1) || (P1.Distance(P2) < BRep_Tool::Tolerance(Vf));
923 //  P1 = BT.Pnt(Vl);
924   P1 = BRep_Tool::Pnt(Vl);
925 //  P2 = BT.Pnt(V2);
926   P2 = BRep_Tool::Pnt(V2);
927 //  pointu_l = Vl.IsSame(V2) || (P1.Distance(P2) < BT.Tolerance(Vl));
928   pointu_l = Vl.IsSame(V2) || (P1.Distance(P2) < BRep_Tool::Tolerance(Vl));
929
930
931   P2d.SetCoord(0.,f1);
932   L = new (Geom2d_Line) (P2d, gp::DX2d());
933   C3 = new (Geom2d_TrimmedCurve) (L, 0, Angle);
934
935
936   P2d.SetCoord(0.,l1);
937   L = new (Geom2d_Line) (P2d, gp::DX2d());   
938   C4 = new (Geom2d_TrimmedCurve) (L, 0, Angle);
939 /*
940   // Determine the constraints and  
941   // their parametric localisation.
942   if (!E1.IsNull()) {
943      AS = new BRepAdaptor_HSurface(TopoDS::Face(F1));
944      AC2d = new BRepAdaptor_HCurve2d();
945      AC2d->ChangeCurve2d().Initialize(E1,TopoDS::Face(F1));
946      HConS = new (Adaptor3d_HCurveOnSurface)();
947      HConS->ChangeCurve().Load(AC2d);
948      HConS->ChangeCurve().Load(AS);
949
950      Handle(BRepFill_CurveConstraint) Cont
951       = new BRepFill_CurveConstraint(HConS, 1, 15);
952      Cont->SetCurve2dOnSurf(C1);
953
954      BPS.Add(Cont);
955      NbInt = HConS->NbIntervals(GeomAbs_CN);
956    }
957
958   if (!E2.IsNull()) {
959     AS = new BRepAdaptor_HSurface(TopoDS::Face(F2));
960     AC2d = new BRepAdaptor_HCurve2d();
961     AC2d->ChangeCurve2d().Initialize(E2,TopoDS::Face(F2));
962     HConS = new (Adaptor3d_HCurveOnSurface);
963
964     HConS->ChangeCurve().Load(AC2d);
965     HConS->ChangeCurve().Load(AS);
966
967     Handle(BRepFill_CurveConstraint) Cont
968       = new BRepFill_CurveConstraint(HConS, 1, 15);
969     Cont->SetCurve2dOnSurf(C2);
970     BPS.Add(Cont);
971   }
972
973   if (WithE3) {
974     Handle(BRepAdaptor_HCurve) AC = new (BRepAdaptor_HCurve) (E3);
975     Handle(BRepFill_CurveConstraint) Cont
976       = new BRepFill_CurveConstraint(AC, 0);
977     Cont->SetCurve2dOnSurf(C3);
978     BPS.Add(Cont);
979   } 
980   else if (pointu_f) {
981     Standard_Real delta = Angle / 11;
982 //    P = BT.Pnt(Vf);
983     P = BRep_Tool::Pnt(Vf);
984     Handle(GeomPlate_PointConstraint) PC;
985     for (ii=1; ii<=10; ii++) {
986       C3->D0(ii*delta, P2d);
987       PC = new (GeomPlate_PointConstraint) (P, 0); 
988       PC->SetPnt2dOnSurf(P2d);
989       BPS.Add(PC);
990     }
991   }
992
993
994   if (WithE4) {
995     Handle(BRepAdaptor_HCurve) AC = new (BRepAdaptor_HCurve) (E4);
996     Handle(BRepFill_CurveConstraint) Cont
997       = new BRepFill_CurveConstraint(AC, 0);
998     Cont->SetCurve2dOnSurf(C4);
999     BPS.Add(Cont);
1000   }
1001   else if (pointu_l) {
1002     Standard_Real delta = Angle / 11;
1003 //    P = BT.Pnt(Vl);
1004     P = BRep_Tool::Pnt(Vl);
1005     Handle(GeomPlate_PointConstraint) PC;
1006     for (ii=1; ii<=10; ii++) {
1007       C4->D0(ii*delta, P2d);
1008       PC = new (GeomPlate_PointConstraint) (P, 0); 
1009       PC->SetPnt2dOnSurf(P2d);
1010       BPS.Add(PC);
1011     }
1012   }
1013
1014   BPS.LoadInitSurface(Surf);
1015   BPS.Perform();
1016
1017   // Controle s'il y a une deformation effective
1018   Handle(GeomPlate_Surface) plate;
1019   plate = BPS.Surface();
1020   plate->SetBounds(0, Angle, f1, l1);
1021   Standard_Boolean Ok=Standard_True;
1022   Standard_Real u, v;
1023   d1 = (l1-f1)/5;
1024   d2 = Angle/5;
1025   for (ii=0; ii<=5 && Ok; ii++) {
1026     u = f1 + ii*d1;
1027     for (jj=0; jj<=5 && Ok; jj++) {
1028       v = jj*d2;
1029       plate->D0(u, v, P1);
1030       Surf->D0(u, v, P2);
1031       Ok = (P2.IsEqual(P1, Tol)); 
1032     }
1033   }
1034
1035
1036   if (!Ok) {
1037     // Approx de la plate surface
1038     // Bords naturelles => pas besoin de criteres.
1039     GeomConvert_ApproxSurface App(BPS.Surface(), 
1040                                   Tol3d,
1041                                   GeomAbs_C1, GeomAbs_C1,
1042                                   8, 8, 2*NbInt, 0);
1043     if (!App.HasResult()) {
1044 #if DEB
1045       cout << "Filling_Approx : Pas de resultat" << endl;
1046 #endif      
1047       return Standard_False;
1048     }
1049 #if DEB
1050     cout <<  "Filling_Approx Error 3d = " << 
1051       App.MaxError() << endl;
1052 #endif
1053     Surf = App.Surface();
1054     Tol3d = App.MaxError();  
1055   }
1056 */
1057
1058 // Update des Edges
1059   TopLoc_Location Loc;
1060   Handle(Geom_Curve) C3d;
1061   B.UpdateEdge(E1, C1, Surf, Loc, /*Tol3d*/Precision::Confusion());
1062   B.UpdateEdge(E2, C2, Surf, Loc, /*Tol3d*/Precision::Confusion());
1063  
1064   if (E3.IsSame(E4)) {
1065     if (!WithE3)
1066       {
1067         C3d = Surf->VIso(f1);
1068         E3 = BuildEdge(C3d, C3, Surf, Vf, V1, 0, Angle, /*Tol3d*/Precision::Confusion());
1069       }
1070     else
1071       {
1072         BRepAdaptor_Curve aCurve(E3);
1073         Standard_Real AngleOld = aCurve.LastParameter();
1074         if (Angle > AngleOld)
1075           {
1076             B.Range( E3, 0, Angle );
1077             TopoDS_Vertex V (TopExp::LastVertex(E3));
1078             Handle(BRep_TVertex)& TVlast = *((Handle(BRep_TVertex)*) &V.TShape());
1079             TVlast->Tolerance( Precision::Confusion() );
1080           }
1081       }
1082
1083     B.UpdateEdge(E3, C3, C4, Surf, Loc, /*Tol3d*/Precision::Confusion());
1084     E4 = E3;
1085     E4.Reverse();
1086   }
1087   else {
1088     if (!WithE3)
1089       {
1090         C3d = Surf->VIso(f1);
1091         E3 = BuildEdge(C3d, C3, Surf, Vf, V1, 0, Angle, /*Tol3d*/Precision::Confusion());
1092       }
1093     else
1094       {
1095         BRepAdaptor_Curve aCurve(E3);
1096         Standard_Real AngleOld = aCurve.LastParameter();
1097         if (Angle > AngleOld)
1098           {
1099             B.Range( E3, 0, Angle );
1100             TopoDS_Vertex V(TopExp::LastVertex(E3));
1101             Handle(BRep_TVertex)& TVlast = *((Handle(BRep_TVertex)*) &V.TShape());
1102             TVlast->Tolerance( Precision::Confusion() );
1103           }
1104
1105         B.UpdateEdge(E3, C3, Surf, Loc, /*Tol3d*/Precision::Confusion());
1106       }
1107     
1108     if (!WithE4)
1109       {
1110         C3d = Surf->VIso(l1);
1111         E4 = BuildEdge(C3d, C4, Surf, Vl, V2, 0, Angle, /*Tol3d*/Precision::Confusion());
1112       }
1113     else
1114       {
1115         BRepAdaptor_Curve aCurve(E4);
1116         Standard_Real AngleOld = aCurve.LastParameter();
1117         if (Angle > AngleOld)
1118           {
1119             B.Range( E4, 0, Angle );
1120             TopoDS_Vertex V (TopExp::LastVertex(E4));
1121             Handle(BRep_TVertex)& TVlast = *((Handle(BRep_TVertex)*)&V.TShape());
1122             TVlast->Tolerance( Precision::Confusion() );
1123           }
1124
1125         B.UpdateEdge(E4, C4, Surf, Loc, /*Tol3d*/Precision::Confusion());
1126       }
1127   }
1128
1129 //Construct face
1130   BuildFace(Surf,E1, E3, E2, E4, EEmap,
1131             Standard_False, Standard_False, 
1132             Result);
1133
1134 // Set the continuities.
1135   B.Continuity(E1, TopoDS::Face(F1), Result, GeomAbs_G1);
1136   B.Continuity(E2, TopoDS::Face(F2), Result, GeomAbs_G1);
1137
1138 // Render the calculated borders.
1139 //  if (!BT.Degenerated(E3))
1140   if (!BRep_Tool::Degenerated(E3))
1141     Aux1 = E3;
1142   else
1143     B.MakeEdge(Aux1); //Nullify
1144
1145 //  if (!BT.Degenerated(E4))
1146   if (!BRep_Tool::Degenerated(E4))
1147     Aux2 = E4;
1148   else
1149     B.MakeEdge(Aux2);
1150
1151   // Set the orientation
1152   gp_Vec D1U, D1V, N1, N2;
1153   C1->D0( (f1+l1)/2, P2d);
1154   Surf->D1(P2d.X(), P2d.Y(), P, D1U, D1V);
1155   N1 = D1U^D1V;
1156   
1157 //  C1 = BT.CurveOnSurface(E1, TopoDS::Face(F1), f2, l2);
1158   C1 = BRep_Tool::CurveOnSurface(E1, TopoDS::Face(F1), f2, l2);
1159   C1->D0( (f1+l1)/2, P2d);
1160   Handle(BRepAdaptor_HSurface) AS = new BRepAdaptor_HSurface(TopoDS::Face(F1));
1161   AS->D1(P2d.X(), P2d.Y(), P, D1U, D1V);
1162   N2 = D1U^D1V;
1163   
1164   if ( (F1.Orientation() == TopAbs_REVERSED) ^ (N1.Angle(N2)>M_PI/2) )
1165     Result.Orientation(TopAbs_REVERSED);
1166   else  Result.Orientation(TopAbs_FORWARD);
1167
1168   if (ToReverseResult)
1169     Result.Reverse();
1170
1171 #if DRAW
1172   if (Affich) DBRep::Set("BoucheTrou", Result);
1173 #endif
1174
1175   return Standard_True;
1176 }
1177
1178 //=======================================================================
1179 //function : Substitute
1180 //purpose  :
1181 //=======================================================================
1182 static void Substitute(BRepTools_Substitution& aSubstitute,
1183                        const TopoDS_Edge& Old,
1184                        const TopoDS_Edge& New) 
1185 {
1186   TopTools_ListOfShape listShape;
1187
1188   TopoDS_Vertex OldV1, OldV2, NewV1, NewV2;
1189   TopExp::Vertices( Old, OldV1, OldV2 );
1190   TopExp::Vertices( New, NewV1, NewV2 );
1191
1192   if (!aSubstitute.IsCopied( OldV1 ))
1193     {
1194       listShape.Append( NewV1.Oriented(TopAbs_FORWARD) );
1195       aSubstitute.Substitute( OldV1, listShape );
1196       listShape.Clear();
1197     }
1198   if (!aSubstitute.IsCopied( OldV2 ))
1199     {
1200       listShape.Append( NewV2.Oriented(TopAbs_FORWARD) );
1201       aSubstitute.Substitute( OldV2, listShape );
1202       listShape.Clear();
1203     }
1204   if (!aSubstitute.IsCopied( Old ))
1205     {
1206       listShape.Append( New.Oriented(TopAbs_FORWARD) );
1207       aSubstitute.Substitute( Old, listShape );
1208     }
1209 }
1210
1211 //=======================================================================
1212 //Function : SetCommonEdgeInFace
1213 //Purpose  : Replace an edge of the face by the corresponding edge from
1214 //           myUEdges
1215 //=======================================================================
1216 /*
1217 static void SetCommonEdgeInFace(BRepTools_Substitution& aSubstitute,
1218                                 const TopoDS_Shape& Face,
1219                                 const TopoDS_Shape& Edge)
1220 {
1221   if (Edge.IsNull())
1222     return;
1223
1224   Standard_Boolean done = Standard_False;
1225 // Class BRep_Tool without fields and without Constructor :
1226 //  BRep_Tool BT;
1227   Standard_Real f, l;
1228   TopExp_Explorer Exp(Face, TopAbs_EDGE);
1229   Handle(Geom_Curve) Cref, C;
1230   TopLoc_Location Lref, L;
1231 //  Cref = BT.Curve(TopoDS::Edge(Edge), Lref, f, l); 
1232   const TopoDS_Edge& NewEdge = TopoDS::Edge(Edge);
1233   Cref = BRep_Tool::Curve( NewEdge, Lref, f, l ); 
1234
1235   for ( ; Exp.More() && !done; Exp.Next()) {
1236 //    C = BT.Curve(TopoDS::Edge(Exp.Current()), L, f, l);
1237     const TopoDS_Edge& OldEdge = TopoDS::Edge(Exp.Current());
1238     C = BRep_Tool::Curve(OldEdge, L, f, l);
1239     if ((Cref==C) && (Lref == L)) {
1240       done = Standard_True;
1241       Substitute( aSubstitute, OldEdge, NewEdge );
1242     }
1243   }
1244 #if DEB
1245   if (!done) cout << "Substitution of Edge failed" << endl;
1246 #endif  
1247 }
1248 */
1249
1250 //=======================================================================
1251 //Fonction : KeepEdge
1252 //Objet : Find edges of the face supported by the same Curve.
1253 //=======================================================================
1254 static void KeepEdge(const TopoDS_Shape& Face,
1255                      const TopoDS_Shape& Edge,
1256                      TopTools_ListOfShape& List)
1257 {
1258   List.Clear();
1259 // Class BRep_Tool without fields and without Constructor :
1260 //  BRep_Tool BT;
1261   Standard_Real f, l;
1262   TopExp_Explorer Exp(Face, TopAbs_EDGE);
1263   Handle(Geom_Curve) Cref, C;
1264   TopLoc_Location Lref, L;
1265 //  Cref = BT.Curve(TopoDS::Edge(Edge), Lref, f, l); 
1266   Cref = BRep_Tool::Curve(TopoDS::Edge(Edge), Lref, f, l); 
1267
1268   for ( ; Exp.More(); Exp.Next()) {
1269 //    C = BT.Curve(TopoDS::Edge(Exp.Current()), L, f, l);
1270     C = BRep_Tool::Curve(TopoDS::Edge(Exp.Current()), L, f, l);
1271     if ((Cref==C) && (Lref == L)) { 
1272       List.Append(Exp.Current());
1273     }
1274   }
1275 }
1276
1277 //=======================================================================
1278 //Function : 
1279 //Objet : Construct a vertex via an iso
1280 //=======================================================================
1281 static void BuildVertex(const Handle(Geom_Curve)& Iso,
1282                         const Standard_Boolean isfirst,
1283                         const Standard_Real First,
1284                         const Standard_Real Last,
1285                         TopoDS_Shape& Vertex)
1286 {
1287   BRep_Builder B;
1288   Standard_Real val;
1289
1290   if (isfirst) val = First;
1291   else val = Last;
1292   B.MakeVertex(TopoDS::Vertex(Vertex),
1293                Iso->Value(val),
1294                Precision::Confusion());
1295 }
1296
1297 //=======================================================================
1298 //Function : 
1299 //Objet : Construct an empty edge
1300 //=======================================================================
1301 static TopoDS_Edge NullEdge(TopoDS_Shape& Vertex)
1302 {
1303   TopoDS_Edge E;
1304   BRep_Builder B;
1305   B.MakeEdge(E);
1306   Vertex.Orientation(TopAbs_FORWARD);
1307   B.Add(E, Vertex);
1308   B.Add(E, Vertex.Reversed());
1309   B.Degenerated(E, Standard_True);
1310   return E;
1311
1312 }
1313         
1314 //=======================================================================
1315 //Function : 
1316 //Objet : Construct an edge via an iso
1317 //=======================================================================
1318 static TopoDS_Edge BuildEdge(const Handle(Geom_Surface)& S,
1319                              const Standard_Boolean isUiso,
1320                              const Standard_Real ValIso,
1321                              const TopoDS_Shape&  VFirst,
1322                              const TopoDS_Shape&  VLast,
1323                              const Standard_Real  Tol)
1324 {
1325   TopoDS_Edge E;
1326   BRep_Builder B;
1327   Handle(Geom_Curve) Iso;
1328   Standard_Boolean sing = Standard_False;
1329   if (isUiso) {
1330     Iso = S->UIso(ValIso);
1331   }
1332   else {      
1333     Iso = S->VIso(ValIso);
1334   }
1335
1336   if (VFirst.IsSame(VLast)) { // Singular case ?
1337     gp_Pnt P; 
1338 // Class BRep_Tool without fields and without Constructor :
1339 //    BRep_Tool BT;
1340     const TopoDS_Vertex& V = TopoDS::Vertex(VFirst);
1341 //    Standard_Real tol = BT.Tolerance(V);
1342     Standard_Real tol = BRep_Tool::Tolerance(V);
1343     if (Tol > tol) tol = Tol; 
1344     Iso->D0((Iso->FirstParameter()+Iso->LastParameter())/2, P);
1345 //    if (P.Distance(BT.Pnt(V)) < tol) {
1346     if (P.Distance(BRep_Tool::Pnt(V)) < tol) {
1347       GeomAdaptor_Curve AC(Iso);
1348       sing = GCPnts_AbscissaPoint::Length(AC, tol/4) < tol;
1349     }
1350   }
1351
1352
1353   if (sing) { // Singular case
1354     TopoDS_Shape V;
1355     V = VFirst;
1356     E = NullEdge(V);
1357 //    Iso.Nullify();
1358 //    B.UpdateEdge(E, Iso, Precision::Confusion());
1359     B.Degenerated(E, Standard_True);
1360   }
1361   
1362   else {
1363     // Construction Via 3d
1364 //    if (isUiso) {
1365 //      Iso = S->UIso(ValIso);
1366     gp_Pnt P1,P2;
1367     Standard_Real p1, p2, p11, p12, p21, p22;
1368     Standard_Boolean fwd = Standard_False;
1369     p1 = Iso->FirstParameter();
1370     p2 = Iso->LastParameter();
1371     P1 = Iso->Value(p1);
1372     P2 = Iso->Value(p2);
1373
1374     Standard_Real t1 = BRep_Tool::Tolerance(TopoDS::Vertex(VFirst));
1375     Standard_Real t2 = BRep_Tool::Tolerance(TopoDS::Vertex(VLast));
1376
1377     BRep_Builder BB;
1378
1379     p11 = P1.Distance(BRep_Tool::Pnt(TopoDS::Vertex(VFirst)));
1380     p22 = P2.Distance(BRep_Tool::Pnt(TopoDS::Vertex(VLast)));
1381     p12 = P1.Distance(BRep_Tool::Pnt(TopoDS::Vertex(VLast)));
1382     p21 = P2.Distance(BRep_Tool::Pnt(TopoDS::Vertex(VFirst)));
1383     
1384     if(p11 < p12 && p22 < p21) fwd = Standard_True;
1385
1386     if(fwd) { //OCC500(apo)
1387       if (p11 >= t1) BB.UpdateVertex(TopoDS::Vertex(VFirst), 1.01*p11);
1388       if (p22 >= t2) BB.UpdateVertex(TopoDS::Vertex(VLast), 1.01*p22);
1389     }
1390     else {      
1391 //      Iso = S->VIso(ValIso);
1392       if (p12 >= t2) BB.UpdateVertex(TopoDS::Vertex(VLast), 1.01*p12);
1393       if (p21 >= t1) BB.UpdateVertex(TopoDS::Vertex(VFirst), 1.01*p21);
1394     }
1395
1396     BRepLib_MakeEdge MkE;
1397
1398 //    MkE.Init(Iso, 
1399 //           TopoDS::Vertex(VFirst), 
1400 //           TopoDS::Vertex(VLast), 
1401 //           Iso->FirstParameter(),
1402 //           Iso->LastParameter());
1403     if(fwd)
1404       MkE.Init(Iso, 
1405                TopoDS::Vertex(VFirst), 
1406                TopoDS::Vertex(VLast), 
1407                Iso->FirstParameter(),
1408                Iso->LastParameter());
1409     else
1410       MkE.Init(Iso,
1411                TopoDS::Vertex(VLast),
1412                TopoDS::Vertex(VFirst), 
1413                Iso->FirstParameter(),
1414                Iso->LastParameter());
1415
1416 //    if (!MkE.IsDone()) { // Il faut peut etre permuter les Vertex
1417 //      MkE.Init(Iso,
1418 //             TopoDS::Vertex(VLast),
1419 //             TopoDS::Vertex(VFirst), 
1420 //             Iso->FirstParameter(),
1421 //             Iso->LastParameter());
1422 //    }
1423
1424     if (!MkE.IsDone()) { // Erreur de construction !!     
1425 #ifdef DRAW
1426       char name[100];
1427       sprintf(name,"firstvertex_error");
1428       DBRep::Set(name, VFirst);
1429       sprintf(name,"lastvertex_error");
1430       DBRep::Set(name, VLast);
1431       sprintf(name,"curve3d_error");
1432       char* Temp = name ;
1433       DrawTrSurf::Set(Temp,Iso);
1434 //      DrawTrSurf::Set(name,Iso);
1435 #endif
1436       Standard_ConstructionError::Raise("BRepFill_Sweep::BuildEdge");
1437     }
1438
1439     E = MkE.Edge();
1440   }
1441
1442   // Associate 2d
1443   Handle(Geom2d_Line) L;
1444   TopLoc_Location Loc;
1445   if (isUiso) {
1446     gp_Pnt2d P(ValIso, 0);
1447     gp_Vec2d V(0., 1.);
1448     L = new (Geom2d_Line) (P, V);
1449   }
1450   else {
1451     gp_Pnt2d P(0., ValIso);
1452     gp_Vec2d V(1., 0.);
1453     L = new (Geom2d_Line) (P, V);
1454   }
1455
1456   B.UpdateEdge(E, L, S, Loc, Precision::Confusion());
1457   if (sing) B.Range(E, S, Loc, 
1458                     Iso->FirstParameter(), 
1459                     Iso->LastParameter());
1460
1461   return E;
1462 }
1463
1464 //=======================================================================
1465 //Function : 
1466 //Objet : Complete an edge via an iso
1467 //=======================================================================
1468 static void UpdateEdge(TopoDS_Edge& E,
1469                        const Handle(Geom_Surface)& S,
1470                        const Standard_Boolean isUiso,
1471                        const Standard_Real ValIso)
1472 {
1473   BRep_Builder B;
1474   Handle(Geom2d_Line) L;
1475   Handle(Geom2d_Curve) PCurve, CL;
1476   TopLoc_Location Loc;
1477   Standard_Real UFirst, ULast, VFirst, VLast, F2d, L2d;
1478   S->Bounds( UFirst, ULast, VFirst, VLast);
1479
1480   Standard_Boolean sing = Standard_False;
1481   Handle(Geom_Curve) Iso;
1482   if (isUiso) {
1483     Iso = S->UIso(ValIso);
1484   }
1485   else {      
1486     Iso = S->VIso(ValIso);
1487   }
1488
1489   TopoDS_Vertex Vf, Vl;
1490   TopExp::Vertices(E, Vf, Vl);
1491   if (Vf.IsSame(Vl)) { // Singular case ?
1492     gp_Pnt Pmid; 
1493     Standard_Real tol = BRep_Tool::Tolerance(Vf);
1494     Iso->D0((Iso->FirstParameter()+Iso->LastParameter())/2, Pmid);
1495     if (Pmid.Distance(BRep_Tool::Pnt(Vf)) < tol) {
1496       GeomAdaptor_Curve AC(Iso);
1497       sing = GCPnts_AbscissaPoint::Length(AC, tol/4) < tol;
1498     }
1499   }
1500
1501   if (isUiso) {
1502     gp_Pnt2d P(ValIso, 0);
1503     gp_Vec2d V(0., 1.);
1504     L = new (Geom2d_Line) (P, V);
1505     F2d = VFirst;
1506     L2d = VLast;
1507   }
1508   else {
1509     gp_Pnt2d P(0., ValIso);
1510     gp_Vec2d V(1., 0.);
1511     L = new (Geom2d_Line) (P, V);
1512     F2d = UFirst;
1513     L2d = ULast;
1514   }
1515   CL = new (Geom2d_TrimmedCurve) (L, F2d, L2d);
1516
1517   // Control direction & Range
1518   Standard_Real R, First, Last, Tol=1.e-4;
1519   Standard_Boolean reverse = Standard_False;;
1520   
1521
1522 // Class BRep_Tool without fields and without Constructor :
1523 //  BRep_Tool BT;
1524   gp_Pnt POnS;
1525   gp_Pnt2d P2d;
1526 //  BT.Range(E, First, Last);
1527   BRep_Tool::Range(E, First, Last);
1528
1529   if (!Vf.IsSame(Vl)) {
1530     // Test distances between "FirstPoint" and "Vertex"
1531     P2d = CL->Value(F2d);
1532     POnS = S->Value(P2d.X(), P2d.Y());
1533 //    reverse = POnS.Distance(BT.Pnt(Vl)) < POnS.Distance(BT.Pnt(Vf));
1534     reverse = POnS.Distance(BRep_Tool::Pnt(Vl)) < POnS.Distance(BRep_Tool::Pnt(Vf));
1535   }
1536   else if (!sing) {
1537     // Test angle between "First Tangente"
1538     gp_Vec2d V2d;
1539     gp_Vec V3d, du, dv, dC3d;
1540     BRepAdaptor_Curve C3d(E);
1541
1542     C3d.D1(First, POnS,  dC3d);
1543     CL->D1(F2d, P2d, V2d);
1544     S->D1(P2d.X(), P2d.Y(), POnS, du, dv);
1545     V3d.SetLinearForm(V2d.X(), du, V2d.Y(), dv);
1546     reverse = ( dC3d.Angle(V3d) > Tol);
1547   }
1548   if (reverse ) { // Return curve 2d
1549     CL = new (Geom2d_TrimmedCurve)(L, F2d, L2d);
1550     CL->Reverse();  
1551     F2d = CL->FirstParameter();
1552     L2d = CL->LastParameter();
1553   }
1554
1555   if (sing)
1556     {
1557       Handle(Geom_Curve) NullCurve;
1558       B.UpdateEdge(E, NullCurve, 0.);
1559       B.Degenerated(E, Standard_True);
1560       B.Range(E, F2d, L2d);
1561       First = F2d;
1562       Last  = L2d;
1563     }
1564
1565   if (First != F2d || Last != L2d) {
1566     Handle(Geom2d_Curve) C2d;
1567     GeomLib::SameRange(Precision::PConfusion(), CL, 
1568                        F2d, L2d, First, Last,
1569                        C2d);
1570     CL = new (Geom2d_TrimmedCurve)(C2d, First, Last);
1571   }
1572
1573   // Update des Vertex
1574
1575   TopoDS_Vertex V;
1576
1577   P2d = CL->Value(First);
1578   POnS = S->Value(P2d.X(), P2d.Y());
1579   V = TopExp::FirstVertex(E); 
1580 //  R = POnS.Distance(BT.Pnt(V));
1581   R = POnS.Distance(BRep_Tool::Pnt(V));
1582   B.UpdateVertex(V, R);
1583
1584   P2d = CL->Value(Last);
1585   POnS = S->Value(P2d.X(), P2d.Y());
1586   V = TopExp::LastVertex(E);
1587 //  R = POnS.Distance(BT.Pnt(V));
1588   R = POnS.Distance(BRep_Tool::Pnt(V));
1589   B.UpdateVertex(V, R);
1590
1591   // Update Edge
1592   if (!sing && SameParameter(E, CL, S, Tol, R)) {
1593     B.UpdateEdge(E, R);
1594   }
1595
1596   PCurve = Couture(E, S, Loc);
1597   if (PCurve.IsNull())
1598     B.UpdateEdge(E, CL, S, Loc, Precision::Confusion());
1599   else { // Sewing edge
1600     TopoDS_Edge e = E;
1601     Oriente(S, e);
1602     if (e.Orientation() == TopAbs_REVERSED)
1603       B.UpdateEdge(E, CL, PCurve, S, Loc, Precision::Confusion());
1604     else         
1605       B.UpdateEdge(E, PCurve, CL, S, Loc, Precision::Confusion());
1606   }
1607
1608   // Attention to case not SameRange on its shapes (PRO13551)
1609 //  if (!BT.SameRange(E)) B.Range(E, S, Loc, First, Last);
1610   if (!BRep_Tool::SameRange(E)) B.Range(E, S, Loc, First, Last);
1611 }
1612
1613 //=======================================================================
1614 // Object : Check if a surface is degenerated
1615 //=======================================================================
1616 static Standard_Boolean IsDegen(const Handle(Geom_Surface)& S,
1617                                 const Standard_Real Tol)
1618 {
1619   Standard_Integer Nb = 5;
1620   Standard_Boolean B = Standard_True;
1621   Standard_Real Umax, Umin, Vmax, Vmin, t, dt, l;
1622   Standard_Integer ii;
1623   Handle(Geom_Curve) Iso;
1624   gp_Pnt P1,P2,P3;
1625   GCPnts_AbscissaPoint GC;
1626
1627   S->Bounds(Umin, Umax, Vmin, Vmax);
1628
1629   // Check the length of Iso-U
1630   t = (Umin + Umax)/2;
1631   S->D0(t, Vmin, P1);
1632   S->D0(t, (Vmin+Vmax)/2, P2);
1633   S->D0(t, Vmax, P3);
1634   B = ((P1.Distance(P2) + P2.Distance(P3)) < Tol);
1635   
1636   for (ii=1, dt = (Umax-Umin)/(Nb+1); B && (ii<=Nb); ii++) {
1637     t =  Umin + ii*dt;
1638     Iso = S->UIso(t);
1639     GeomAdaptor_Curve AC(Iso);
1640     l = GC.Length(AC, Tol/4);
1641     B = (l <= Tol);
1642   }
1643  
1644   if (B) return Standard_True;
1645
1646   // Check the length of Iso-V
1647   t = (Vmin + Vmax)/2;
1648   S->D0(Umin, t, P1);
1649   S->D0((Umin+Umax)/2, t, P2);
1650   S->D0(Umax, t, P3);
1651   B = ((P1.Distance(P2) + P2.Distance(P3)) < Tol); 
1652  
1653  
1654   for (ii=1, dt = (Vmax-Vmin)/(Nb+1); B && (ii<=Nb); ii++) {
1655     t =  Vmin + ii*dt;
1656     Iso = S->VIso(t);
1657     GeomAdaptor_Curve AC(Iso);
1658     l = GC.Length(AC, Tol/4);
1659     B = (l <= Tol);
1660   }  
1661     
1662   return B;
1663 }
1664
1665 //=======================================================================
1666 //function : Constructeur
1667 //purpose  : 
1668 //======================================================================
1669 BRepFill_Sweep::BRepFill_Sweep(const Handle(BRepFill_SectionLaw)& Section,
1670                                const Handle(BRepFill_LocationLaw)& Location,
1671                                const Standard_Boolean WithKPart) : 
1672                                isDone(Standard_False),
1673                                KPart(WithKPart)
1674
1675
1676 {
1677  mySec = Section;
1678  myLoc = Location;
1679  
1680  SetTolerance(1.e-4);
1681  SetAngularControl();
1682  myAuxShape.Clear();
1683
1684  myApproxStyle = GeomFill_Location;
1685  myContinuity  = GeomAbs_C2;
1686  myDegmax      = 11;
1687  mySegmax      = 30;
1688 }
1689
1690 //=======================================================================
1691 //function : SetBounds
1692 //purpose  : Define start and end shapes
1693 //======================================================================
1694  void BRepFill_Sweep::SetBounds(const TopoDS_Wire& First,
1695                                 const TopoDS_Wire& Last)
1696
1697   FirstShape = First;
1698   LastShape  = Last; 
1699
1700   // It is necessary to check the SameRange on its (PRO13551)
1701   Standard_Boolean issame = Standard_True;
1702   BRep_Builder B;
1703   BRepTools_WireExplorer wexp;
1704   if (!FirstShape.IsNull()) {
1705     for (wexp.Init(FirstShape); wexp.More(); wexp.Next()) {
1706       if (!BRepLib::CheckSameRange(wexp.Current())) {
1707         B.SameRange(wexp.Current(), Standard_False);
1708         B.SameParameter(wexp.Current(), Standard_False);
1709         issame = Standard_False;
1710       }
1711     }
1712   }
1713   
1714   if (!LastShape.IsNull()) {
1715     for (wexp.Init(LastShape); wexp.More(); wexp.Next()) {
1716       if (!BRepLib::CheckSameRange(wexp.Current())) {
1717         B.SameRange(wexp.Current(), Standard_False); 
1718         B.SameParameter(wexp.Current(), Standard_False);
1719         issame = Standard_False;
1720       }
1721     }
1722   }
1723
1724 #if DEB
1725   if (!issame) 
1726     cout<<"Sweep Warning : Edge not SameRange in the limits"<<endl;
1727 #endif
1728 }
1729
1730 //=======================================================================
1731 //function : SetTolerance
1732 //purpose  :
1733 //======================================================================
1734  void BRepFill_Sweep::SetTolerance(const Standard_Real Tol3d,
1735                                    const Standard_Real BoundTol,
1736                                    const Standard_Real Tol2d, 
1737                                    const Standard_Real TolAngular) 
1738 {
1739   myTol3d = Tol3d;
1740   myBoundTol = BoundTol;
1741   myTol2d =Tol2d;
1742   myTolAngular = TolAngular;
1743 }
1744 //=======================================================================
1745 //function : SetAngularControl
1746 //purpose  :
1747 //======================================================================
1748  void BRepFill_Sweep::SetAngularControl(const Standard_Real MinAngle,
1749                                    const Standard_Real MaxAngle)
1750 {
1751   myAngMin = Max (MinAngle, Precision::Angular());
1752   myAngMax = Min (MaxAngle, 6.28);
1753 }
1754
1755 ///=======================================================================
1756 //function : CorrectApproxParameters
1757 //purpose  : 
1758 //=======================================================================
1759  Standard_Boolean BRepFill_Sweep::CorrectApproxParameters()
1760 {
1761   TopoDS_Wire thePath = myLoc->Wire();
1762   GeomAbs_Shape    NewCont   = myContinuity;
1763   Standard_Integer NewSegmax = mySegmax;
1764
1765   TopoDS_Iterator iter(thePath);
1766   for (; iter.More(); iter.Next())
1767     {
1768       TopoDS_Edge anEdge = TopoDS::Edge(iter.Value());
1769       BRepAdaptor_Curve aBAcurve(anEdge);
1770       GeomAbs_Shape aContinuity = aBAcurve.Continuity();
1771       Standard_Integer aNbInterv = aBAcurve.NbIntervals(GeomAbs_CN);
1772       if (aContinuity < NewCont)
1773         NewCont = aContinuity;
1774       if (aNbInterv > NewSegmax)
1775         NewSegmax = aNbInterv;
1776     }
1777
1778   Standard_Boolean Corrected = Standard_False;
1779   if (NewCont != myContinuity || NewSegmax != mySegmax)
1780     Corrected = Standard_True;
1781   myContinuity = NewCont;
1782   mySegmax     = NewSegmax;
1783   return Corrected;
1784 }
1785
1786 //=======================================================================
1787 //function : BuildWire
1788 //purpose  : Construit a wire by sweeping
1789 //======================================================================
1790  Standard_Boolean BRepFill_Sweep::
1791  BuildWire(const BRepFill_TransitionStyle /*Transition*/)
1792 {
1793   Standard_Integer ipath, isec = 1;
1794   gp_Pnt P1;//, P2;
1795
1796   BRep_Builder B;
1797 // Class BRep_Tool without fields and without Constructor :
1798 //  BRep_Tool BT;
1799   Standard_Integer NbPath = myLoc->NbLaw();
1800   Standard_Boolean vclose;
1801   vclose = (myLoc->IsClosed() && (myLoc->IsG1(0, myTol3d)>= 0));
1802   Error = 0.;
1803   Handle(Geom_Surface) S;
1804   Handle(Geom_Curve) Iso;
1805   Standard_Real val, bid, First, Last, Tol;
1806
1807  TopoDS_Wire wire;
1808  TopoDS_Edge E;
1809  B.MakeWire(wire);
1810
1811  // (1) Construction of all curves
1812
1813  // (1.1) Construction of Tables
1814  myFaces = new (TopTools_HArray2OfShape) (1, 1, 1, NbPath);
1815  myUEdges = new (TopTools_HArray2OfShape) (1, 2, 1, NbPath);
1816  myVEdges = new (TopTools_HArray2OfShape) (1, 1, 1, NbPath+1);
1817
1818  // (1.2) Calculate curves / vertex / edge
1819   for (ipath=1; ipath <=NbPath; ipath++) { 
1820     // Curve by iso value
1821     GeomFill_Sweep Sweep(myLoc->Law(ipath), KPart);
1822     Sweep.SetTolerance(myTol3d, myBoundTol, myTol2d, myTolAngular);
1823     Sweep.Build(mySec->Law(isec), myApproxStyle, myContinuity, myDegmax, mySegmax);
1824     if (!Sweep.IsDone())  
1825       return Standard_False;
1826     S = Sweep.Surface();
1827     if (Sweep.ExchangeUV()) {
1828       if  (Sweep.UReversed()) S->Bounds(First, Last, bid, val);
1829       else S->Bounds(First, Last, val, bid);
1830       Iso = S->VIso(val); 
1831     }
1832     else {
1833       if (Sweep.UReversed()) S->Bounds(bid,  val, First, Last);
1834       else  S->Bounds(val, bid, First, Last);
1835       Iso = S->UIso(val); 
1836     }
1837     // Vertex by position
1838     if (ipath < NbPath) 
1839       BuildVertex(Iso, Standard_False, First, Last, 
1840                   myVEdges->ChangeValue(1, ipath+1));
1841     else {
1842       if (vclose) { 
1843         TopoDS_Vertex& V = TopoDS::Vertex(myVEdges->ChangeValue(1, 1));
1844         myVEdges->SetValue(1, ipath+1, V);
1845         Iso->D0(Last, P1);
1846 //      Tol = P1.Distance(BT.Pnt(V));
1847         Tol = P1.Distance(BRep_Tool::Pnt(V));
1848         B.UpdateVertex(V, Tol);
1849       }
1850       else {
1851         if (!LastShape.IsNull()) myVEdges->SetValue(1, NbPath, FirstShape);
1852         else BuildVertex(Iso, Standard_False, First, Last, 
1853                          myVEdges->ChangeValue(1, NbPath+1));
1854       }
1855     }
1856   
1857     if (ipath > 1) {
1858       Iso->D0(First, P1);
1859       TopoDS_Vertex& V = TopoDS::Vertex(myVEdges->ChangeValue(1, ipath));
1860 //      Tol = P1.Distance(BT.Pnt(V));
1861       Tol = P1.Distance(BRep_Tool::Pnt(V));
1862       B.UpdateVertex(V, Tol);
1863     }
1864     if (ipath == 1) {
1865       if (!FirstShape.IsNull()) myVEdges->SetValue(1,1, FirstShape);
1866       else BuildVertex(Iso, Standard_True, First, Last, 
1867                        myVEdges->ChangeValue(1, 1));
1868     }
1869
1870     // Construction of the edge
1871     BRepLib_MakeEdge MkE;
1872     MkE.Init(Iso, 
1873              TopoDS::Vertex(myVEdges->Value(1, ipath)), 
1874              TopoDS::Vertex(myVEdges->Value(1, ipath+1)), 
1875              Iso->FirstParameter(),
1876              Iso->LastParameter());
1877     if (!MkE.IsDone()) { // Error of construction !!     
1878 #ifdef DRAW
1879       char name[100];
1880       sprintf(name,"firstvertex_error");
1881       DBRep::Set(name, myVEdges->Value(1, ipath));
1882       sprintf(name,"lastvertex_error");
1883       DBRep::Set(name, myVEdges->Value(1, ipath+1));
1884       sprintf(name,"curve3d_error");
1885       char* Temp = name ;
1886       DrawTrSurf::Set(Temp,Iso);
1887 //       DrawTrSurf::Set(name,Iso);
1888       Standard_ConstructionError::Raise("BRepFill_Sweep::BuildEdge");
1889 #endif
1890        return Standard_False;  
1891      }
1892     E = MkE.Edge();
1893 #if DRAW
1894     if (Affich) {
1895       sprintf(name,"Surf_%d", ipath);
1896       char* Temp = name;
1897       DrawTrSurf::Set(Temp, S);
1898 //      DrawTrSurf::Set(name, S);
1899       sprintf(name,"Edge_%d", ipath);
1900       DBRep::Set(name, E);
1901     }
1902 #endif
1903     B.UpdateEdge(E, Sweep.ErrorOnSurface());
1904     B.Add(wire, E);
1905     myFaces->SetValue(1, ipath, E);
1906   }  
1907   myShape = wire;
1908   return Standard_True;
1909 }
1910
1911 //=======================================================================
1912 //function : BuildShell
1913 //purpose  : Construct a Shell by sweeping
1914 //======================================================================
1915  Standard_Boolean BRepFill_Sweep::
1916  BuildShell(const BRepFill_TransitionStyle /*Transition*/,
1917             const Standard_Integer IFirst,
1918             const Standard_Integer ILast,
1919             const Standard_Real ExtendFirst,
1920             const Standard_Real ExtendLast) 
1921 {
1922   Standard_Integer ipath, isec, IPath;
1923 #ifdef DRAW
1924   char name[100];
1925 #endif
1926   BRep_Builder B;
1927   Standard_Integer NbPath = ILast - IFirst;
1928   Standard_Integer NbLaw =  mySec->NbLaw();
1929   Standard_Boolean uclose, vclose,  constSection, hasdegen = Standard_False;
1930   constSection = mySec->IsConstant();
1931   uclose = mySec->IsUClosed();
1932   vclose = (mySec->IsVClosed() && myLoc->IsClosed()) && 
1933            (NbPath == myLoc->NbLaw()) && (myLoc->IsG1(0, myTol3d)>= 0);
1934   Error = 0.;
1935
1936   // (1) Construction of all surfaces
1937
1938   // (1.1) Construction of Tables
1939
1940   TColStd_Array2OfInteger ExchUV(1, NbLaw, 1, NbPath);
1941   TColStd_Array2OfInteger UReverse(1, NbLaw, 1, NbPath);
1942   TColStd_Array2OfInteger Degenerated(1, NbLaw, 1, NbPath);
1943   Degenerated.Init(0);
1944   // No VReverse for the moment...
1945   TColStd_Array2OfReal TabErr(1, NbLaw   , 1, NbPath);
1946   TColGeom_Array2OfSurface TabS(1, NbLaw , 1, NbPath);
1947   
1948   TopTools_Array2OfShape UEdge(1, NbLaw+1, 1, NbPath);
1949   TopTools_Array2OfShape VEdge(1, NbLaw  , 1, NbPath+1);
1950   TopTools_Array2OfShape Vertex(1,NbLaw+1, 1, NbPath+1);
1951
1952   TopoDS_Vertex VNULL;
1953   VNULL.Nullify();
1954   Vertex.Init(VNULL);
1955
1956   TopTools_Array1OfShape SecVertex(1, NbLaw+1);
1957   TColStd_Array1OfReal VError(1, NbLaw+1);
1958   TColStd_Array1OfReal Vi(1, NbPath+1);
1959
1960 //Initialization of management of parametric intervals 
1961 //(Case of evolutionary sections)
1962   Standard_Real Length, SecDom, SecDeb;
1963   myLoc->CurvilinearBounds(myLoc->NbLaw(), SecDom, Length);
1964   mySec->Law(1)->GetDomain(SecDeb, SecDom);
1965   SecDom -= SecDeb;
1966   if (IFirst > 1) {
1967     Standard_Real Lf, Ll;
1968     myLoc->CurvilinearBounds(IFirst-1, Lf, Ll);
1969     Vi(1) = SecDeb + (Ll/Length)*SecDom;
1970   }
1971   else 
1972     Vi(1) = SecDeb;
1973
1974   // Error a priori on vertices
1975   if (constSection) {
1976     for (isec=1; isec<=NbLaw+1; isec++) {
1977       VError(isec) = mySec->VertexTol(isec-1, 0.);
1978       SecVertex(isec) = mySec->Vertex(isec, 0.);
1979     }
1980   }
1981  
1982
1983   // (1.2) Calculate surfaces
1984   for (ipath=1, IPath=IFirst; ipath <=NbPath; ipath++, IPath++) {
1985
1986     GeomFill_Sweep Sweep(myLoc->Law(IPath), KPart);
1987     Sweep.SetTolerance(myTol3d, myBoundTol, myTol2d, myTolAngular);
1988
1989     // Case of evolutionary section, definition of parametric correspondence
1990     if (!constSection) {
1991       Standard_Real lf, ll, Lf, Ll;
1992       myLoc->Law(IPath)->GetDomain(lf, ll);
1993       myLoc->CurvilinearBounds(IPath, Lf, Ll);
1994       Vi(ipath+1) = SecDeb + (Ll/Length)*SecDom;
1995       Sweep.SetDomain(lf, ll, Vi(ipath), Vi(ipath+1));
1996     }
1997     else //section is constant
1998       {
1999         Standard_Real lf, ll, Lf, Ll;
2000         myLoc->Law(IPath)->GetDomain(lf, ll);
2001         myLoc->CurvilinearBounds(IPath, Lf, Ll);
2002         Vi(ipath+1) = SecDeb + (Ll/Length)*SecDom;
2003       }
2004     
2005     for(isec=1; isec<=NbLaw; isec++) {
2006       Sweep.Build(mySec->Law(isec), myApproxStyle, myContinuity, myDegmax, mySegmax);
2007       if (!Sweep.IsDone()) 
2008         return Standard_False;
2009       TabS(isec,ipath) = Sweep.Surface();
2010       TabErr(isec,ipath) = Sweep.ErrorOnSurface();
2011       ExchUV(isec, ipath) =  Sweep.ExchangeUV();
2012       UReverse(isec, ipath) =  Sweep.UReversed();
2013       if (Sweep.ErrorOnSurface()>Error) Error = Sweep.ErrorOnSurface();
2014
2015       if ((ipath==1)&&(ExtendFirst>0)) {
2016         Handle(Geom_BoundedSurface) BndS;
2017         BndS = Handle(Geom_BoundedSurface)::DownCast(TabS(isec,ipath));
2018         GeomLib::ExtendSurfByLength(BndS, ExtendFirst, 1, 
2019                                     Sweep.ExchangeUV(), Standard_False);
2020         TabS(isec,ipath) = BndS;
2021       }
2022       if ((ipath==NbPath)&&(ExtendLast>0)){
2023         Handle(Geom_BoundedSurface) BndS;
2024         BndS = Handle(Geom_BoundedSurface)::DownCast(TabS(isec,ipath));
2025         GeomLib::ExtendSurfByLength(BndS, ExtendLast, 1, 
2026                                     Sweep.ExchangeUV(), Standard_True);
2027         TabS(isec,ipath) = BndS;
2028       }
2029
2030 #ifdef DRAW
2031       if (Affich) {
2032         sprintf(name,"Surf_%d_%d", isec, IPath);
2033         char* Temp = name ;
2034         DrawTrSurf::Set(Temp, TabS(isec,ipath));
2035       }
2036 #endif
2037     }
2038   }
2039
2040   // (2) Construction of Edges
2041   Standard_Real UFirst, ULast, VFirst, VLast;
2042   Standard_Boolean exuv, singu, singv;
2043   Handle(Geom_Surface) S;
2044
2045   if (! vclose) {
2046     // (2.0) return preexisting Edges and vertices
2047     TopoDS_Edge E;
2048     if (! FirstShape.IsNull() && (IFirst==1)) {
2049       mySec->Init(FirstShape);
2050       for (isec=1; isec<=NbLaw; isec++) {
2051         E = mySec->CurrentEdge();
2052         VEdge(isec, 1) = E;
2053          if (E.Orientation() == TopAbs_REVERSED)
2054            Vertex(isec+1, 1) = TopExp::FirstVertex(E);
2055          else 
2056            Vertex(isec+1, 1) =  TopExp::LastVertex(E);
2057         UpdateVertex(IFirst-1, isec+1, 
2058                      TabErr(isec, 1), Vi(1),  Vertex(isec+1, 1));
2059        }
2060       if (VEdge(1, 1).Orientation() == TopAbs_REVERSED)
2061         Vertex(1, 1) =  TopExp::LastVertex(TopoDS::Edge(VEdge(1, 1)));
2062       else
2063         Vertex(1, 1) = TopExp::FirstVertex(TopoDS::Edge(VEdge(1, 1)));
2064       UpdateVertex(IFirst-1, 1, 
2065                    TabErr(1, 1), Vi(1),  Vertex(1, 1));
2066     }
2067     else { // Otherwise construct vertices
2068       Standard_Real u, v, aux;
2069       Standard_Boolean ureverse;
2070       for (isec=1; isec<=NbLaw+1; isec++) {
2071         // Return data
2072         if (isec >NbLaw) {
2073           S = TabS(NbLaw, 1);
2074           ureverse = UReverse(NbLaw, 1);
2075           exuv = ExchUV(NbLaw, 1);
2076         }
2077         else  {
2078           S = TabS(isec, 1);
2079           ureverse = UReverse(isec, 1);
2080           exuv = ExchUV(isec, 1);
2081         }
2082         S->Bounds(UFirst, ULast, VFirst, VLast);
2083
2084         // Choice of parameters
2085         if (ureverse) {
2086           if (exuv) {
2087             aux = VFirst; VFirst = VLast; VLast = aux;    
2088           }
2089           else {
2090             aux = UFirst; UFirst = ULast; ULast = aux;
2091           }
2092         }
2093         if (isec!= NbLaw+1) {
2094           u = UFirst;
2095           v = VFirst;
2096         }
2097         else {
2098           if (exuv) {
2099             u = UFirst;
2100             v = VLast;
2101           }
2102           else {
2103             u = ULast;
2104             v = VFirst;
2105           }
2106         }
2107
2108         // construction of vertices
2109         B.MakeVertex(TopoDS::Vertex(Vertex(isec, 1)), 
2110                      S->Value(u,v), 
2111                      mySec->VertexTol(isec-1,Vi(1)));
2112       }
2113    }
2114
2115     if (! LastShape.IsNull() && (ILast==myLoc->NbLaw()+1) ) {
2116       mySec->Init(LastShape);
2117       for (isec=1; isec<=NbLaw; isec++) {
2118         E = mySec->CurrentEdge();
2119         VEdge(isec, NbPath+1) = E;
2120         if (E.Orientation() == TopAbs_REVERSED)
2121            Vertex(isec+1, NbPath+1) = TopExp::FirstVertex(E);
2122         else 
2123           Vertex(isec+1, NbPath+1) = TopExp::LastVertex(E);
2124         UpdateVertex(ILast-1, isec+1, TabErr(isec, NbPath), 
2125                      Vi(NbPath+1),  Vertex(isec+1, NbPath+1));
2126       }
2127       if (VEdge(1,  NbPath+1).Orientation() == TopAbs_REVERSED)
2128         Vertex(1,  NbPath+1) =  
2129           TopExp::LastVertex(TopoDS::Edge(VEdge(1,  NbPath+1)));
2130       else
2131         Vertex(1,  NbPath+1) = 
2132           TopExp::FirstVertex(TopoDS::Edge(VEdge(1, NbPath+1)));
2133       UpdateVertex(ILast-1, 1, 
2134                    TabErr(1, NbPath), Vi(NbPath+1),  Vertex(1, NbPath+1 ));
2135     }    
2136     else {
2137       Standard_Real u, v, aux;
2138       Standard_Boolean ureverse;
2139       for (isec=1; isec<=NbLaw+1; isec++) {
2140         // Return data
2141         if (isec >NbLaw) {
2142           S = TabS(NbLaw, NbPath);
2143           ureverse = UReverse(NbLaw, NbPath);
2144           exuv = ExchUV(NbLaw, NbPath);
2145         }
2146         else  {
2147           S = TabS(isec, NbPath);
2148           ureverse = UReverse(isec, NbPath);
2149           exuv = ExchUV(isec, NbPath);
2150         }
2151         S->Bounds(UFirst, ULast, VFirst, VLast);
2152
2153         // Choice of parametres
2154         if (ureverse) {
2155           if (exuv) {
2156             aux = VFirst; VFirst = VLast; VLast = aux;    
2157           }
2158           else {
2159             aux = UFirst; UFirst = ULast; ULast = aux;
2160           }
2161         }
2162         if (isec == NbLaw+1) {
2163           u = ULast;
2164           v = VLast;
2165         }
2166         else {
2167           if (exuv) {
2168             u = ULast;
2169             v = VFirst;
2170           }
2171           else {
2172             u = UFirst;
2173             v = VLast;
2174           }
2175         }
2176
2177         // construction of vertex
2178         B.MakeVertex(TopoDS::Vertex(Vertex(isec, NbPath+1)), 
2179                      S->Value(u,v), 
2180                      mySec->VertexTol(isec-1, Vi(NbPath+1)));
2181       }
2182     }
2183   }
2184
2185  
2186   // ---------- Creation of Vertex and edge ------------
2187   for (ipath=1, IPath=IFirst; ipath<=NbPath; 
2188        ipath++, IPath++) {
2189     for (isec=1; isec <=NbLaw; isec++) {
2190       S = TabS(isec, ipath);
2191       exuv = ExchUV(isec, ipath);
2192       S->Bounds(UFirst, ULast, VFirst, VLast);
2193       if (UReverse(isec, ipath)) {
2194         Standard_Real aux;
2195         if (exuv) {
2196           aux = VFirst; VFirst = VLast; VLast = aux;      
2197         }
2198         else {
2199           aux = UFirst; UFirst = ULast; ULast = aux;
2200         }
2201       }
2202
2203       // (2.1) Construction of new vertices
2204       if (isec == 1) {
2205         if (ipath == 1 && Vertex(1, 1).IsNull()) {
2206           // All first
2207           if (constSection)
2208             myLoc->PerformVertex(IPath-1, 
2209                                  TopoDS::Vertex(SecVertex(1)), 
2210                                  VError(1),
2211                                  TopoDS::Vertex(Vertex(1, 1)));
2212           else
2213             myLoc->PerformVertex(IPath-1, 
2214                                  mySec->Vertex(1,Vi(1)), 
2215                                  mySec->VertexTol(0,Vi(1)),
2216                                  TopoDS::Vertex(Vertex(1, 1)));
2217         }
2218         // the first and the next column
2219         if (vclose &&(ipath == NbPath) ) {
2220           Vertex(1, ipath+1) =  Vertex(1, 1);
2221         }
2222         else if (Vertex(1, ipath+1).IsNull()) {
2223           if (constSection)
2224             myLoc->PerformVertex(IPath, 
2225                                  TopoDS::Vertex(SecVertex(1)),
2226                                  TabErr(1,ipath)+VError(1),
2227                                  TopoDS::Vertex(Vertex(1, ipath+1)) );
2228           else
2229             myLoc->PerformVertex(IPath, 
2230                                  mySec->Vertex(1,Vi(ipath+1)), 
2231                                  TabErr(1,ipath) +
2232                                  mySec->VertexTol(0,Vi(ipath+1)),
2233                                  TopoDS::Vertex(Vertex(1, ipath+1)));
2234
2235           if (MergeVertex(Vertex(1,ipath), Vertex(1,ipath+1))) {
2236             UEdge(1, ipath) = NullEdge(Vertex(1,ipath));
2237           }
2238          }
2239        }
2240
2241       if (ipath == 1)
2242         if (uclose && (isec == NbLaw)) {
2243           Vertex(isec+1, 1) =  Vertex(1, 1);
2244         }  
2245         else if (Vertex(isec+1, 1).IsNull()) {
2246           if (constSection)
2247             myLoc->PerformVertex(IPath-1, 
2248                                  TopoDS::Vertex(SecVertex(isec+1)),
2249                                  TabErr(isec,1)+VError(isec+1),
2250                                  TopoDS::Vertex(Vertex(isec+1, 1)) );
2251           else
2252             myLoc->PerformVertex(IPath-1, 
2253                                  mySec->Vertex(isec+1,Vi(1)), 
2254                                  TabErr(isec,1) +
2255                                  mySec->VertexTol(isec,Vi(1)),
2256                                  TopoDS::Vertex(Vertex(isec+1, 1)) );
2257           if (MergeVertex(Vertex(isec,1), Vertex(isec+1,1))) {
2258             VEdge(isec, 1) = NullEdge(Vertex(isec, 1)); 
2259           }
2260         }
2261
2262       if (uclose && (isec == NbLaw)) {
2263         Vertex(isec+1, ipath+1) = Vertex(1, ipath+1);
2264       }
2265       else if (vclose && (ipath == NbPath)) {
2266         Vertex(isec+1, ipath+1) =  Vertex(isec+1, 1);
2267       }
2268       else if (Vertex(isec+1, ipath+1).IsNull()) {
2269         if (constSection)
2270           myLoc->PerformVertex(IPath, 
2271                                TopoDS::Vertex(SecVertex(isec+1)),
2272                                TabErr(isec, ipath)+ VError(isec+1),
2273                                TopoDS::Vertex(Vertex(isec+1, ipath+1)) );
2274         else
2275          myLoc->PerformVertex(IPath, 
2276                               mySec->Vertex(isec+1,Vi(ipath+1)),
2277                               TabErr(isec, ipath) + 
2278                               mySec->VertexTol(isec, Vi(ipath+1)),
2279                               TopoDS::Vertex(Vertex(isec+1, ipath+1)) ); 
2280       }
2281
2282       // Singular cases
2283       singv = MergeVertex(Vertex(isec,ipath+1), Vertex(isec+1,ipath+1));
2284       singu = MergeVertex(Vertex(isec+1,ipath), Vertex(isec+1,ipath+1));
2285
2286       
2287
2288       if (singu || singv) {
2289         Degenerated(isec, ipath) = IsDegen(TabS(isec,ipath), 
2290                                            Max(myTol3d, TabErr(isec,ipath)));
2291       }
2292       if (Degenerated(isec, ipath)) { 
2293 #if DEB
2294         cout << "Sweep : Degenerated case" << endl;
2295 #endif
2296         hasdegen = Standard_True;
2297         // Particular construction of edges
2298         if (UEdge(isec+1, ipath).IsNull()) {
2299           if (singu) {
2300             // Degenerated edge
2301             UEdge(isec+1, ipath) = NullEdge(Vertex(isec+1,ipath));
2302           }
2303           else { // Copy the previous edge
2304             UEdge(isec+1, ipath) = UEdge(isec, ipath);
2305           }
2306         }
2307         if (VEdge(isec, ipath+1).IsNull()) {
2308           if (singv) {
2309             // Degenerated Edge
2310             VEdge(isec, ipath+1) = NullEdge(Vertex(isec,ipath+1));
2311           }
2312           else { // Copy the previous edge
2313             VEdge(isec, ipath+1) = VEdge(isec, ipath);
2314           }
2315         }
2316       }
2317       else { // Construction of edges by isos
2318         if (exuv) {
2319           Standard_Real UV;
2320           UV = UFirst; UFirst = VFirst; VFirst = UV;
2321           UV = ULast ; ULast = VLast  ; VLast = UV;
2322         }
2323   
2324         // (2.2) Iso-u
2325         if (isec == 1) {
2326           if (!Vertex(1,ipath).IsSame(Vertex(1,ipath+1))) {
2327             gp_Pnt P1 = BRep_Tool::Pnt(TopoDS::Vertex(Vertex(1,ipath)));
2328             gp_Pnt P2 = BRep_Tool::Pnt(TopoDS::Vertex(Vertex(1,ipath+1)));
2329             if (P1.Distance(P2) <= myTol3d)
2330               Vertex(1,ipath+1) = Vertex(1,ipath);
2331           }
2332           UEdge(1, ipath) = BuildEdge(S, !exuv, UFirst, 
2333                                       Vertex(1,ipath), 
2334                                       Vertex(1,ipath+1),
2335                                       myTol3d);
2336         }
2337         else UpdateEdge(TopoDS::Edge(UEdge(isec, ipath)), 
2338                         S, !exuv, UFirst);
2339      
2340         if (uclose && (isec==NbLaw)) {
2341           UpdateEdge(TopoDS::Edge(UEdge(1, ipath)), 
2342                      S, !exuv, ULast);
2343           UEdge(isec+1, ipath) = UEdge(1, ipath);
2344         }
2345         else {
2346           UEdge(isec+1, ipath) = BuildEdge(S, !exuv, ULast, 
2347                                            Vertex(isec+1, ipath), 
2348                                            Vertex(isec+1, ipath+1),
2349                                            myTol3d);
2350         }
2351
2352         // (2.3) Iso-v 
2353         if (ipath == 1 && VEdge(isec, ipath).IsNull())
2354           VEdge(isec, ipath) = BuildEdge(S, exuv, VFirst, 
2355                                          Vertex(isec  , 1), 
2356                                          Vertex(isec+1, 1),
2357                                          myTol3d);
2358         
2359         else UpdateEdge(TopoDS::Edge(VEdge(isec, ipath)), 
2360                         S, exuv, VFirst);
2361         
2362         if (vclose && (ipath == NbPath)) {
2363           UpdateEdge(TopoDS::Edge(VEdge(isec, 1)), 
2364                      S, exuv, VLast);
2365           VEdge(isec, ipath+1) = VEdge(isec, 1);
2366         }
2367         else if (VEdge(isec, ipath+1).IsNull())
2368           VEdge(isec, ipath+1) = BuildEdge(S, exuv, VLast, 
2369                                            Vertex(isec  , ipath+1), 
2370                                            Vertex(isec+1, ipath+1),
2371                                            myTol3d);
2372         else UpdateEdge(TopoDS::Edge(VEdge(isec, ipath+1)), 
2373                         S, exuv, VLast);
2374           
2375       }
2376     }// End of construction of edges
2377   }
2378
2379   // (3) Construction of Faces
2380   TopoDS_Face face;
2381
2382 #ifdef DRAW
2383   if (Affich) {
2384     for (ipath=1, IPath=IFirst; ipath<=NbPath; ipath++, IPath++) {
2385       for (isec=1; isec <=NbLaw+1; isec++){
2386         sprintf(name,"uedge_%d_%d", isec, IPath);
2387         DBRep::Set(name,UEdge(isec, ipath));
2388       }
2389     }
2390
2391     for (ipath=1, IPath=IFirst; ipath<=NbPath+1; ipath++, IPath++) {
2392       for (isec=1; isec <=NbLaw; isec++){
2393         sprintf(name,"vedge_%d_%d", isec, IPath);
2394         DBRep::Set(name,VEdge(isec, ipath));
2395       }
2396
2397       for (isec=1; isec <=NbLaw+1; isec++){
2398         sprintf(name,"vertex_%d_%d", isec, IPath);
2399         DBRep::Set(name,Vertex(isec, ipath));
2400       }
2401     }
2402   }
2403 #endif 
2404
2405   for (ipath=1, IPath=IFirst; ipath<=NbPath; ipath++, IPath++) {
2406     for (isec=1; isec <=NbLaw; isec++) {
2407       if (Degenerated(isec, ipath)) {
2408         if (UEdge(isec, ipath).IsSame(UEdge(isec+1, ipath))) 
2409           myFaces->SetValue(isec, IPath, UEdge(isec, ipath));
2410         else  
2411           myFaces->SetValue(isec, IPath, VEdge(isec, ipath));
2412       }
2413       else {
2414         BuildFace(TabS(isec,ipath), 
2415                   TopoDS::Edge(UEdge(isec, ipath)),
2416                   TopoDS::Edge(VEdge(isec, ipath)),
2417                   TopoDS::Edge(UEdge(isec+1, ipath)),
2418                   TopoDS::Edge(VEdge(isec, ipath+1)),
2419                   myVEdgesModified,
2420                   ExchUV(isec, ipath),
2421                   UReverse(isec, ipath),
2422                   face);
2423         myFaces->SetValue(isec, IPath, face);
2424       }
2425     }
2426   }
2427
2428
2429   // (4) History and Continuity 
2430
2431   if (hasdegen) {
2432   //(4.1) // Degenerated case => Sledgehammer
2433     TopoDS_Compound Comp;
2434     B.MakeCompound(Comp);
2435     for (isec=1; isec <=  NbLaw+1; isec++) 
2436       for (ipath=1, IPath=IFirst; ipath<=  NbPath+1; ipath++, IPath++) {
2437       if (ipath <= NbPath) myUEdges->SetValue(isec, IPath, UEdge(isec, ipath));
2438       if (isec <= NbLaw) myVEdges->SetValue(isec, IPath, VEdge(isec, ipath)); 
2439       if ((ipath <= NbPath) && (isec <= NbLaw) && 
2440           (myFaces->Value(isec, IPath).ShapeType() == TopAbs_FACE))
2441         B.Add(Comp, myFaces->Value(isec, IPath));
2442     }
2443     BRepLib::EncodeRegularity(Comp, myTolAngular);
2444   }
2445   else {
2446     //(4.2) // General case => Tweezers 
2447     Standard_Boolean isG1;
2448     TopoDS_Face FF;
2449     TopoDS_Edge E;
2450  
2451     for (isec=1; isec <=  NbLaw+1; isec++) {
2452       if (isec>1) isG1 = 
2453         (mySec->Continuity(isec-1, myTolAngular) >= GeomAbs_G1);
2454       else isG1 = Standard_False;
2455       for (ipath=1, IPath=IFirst; ipath<=  NbPath; ipath++, IPath++) {
2456         myUEdges->SetValue(isec, IPath, UEdge(isec, ipath));
2457         if (isG1) {
2458           if (isec == NbLaw+1) FF = TopoDS::Face(myFaces->Value(1, IPath));
2459           else  FF = TopoDS::Face(myFaces->Value(isec, IPath));
2460           B.Continuity(TopoDS::Edge(myUEdges->Value(isec, IPath)),
2461                        TopoDS::Face(myFaces->Value(isec-1, IPath)), 
2462                        FF, GeomAbs_G1);
2463         }
2464       }
2465     }
2466
2467     Standard_Integer nbpath = NbPath;
2468     if (vclose) nbpath++; //Another test G1 
2469     for (ipath=1, IPath=IFirst; ipath<=  NbPath+1; ipath++, IPath++) {
2470       if ((ipath > 1) && (ipath <=nbpath)) 
2471         isG1 = (myLoc->IsG1(IPath-1, myTol3d, myTolAngular) >= 0);
2472       else isG1 = Standard_False;
2473       for (isec=1; isec <=  NbLaw; isec++) {
2474         myVEdges->SetValue(isec, IPath, VEdge(isec, ipath));
2475         if (isG1) { 
2476           if (ipath==NbPath+1) FF = TopoDS::Face(myFaces->Value(isec, 1));
2477           else  FF = TopoDS::Face(myFaces->Value(isec, IPath));
2478           E = TopoDS::Edge(myVEdges->Value(isec, IPath));
2479           BRepLib::EncodeRegularity(E, FF,
2480                                     TopoDS::Face(myFaces->Value(isec, IPath-1)),
2481                                     myTolAngular);
2482         }
2483       } 
2484     }
2485   }
2486   return Standard_True;
2487 }
2488
2489 //=======================================================================
2490 //function : Build
2491 //purpose  : Construt the result of sweeping
2492 //======================================================================
2493  void BRepFill_Sweep::Build(const BRepFill_TransitionStyle Transition,
2494                             const GeomFill_ApproxStyle Approx,
2495                             const GeomAbs_Shape Continuity,
2496                             const Standard_Integer Degmax,
2497                             const Standard_Integer Segmax) 
2498 {
2499   myApproxStyle = Approx;
2500   myContinuity  = Continuity;
2501   myDegmax = Degmax;
2502   mySegmax = Segmax;
2503
2504   CorrectApproxParameters();
2505
2506   // Wire
2507   if (mySec->IsVertex()) isDone = BuildWire(Transition);
2508
2509   else { // Shell   
2510     Standard_Integer NbTrous = myLoc->NbHoles(myTol3d),
2511                      NbPath   = myLoc->NbLaw(),
2512                      NbLaw    = mySec->NbLaw(), ii, jj, NbPart=1;
2513     Standard_Integer ipath, isec;
2514     BRep_Builder B;
2515     myUEdges = new (TopTools_HArray2OfShape) (1, NbLaw+1, 1, NbPath);
2516     myVEdges = new (TopTools_HArray2OfShape) (1, NbLaw, 1, NbPath+1); 
2517     myFaces = new (TopTools_HArray2OfShape) (1, NbLaw, 1, NbPath);
2518     Handle (TopTools_HArray2OfShape) Bounds =  
2519       new (TopTools_HArray2OfShape) (1, NbLaw, 1, 2);
2520  
2521     Handle(TColStd_HArray1OfInteger) Trous;
2522  
2523     if (NbTrous>0) { // How many sub-parts ?
2524       Trous = new (TColStd_HArray1OfInteger) (1, NbTrous);
2525       myLoc->Holes(Trous->ChangeArray1());
2526       NbPart += NbTrous;
2527       if (Trous->Value(NbTrous) == NbPath+1) NbPart--;  
2528     }
2529     if (NbPart == 1)  { // This is done at once
2530       Standard_Real Extend = 0.0;
2531       if (NbTrous==1)  Extend = EvalExtrapol(1, Transition);
2532       isDone = BuildShell(Transition, 
2533                           1, NbPath+1,
2534                           Extend, Extend);
2535     }
2536     else { //  This is done piece by piece
2537       Standard_Integer IFirst = 1, ILast;
2538       for (ii=1, isDone=Standard_True; 
2539            ii<=NbPart && isDone; ii++) {
2540         if (ii > NbTrous) ILast =  NbPath+1;
2541         else ILast = Trous->Value(ii);
2542         isDone = BuildShell(Transition, 
2543                             IFirst, ILast,
2544                             EvalExtrapol(IFirst, Transition),
2545                             EvalExtrapol(ILast,  Transition));
2546         if (IFirst>1) {
2547           Translate(myVEdges, IFirst, Bounds, 2);
2548           PerformCorner(IFirst, 
2549                         Transition, Bounds);
2550         }
2551         IFirst = ILast;
2552         Translate(myVEdges, IFirst, Bounds, 1);
2553       }
2554     }
2555     // Management of looping ends
2556     if ( (NbTrous>0) && (myLoc->IsClosed()) &&
2557          (Trous->Value(NbTrous) == NbPath+1) ) {
2558       Translate(myVEdges,  NbPath+1, Bounds, 1);
2559       Translate(myVEdges,  1, Bounds, 2);
2560       PerformCorner(1, Transition, Bounds); 
2561     }
2562
2563     // Construction of the shell
2564     TopoDS_Shell shell;
2565     B.MakeShell(shell);
2566     for (ipath=1; ipath<=NbPath; ipath++) 
2567       for (isec=1; isec <=NbLaw; isec++) {
2568       const TopoDS_Shape& face = myFaces->Value(isec, ipath);
2569         if (!face.IsNull() && 
2570             (face.ShapeType() == TopAbs_FACE) ) B.Add(shell, face);
2571       }
2572
2573     TopTools_ListIteratorOfListOfShape It(myAuxShape);
2574     for (; It.More(); It.Next()) {
2575        const TopoDS_Shape& face = It.Value();
2576        if (!face.IsNull() && 
2577             (face.ShapeType() == TopAbs_FACE) ) B.Add(shell, face);
2578     }
2579     //Set common Uedges to faces
2580     BRepTools_Substitution aSubstitute;
2581     /*
2582     for (ii = 1; ii <= NbLaw; ii++)
2583       for (jj = 1; jj <= NbPath; jj++)
2584         {
2585           SetCommonEdgeInFace(aSubstitute,
2586                               myFaces->Value(ii, jj),
2587                               myUEdges->Value(ii, jj));
2588           SetCommonEdgeInFace(aSubstitute,
2589                               myFaces->Value(ii, jj),
2590                               myUEdges->Value(ii+1, jj));
2591         }
2592     if (mySec->IsUClosed())
2593       for (jj = 1; jj <= NbPath; jj++)
2594         SetCommonEdgeInFace(aSubstitute,
2595                             myFaces->Value( 1, jj ),
2596                             myUEdges->Value( NbLaw+1, jj));
2597     */
2598     TopTools_DataMapIteratorOfDataMapOfShapeShape mapit( myVEdgesModified );
2599     for (; mapit.More(); mapit.Next())
2600       {
2601         const TopoDS_Edge& OldEdge = TopoDS::Edge(mapit.Key());
2602         const TopoDS_Edge& NewEdge = TopoDS::Edge(mapit.Value());
2603         Substitute( aSubstitute, OldEdge, NewEdge );
2604       }
2605     aSubstitute.Build( shell );
2606     if (aSubstitute.IsCopied( shell )) {
2607       const TopTools_ListOfShape& listSh = aSubstitute.Copy( shell );
2608       shell = TopoDS::Shell( listSh.First() );
2609     }
2610
2611     for (ii = myFaces->LowerRow(); ii <= myFaces->UpperRow(); ii++) {
2612       for (jj = myFaces->LowerCol(); jj <= myFaces->UpperCol(); jj++) {
2613         const TopoDS_Shape& aLocalShape = myFaces->Value(ii, jj);
2614
2615         if(!aLocalShape.IsNull() && aSubstitute.IsCopied(aLocalShape)) {
2616           const TopTools_ListOfShape& aList = aSubstitute.Copy(aLocalShape);
2617
2618           if(!aList.IsEmpty())
2619             myFaces->ChangeValue(ii, jj) = aList.First();
2620         }
2621       }
2622     }
2623
2624     for (ii = myVEdges->LowerRow(); ii <= myVEdges->UpperRow(); ii++) {
2625       for (jj = myVEdges->LowerCol(); jj <= myVEdges->UpperCol(); jj++) {
2626         const TopoDS_Shape& aLocalShape = myVEdges->Value(ii, jj);
2627
2628         if(!aLocalShape.IsNull() && aSubstitute.IsCopied(aLocalShape)) {
2629           const TopTools_ListOfShape& aList = aSubstitute.Copy(aLocalShape);
2630
2631           if(!aList.IsEmpty())
2632             myVEdges->ChangeValue(ii, jj) = aList.First();
2633         }
2634       }
2635     }
2636
2637     for (ii = myUEdges->LowerRow(); ii <= myUEdges->UpperRow(); ii++) {
2638       for (jj = myUEdges->LowerCol(); jj <= myUEdges->UpperCol(); jj++) {
2639         const TopoDS_Shape& aLocalShape = myUEdges->Value(ii, jj);
2640
2641         if(!aLocalShape.IsNull() && aSubstitute.IsCopied(aLocalShape)) {
2642           const TopTools_ListOfShape& aList = aSubstitute.Copy(aLocalShape);
2643
2644           if(!aList.IsEmpty())
2645             myUEdges->ChangeValue(ii, jj) = aList.First();
2646         }
2647       }
2648     }
2649
2650     // Is it Closed ?
2651     if (myLoc->IsClosed() && mySec->IsUClosed()) {
2652       //Check
2653       Standard_Boolean closed = Standard_True;
2654       Standard_Integer iedge;
2655       TopTools_IndexedDataMapOfShapeListOfShape EFmap;
2656       TopExp::MapShapesAndAncestors(shell, TopAbs_EDGE, 
2657                                     TopAbs_FACE, EFmap);
2658       
2659       for (iedge = 1; iedge <=EFmap.Extent() && closed; iedge++) {
2660         const TopoDS_Edge& theEdge = TopoDS::Edge(EFmap.FindKey(iedge));
2661         if (BRep_Tool::Degenerated(theEdge)) continue;
2662         closed = (  EFmap(iedge).Extent() > 1);
2663       }
2664       shell.Closed(closed);
2665     }
2666     myShape = shell;
2667   }
2668 }
2669
2670
2671 //=======================================================================
2672 //function : IsDone
2673 //purpose  : 
2674 //=======================================================================
2675  Standard_Boolean BRepFill_Sweep::IsDone() const
2676 {
2677   return isDone;
2678 }
2679
2680 //=======================================================================
2681 //function : Shape
2682 //purpose  : 
2683 //=======================================================================
2684  TopoDS_Shape BRepFill_Sweep::Shape() const
2685 {
2686   return myShape;
2687 }
2688
2689 //=======================================================================
2690 //function : ErrorOnSurface
2691 //purpose  : 
2692 //=======================================================================
2693  Standard_Real BRepFill_Sweep::ErrorOnSurface() const
2694 {
2695   return Error;
2696 }
2697
2698 //=======================================================================
2699 //function : SubShape
2700 //purpose  : Faces obtained by sweeping
2701 //=======================================================================
2702  Handle(TopTools_HArray2OfShape) BRepFill_Sweep::SubShape() const
2703 {
2704   return myFaces;
2705 }
2706
2707 //=======================================================================
2708 //function : InterFaces
2709 //purpose  : Edges obtained by sweeping
2710 //=======================================================================
2711  Handle(TopTools_HArray2OfShape) BRepFill_Sweep::InterFaces() const
2712 {
2713   return myUEdges;
2714 }
2715
2716 //=======================================================================
2717 //function : Sections
2718 //purpose  : Edges or Face (or compound of 2) Transition between 2 sweepings
2719 //=======================================================================
2720  Handle(TopTools_HArray2OfShape) BRepFill_Sweep::Sections() const
2721 {
2722   return myVEdges;
2723 }
2724
2725 //=======================================================================
2726 //function : PerformCorner
2727 //purpose  : Trim and/or loop a corner
2728 //======================================================================
2729  void  BRepFill_Sweep::PerformCorner(const Standard_Integer Index,
2730                                      const BRepFill_TransitionStyle Transition,
2731                                      const Handle(TopTools_HArray2OfShape)& Bounds)
2732 {
2733
2734   if (Transition == BRepFill_Modified) return; // Do nothing.
2735
2736   BRepFill_TransitionStyle TheTransition = Transition;
2737   Standard_Boolean isTangent=Standard_False;
2738   Standard_Real F, L;
2739   Standard_Integer I1, I2, ii; //, jj;
2740   gp_Pnt P1,P2;
2741   gp_Vec T1, T2, Tang, Sortant;
2742 //  gp_Mat M;
2743   //Handle(TopTools_HArray1OfShape) TheShape = 
2744     //new TopTools_HArray1OfShape( 1, mySec->NbLaw() );
2745 //  TopTools_ListIteratorOfListOfShape Iterator;
2746
2747   if (Index > 1) { 
2748     I1 = Index-1;
2749     I2 = Index;
2750   }
2751   else {
2752     I1 = myLoc->NbLaw();
2753     I2 = 1;
2754   }
2755
2756   // Construct an axis supported by the bissectrice
2757   myLoc->Law(I1)->GetDomain(F, L);
2758   myLoc->Law(I1)->GetCurve()->D1(L, P1, T1);
2759   T1.Normalize();
2760
2761   myLoc->Law(I2)->GetDomain(F, L);  
2762   myLoc->Law(I2)->GetCurve()->D1(F, P2, T2);
2763   T2.Normalize();
2764
2765   if (T1.Angle(T2) <  myAngMin) {
2766     isTangent = Standard_True;
2767     gp_Vec t1, t2, V;
2768     gp_Mat M;
2769     myLoc->Law(I1)->GetDomain(F, L);
2770     myLoc->Law(I1)->D0(L, M, V);
2771     t1 = M.Column(3);
2772     myLoc->Law(I2)->GetDomain(F, L);
2773     myLoc->Law(I2)->D0(L, M, V);
2774     t2 = M.Column(3);
2775
2776     if (t1.Angle(t2) < myAngMin) {
2777 #if DEB
2778       cout << "BRepFill_Sweep::PerformCorner : This is not a corner !" << endl;
2779 #endif
2780       return;
2781     }
2782     Sortant = t2 - t1;
2783   }
2784
2785   if ((TheTransition == BRepFill_Right) 
2786       && (T1.Angle(T2) >  myAngMax) ) {
2787     TheTransition =  BRepFill_Round;
2788   }
2789
2790   Tang = T1 + T2; //Average direction
2791   gp_Dir NormalOfBisPlane = Tang;
2792
2793   if (isTangent) {
2794     Sortant -= Tang.Dot(Tang)*Tang;
2795   }
2796   else {
2797     Sortant = T2-T1; //Direction input 
2798     Sortant *= -1; //   "   "   output
2799     Tang -= (Tang.Dot(T2))*T2;
2800   }
2801
2802   P1.BaryCenter(0.5, P2, 0.5);
2803   gp_Dir N(Sortant);
2804   gp_Dir Dx(Tang);
2805     
2806   gp_Ax2 Axe (P1, N, Dx);
2807   gp_Ax2 AxeOfBisPlane( P1, NormalOfBisPlane );
2808
2809   // Construct 2 intersecting Shells
2810   Handle (TopTools_HArray2OfShape) UEdges =
2811     new TopTools_HArray2OfShape( 1, mySec->NbLaw()+1, 1, myLoc->NbLaw() );
2812   UEdges->ChangeArray2() = myUEdges->Array2();
2813
2814 // modified by NIZHNY-MKK  Wed Oct 29 18:31:47 2003.BEGIN
2815   Handle (TopTools_HArray2OfShape) aFaces =
2816     new TopTools_HArray2OfShape(myFaces->LowerRow(), myFaces->UpperRow(), 1, 2);
2817   Translate(myFaces, I1, aFaces, 1);
2818   Translate(myFaces, I2, aFaces, 2);
2819
2820   Handle (TopTools_HArray2OfShape) aUEdges =
2821     new TopTools_HArray2OfShape(myUEdges->LowerRow(), myUEdges->UpperRow(), 1, 2);
2822   Translate(myUEdges, I1, aUEdges, 1);
2823   Translate(myUEdges, I2, aUEdges, 2);
2824
2825   gp_Vec aNormal = T2 + T1;
2826   TopoDS_Face aPlaneF;
2827
2828   if(aNormal.Magnitude() > gp::Resolution()) {
2829     gp_Pln pl(P1, gp_Dir(aNormal));
2830     BRepLib_MakeFace aFMaker(pl);
2831
2832     if(aFMaker.Error() == BRepLib_FaceDone) {
2833       aPlaneF = aFMaker.Face();
2834       BRep_Builder aBB;
2835       aBB.UpdateFace(aPlaneF, Precision::Confusion() * 10.);
2836     }
2837   }
2838
2839   BRepFill_TrimShellCorner aTrim(aFaces, AxeOfBisPlane, aPlaneF);
2840   aTrim.AddBounds(Bounds);
2841   aTrim.AddUEdges(aUEdges);
2842   aTrim.Perform();
2843
2844   if (aTrim.IsDone()) {
2845     TopTools_ListOfShape listmodif;
2846     Standard_Integer iit = 0;
2847
2848     for(iit = 0; iit < 2; iit++) {
2849       Standard_Integer II = (iit == 0) ? I1 : I2;
2850
2851       for (ii = 1; ii <= mySec->NbLaw(); ii++) {
2852         aTrim.Modified(myFaces->Value(ii, II), listmodif);
2853
2854         if(!listmodif.IsEmpty()) {
2855           myFaces->SetValue(ii, II, listmodif.First());
2856         }
2857       }
2858
2859       for (ii = myUEdges->LowerRow(); ii <= myUEdges->UpperRow(); ii++) {
2860         aTrim.Modified(myUEdges->Value(ii, II), listmodif);
2861
2862         if(!listmodif.IsEmpty()) {
2863           myUEdges->SetValue(ii, II, listmodif.First());
2864         }
2865       }
2866     }
2867   }
2868   else if ((TheTransition == BRepFill_Right) ||
2869            aTrim.HasSection() ) { 
2870 #if DEB
2871     cout << "Fail of TrimCorner" << endl;
2872 #endif
2873     return; // Nothing is touched
2874   }
2875
2876   if (mySec->IsUClosed())
2877     {
2878       myUEdges->SetValue( 1, I1, myUEdges->Value(mySec->NbLaw()+1, I1) );
2879       myUEdges->SetValue( 1, I2, myUEdges->Value(mySec->NbLaw()+1, I2) );
2880     }
2881
2882   if (TheTransition == BRepFill_Round) {
2883   // Filling
2884     TopTools_ListOfShape list1, list2;
2885     TopoDS_Edge Bord1, Bord2, BordFirst;
2886     BordFirst.Nullify();
2887     Bord1.Nullify();
2888     Bord2.Nullify();
2889     Standard_Boolean HasFilling = Standard_False;
2890     TopoDS_Face FF;
2891     for (ii=1; ii<=mySec->NbLaw(); ii++) {
2892       KeepEdge(myFaces->Value(ii, I1), Bounds->Value(ii, 1), list1);
2893       KeepEdge(myFaces->Value(ii, I2), Bounds->Value(ii, 2), list2);
2894       if (list1.Extent() == list2.Extent()) {
2895         TopTools_ListIteratorOfListOfShape It1(list1);
2896         TopTools_ListIteratorOfListOfShape It2(list2);
2897         Standard_Boolean B;
2898         for (; It1.More(); It1.Next(), It2.Next()) {
2899           if (HasFilling) { // Transversal choice of constraints
2900             TopoDS_Vertex VF, VL, VC;
2901             TopoDS_Edge E = TopoDS::Edge(It1.Value());
2902             TopoDS_Edge E1, E2;
2903             E1.Nullify();
2904             E2.Nullify();
2905             TopExp::Vertices(E, VF, VL);
2906             if (!Bord1.IsNull() && 
2907                 TopExp::CommonVertex(E, Bord1, VC)) {
2908               if (VC.IsSame(VF)) E1 = Bord1;
2909               else               E2 = Bord1;
2910             }
2911             if (!Bord2.IsNull() && 
2912                 TopExp::CommonVertex(E, Bord2, VC)) {
2913               if (VC.IsSame(VF)) E1 = Bord2;
2914               else               E2 = Bord2;
2915             }
2916             if (!BordFirst.IsNull() && 
2917                 TopExp::CommonVertex(E, BordFirst, VC)) {
2918               if (VC.IsSame(VF)) E1 = BordFirst;
2919               else               E2 = BordFirst;
2920             }
2921             Bord1 = E1;
2922             Bord2 = E2;
2923           }
2924           
2925           // Filling
2926           B = Filling(It1.Value(), myFaces->Value(ii, I1),
2927                       It2.Value(), myFaces->Value(ii, I2),
2928                       myVEdgesModified, myTol3d, Axe, T1, Bord1, Bord2, FF);
2929           
2930           if (B) {
2931             myAuxShape.Append(FF);
2932             myVEdges->ChangeValue(ii, I2) = FF;
2933             HasFilling = Standard_True;
2934           }
2935           if (ii==1) BordFirst = Bord1;
2936         }
2937       }
2938 #if DEB
2939       else cout << "PerformCorner : Unsymmetry of free border" << endl;
2940 #endif
2941     }
2942   }
2943
2944 /*  
2945 #if DRAW
2946   if (Affich) {
2947     Standard_Integer jj;
2948     char name[100];
2949     DBRep::Set("TrimmedShell", TheShape);
2950     for (jj=1; jj <=myFaces->ColLength(); jj++){
2951       sprintf(name,"Tfaces_%d_%d", jj, I1);
2952       DBRep::Set(name, myFaces->Value(jj, I1));
2953       sprintf(name,"Tfaces_%d_%d", jj, I2);
2954       DBRep::Set(name, myFaces->Value(jj, I2));
2955     }
2956   }
2957 #endif
2958 */
2959 }
2960
2961 //=======================================================================
2962 //function : EvalExtrapol
2963 //purpose  : 
2964 //======================================================================
2965 Standard_Real BRepFill_Sweep::
2966   EvalExtrapol(const Standard_Integer Index,
2967                const BRepFill_TransitionStyle Transition) const
2968 {
2969   Standard_Real Extrap = 0.0;
2970   if (Transition == BRepFill_Right) {
2971     Standard_Integer I1, I2;
2972     if ((Index == 1) || (Index ==myLoc->NbLaw()+1) ) {
2973       if (!myLoc->IsClosed() || !mySec->IsVClosed()) return Extrap;
2974       I1 = myLoc->NbLaw();
2975       I2 = 1;
2976     }
2977     else {
2978       I1 = Index-1;
2979       I2 = Index;
2980     }
2981
2982     gp_Vec V1, V2, T1, T2;
2983     gp_Mat M1, M2;
2984     Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax, R, f, l;
2985
2986     myLoc->Law(I1)->GetDomain(f, l);
2987     myLoc->Law(I1)->D0(l, M1, V1);
2988     T1.SetXYZ(M1.Column(3));
2989     myLoc->Law(I2)->GetDomain(f, l);
2990     myLoc->Law(I2)->D0(f, M2, V2);
2991     T2.SetXYZ(M2.Column(3));
2992      
2993     Standard_Real alpha = T1.Angle(T2);
2994     if ((alpha >  myAngMax) || (alpha <  myAngMin)) {
2995       //Angle too great => No "straight" connection
2996       //Angle too small => No connection
2997       return Extrap; // = 0.0
2998     }   
2999
3000     Handle(GeomFill_SectionLaw) Sec;
3001     Sec = mySec->ConcatenedLaw();
3002
3003     //Calculating parameter U
3004     Standard_Real U, Length, SecFirst, SecLen, Lf, Ll;
3005     myLoc->CurvilinearBounds( myLoc->NbLaw(), Lf, Length );
3006     mySec->Law(1)->GetDomain( SecFirst, SecLen );
3007     SecLen -= SecFirst;
3008     myLoc->CurvilinearBounds( I1, Lf, Ll );
3009     U = SecFirst + (Ll/Length)*SecLen;
3010
3011     Bnd_Box box;
3012     //Box(Sec, 0., box);
3013     Box(Sec, U, box);
3014     box.Get(Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
3015     
3016     R =  Max(Max(Abs(Xmin), Abs(Xmax)),Max(Abs(Ymin), Abs(Ymax)));
3017     //R *= 1.1;
3018     // modified by NIZHNY-MKK  Fri Oct 31 18:57:51 2003
3019     //     Standard_Real coef = 1.2;
3020     Standard_Real coef = 2.;
3021     R *= coef;
3022     Extrap = Max(Abs(Zmin), Abs(Zmax)) + 100*myTol3d; 
3023     Extrap += R*Tan(alpha/2);
3024   }
3025   return Extrap;
3026 }
3027
3028 //=======================================================================
3029 //function : MergeVertex
3030 //purpose  : Make V2 = V1 if V2 is too close to V1
3031 //======================================================================
3032 Standard_Boolean BRepFill_Sweep::MergeVertex(const TopoDS_Shape& V1,
3033                                                    TopoDS_Shape& V2) const
3034 {
3035 // Class BRep_Tool without fields and without Constructor :
3036 //  BRep_Tool BT;
3037   const TopoDS_Vertex& v1 = TopoDS::Vertex(V1);
3038   const TopoDS_Vertex& v2 = TopoDS::Vertex(V2);  
3039   Standard_Real tol;
3040 //  tol = Max(BT.Tolerance(v1), BT.Tolerance(v2));
3041   tol = Max(BRep_Tool::Tolerance(v1), BRep_Tool::Tolerance(v2));
3042   if (tol < myTol3d) tol = myTol3d;
3043 //  if (BT.Pnt(v1).Distance(BT.Pnt(v2)) <= tol ){
3044   if (BRep_Tool::Pnt(v1).Distance(BRep_Tool::Pnt(v2)) <= tol ){
3045     V2 = V1;
3046     return Standard_True;
3047   }                              
3048   return Standard_False;
3049 }
3050
3051         
3052 //=======================================================================
3053 //function : UpdateVertex
3054 //purpose  : Update the Tolerance of Vertices depending on Laws.
3055 //======================================================================
3056 void BRepFill_Sweep::UpdateVertex(const Standard_Integer ipath,
3057                                   const Standard_Integer isec,
3058                                   const Standard_Real ErrApp,
3059                                   const Standard_Real Param,
3060                                   TopoDS_Shape& V) const
3061 {
3062   TopoDS_Vertex vv, TheV;
3063   TheV = TopoDS::Vertex(V);
3064   myLoc->PerformVertex(ipath, 
3065                        mySec->Vertex(isec, Param), 
3066                        ErrApp+mySec->VertexTol(isec-1, Param),
3067                        vv);
3068 // Class BRep_Tool without fields and without Constructor :
3069 //  BRep_Tool BT;
3070   gp_Pnt P1, P2;
3071 //  P1 = BT.Pnt(vv);
3072   P1 = BRep_Tool::Pnt(vv);
3073 //  P2 = BT.Pnt(TheV);
3074   P2 = BRep_Tool::Pnt(TheV);
3075
3076 //  Standard_Real Tol = BT.Tolerance(vv);
3077   Standard_Real Tol = BRep_Tool::Tolerance(vv);
3078   Tol += P1.Distance(P2);
3079   
3080 //  if (Tol >  BT.Tolerance(TheV)) {
3081   if (Tol >  BRep_Tool::Tolerance(TheV)) {
3082     BRep_Builder B;
3083     B.UpdateVertex(TheV, Tol);
3084   }
3085 }