0025124: [Feature request] Removal of continuity checks for offset geometries
[occt.git] / src / BRepOffset / BRepOffset_Tool.cxx
1 // Created on: 1995-10-23
2 // Created by: Yves FRICAUD
3 // Copyright (c) 1995-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <stdio.h>
18
19 #include <BRepOffset_Tool.ixx>
20
21 #include <BRepAlgo_Tool.hxx>
22
23 #include <BRepAdaptor_Curve.hxx>
24 #include <BRepAdaptor_Surface.hxx>
25 #include <BRepAdaptor_HCurve.hxx>
26 #include <BRepAdaptor_HSurface.hxx>
27
28 #include <BRepBndLib.hxx>
29
30 #include <Bnd_Box2d.hxx>
31 #include <BndLib_Add3dCurve.hxx>
32 #include <BRep_Tool.hxx>
33 #include <BRepLib.hxx>
34 #include <BRepLib_MakeEdge.hxx>
35 #include <BRepLib_MakeVertex.hxx>
36 #include <BRepLib_MakePolygon.hxx>
37 #include <BRepLib_MakeFace.hxx>
38 #include <BRepLib_MakeWire.hxx>
39 #include <BRepTools.hxx>
40 #include <BRepTools_WireExplorer.hxx>
41
42 #include <BRepTools_Modifier.hxx>
43 #include <BRepTools_TrsfModification.hxx>
44 #include <BRepTopAdaptor_FClass2d.hxx>
45 #include <BRepAdaptor_Curve.hxx>
46 #include <BRepAdaptor_Curve2d.hxx>
47
48 #include <IntRes2d_IntersectionPoint.hxx>
49 #include <IntRes2d_IntersectionSegment.hxx>
50 #include <Extrema_ExtPC.hxx>
51
52 #include <TopExp.hxx>
53 #include <TopExp_Explorer.hxx>
54 #include <TopAbs.hxx>
55 #include <Standard_ConstructionError.hxx>
56
57 #include <TopOpeBRepBuild_Builder.hxx>
58 #include <TopOpeBRepDS_HDataStructure.hxx>
59 #include <TopOpeBRepDS_CurveExplorer.hxx>
60 #include <TopOpeBRep_DSFiller.hxx>
61 #include <TopOpeBRepTool_GeomTool.hxx>
62 #include <TopOpeBRep_ShapeIntersector.hxx>
63 #include <TopOpeBRep_FacesFiller.hxx>
64 #include <TopOpeBRep_GeomTool.hxx>
65 #include <TopoDS.hxx>
66 #include <TopoDS_Iterator.hxx>
67 #include <TopTools_ListIteratorOfListOfShape.hxx>
68 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
69
70 #include <Geom_Surface.hxx>
71 #include <Geom_RectangularTrimmedSurface.hxx>
72 #include <Geom_OffsetSurface.hxx>
73 #include <Geom_BezierSurface.hxx>
74 #include <Geom_BSplineSurface.hxx>
75 #include <Geom_ConicalSurface.hxx>
76 #include <Geom_Curve.hxx>
77 #include <Geom_Line.hxx>
78 #include <Geom_Plane.hxx>
79 #include <Geom_Conic.hxx>
80 #include <Geom_TrimmedCurve.hxx>
81 #include <GCPnts_QuasiUniformDeflection.hxx>
82
83 #include <GeomLib.hxx>
84 #include <GeomAPI.hxx>
85 #include <GeomAPI_ProjectPointOnCurve.hxx>
86 #include <Geom2d_TrimmedCurve.hxx>
87 #include <Geom2d_Line.hxx>
88 #include <Geom2d_Curve.hxx>
89 #include <Geom2d_Circle.hxx>
90 #include <Geom2d_Ellipse.hxx>
91 #include <Geom2d_Parabola.hxx>
92 #include <Geom2d_Hyperbola.hxx>
93 #include <Geom2d_BezierCurve.hxx>
94 #include <Geom2d_BSplineCurve.hxx>
95
96 #include <Geom2dAdaptor_Curve.hxx>
97 #include <Geom2dInt_GInter.hxx>
98
99 #include <GeomAdaptor_Surface.hxx>
100 #include <GeomProjLib.hxx>
101 #include <GeomInt_IntSS.hxx>
102 #include <ProjLib_ProjectedCurve.hxx>
103 #include <ProjLib_HProjectedCurve.hxx>
104
105 #include <ElSLib.hxx>
106 #include <ElCLib.hxx>
107
108 #include <gp.hxx>
109 #include <gp_Pnt.hxx>
110 #include <gp_Vec.hxx>
111
112
113 #include <Precision.hxx>
114 #include <Standard_ConstructionError.hxx>
115
116 #include <BRep_TEdge.hxx>
117 #include <Extrema_ExtPC2d.hxx>
118
119 #include <Geom_SurfaceOfLinearExtrusion.hxx>
120 #include <Geom_SurfaceOfRevolution.hxx>
121 #include <GCPnts_AbscissaPoint.hxx>
122
123 //tma: for new boolean operation
124 #include <TopTools_SequenceOfShape.hxx>
125 #include <Geom_BSplineCurve.hxx>
126 #include <GeomConvert_CompCurveToBSplineCurve.hxx>
127 #include <Geom2dConvert_CompCurveToBSplineCurve.hxx>
128 #include <GeomConvert_ApproxCurve.hxx>
129 #include <Geom2dConvert_ApproxCurve.hxx>
130 #include <TopoDS_Compound.hxx>
131 #include <GCPnts_UniformAbscissa.hxx>
132 #include <BRep_ListIteratorOfListOfCurveRepresentation.hxx>
133 #include <BRep_CurveRepresentation.hxx>
134
135 #include <BRepOffset_ListOfInterval.hxx>
136 #include <BRepOffset_Interval.hxx>
137 #include <TColgp_Array1OfPnt2d.hxx>
138 #include <ShapeCustom_Curve2d.hxx>
139 #include <GeomAPI_ExtremaCurveCurve.hxx>
140
141 #include <BOPDS_DS.hxx>
142 #include <BOPAlgo_PaveFiller.hxx>
143 #include <BOPTools_AlgoTools2D.hxx>
144
145 #ifdef DRAW
146 #include <DBRep.hxx>
147 Standard_Boolean AffichInter  = Standard_False;
148 static Standard_Integer NbNewEdges  = 1;
149 static Standard_Integer NbFaces     = 1;
150 static Standard_Integer NbFOB       = 1;
151 static Standard_Integer NbFTE       = 1;
152 static Standard_Integer NbExtE      = 1;
153 #endif
154
155 #ifdef OCCT_DEBUG
156 static Standard_Boolean AffichExtent = Standard_False;
157 #endif
158
159 //=======================================================================
160 //function : EdgeVertices
161 //purpose  : 
162 //=======================================================================
163
164 void BRepOffset_Tool::EdgeVertices (const TopoDS_Edge&   E,
165                                     TopoDS_Vertex& V1, 
166                                     TopoDS_Vertex& V2)
167 {
168   if (E.Orientation() == TopAbs_REVERSED) {
169     TopExp::Vertices(E,V2,V1);
170   }
171   else {
172     TopExp::Vertices(E,V1,V2);
173   }
174 }
175
176 //=======================================================================
177 //function : OriEdgeInFace
178 //purpose  : 
179 //=======================================================================
180
181 TopAbs_Orientation BRepOffset_Tool::OriEdgeInFace (const TopoDS_Edge& E,
182                                                    const TopoDS_Face& F )
183
184 {
185   TopExp_Explorer Exp;
186   Exp.Init(F.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
187
188   for (; Exp.More() ;Exp.Next()) {
189     if (Exp.Current().IsSame(E)) {
190       return Exp.Current().Orientation();
191     }
192   }
193   Standard_ConstructionError::Raise("BRepOffset_Tool::OriEdgeInFace");
194   return E.Orientation();
195 }
196
197
198 //=======================================================================
199 //function : FindPeriod
200 //purpose  : 
201 //=======================================================================
202
203 static void FindPeriod (const TopoDS_Face& F,
204                         Standard_Real&     umin,
205                         Standard_Real&     umax,
206                         Standard_Real&     vmin,
207                         Standard_Real&     vmax)
208 {
209
210   Bnd_Box2d B;
211   TopExp_Explorer exp;
212   for (exp.Init(F,TopAbs_EDGE); exp.More(); exp.Next()) {
213     const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
214     
215     Standard_Real pf,pl;
216     const Handle(Geom2d_Curve) C = BRep_Tool::CurveOnSurface(E,F,pf,pl);
217     if (C.IsNull()) return;
218     Geom2dAdaptor_Curve PC(C,pf,pl);
219     Standard_Real i, nbp = 20;
220     if (PC.GetType() == GeomAbs_Line) nbp = 2;
221     Standard_Real step = (pl - pf) / nbp;
222     gp_Pnt2d P;
223     PC.D0(pf,P);
224     B.Add(P);
225     for (i = 2; i < nbp; i++) {
226       pf += step;
227       PC.D0(pf,P);
228       B.Add(P);
229     }
230     PC.D0(pl,P);
231     B.Add(P);
232     B.Get(umin,vmin,umax,vmax);
233   }
234 }
235
236 //=======================================================================
237 //function : PutInBounds
238 //purpose  : Recadre la courbe 2d dans les bounds de la face
239 //=======================================================================
240
241 static void PutInBounds (const TopoDS_Face&          F,
242                          const TopoDS_Edge&          E,
243                          Handle(Geom2d_Curve)&       C2d)
244 {
245   Standard_Real   umin,umax,vmin,vmax;
246   Standard_Real   f,l;
247   BRep_Tool::Range(E,f,l);  
248
249   TopLoc_Location L; // Recup S avec la location pour eviter la copie.
250   Handle (Geom_Surface) S   = BRep_Tool::Surface(F,L);
251
252   if (S->IsInstance(STANDARD_TYPE(Geom_RectangularTrimmedSurface))) {
253     S = (*(Handle(Geom_RectangularTrimmedSurface)*)&S)->BasisSurface();
254   }
255   //---------------
256   // Recadre en U.
257   //---------------
258   if (!S->IsUPeriodic() && !S->IsVPeriodic()) return;
259
260   FindPeriod (F,umin,umax,vmin,vmax);
261
262   if (S->IsUPeriodic()) {
263     Standard_Real period  = S->UPeriod();
264     Standard_Real eps     = period*1.e-6;
265     gp_Pnt2d      Pf      = C2d->Value(f);
266     gp_Pnt2d      Pl      = C2d->Value(l);
267     gp_Pnt2d      Pm      = C2d->Value(0.34*f + 0.66*l);
268     Standard_Real minC    = Min(Pf.X(),Pl.X()); minC = Min(minC,Pm.X());
269     Standard_Real maxC    = Max(Pf.X(),Pl.X()); maxC = Max(maxC,Pm.X());
270     Standard_Real du = 0.;
271     if (minC< umin - eps) {
272       du = (int((umin - minC)/period) + 1)*period;
273     }
274     if (minC > umax + eps) {
275       du = -(int((minC - umax)/period) + 1)*period;
276     }
277     if (du != 0) {
278       gp_Vec2d T1(du,0.);
279       C2d->Translate(T1);
280       minC += du; maxC += du;
281     }
282     // Ajuste au mieux la courbe dans le domaine.
283     if (maxC > umax +100*eps) {
284       Standard_Real d1 = maxC - umax;
285       Standard_Real d2 = umin - minC + period;
286       if (d2 < d1) du =-period;
287       if ( du != 0.) {
288         gp_Vec2d T2(du,0.);
289         C2d->Translate(T2);
290       }
291     }
292   }
293   //------------------
294   // Recadre en V.
295   //------------------
296   if (S->IsVPeriodic()) {
297     Standard_Real period  = S->VPeriod();
298     Standard_Real eps     = period*1.e-6;
299     gp_Pnt2d      Pf      = C2d->Value(f);
300     gp_Pnt2d      Pl      = C2d->Value(l);
301     gp_Pnt2d      Pm      = C2d->Value(0.34*f + 0.66*l);
302     Standard_Real minC    = Min(Pf.Y(),Pl.Y()); minC = Min(minC,Pm.Y());
303     Standard_Real maxC    = Max(Pf.Y(),Pl.Y()); maxC = Max(maxC,Pm.Y());
304     Standard_Real dv = 0.;
305     if (minC< vmin - eps) {
306       dv = (int((vmin - minC)/period) + 1)*period;
307     }
308     if (minC > vmax + eps) {
309       dv = -(int((minC - vmax)/period) + 1)*period;
310     }
311     if (dv != 0) {
312       gp_Vec2d T1(0.,dv);
313       C2d->Translate(T1);
314       minC += dv; maxC += dv;
315     }
316     // Ajuste au mieux la courbe dans le domaine.
317     if (maxC > vmax +100*eps) {
318       Standard_Real d1 = maxC - vmax;
319       Standard_Real d2 = vmin - minC + period;
320       if (d2 < d1) dv =-period;
321       if ( dv != 0.) {
322         gp_Vec2d T2(0.,dv);
323         C2d->Translate(T2);
324       }
325     }
326   }
327 }
328
329 //=======================================================================
330 //function : Gabarit
331 //purpose  : 
332 //=======================================================================
333
334 Standard_Real BRepOffset_Tool::Gabarit(const Handle(Geom_Curve)& aCurve)
335 {
336   GeomAdaptor_Curve GC( aCurve );
337   Bnd_Box aBox;
338   BndLib_Add3dCurve::Add( GC, Precision::Confusion(), aBox );
339   Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax, dist;
340   aBox.Get( aXmin, aYmin, aZmin, aXmax, aYmax, aZmax );
341   dist = Max( (aXmax-aXmin), (aYmax-aYmin) );
342   dist = Max( dist, (aZmax-aZmin) );
343   return dist;
344 }
345
346 //=======================================================================
347 //function : BuildPCurves
348 //purpose  : 
349 //=======================================================================
350
351 static void BuildPCurves (const TopoDS_Edge&  E,
352                           const TopoDS_Face&  F)
353
354   Standard_Real   ff,ll;
355   Handle (Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface (E,F,ff,ll);
356   if (!C2d.IsNull()) return;
357
358   //Standard_Real Tolerance = Max(Precision::Confusion(),BRep_Tool::Tolerance(E));
359   Standard_Real Tolerance = Precision::Confusion();
360
361   BRepAdaptor_Surface AS(F,0);
362   BRepAdaptor_Curve   AC(E);
363
364   //Try to find pcurve on a bound of BSpline or Bezier surface
365   Handle( Geom_Surface ) theSurf = BRep_Tool::Surface( F );
366   Handle( Standard_Type ) typS = theSurf->DynamicType();
367   if (typS == STANDARD_TYPE(Geom_OffsetSurface))
368     typS = (*((Handle(Geom_OffsetSurface)*)&theSurf))->BasisSurface()->DynamicType();
369   if (typS == STANDARD_TYPE(Geom_BezierSurface) || typS == STANDARD_TYPE(Geom_BSplineSurface))
370     {
371       gp_Pnt fpoint = AC.Value( AC.FirstParameter() );
372       gp_Pnt lpoint = AC.Value( AC.LastParameter() );
373       TopoDS_Face theFace = BRepLib_MakeFace( theSurf, Precision::Confusion() );
374       Standard_Real U1 = 0., U2 = 0., TolProj = 1.e-4; //1.e-5;
375       TopoDS_Edge theEdge;
376       TopExp_Explorer Explo;
377       Explo.Init( theFace, TopAbs_EDGE );
378       for (; Explo.More(); Explo.Next())
379         {
380           TopoDS_Edge anEdge = TopoDS::Edge( Explo.Current() );
381           BRepAdaptor_Curve aCurve( anEdge );
382           Extrema_ExtPC fextr( fpoint, aCurve );
383           if (!fextr.IsDone() || fextr.NbExt() < 1)
384             continue;
385           Standard_Real dist2, dist2min = RealLast();
386           Standard_Integer i;
387           for (i = 1; i <= fextr.NbExt(); i++)
388             {
389               dist2 = fextr.SquareDistance(i);
390               if (dist2 < dist2min)
391                 {
392                   dist2min = dist2;
393                   U1 = fextr.Point(i).Parameter();
394                 }
395             }
396           if (dist2min > TolProj * TolProj)
397             continue;
398           Extrema_ExtPC lextr( lpoint, aCurve );
399           if (!lextr.IsDone() || lextr.NbExt() <1)
400             continue;
401           dist2min = RealLast();
402           for (i = 1; i <= lextr.NbExt(); i++)
403             {
404               dist2 = lextr.SquareDistance(i);
405               if (dist2 < dist2min)
406                 {
407                   dist2min = dist2;
408                   U2 = lextr.Point(i).Parameter();
409                 }
410             }
411           if (dist2min <= TolProj * TolProj)
412             {
413               theEdge = anEdge;
414               break;
415             }
416         } // for (; Explo.More(); Explo.Current())
417       
418       if (! theEdge.IsNull())
419         {
420           //Construction of pcurve
421           if (U2 < U1)
422             {
423               Standard_Real temp = U1;
424               U1 = U2;
425               U2 = temp;
426             }
427           Standard_Real f, l;
428           C2d = BRep_Tool::CurveOnSurface( theEdge, theFace, f, l );
429           C2d = new Geom2d_TrimmedCurve( C2d, U1, U2 );
430
431           if (theSurf->IsUPeriodic() || theSurf->IsVPeriodic())
432             PutInBounds( F, E, C2d );
433
434           BRep_Builder B;
435           B.UpdateEdge( E, C2d, F, BRep_Tool::Tolerance(E) );
436           BRepLib::SameRange( E );
437
438           return;
439         }
440     } // if (typS == ...
441
442   Handle(BRepAdaptor_HSurface) HS = new BRepAdaptor_HSurface(AS);
443   Handle(BRepAdaptor_HCurve)   HC = new BRepAdaptor_HCurve(AC);
444
445   ProjLib_ProjectedCurve Proj(HS,HC,Tolerance);
446   
447   switch ( Proj.GetType()) {
448
449   case GeomAbs_Line:
450     C2d = new Geom2d_Line(Proj.Line());
451     break;
452
453   case GeomAbs_Circle:
454     C2d = new Geom2d_Circle(Proj.Circle());
455     break;
456
457   case GeomAbs_Ellipse:
458     C2d = new Geom2d_Ellipse(Proj.Ellipse());
459     break;
460
461   case GeomAbs_Parabola:
462     C2d = new Geom2d_Parabola(Proj.Parabola());
463     break;
464
465   case GeomAbs_Hyperbola:
466     C2d = new Geom2d_Hyperbola(Proj.Hyperbola());
467     break;
468
469   case GeomAbs_BezierCurve:
470     C2d = Proj.Bezier();
471     break;
472
473   case GeomAbs_BSplineCurve:
474     C2d = Proj.BSpline();
475     break;
476   default:
477     break;
478   }
479
480   if (AS.IsUPeriodic() || AS.IsVPeriodic()) {
481     PutInBounds(F,E,C2d);
482   }
483   if (!C2d.IsNull()) {
484     BRep_Builder    B;
485     B.UpdateEdge (E,C2d,F,BRep_Tool::Tolerance(E));
486   }
487   else {
488     Standard_ConstructionError::Raise("BRepOffset_Tool::BuildPCurves");
489     cout <<"Echec ProjLib"<<endl;
490   }
491 }
492
493 //=======================================================================
494 //function : OriSect
495 //purpose  : 
496 //=======================================================================
497
498 void BRepOffset_Tool::OrientSection (const TopoDS_Edge&  E,
499                                      const TopoDS_Face&  F1,
500                                      const TopoDS_Face&  F2,
501                                      TopAbs_Orientation& O1,
502                                      TopAbs_Orientation& O2) 
503 {
504   TopLoc_Location L;
505   Standard_Real   f,l;
506   
507   
508   Handle (Geom_Surface) S1 = BRep_Tool::Surface(F1);
509   Handle (Geom_Surface) S2 = BRep_Tool::Surface(F2);    
510   Handle (Geom2d_Curve) C1 = BRep_Tool::CurveOnSurface(E,F1,f,l);
511   Handle (Geom2d_Curve) C2 = BRep_Tool::CurveOnSurface(E,F2,f,l); 
512   Handle (Geom_Curve)   C  = BRep_Tool::Curve(E,L,f,l);
513
514   BRepAdaptor_Curve BAcurve( E );
515   
516   GCPnts_AbscissaPoint AP(BAcurve,GCPnts_AbscissaPoint::Length(BAcurve)/2.0,f);
517   Standard_Real ParOnC;
518
519   if(AP.IsDone())
520     ParOnC = AP.Parameter();
521   else
522     ParOnC = BOPTools_AlgoTools2D::IntermediatePoint(f, l);
523
524   gp_Vec T1 = C->DN(ParOnC,1).Transformed(L.Transformation());
525   if (T1.SquareMagnitude() > gp::Resolution()) {
526     T1.Normalize();
527   }
528
529   gp_Pnt2d P  = C1->Value(ParOnC);
530   gp_Pnt   P3;
531   gp_Vec   D1U,D1V;
532   
533   S1->D1(P.X(),P.Y(),P3,D1U,D1V);
534   gp_Vec DN1(D1U^D1V);
535   if (F1.Orientation() == TopAbs_REVERSED) DN1.Reverse();
536   
537   P = C2->Value(ParOnC);
538   S2->D1(P.X(),P.Y(),P3,D1U,D1V);
539   gp_Vec DN2(D1U^D1V);
540   if (F2.Orientation() == TopAbs_REVERSED) DN2.Reverse();
541   
542   gp_Vec        ProVec = DN2^T1;
543   Standard_Real Prod  =  DN1.Dot(ProVec);
544   if (Prod < 0.0) {
545     O1 = TopAbs_FORWARD;
546   }
547   else {
548     O1 = TopAbs_REVERSED;
549   }
550   ProVec = DN1^T1;
551   Prod  =  DN2.Dot(ProVec);
552   if (Prod < 0.0) {
553     O2 = TopAbs_FORWARD;
554   }
555   else {
556     O2 = TopAbs_REVERSED;
557   }
558   if (F1.Orientation() == TopAbs_REVERSED) O1 = TopAbs::Reverse(O1);
559   if (F2.Orientation() == TopAbs_REVERSED) O2 = TopAbs::Reverse(O2);
560 }
561
562 //=======================================================================
563 //function : HasCommonShape
564 //purpose  : 
565 //=======================================================================
566
567 Standard_Boolean BRepOffset_Tool::HasCommonShapes (const TopoDS_Face& F1,
568                                                    const TopoDS_Face& F2,
569                                                    TopTools_ListOfShape& LE,
570                                                    TopTools_ListOfShape& LV)
571 {
572   Standard_Boolean Common = Standard_False;
573   LE.Clear(); LV.Clear();
574
575   TopExp_Explorer exp1;
576   exp1.Init(F1,TopAbs_EDGE);
577
578   for (; exp1.More(); exp1.Next()) {
579     TopExp_Explorer exp2;
580     exp2.Init(F2,TopAbs_EDGE);
581     for (; exp2.More(); exp2.Next()) {
582       if (exp1.Current().IsSame(exp2.Current())) {
583         Common = Standard_True;
584         LE.Append(exp1.Current());
585       }
586     }
587   }
588   for (exp1.Init(F1,TopAbs_VERTEX); exp1.More(); exp1.Next()) {
589     TopExp_Explorer exp2;
590     exp2.Init(F2,TopAbs_EDGE);
591     for (exp2.Init(F2,TopAbs_VERTEX); exp2.More(); exp2.Next()) {
592       if (exp1.Current().IsSame(exp2.Current())) {
593         Common = Standard_True;
594         LV.Append(exp1.Current());
595       }
596     }
597   }
598   return Common;
599 }
600
601 //=======================================================================
602 //function : ToSmall
603 //purpose  : 
604 //=======================================================================
605
606 static Standard_Boolean ToSmall (const Handle(Geom_Curve)& C)
607 {
608   Standard_Real Tol = 10*Precision::Confusion();
609   Standard_Real m   = (C->FirstParameter()*0.668 + C->LastParameter()*0.332); 
610   gp_Pnt P1 = C->Value(C->FirstParameter());
611   gp_Pnt P2 = C->Value(C->LastParameter());
612   gp_Pnt P3 = C->Value(m);
613   if (P1.Distance(P2) > Tol) return Standard_False;
614   if (P2.Distance(P3) > Tol) return Standard_False;
615   return Standard_True;
616 }
617
618
619 //=======================================================================
620 //function : IsOnSurface
621 //purpose  : 
622 //=======================================================================
623
624 static Standard_Boolean IsOnSurface(const Handle(Geom_Curve)&   C,
625                                     const Handle(Geom_Surface)& S,
626                                     Standard_Real               TolConf,
627                                     Standard_Real&              TolReached) 
628 {
629   Standard_Real    f = C->FirstParameter();
630   Standard_Real    l = C->LastParameter();
631   Standard_Integer n = 5;
632   Standard_Real du = (f-l)/(n-1);
633   TolReached = 0.;
634
635   gp_Pnt P;
636   Standard_Real U,V;
637
638   GeomAdaptor_Surface AS(S);
639
640   switch ( AS.GetType()) {
641   case GeomAbs_Plane:
642     {
643       gp_Ax3 Ax = AS.Plane().Position();
644       for ( Standard_Integer i = 0; i < n; i++) {
645         P = C->Value(f+i*du);
646         ElSLib::PlaneParameters(Ax,P,U,V); 
647         TolReached = P.Distance(ElSLib::PlaneValue(U,V,Ax));
648         if ( TolReached  > TolConf)
649           return Standard_False;
650       }
651       break;
652     }
653   case GeomAbs_Cylinder:
654     {
655       gp_Ax3        Ax  = AS.Cylinder().Position();
656       Standard_Real Rad = AS.Cylinder().Radius();
657       for ( Standard_Integer i = 0; i < n; i++) {
658         P = C->Value(f+i*du);
659         ElSLib::CylinderParameters(Ax,Rad,P,U,V); 
660         TolReached = P.Distance(ElSLib::CylinderValue(U,V,Ax,Rad));
661         if ( TolReached > TolConf)
662           return Standard_False;
663       }
664       break;
665     }
666   case GeomAbs_Cone:
667     {
668       gp_Ax3        Ax  = AS.Cone().Position();
669       Standard_Real Rad = AS.Cone().RefRadius();
670       Standard_Real Alp = AS.Cone().SemiAngle();
671       for ( Standard_Integer i = 0; i < n; i++) {
672         P = C->Value(f+i*du);
673         ElSLib::ConeParameters(Ax,Rad,Alp,P,U,V); 
674         TolReached = P.Distance(ElSLib::ConeValue(U,V,Ax,Rad,Alp));
675         if ( TolReached > TolConf)
676           return Standard_False;
677       }
678       break;
679     }
680   case GeomAbs_Sphere:
681     {
682       gp_Ax3        Ax  = AS.Sphere().Position();
683       Standard_Real Rad = AS.Sphere().Radius();
684       for ( Standard_Integer i = 0; i < n; i++) {
685         P = C->Value(f+i*du);
686         ElSLib::SphereParameters(Ax,Rad,P,U,V); 
687         TolReached = P.Distance(ElSLib::SphereValue(U,V,Ax,Rad));
688         if ( TolReached > TolConf)
689           return Standard_False;
690       }
691       break;
692     }
693   case GeomAbs_Torus:
694     {
695       gp_Ax3        Ax  = AS.Torus().Position();
696       Standard_Real R1  = AS.Torus().MajorRadius();
697       Standard_Real R2  = AS.Torus().MinorRadius();
698       for ( Standard_Integer i = 0; i < n; i++) {
699         P = C->Value(f+i*du);
700         ElSLib::TorusParameters(Ax,R1,R2,P,U,V); 
701         TolReached =  P.Distance(ElSLib::TorusValue(U,V,Ax,R1,R2));
702         if ( TolReached > TolConf)
703           return Standard_False;
704       }
705       break;
706     }
707     
708   default:
709     {
710       return Standard_False;
711     }
712   }
713   
714   return Standard_True;
715
716
717
718 //=======================================================================
719 //function : PipeInter
720 //purpose  : 
721 //=======================================================================
722
723 void BRepOffset_Tool::PipeInter(const TopoDS_Face& F1,
724                                 const TopoDS_Face& F2,
725                                 TopTools_ListOfShape& L1,
726                                 TopTools_ListOfShape& L2,
727                                 const TopAbs_State    Side)
728
729 #ifdef DRAW
730   if (AffichInter) {
731     char name[256];
732     sprintf(name,"FF_%d",NbFaces++);
733     DBRep::Set(name,F1);
734     sprintf(name,"FF_%d",NbFaces++);
735     DBRep::Set(name,F2);
736   }
737 #endif
738
739   Handle (Geom_Curve) CI;
740   TopoDS_Edge E;
741   TopAbs_Orientation O1,O2;
742   L1.Clear(); L2.Clear();
743   BRep_Builder B;
744   Handle (Geom_Surface) S1 = BRep_Tool::Surface(F1);
745   Handle (Geom_Surface) S2 = BRep_Tool::Surface(F2);  
746
747   GeomInt_IntSS Inter (S1,S2, Precision::Confusion(),1,1,1);
748   
749   if (Inter.IsDone()) {
750     for (Standard_Integer i = 1; i <= Inter.NbLines(); i++) {
751       CI = Inter.Line(i);
752       if (ToSmall(CI)) continue;
753       TopoDS_Edge E = BRepLib_MakeEdge(CI);
754       if (Inter.HasLineOnS1(i)) {
755         Handle(Geom2d_Curve) C2 = Inter.LineOnS1(i);
756         PutInBounds  (F1,E,C2);
757         B.UpdateEdge (E,C2,F1,BRep_Tool::Tolerance(E));
758       }
759       else {
760         BuildPCurves (E,F1);
761       }
762       if (Inter.HasLineOnS2(i)) {
763         Handle(Geom2d_Curve) C2 = Inter.LineOnS2(i);
764         PutInBounds  (F2,E,C2);
765         B.UpdateEdge (E,C2,F2,BRep_Tool::Tolerance(E));
766       }
767       else {
768         BuildPCurves (E,F2);
769       }
770       OrientSection (E,F1,F2,O1,O2);
771       if (Side == TopAbs_OUT) {
772         O1 = TopAbs::Reverse(O1);
773         O2 = TopAbs::Reverse(O2);
774       }
775       L1.Append (E.Oriented(O1));
776       L2.Append (E.Oriented(O2));
777 #ifdef DRAW
778       if (AffichInter) {
779         char name[256];
780         sprintf(name,"EI_%d",NbNewEdges++);     
781         DBRep::Set(name,E.Oriented(O1));
782       }
783 #endif      
784     }
785   }
786 }
787
788
789 //=======================================================================
790 //function : IsAutonomVertex
791 //purpose  : Checks wether a vertex is "autonom" or not
792 //=======================================================================
793
794 static Standard_Boolean IsAutonomVertex(const TopoDS_Shape& aVertex,
795                                         const BOPDS_PDS& pDS)
796 {
797   Standard_Integer index;
798   Standard_Integer aNbVVs, aNbEEs, aNbEFs, aInt;
799   //
800   index = pDS->Index(aVertex);
801   if (index == -1) {
802     Standard_Integer i, i1, i2;
803     i1=pDS->NbSourceShapes();
804     i2=pDS->NbShapes();
805     for (i=i1; i<i2; ++i) {
806       const TopoDS_Shape& aSx=pDS->Shape(i);
807       if(aSx.IsSame(aVertex)) {
808                   index = i;
809                   break;
810                 }
811             }
812         }
813   //
814   if (!pDS->IsNewShape(index)) {
815     return Standard_False;
816     }
817   //check if vertex with index "index" is not created in VV or EE or EF interference
818   //VV
819   BOPDS_VectorOfInterfVV& aVVs=pDS->InterfVV();
820   aNbVVs = aVVs.Extent();
821   for(aInt = 0; aInt < aNbVVs; aInt++) {
822     const BOPDS_InterfVV& aVV = aVVs(aInt);
823     if (aVV.HasIndexNew()) {
824       if (aVV.IndexNew() == index) {
825                 return Standard_False;
826             }
827         }
828     }
829   //EE
830   BOPDS_VectorOfInterfEE& aEEs=pDS->InterfEE();
831   aNbEEs = aEEs.Extent();
832   for(aInt = 0; aInt < aNbEEs; aInt++) {
833     const BOPDS_InterfEE& aEE = aEEs(aInt);
834     IntTools_CommonPrt aCP = aEE.CommonPart();
835     if(aCP.Type() == TopAbs_VERTEX) {
836       if (aEE.IndexNew() == index) {
837                     return Standard_False;
838                 }
839             }
840         }
841   //EF
842   BOPDS_VectorOfInterfEF& aEFs=pDS->InterfEF();
843   aNbEFs = aEFs.Extent();
844   for(aInt = 0; aInt < aNbEFs; aInt++) {
845     const BOPDS_InterfEF& aEF = aEFs(aInt);
846     IntTools_CommonPrt aCP = aEF.CommonPart();
847     if(aCP.Type() == TopAbs_VERTEX) {
848       if (aEF.IndexNew() == index) {
849         return Standard_False;
850     }
851     }
852   }
853   return Standard_True;
854 }
855
856
857 //=======================================================================
858 //function : AreConnex
859 //purpose  : define if two shapes are connex by a vertex (vertices)
860 //=======================================================================
861
862 static Standard_Boolean AreConnex(const TopoDS_Wire& W1,
863                                   const TopoDS_Wire& W2,
864                                   const BOPDS_PDS& pDS)
865 {
866   TopoDS_Vertex V11, V12, V21, V22;
867   TopExp::Vertices( W1, V11, V12 );
868   TopExp::Vertices( W2, V21, V22 );
869
870   if (V11.IsSame(V21) || V11.IsSame(V22) ||
871       V12.IsSame(V21) || V12.IsSame(V22))
872     {
873       Standard_Boolean isCV1 = V11.IsSame(V21) || V11.IsSame(V22);
874       Standard_Boolean isCV2 = V12.IsSame(V21) || V12.IsSame(V22);
875       if (isCV1 && !IsAutonomVertex(V11, pDS))
876         {
877           if (!isCV2)
878             return Standard_False;
879           if (!IsAutonomVertex(V12, pDS))
880             return Standard_False;
881         }
882       if (!isCV1 && !IsAutonomVertex(V12, pDS))
883         return Standard_False;
884
885       TopoDS_Vertex CV = (V11.IsSame(V21) || V11.IsSame(V22))? V11 : V12;
886       TopoDS_Edge E1, E2;
887       TopoDS_Iterator itw( W1 );
888       for (; itw.More(); itw.Next())
889         {
890           E1 = TopoDS::Edge(itw.Value());
891           TopoDS_Vertex V1, V2;
892           TopExp::Vertices( E1, V1, V2 );
893           if (V1.IsSame(CV) || V2.IsSame(CV))
894             break;
895         }
896       itw.Initialize( W2 );
897       E2 = TopoDS::Edge(itw.Value());
898
899       Standard_Real f, l;
900       Handle(Geom_Curve) C1 = BRep_Tool::Curve( E1, f, l ); 
901       if (C1->IsInstance(STANDARD_TYPE(Geom_TrimmedCurve)))
902         C1 = (*((Handle(Geom_TrimmedCurve)*)&C1))->BasisCurve();
903       
904       Handle(Geom_Curve) C2 = BRep_Tool::Curve( E2, f, l );
905       if (C2->IsInstance(STANDARD_TYPE(Geom_TrimmedCurve)))
906         C2 = (*((Handle(Geom_TrimmedCurve)*)&C2))->BasisCurve();
907
908       if (C1->IsInstance(STANDARD_TYPE(Geom_Line)) &&
909           C2->IsInstance(STANDARD_TYPE(Geom_Line)))
910         {
911           Handle(Geom_Line) L1 = *((Handle(Geom_Line)*) &C1);
912           gp_Ax1 Axis1 = L1->Position();
913           Handle(Geom_Line) L2 = *((Handle(Geom_Line)*) &C2);
914           gp_Ax1 Axis2 = L2->Position();
915           if (! Axis1.IsParallel( Axis2, Precision::Angular() ))
916             return Standard_False;
917         }
918
919       return Standard_True;
920     }
921
922   return Standard_False;
923 }
924
925 //=======================================================================
926 //function : AreClosed
927 //purpose  : define if two edges are connex by two vertices
928 //=======================================================================
929
930 static Standard_Boolean AreClosed(const TopoDS_Edge& E1,
931                                   const TopoDS_Edge& E2)
932 {
933   TopoDS_Vertex V11, V12, V21, V22;
934   TopExp::Vertices( E1, V11, V12 );
935   TopExp::Vertices( E2, V21, V22 );
936
937   if ((V11.IsSame(V21) && V12.IsSame(V22)) ||
938       (V11.IsSame(V22) && V12.IsSame(V21)))
939     return Standard_True;
940
941   return Standard_False;
942 }
943
944 //=======================================================================
945 //function : BSplineEdges
946 //purpose  : 
947 //=======================================================================
948
949 static Standard_Boolean BSplineEdges(const TopoDS_Edge& E1,
950                                      const TopoDS_Edge& E2,
951                                      const Standard_Integer par1,
952                                      const Standard_Integer par2,
953                                      Standard_Real& angle)
954 {
955   Standard_Real first1, last1, first2, last2, Param1, Param2;
956
957   Handle(Geom_Curve) C1 = BRep_Tool::Curve( E1, first1, last1 ); 
958   if (C1->IsInstance(STANDARD_TYPE(Geom_TrimmedCurve)))
959     C1 = (*((Handle(Geom_TrimmedCurve)*)&C1))->BasisCurve();
960
961   Handle(Geom_Curve) C2 = BRep_Tool::Curve( E2, first2, last2 );
962   if (C2->IsInstance(STANDARD_TYPE(Geom_TrimmedCurve)))
963     C2 = (*((Handle(Geom_TrimmedCurve)*)&C2))->BasisCurve();
964
965   if (!C1->IsInstance(STANDARD_TYPE(Geom_BSplineCurve)) ||
966       !C2->IsInstance(STANDARD_TYPE(Geom_BSplineCurve)))
967     return Standard_False;
968
969   Param1 = (par1 == 0)? first1 : last1;
970   Param2 = (par2 == 0)? first2 : last2;
971
972   gp_Pnt Pnt1, Pnt2;
973   gp_Vec Der1, Der2;
974   C1->D1( Param1, Pnt1, Der1 );
975   C2->D1( Param2, Pnt2, Der2 );
976
977   if (Der1.Magnitude() <= gp::Resolution() ||
978       Der2.Magnitude() <= gp::Resolution())
979     angle = M_PI/2.;
980   else
981     angle = Der1.Angle(Der2);
982
983   return Standard_True;
984 }
985
986 //=======================================================================
987 //function : AngleWireEdge
988 //purpose  : 
989 //=======================================================================
990
991 static Standard_Real AngleWireEdge(const TopoDS_Wire& aWire,
992                                    const TopoDS_Edge& anEdge)
993 {
994   TopoDS_Vertex V11, V12, V21, V22, CV;
995   TopExp::Vertices( aWire,  V11, V12 );
996   TopExp::Vertices( anEdge, V21, V22 );
997   CV = (V11.IsSame(V21) || V11.IsSame(V22))? V11 : V12;
998   TopoDS_Edge FirstEdge;
999   TopoDS_Iterator itw(aWire);
1000   for (; itw.More(); itw.Next())
1001     {
1002       FirstEdge = TopoDS::Edge(itw.Value());
1003       TopoDS_Vertex v1, v2;
1004       TopExp::Vertices( FirstEdge, v1, v2 );
1005       if (v1.IsSame(CV) || v2.IsSame(CV))
1006         {
1007           V11 = v1;
1008           V12 = v2;
1009           break;
1010         }
1011     }
1012   Standard_Real Angle;
1013   if (V11.IsSame(CV) && V21.IsSame(CV))
1014     {
1015       BSplineEdges( FirstEdge, anEdge, 0, 0, Angle );
1016       Angle = M_PI - Angle;
1017     }
1018   else if (V11.IsSame(CV) && V22.IsSame(CV))
1019     BSplineEdges( FirstEdge, anEdge, 0, 1, Angle );
1020   else if (V12.IsSame(CV) && V21.IsSame(CV))
1021     BSplineEdges( FirstEdge, anEdge, 1, 0, Angle );
1022   else
1023     {
1024       BSplineEdges( FirstEdge, anEdge, 1, 1, Angle );
1025       Angle = M_PI - Angle;
1026     }
1027   return Angle;
1028 }
1029
1030
1031 //=======================================================================
1032 //function : ReconstructPCurves
1033 //purpose  : 
1034 //=======================================================================
1035
1036 static void ReconstructPCurves(const TopoDS_Edge& anEdge)
1037 {
1038   Standard_Real f, l;
1039   Handle(Geom_Curve) C3d = BRep_Tool::Curve(anEdge, f, l);
1040
1041   BRep_ListIteratorOfListOfCurveRepresentation
1042     itcr( (Handle(BRep_TEdge)::DownCast(anEdge.TShape()))->ChangeCurves() );
1043   for (; itcr.More(); itcr.Next())
1044     {
1045       Handle( BRep_CurveRepresentation ) CurveRep = itcr.Value();
1046       if (CurveRep->IsCurveOnSurface())
1047         {
1048           Handle(Geom_Surface) theSurf  = CurveRep->Surface();
1049           TopLoc_Location      theLoc   = CurveRep->Location();
1050           theLoc = anEdge.Location() * theLoc;
1051           theSurf = Handle(Geom_Surface)::DownCast
1052             (theSurf->Transformed(theLoc.Transformation()));
1053           Handle(Geom2d_Curve) ProjPCurve =
1054             GeomProjLib::Curve2d( C3d, f, l, theSurf );
1055           CurveRep->PCurve( ProjPCurve );
1056         }
1057     }
1058 }
1059
1060 //=======================================================================
1061 //function : ConcatPCurves
1062 //purpose  : 
1063 //=======================================================================
1064
1065 static Handle(Geom2d_Curve) ConcatPCurves(const TopoDS_Edge& E1,
1066                                           const TopoDS_Edge& E2,
1067                                           const TopoDS_Face& F,
1068                                           const Standard_Boolean After,
1069                                           Standard_Real& newFirst,
1070                                           Standard_Real& newLast)
1071 {
1072   Standard_Real Tol = 1.e-7;
1073   GeomAbs_Shape Continuity = GeomAbs_C1;
1074   Standard_Integer MaxDeg = 14;
1075   Standard_Integer MaxSeg = 16;
1076
1077   Standard_Real first1, last1, first2, last2;
1078   Handle(Geom2d_Curve) PCurve1, PCurve2, newPCurve;
1079
1080   PCurve1 = BRep_Tool::CurveOnSurface( E1, F, first1, last1 );
1081   if (PCurve1->IsInstance(STANDARD_TYPE(Geom2d_TrimmedCurve)))
1082     PCurve1 = (*((Handle(Geom2d_TrimmedCurve)*)&PCurve1))->BasisCurve();
1083
1084   PCurve2 = BRep_Tool::CurveOnSurface( E2, F, first2, last2 );
1085   if (PCurve2->IsInstance(STANDARD_TYPE(Geom2d_TrimmedCurve)))
1086     PCurve2 = (*((Handle(Geom2d_TrimmedCurve)*)&PCurve2))->BasisCurve();
1087       
1088   if (PCurve1 == PCurve2)
1089     {
1090       newPCurve = PCurve1;
1091       newFirst  = Min( first1, first2 );
1092       newLast   = Max( last1, last2 );
1093     }
1094   else if (PCurve1->DynamicType() == PCurve2->DynamicType() &&
1095            (PCurve1->IsInstance(STANDARD_TYPE(Geom2d_Line)) ||
1096             PCurve1->IsKind(STANDARD_TYPE(Geom2d_Conic))))
1097     {
1098       newPCurve = PCurve1;
1099       gp_Pnt2d P1, P2;
1100       P1 = PCurve2->Value( first2 );
1101       P2 = PCurve2->Value( last2 );
1102       if (PCurve1->IsInstance(STANDARD_TYPE(Geom2d_Line)))
1103         {
1104           Handle(Geom2d_Line) Lin1 = *((Handle(Geom2d_Line)*) &PCurve1);
1105           gp_Lin2d theLin = Lin1->Lin2d();
1106           first2 = ElCLib::Parameter( theLin, P1 );
1107           last2  = ElCLib::Parameter( theLin, P2 );
1108         }
1109       else if (PCurve1->IsInstance(STANDARD_TYPE(Geom2d_Circle)))
1110         {
1111           Handle(Geom2d_Circle) Circ1 = *((Handle(Geom2d_Circle)*) &PCurve1);
1112           gp_Circ2d theCirc = Circ1->Circ2d();
1113           first2 = ElCLib::Parameter( theCirc, P1 );
1114           last2  = ElCLib::Parameter( theCirc, P2 );
1115         }
1116       else if (PCurve1->IsInstance(STANDARD_TYPE(Geom2d_Ellipse)))
1117         {
1118           Handle(Geom2d_Ellipse) Ell1 = *((Handle(Geom2d_Ellipse)*) &PCurve1);
1119           gp_Elips2d theElips = Ell1->Elips2d();
1120           first2 = ElCLib::Parameter( theElips, P1 );
1121           last2  = ElCLib::Parameter( theElips, P2 );
1122         }
1123       else if (PCurve1->IsInstance(STANDARD_TYPE(Geom2d_Parabola)))
1124         {
1125           Handle(Geom2d_Parabola) Parab1 = *((Handle(Geom2d_Parabola)*) &PCurve1);
1126           gp_Parab2d theParab = Parab1->Parab2d();
1127           first2 = ElCLib::Parameter( theParab, P1 );
1128           last2  = ElCLib::Parameter( theParab, P2 );
1129         }
1130       else if (PCurve1->IsInstance(STANDARD_TYPE(Geom2d_Hyperbola)))
1131         {
1132           Handle(Geom2d_Hyperbola) Hypr1 = *((Handle(Geom2d_Hyperbola)*) &PCurve1);
1133           gp_Hypr2d theHypr = Hypr1->Hypr2d();
1134           first2 = ElCLib::Parameter( theHypr, P1 );
1135           last2  = ElCLib::Parameter( theHypr, P2 );
1136         }
1137       newFirst  = Min( first1, first2 );
1138       newLast   = Max( last1, last2 );
1139     }
1140   else
1141     {
1142       Handle(Geom2d_TrimmedCurve) TC1 = new Geom2d_TrimmedCurve( PCurve1, first1, last1 );
1143       Handle(Geom2d_TrimmedCurve) TC2 = new Geom2d_TrimmedCurve( PCurve2, first2, last2 );
1144       Geom2dConvert_CompCurveToBSplineCurve Concat2d( TC1 );
1145       Concat2d.Add( TC2, Precision::Confusion(), After );
1146       newPCurve = Concat2d.BSplineCurve();
1147       if (newPCurve->Continuity() < GeomAbs_C1)
1148         {
1149           Geom2dConvert_ApproxCurve Approx2d( newPCurve, Tol, Continuity, MaxSeg, MaxDeg );
1150           if (Approx2d.HasResult())
1151             newPCurve = Approx2d.Curve();
1152         }
1153       newFirst = newPCurve->FirstParameter();
1154       newLast  = newPCurve->LastParameter();
1155     }
1156
1157   return newPCurve;
1158 }
1159
1160 //=======================================================================
1161 //function : Glue
1162 //purpose  : glue two edges.
1163 //=======================================================================
1164
1165 static TopoDS_Edge Glue(const TopoDS_Edge& E1,
1166                         const TopoDS_Edge& E2,
1167                         const TopoDS_Vertex& Vfirst,
1168                         const TopoDS_Vertex& Vlast,
1169                         const Standard_Boolean After,
1170                         const TopoDS_Face& F1,
1171                         const Standard_Boolean addPCurve1,
1172                         const TopoDS_Face& F2,
1173                         const Standard_Boolean addPCurve2)
1174 {
1175   Standard_Real Tol = 1.e-7;
1176   GeomAbs_Shape Continuity = GeomAbs_C1;
1177   Standard_Integer MaxDeg = 14;
1178   Standard_Integer MaxSeg = 16;
1179
1180   Handle(Geom_Curve) C1, C2, newCurve;
1181   Handle(Geom2d_Curve) PCurve1, PCurve2, newPCurve;
1182   Standard_Real first1, last1, first2, last2, fparam=0., lparam=0.;
1183   Standard_Boolean IsCanonic = Standard_False;
1184
1185   C1 = BRep_Tool::Curve( E1, first1, last1 ); 
1186   if (C1->IsInstance(STANDARD_TYPE(Geom_TrimmedCurve)))
1187     C1 = (*((Handle(Geom_TrimmedCurve)*)&C1))->BasisCurve();
1188
1189   C2 = BRep_Tool::Curve( E2, first2, last2 );
1190   if (C2->IsInstance(STANDARD_TYPE(Geom_TrimmedCurve)))
1191     C2 = (*((Handle(Geom_TrimmedCurve)*)&C2))->BasisCurve();
1192
1193   if (C1 == C2)
1194     {
1195       newCurve = C1;
1196       fparam = Min( first1, first2 );
1197       lparam = Max( last1, last2 );
1198     }
1199   else if (C1->DynamicType() == C2->DynamicType() &&
1200            (C1->IsInstance(STANDARD_TYPE(Geom_Line)) ||
1201             C1->IsKind(STANDARD_TYPE(Geom_Conic))))
1202     {
1203       IsCanonic = Standard_True;
1204       newCurve  = C1;
1205     }
1206   else
1207     {
1208       Handle(Geom_TrimmedCurve) TC1 = new Geom_TrimmedCurve( C1, first1, last1 );
1209       Handle(Geom_TrimmedCurve) TC2 = new Geom_TrimmedCurve( C2, first2, last2 );
1210       GeomConvert_CompCurveToBSplineCurve Concat( TC1 );
1211       Concat.Add( TC2, Precision::Confusion(), After );
1212       newCurve = Concat.BSplineCurve();
1213       if (newCurve->Continuity() < GeomAbs_C1)
1214         {
1215           GeomConvert_ApproxCurve Approx3d( newCurve, Tol, Continuity, MaxSeg, MaxDeg );
1216           if (Approx3d.HasResult())
1217             newCurve = Approx3d.Curve();
1218         }
1219       fparam = newCurve->FirstParameter();
1220       lparam = newCurve->LastParameter();
1221     }
1222
1223   TopoDS_Edge newEdge;
1224   BRep_Builder BB;
1225
1226   if (IsCanonic)
1227     newEdge = BRepLib_MakeEdge( newCurve, Vfirst, Vlast );
1228   else
1229     newEdge = BRepLib_MakeEdge( newCurve, Vfirst, Vlast, fparam, lparam );
1230
1231   Standard_Real newFirst, newLast;
1232   if (addPCurve1)
1233     {
1234       newPCurve = ConcatPCurves( E1, E2, F1, After, newFirst, newLast );
1235       BB.UpdateEdge( newEdge, newPCurve, F1, 0. );
1236       BB.Range( newEdge, F1, newFirst, newLast );
1237     }
1238   if (addPCurve2)
1239     {
1240       newPCurve = ConcatPCurves( E1, E2, F2, After, newFirst, newLast );
1241       BB.UpdateEdge( newEdge, newPCurve, F2, 0. );
1242       BB.Range( newEdge, F2, newFirst, newLast );
1243     }
1244
1245   return newEdge;
1246 }
1247
1248
1249 //=======================================================================
1250 //function : FindNewVerticesOnBoundsOfFace
1251 //purpose  : 
1252 //=======================================================================
1253
1254 static void FindNewVerticesOnBoundsOfFace(const BOPDS_PDS& pDS,
1255                                           const TopoDS_Face& aFace,
1256                                           TopTools_DataMapOfShapeShape& VEmap)
1257 {
1258   TopTools_IndexedMapOfShape OldVertices;
1259   TopExp::MapShapes( aFace, TopAbs_VERTEX, OldVertices );
1260   BOPDS_ListIteratorOfListOfPaveBlock aItLPB;
1261   TopoDS_Vertex V1, V2;
1262
1263   TopExp_Explorer Explo( aFace, TopAbs_EDGE );
1264   for (; Explo.More(); Explo.Next()) {
1265     const TopoDS_Shape& aE = Explo.Current();
1266     Standard_Integer nE = pDS->Index(aE);
1267     //
1268     const BOPDS_ListOfPaveBlock& aLPB = pDS->PaveBlocks(nE);
1269     aItLPB.Initialize(aLPB);
1270     for (; aItLPB.More(); aItLPB.Next()) {
1271       const Handle(BOPDS_PaveBlock)& aPB = aItLPB.Value();
1272       const TopoDS_Edge& aESp = *(TopoDS_Edge*)&pDS->Shape(aPB->Edge());
1273       //
1274       TopExp::Vertices( aESp, V1, V2 );
1275       if (!OldVertices.Contains( V1 )) {
1276         VEmap.Bind( V1, aE );
1277         }
1278       //
1279       if (!OldVertices.Contains( V2 )) {
1280         VEmap.Bind( V2, aE );
1281     }
1282 }
1283   }
1284 }
1285                                    
1286 //=======================================================================
1287 //function : CheckIntersFF
1288 //purpose  : 
1289 //=======================================================================
1290
1291 static Standard_Boolean CheckIntersFF(const BOPDS_PDS& pDS,
1292                                       const TopoDS_Edge& RefEdge,
1293                                       const TopoDS_Face& F1,
1294                                       const TopoDS_Face& F2,
1295                                       TopTools_IndexedMapOfShape& TrueEdges)
1296 {
1297   Standard_Boolean isEl1 = Standard_False, isEl2 = Standard_False;
1298   Standard_Boolean isPlane1 = Standard_False, isPlane2 = Standard_False;
1299
1300   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(F1);
1301   if (aSurf->IsInstance(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
1302     aSurf = (*((Handle(Geom_RectangularTrimmedSurface)*)&aSurf))->BasisSurface();
1303   if (aSurf->IsInstance(STANDARD_TYPE(Geom_Plane)))
1304     isPlane1 = Standard_True;
1305   else if (aSurf->IsKind(STANDARD_TYPE(Geom_ElementarySurface)))
1306     isEl1 = Standard_True;
1307
1308   aSurf = BRep_Tool::Surface(F2);
1309   if (aSurf->IsInstance(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
1310     aSurf = (*((Handle(Geom_RectangularTrimmedSurface)*)&aSurf))->BasisSurface();
1311   if (aSurf->IsInstance(STANDARD_TYPE(Geom_Plane)))
1312     isPlane2 = Standard_True;
1313   else if (aSurf->IsKind(STANDARD_TYPE(Geom_ElementarySurface)))
1314     isEl2 = Standard_True;
1315
1316   if (isPlane1 || isPlane2)
1317     return Standard_True;
1318
1319   if (isEl1 && isEl2)
1320     return Standard_True;
1321
1322   BOPDS_VectorOfInterfFF& aFFs = pDS->InterfFF();
1323   Standard_Integer aNb = aFFs.Extent();
1324   Standard_Integer i, j, nbe = 0;
1325
1326   TopTools_SequenceOfShape Edges;
1327   
1328   for (i = 0; i < aNb; ++i) 
1329     {
1330       BOPDS_InterfFF& aFFi=aFFs(i);
1331       const BOPDS_VectorOfCurve& aBCurves=aFFi.Curves();
1332       Standard_Integer aNbCurves = aBCurves.Extent();
1333       
1334       for (j = 0; j < aNbCurves; ++j) 
1335         {
1336           const BOPDS_Curve& aBC=aBCurves(j);
1337           const BOPDS_ListOfPaveBlock& aSectEdges = aBC.PaveBlocks();
1338           
1339           BOPDS_ListIteratorOfListOfPaveBlock aPBIt;
1340           aPBIt.Initialize(aSectEdges);
1341           
1342           for (; aPBIt.More(); aPBIt.Next())
1343             {
1344               const Handle(BOPDS_PaveBlock)& aPB = aPBIt.Value();
1345               Standard_Integer nSect = aPB->Edge();
1346               const TopoDS_Edge& anEdge = *(TopoDS_Edge*)&pDS->Shape(nSect);
1347               Edges.Append( anEdge );
1348               nbe++;
1349             }
1350         }
1351     }
1352
1353   if (nbe <= 1)
1354     return Standard_True;
1355
1356   //define tangents of RefEdge on start and on end
1357   BRepAdaptor_Curve cref(RefEdge);
1358   gp_Vec RefTangFirst = cref.DN(cref.FirstParameter(), 1);
1359   gp_Vec RefTangLast  = cref.DN(cref.LastParameter(), 1);
1360
1361   //find the start edge and take it from Edges
1362   TopoDS_Edge StartEdge; //, StartEonF1, StartEonF2, EndEonF1, EndEonF2;
1363
1364   TopTools_DataMapOfShapeShape VEmapF1, VEmapF2;
1365   FindNewVerticesOnBoundsOfFace( pDS, F1, VEmapF1 );
1366   FindNewVerticesOnBoundsOfFace( pDS, F2, VEmapF2 );
1367
1368   Standard_Real AngTol = 0.1;
1369   Standard_Boolean V1onBound = Standard_False;
1370   Standard_Boolean V2onBound = Standard_False;
1371   TopoDS_Vertex V1, V2, Vcur;
1372   gp_Vec TangFirst, TangLast, TangCur;
1373   for (i = 1; i <= Edges.Length(); i++)
1374     {
1375       StartEdge = TopoDS::Edge(Edges(i));
1376       TopExp::Vertices( StartEdge, V1, V2 );
1377       V1onBound = VEmapF1.IsBound(V1) || VEmapF2.IsBound(V1); // && ?
1378       V2onBound = VEmapF1.IsBound(V2) || VEmapF2.IsBound(V2); // && ?
1379       if (V1onBound || V2onBound)
1380         {
1381           BRepAdaptor_Curve CE(StartEdge);
1382           TangFirst = CE.DN( CE.FirstParameter(), 1 );
1383           TangLast = CE.DN( CE.LastParameter(), 1 );
1384           if (V1onBound)
1385             {
1386               if (TangFirst.IsParallel( RefTangFirst, AngTol ) ||
1387                   TangFirst.IsParallel( RefTangLast,  AngTol ))
1388                 break; //start edged found
1389             }
1390           else if (V2onBound)
1391             {
1392               if (TangLast.IsParallel( RefTangLast,  AngTol ) ||
1393                   TangLast.IsParallel( RefTangFirst, AngTol ))
1394                 break; //start edged found
1395             }
1396         }
1397     }
1398
1399   if (i > Edges.Length()) //start edged not found
1400     return Standard_False;
1401
1402   if (V1onBound && V2onBound)
1403     {
1404       if ((TangFirst.IsParallel(RefTangFirst,AngTol) && TangLast.IsParallel(RefTangLast,AngTol)) ||
1405           (TangFirst.IsParallel(RefTangLast,AngTol)  && TangLast.IsParallel(RefTangFirst,AngTol)))
1406       {
1407         TrueEdges.Add( Edges(i) );
1408         return Standard_True;
1409       }
1410       else
1411         return Standard_False;
1412     }
1413
1414   //StartEonF1 = (V1onBound)? VEmapF1( V1 ) : VEmapF1( V2 );
1415   //StartEonF2 = (V1onBound)? VEmapF2( V1 ) : VEmapF2( V2 );
1416
1417   TrueEdges.Add( Edges(i) );
1418   Edges.Remove(i);
1419   Vcur    = (V1onBound)? V2 : V1;
1420   TangCur = (V1onBound)? TangLast : TangFirst;
1421   if (V2onBound)
1422     TangCur.Reverse();
1423   
1424   //build the chain from StartEdge till the opposite bound of face
1425   for (;;)
1426     {
1427       TColStd_SequenceOfInteger Candidates;
1428       for (i = 1; i <= Edges.Length(); i++)
1429         {
1430           TopoDS_Edge anEdge = TopoDS::Edge(Edges(i));
1431           TopExp::Vertices( anEdge, V1, V2 );
1432           if (V1.IsSame(Vcur) || V2.IsSame(Vcur))
1433             Candidates.Append(i);
1434         }
1435       if (Candidates.IsEmpty())
1436         {
1437           TrueEdges.Clear();
1438           return Standard_False;
1439         }
1440
1441       Standard_Integer minind = 1;
1442       if (Candidates.Length() > 1)
1443         {
1444           Standard_Real MinAngle = RealLast();
1445           for (i = 1; i <= Candidates.Length(); i++)
1446             {
1447               TopoDS_Edge anEdge = TopoDS::Edge(Edges(Candidates(i)));
1448               TopExp::Vertices( anEdge, V1, V2 );
1449               Standard_Boolean ConnectByFirst = (Vcur.IsSame(V1))? Standard_True : Standard_False;
1450               BRepAdaptor_Curve CE(anEdge);
1451               gp_Vec aTang = (ConnectByFirst)?
1452                 CE.DN( CE.FirstParameter(), 1 ) : CE.DN( CE.LastParameter(), 1 );
1453               if (!ConnectByFirst)
1454                 aTang.Reverse();
1455               Standard_Real anAngle = TangCur.Angle(aTang);
1456               if (anAngle < MinAngle)
1457                 {
1458                   MinAngle = anAngle;
1459                   minind = i;
1460                 }
1461             }
1462         }
1463       TopoDS_Edge CurEdge = TopoDS::Edge(Edges(Candidates(minind)));
1464       TrueEdges.Add( CurEdge );
1465       Edges.Remove(Candidates(minind));
1466       TopExp::Vertices( CurEdge, V1, V2 );
1467       Standard_Boolean ConnectByFirst = (Vcur.IsSame(V1))? Standard_True : Standard_False;
1468       Vcur = (ConnectByFirst)? V2 : V1;
1469       BRepAdaptor_Curve CE(CurEdge);
1470       TangCur = (ConnectByFirst)? CE.DN( CE.LastParameter(), 1 ) : CE.DN( CE.FirstParameter(), 1 );
1471       if (!ConnectByFirst)
1472         TangCur.Reverse();
1473       //check if Vcur is on bounds of faces
1474       if (VEmapF1.IsBound(Vcur) || VEmapF2.IsBound(Vcur))
1475         break;
1476     } //end of for (;;)
1477   
1478   if (TangCur.IsParallel( RefTangFirst, AngTol ) ||
1479       TangCur.IsParallel( RefTangLast,  AngTol ))
1480     return Standard_True;
1481
1482   TrueEdges.Clear();
1483   return Standard_False;
1484 }
1485
1486 //=======================================================================
1487 //function : AssembleEdge
1488 //purpose  : 
1489 //=======================================================================
1490
1491 static TopoDS_Edge AssembleEdge(const BOPDS_PDS& pDS,
1492                                 const TopoDS_Face& F1,
1493                                 const TopoDS_Face& F2,
1494                                 const Standard_Boolean addPCurve1,
1495                                 const Standard_Boolean addPCurve2,
1496                                 const TopTools_SequenceOfShape& EdgesForConcat)
1497 {
1498   TopoDS_Edge CurEdge = TopoDS::Edge( EdgesForConcat(1) );
1499   for (Standard_Integer j = 2; j <= EdgesForConcat.Length(); j++)
1500     {
1501       TopoDS_Edge anEdge = TopoDS::Edge( EdgesForConcat(j) );
1502       Standard_Boolean After = Standard_False;
1503       TopoDS_Vertex Vfirst, Vlast;
1504       if (AreClosed( CurEdge, anEdge ))
1505         {
1506           TopoDS_Vertex V1, V2;
1507           TopExp::Vertices( CurEdge, V1, V2 );
1508           if (IsAutonomVertex( V1, pDS ))
1509             {
1510               After = Standard_False;
1511               Vfirst = Vlast = V2;
1512             }
1513           else
1514             {
1515               After = Standard_True;
1516               Vfirst = Vlast = V1;
1517             }
1518         }
1519       else
1520         {
1521           TopoDS_Vertex CV, V11, V12, V21, V22;
1522           TopExp::CommonVertex( CurEdge, anEdge, CV );
1523           TopExp::Vertices( CurEdge, V11, V12 );
1524           TopExp::Vertices( anEdge,  V21, V22 );
1525           if (V11.IsSame(CV) && V21.IsSame(CV))
1526             {
1527               Vfirst = V22;
1528               Vlast  = V12;
1529             }
1530           else if (V11.IsSame(CV) && V22.IsSame(CV))
1531             {
1532               Vfirst = V21;
1533               Vlast  = V12;
1534             }
1535           else if (V12.IsSame(CV) && V21.IsSame(CV))
1536             {
1537               Vfirst = V11;
1538               Vlast  = V22;
1539             }
1540           else
1541             {
1542               Vfirst = V11;
1543               Vlast  = V21;
1544             }
1545         } //end of else (open wire)
1546       
1547       TopoDS_Edge NewEdge = Glue(CurEdge, anEdge,
1548                                  Vfirst, Vlast, After,
1549                                  F1, addPCurve1, F2, addPCurve2);
1550       CurEdge = NewEdge;
1551     } //end of for (Standard_Integer j = 2; j <= EdgesForConcat.Length(); j++)
1552   
1553   return CurEdge;
1554 }
1555
1556 //=======================================================================
1557 //function : Inter3D
1558 //purpose  : 
1559 //=======================================================================
1560
1561 void BRepOffset_Tool::Inter3D(const TopoDS_Face& F1,
1562                               const TopoDS_Face& F2,
1563                               TopTools_ListOfShape& L1,
1564                               TopTools_ListOfShape& L2,
1565                               const TopAbs_State    Side,
1566                               const TopoDS_Edge&     RefEdge,
1567                               const Standard_Boolean IsRefEdgeDefined)
1568 {
1569 #ifdef DRAW
1570   if (AffichInter) {
1571     char name[256];
1572     sprintf(name,"FF_%d",NbFaces++);
1573     DBRep::Set(name,F1);
1574     sprintf(name,"FF_%d",NbFaces++);
1575     DBRep::Set(name,F2);
1576   }
1577 #endif
1578
1579   TopoDS_Face cpF1=F1; 
1580   TopoDS_Face cpF2=F2;
1581   // create 3D curves on faces
1582   BRepLib::BuildCurves3d(cpF1);
1583   BRepLib::BuildCurves3d(cpF2);
1584  
1585   BOPAlgo_PaveFiller aPF1, aPF2;
1586   BOPCol_ListOfShape aLS;
1587   aLS.Append(cpF1);
1588   aLS.Append(cpF2);
1589   aPF1.SetArguments(aLS);
1590   //
1591   aPF1.Perform();
1592   
1593   BOPAlgo_PaveFiller *pPF = &aPF1;
1594
1595   aLS.Clear();
1596   TopTools_IndexedMapOfShape TrueEdges;
1597   if (IsRefEdgeDefined && !CheckIntersFF( pPF->PDS(), RefEdge, cpF1, cpF2, TrueEdges ))
1598     {
1599       cpF1 = F2;
1600       cpF2 = F1;
1601       aLS.Append(cpF1);
1602       aLS.Append(cpF2);
1603       aPF2.SetArguments(aLS);
1604       aPF2.Perform();
1605       pPF = &aPF2;
1606       CheckIntersFF( pPF->PDS(), RefEdge, cpF1, cpF2, TrueEdges );
1607    }
1608
1609   Standard_Boolean addPCurve1 = 1;
1610   Standard_Boolean addPCurve2 = 1;
1611   
1612   const BOPDS_PDS& pDS = pPF->PDS();
1613   BOPDS_VectorOfInterfFF& aFFs=pDS->InterfFF();
1614   Standard_Integer aNb = aFFs.Extent();
1615   Standard_Integer i = 0, j = 0, k;
1616   // Store Result
1617   L1.Clear(); L2.Clear();
1618   TopAbs_Orientation O1,O2;
1619   
1620   for (i = 0; i < aNb; i++) {
1621     BOPDS_InterfFF& aFFi=aFFs(i);
1622     const BOPDS_VectorOfCurve& aBCurves=aFFi.Curves();
1623         
1624     Standard_Integer aNbCurves = aBCurves.Extent();
1625       
1626     for (j = 0; j < aNbCurves; j++) {
1627       const BOPDS_Curve& aBC=aBCurves(j);
1628       const BOPDS_ListOfPaveBlock& aSectEdges = aBC.PaveBlocks();
1629       
1630       BOPDS_ListIteratorOfListOfPaveBlock aPBIt;
1631       aPBIt.Initialize(aSectEdges);
1632       
1633       for (; aPBIt.More(); aPBIt.Next()) {
1634         const Handle(BOPDS_PaveBlock)& aPB = aPBIt.Value();
1635         Standard_Integer nSect = aPB->Edge();
1636         const TopoDS_Edge& anEdge = *(TopoDS_Edge*)&pDS->Shape(nSect);
1637         if (!TrueEdges.IsEmpty() && !TrueEdges.Contains(anEdge))
1638           continue;
1639         
1640         Standard_Real f, l;
1641         const Handle(Geom_Curve)& aC3DE = BRep_Tool::Curve(anEdge, f, l);
1642         Handle(Geom_TrimmedCurve) aC3DETrim;
1643             
1644         if(!aC3DE.IsNull()) 
1645             aC3DETrim = new Geom_TrimmedCurve(aC3DE, f, l);
1646         
1647         BRep_Builder aBB;
1648         Standard_Real aTolEdge = BRep_Tool::Tolerance(anEdge);
1649                 
1650         if (!BOPTools_AlgoTools2D::HasCurveOnSurface(anEdge, cpF1)) {
1651           Handle(Geom2d_Curve) aC2d = aBC.Curve().FirstCurve2d();
1652           if(!aC3DETrim.IsNull()) {
1653                 Handle(Geom2d_Curve) aC2dNew;
1654                 
1655                 if(aC3DE->IsPeriodic()) {
1656                   BOPTools_AlgoTools2D::AdjustPCurveOnFace(cpF1, f, l,  aC2d, aC2dNew);
1657                   }
1658                 else {
1659                   BOPTools_AlgoTools2D::AdjustPCurveOnFace(cpF1, aC3DETrim, aC2d, aC2dNew); 
1660                   }
1661                 aC2d = aC2dNew;
1662               }
1663               aBB.UpdateEdge(anEdge, aC2d, cpF1, aTolEdge);
1664         }
1665         
1666         if (!BOPTools_AlgoTools2D::HasCurveOnSurface(anEdge, cpF2)) {
1667           Handle(Geom2d_Curve) aC2d = aBC.Curve().SecondCurve2d();
1668           if(!aC3DETrim.IsNull()) {
1669                 Handle(Geom2d_Curve) aC2dNew;
1670                 
1671                 if(aC3DE->IsPeriodic()) {
1672                   BOPTools_AlgoTools2D::AdjustPCurveOnFace(cpF2, f, l,  aC2d, aC2dNew);
1673                   }
1674                 else {
1675                   BOPTools_AlgoTools2D::AdjustPCurveOnFace(cpF2, aC3DETrim, aC2d, aC2dNew); 
1676                   }
1677                 aC2d = aC2dNew;
1678               }
1679               aBB.UpdateEdge(anEdge, aC2d, cpF2, aTolEdge);
1680         }
1681          
1682         OrientSection (anEdge, F1, F2, O1, O2);
1683         if (Side == TopAbs_OUT) {
1684           O1 = TopAbs::Reverse(O1);
1685           O2 = TopAbs::Reverse(O2);
1686         }
1687         
1688         L1.Append (anEdge.Oriented(O1));
1689         L2.Append (anEdge.Oriented(O2));
1690         
1691 #ifdef DRAW
1692         if (AffichInter) {
1693           char name[256];
1694           sprintf(name,"EI_%d",NbNewEdges++);   
1695           DBRep::Set(name,anEdge.Oriented(O1));
1696          
1697         }
1698 #endif       
1699       }
1700     }
1701   }
1702
1703   Standard_Real aSameParTol = Precision::Confusion();
1704   Standard_Boolean isEl1 = Standard_False, isEl2 = Standard_False;
1705
1706   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(cpF1);
1707   if (aSurf->IsInstance(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
1708     aSurf = (*((Handle(Geom_RectangularTrimmedSurface)*)&aSurf))->BasisSurface();
1709   if (aSurf->IsInstance(STANDARD_TYPE(Geom_Plane)))
1710     addPCurve1 = Standard_False;
1711   else if (aSurf->IsKind(STANDARD_TYPE(Geom_ElementarySurface)))
1712     isEl1 = Standard_True;
1713
1714   aSurf = BRep_Tool::Surface(cpF2);
1715   if (aSurf->IsInstance(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
1716     aSurf = (*((Handle(Geom_RectangularTrimmedSurface)*)&aSurf))->BasisSurface();
1717   if (aSurf->IsInstance(STANDARD_TYPE(Geom_Plane)))
1718     addPCurve2 = Standard_False;
1719   else if (aSurf->IsKind(STANDARD_TYPE(Geom_ElementarySurface)))
1720     isEl2 = Standard_True;
1721
1722   if (L1.Extent() > 1 && (!isEl1 || !isEl2)) {
1723     TopTools_SequenceOfShape eseq;
1724     TopTools_SequenceOfShape EdgesForConcat;
1725
1726     if (!TrueEdges.IsEmpty())
1727       {
1728         for (i = TrueEdges.Extent(); i >= 1; i--)
1729           EdgesForConcat.Append( TrueEdges(i) );
1730         TopoDS_Edge theEdge =
1731           AssembleEdge( pDS, cpF1, cpF2, addPCurve1, addPCurve2, EdgesForConcat );
1732         eseq.Append(theEdge);
1733       }
1734     else
1735       {
1736         
1737         TopTools_SequenceOfShape wseq;
1738         TopTools_SequenceOfShape edges;
1739         TopTools_ListIteratorOfListOfShape itl(L1);
1740         for (; itl.More(); itl.Next())
1741           edges.Append( itl.Value() );
1742         while (!edges.IsEmpty())
1743           {
1744             TopoDS_Edge anEdge = TopoDS::Edge( edges.First() );
1745             TopoDS_Wire aWire = BRepLib_MakeWire( anEdge ), resWire;
1746             TColStd_SequenceOfInteger Candidates;
1747             for (k = 1; k <= wseq.Length(); k++)
1748               {
1749                 resWire = TopoDS::Wire(wseq(k));
1750                 if (AreConnex( resWire, aWire, pDS ))
1751                   {
1752                     Candidates.Append( 1 );
1753                     break;
1754                   }
1755               }
1756             if (Candidates.IsEmpty())
1757               {
1758                 wseq.Append( aWire );
1759                 edges.Remove(1);
1760               }
1761             else
1762               {
1763                 for (j = 2; j <= edges.Length(); j++)
1764                   {
1765                     anEdge = TopoDS::Edge( edges(j) );
1766                     //if (anEdge.IsSame(edges(Candidates.First())))
1767                     //continue;
1768                     aWire = BRepLib_MakeWire( anEdge );
1769                     if (AreConnex( resWire, aWire, pDS ))
1770                       Candidates.Append( j );
1771                   }
1772                 Standard_Integer minind = 1;
1773                 if (Candidates.Length() > 1)
1774                   {
1775                     Standard_Real MinAngle = RealLast();
1776                     for (j = 1; j <= Candidates.Length(); j++)
1777                       {
1778                         anEdge = TopoDS::Edge( edges(Candidates(j)) );
1779                         Standard_Real anAngle = AngleWireEdge( resWire, anEdge );
1780                         if (anAngle < MinAngle)
1781                           {
1782                             MinAngle = anAngle;
1783                             minind = j;
1784                           }
1785                       }
1786                   }
1787                 TopoDS_Wire NewWire = BRepLib_MakeWire( resWire, TopoDS::Edge(edges(Candidates(minind))) );
1788                 wseq(k) = NewWire;
1789                 edges.Remove(Candidates(minind));
1790               }
1791           } //end of while (!edges.IsEmpty())
1792         
1793         for (i = 1; i <= wseq.Length(); i++)
1794           {
1795             TopoDS_Wire aWire = TopoDS::Wire(wseq(i));
1796             TopTools_SequenceOfShape EdgesForConcat;
1797             if (aWire.Closed())
1798               {
1799                 TopoDS_Vertex StartVertex;
1800                 TopoDS_Edge StartEdge;
1801                 Standard_Boolean StartFound = Standard_False;
1802                 TopTools_ListOfShape Elist;
1803                 
1804                 TopoDS_Iterator itw(aWire);
1805                 for (; itw.More(); itw.Next())
1806                   {
1807                     TopoDS_Edge anEdge = TopoDS::Edge(itw.Value());
1808                     if (StartFound)
1809                       Elist.Append(anEdge);
1810                     else
1811                       {
1812                         TopoDS_Vertex V1, V2;
1813                         TopExp::Vertices( anEdge, V1, V2 );
1814                         if (!IsAutonomVertex( V1, pDS ))
1815                           {
1816                             StartVertex = V2;
1817                             StartEdge = anEdge;
1818                             StartFound = Standard_True;
1819                           }
1820                         else if (!IsAutonomVertex( V2, pDS ))
1821                           {
1822                             StartVertex = V1;
1823                             StartEdge = anEdge;
1824                             StartFound = Standard_True;
1825                           }
1826                         else
1827                           Elist.Append(anEdge);
1828                       }
1829                   } //end of for (; itw.More(); itw.Next())
1830                 if (!StartFound)
1831                   {
1832                     itl.Initialize(Elist);
1833                     StartEdge = TopoDS::Edge(itl.Value());
1834                     Elist.Remove(itl);
1835                     TopoDS_Vertex V1, V2;
1836                     TopExp::Vertices( StartEdge, V1, V2 );
1837                     StartVertex = V1;
1838                   }
1839                 EdgesForConcat.Append( StartEdge );
1840                 while (!Elist.IsEmpty())
1841                   {
1842                     for (itl.Initialize(Elist); itl.More(); itl.Next())
1843                       {
1844                         TopoDS_Edge anEdge = TopoDS::Edge(itl.Value());
1845                         TopoDS_Vertex V1, V2;
1846                         TopExp::Vertices( anEdge, V1, V2 );
1847                         if (V1.IsSame(StartVertex))
1848                           {
1849                             StartVertex = V2;
1850                             EdgesForConcat.Append( anEdge );
1851                             Elist.Remove(itl);
1852                             break;
1853                           }
1854                         else if (V2.IsSame(StartVertex))
1855                           {
1856                             StartVertex = V1;
1857                             EdgesForConcat.Append( anEdge );
1858                             Elist.Remove(itl);
1859                             break;
1860                           }
1861                       }
1862                   } //end of while (!Elist.IsEmpty())
1863               } //end of if (aWire.Closed())
1864             else
1865               {
1866                 BRepTools_WireExplorer Wexp( aWire );
1867                 for (; Wexp.More(); Wexp.Next())
1868                   EdgesForConcat.Append( Wexp.Current() );
1869               }
1870             
1871             TopoDS_Edge theEdge =
1872               AssembleEdge( pDS, cpF1, cpF2, addPCurve1, addPCurve2, EdgesForConcat );
1873             eseq.Append( theEdge );
1874           }
1875       } //end of else (when TrueEdges is empty)
1876     
1877     if (eseq.Length() < L1.Extent())
1878       {
1879         L1.Clear();
1880         L2.Clear();
1881         for (i = 1; i <= eseq.Length(); i++)
1882           {
1883             TopoDS_Edge anEdge = TopoDS::Edge(eseq(i));
1884             BRepLib::SameParameter(anEdge, aSameParTol, Standard_True);
1885             Standard_Real EdgeTol = BRep_Tool::Tolerance(anEdge);
1886 #ifdef OCCT_DEBUG
1887             cout<<"Tolerance of glued E =      "<<EdgeTol<<endl;
1888 #endif
1889             if (EdgeTol > 1.e-2)
1890               continue;
1891
1892             if (EdgeTol >= 1.e-4)
1893               {
1894                 ReconstructPCurves(anEdge);
1895                 BRepLib::SameParameter(anEdge, aSameParTol, Standard_True);
1896 #ifdef OCCT_DEBUG
1897                 cout<<"After projection tol of E = "<<BRep_Tool::Tolerance(anEdge)<<endl;
1898 #endif
1899               }
1900
1901             OrientSection( anEdge, F1, F2, O1, O2 );
1902             if (Side == TopAbs_OUT)
1903               {
1904                 O1 = TopAbs::Reverse(O1);
1905                 O2 = TopAbs::Reverse(O2);
1906               }
1907             
1908             L1.Append( anEdge.Oriented(O1) );
1909             L2.Append( anEdge.Oriented(O2) );
1910           }
1911       }
1912   } //end of if (L1.Extent() > 1)
1913
1914   else
1915     {
1916       TopTools_ListIteratorOfListOfShape itl(L1);
1917       for (; itl.More(); itl.Next())
1918         {
1919           const TopoDS_Edge& anEdge = TopoDS::Edge( itl.Value() );
1920           BRepLib::SameParameter(anEdge, aSameParTol, Standard_True);
1921         }
1922     }
1923 }
1924
1925 //=======================================================================
1926 //function : TryProject
1927 //purpose  : 
1928 //=======================================================================
1929
1930 Standard_Boolean BRepOffset_Tool::TryProject
1931 (const TopoDS_Face&          F1,
1932  const TopoDS_Face&          F2,
1933  const TopTools_ListOfShape& Edges,
1934        TopTools_ListOfShape& LInt1,
1935        TopTools_ListOfShape& LInt2,
1936  const TopAbs_State          Side,
1937  const Standard_Real         TolConf)
1938 {
1939 #ifdef DRAW
1940   if (AffichInter) {
1941     char name[256];
1942     sprintf(name,"FF_%d",NbFaces++);
1943     DBRep::Set(name,F1);
1944     sprintf(name,"FF_%d",NbFaces++);
1945     DBRep::Set(name,F2);
1946   }
1947 #endif
1948
1949   // try to find if the edges <Edges> are laying on the face F1.
1950   LInt1.Clear(); LInt2.Clear();
1951   TopTools_ListIteratorOfListOfShape it(Edges);
1952   Standard_Boolean     isOk = Standard_True;
1953   Standard_Boolean     Ok   = Standard_True;
1954   TopAbs_Orientation   O1,O2;
1955   Handle(Geom_Surface) Bouchon = BRep_Tool::Surface(F1);
1956   BRep_Builder B;
1957
1958   for ( ; it.More(); it.Next()) {
1959     TopLoc_Location L;
1960     Standard_Real f,l;
1961     TopoDS_Edge CurE     = TopoDS::Edge(it.Value());
1962     Handle(Geom_Curve) C = BRep_Tool::Curve(CurE,L,f,l);
1963     if (C.IsNull()) {
1964       BRepLib::BuildCurve3d(CurE,BRep_Tool::Tolerance(CurE));
1965       C  = BRep_Tool::Curve(CurE,L,f,l);
1966     }
1967     C = new Geom_TrimmedCurve(C,f,l);
1968     if ( !L.IsIdentity()) C->Transform(L);
1969     Standard_Real TolReached;
1970     isOk = IsOnSurface(C,Bouchon,TolConf,TolReached);
1971     
1972     if ( isOk) {
1973       B.UpdateEdge(CurE,TolReached);
1974       BuildPCurves(CurE,F1);
1975       OrientSection (CurE,F1,F2,O1,O2);
1976       if (Side == TopAbs_OUT) {
1977         O1 = TopAbs::Reverse(O1);
1978         O2 = TopAbs::Reverse(O2);
1979       }
1980       LInt1.Append (CurE.Oriented(O1));
1981       LInt2.Append (CurE.Oriented(O2));
1982 #ifdef DRAW
1983       if (AffichInter) {
1984         char name[256];
1985         sprintf(name,"EI_%d",NbNewEdges++);     
1986         DBRep::Set(name,CurE.Oriented(O1));
1987       }
1988 #endif      
1989     }
1990     else 
1991       Ok = Standard_False;
1992   }
1993   return Ok;
1994 }
1995
1996
1997 //=======================================================================
1998 //function : InterOrExtent
1999 //purpose  : 
2000 //=======================================================================
2001
2002 void BRepOffset_Tool::InterOrExtent(const TopoDS_Face& F1,
2003                                     const TopoDS_Face& F2,
2004                                     TopTools_ListOfShape& L1,
2005                                     TopTools_ListOfShape& L2,
2006                                     const TopAbs_State    Side)
2007 {
2008 #ifdef DRAW
2009   if (AffichInter) {
2010     char name[256];
2011     sprintf(name,"FF_%d",NbFaces++);
2012     DBRep::Set(name,F1);
2013     sprintf(name,"FF_%d",NbFaces++);
2014     DBRep::Set(name,F2);
2015   }
2016 #endif
2017
2018   Handle (Geom_Curve) CI;
2019   TopoDS_Edge E;
2020   TopAbs_Orientation O1,O2;
2021   L1.Clear(); L2.Clear();
2022   Handle (Geom_Surface) S1 = BRep_Tool::Surface(F1);
2023   Handle (Geom_Surface) S2 = BRep_Tool::Surface(F2);  
2024
2025   if (S1->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
2026     Handle(Geom_RectangularTrimmedSurface) RTS ;
2027     RTS = *((Handle(Geom_RectangularTrimmedSurface)*) &S1);
2028     if (RTS->BasisSurface()->DynamicType() == STANDARD_TYPE(Geom_Plane)) {
2029       S1 = RTS->BasisSurface();
2030     }
2031   }
2032   if (S2->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
2033     Handle(Geom_RectangularTrimmedSurface) RTS ;
2034     RTS = *((Handle(Geom_RectangularTrimmedSurface)*) &S2);
2035     if (RTS->BasisSurface()->DynamicType() == STANDARD_TYPE(Geom_Plane)) {
2036       S2 = RTS->BasisSurface();
2037     }
2038   }
2039
2040   GeomInt_IntSS Inter  (S1,S2, Precision::Confusion());
2041
2042   if (Inter.IsDone()) {
2043     for (Standard_Integer i = 1; i <= Inter.NbLines(); i++) {
2044       CI = Inter.Line(i);
2045       
2046       if (ToSmall(CI)) continue;
2047       TopoDS_Edge E = BRepLib_MakeEdge(CI);
2048       BuildPCurves (E,F1);
2049       BuildPCurves (E,F2);
2050       OrientSection (E,F1,F2,O1,O2);
2051       if (Side == TopAbs_OUT) {
2052         O1 = TopAbs::Reverse(O1);
2053         O2 = TopAbs::Reverse(O2);
2054       }
2055       L1.Append (E.Oriented(O1));
2056       L2.Append (E.Oriented(O2));
2057 #ifdef DRAW
2058       if (AffichInter) {
2059         char name[256];
2060         sprintf(name,"EI_%d",NbNewEdges++);     
2061         DBRep::Set(name,E.Oriented(O1));
2062       }
2063 #endif      
2064     }
2065   }
2066 }
2067
2068 //=======================================================================
2069 //function : ExtentEdge
2070 //purpose  : 
2071 //=======================================================================
2072
2073 static void ExtentEdge(const TopoDS_Face& F,
2074                        const TopoDS_Face& EF,
2075                        const TopoDS_Edge& E,
2076                        TopoDS_Edge&       NE)
2077 {
2078   BRepAdaptor_Curve CE(E);
2079   GeomAbs_CurveType Type = CE.GetType();
2080   TopoDS_Shape aLocalEdge = E.EmptyCopied();
2081   NE = TopoDS::Edge(aLocalEdge); 
2082 //  NE = TopoDS::Edge(E.EmptyCopied()); 
2083
2084   if (Type == GeomAbs_Line || Type == GeomAbs_Circle || Type == GeomAbs_Ellipse || 
2085       Type == GeomAbs_Hyperbola || Type == GeomAbs_Parabola) {
2086     return;
2087   }
2088   // Extension en tangence jusqu'au bord de la surface.
2089   Standard_Real   PMax = 1.e2;
2090   TopLoc_Location L;
2091   Handle(Geom_Surface) S = BRep_Tool::Surface(F,L);
2092   Standard_Real umin,umax,vmin,vmax;
2093
2094   S->Bounds(umin,umax,vmin,vmax);
2095   umin = Max(umin,-PMax);vmin = Max(vmin,-PMax);
2096   umax = Min(umax, PMax);vmax = Min(vmax, PMax);
2097
2098  
2099   Standard_Real f,l;
2100   Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E,F,f,l);
2101
2102   //calcul point cible . ie point d'intersection du prolongement tangent et des bords.
2103   gp_Pnt2d P;
2104   gp_Vec2d Tang;
2105   C2d->D1(CE.FirstParameter(),P,Tang);
2106   Standard_Real tx,ty,tmin;
2107   tx = ty = Precision::Infinite();
2108   if (Abs(Tang.X()) > Precision::Confusion())
2109     tx = Min (Abs((umax - P.X())/Tang.X()), Abs((umin - P.X())/Tang.X()));
2110   if (Abs(Tang.Y()) > Precision::Confusion())
2111     ty = Min (Abs((vmax - P.Y())/Tang.Y()), Abs((vmin - P.Y())/Tang.Y()));
2112   tmin = Min (tx,ty);
2113   Tang = tmin*Tang;
2114   gp_Pnt2d  PF2d (P.X() - Tang.X(),P.Y() - Tang.Y());
2115
2116   C2d->D1(CE.LastParameter(),P,Tang);
2117   tx = ty = Precision::Infinite();
2118   if (Abs(Tang.X()) > Precision::Confusion())
2119     tx = Min (Abs((umax - P.X())/Tang.X()), Abs((umin - P.X())/Tang.X()));
2120   if (Abs(Tang.Y()) > Precision::Confusion())
2121     ty = Min (Abs((vmax - P.Y())/Tang.Y()), Abs((vmin - P.Y())/Tang.Y()));
2122   tmin = Min (tx,ty);
2123   Tang = tmin*Tang;
2124   gp_Pnt2d  PL2d (P.X() + Tang.X(),P.Y() + Tang.Y());
2125
2126   Handle(Geom_Curve) CC = GeomAPI::To3d(C2d,gp_Pln(gp::XOY()));
2127   gp_Pnt PF(PF2d.X(),PF2d.Y(),0.);
2128   gp_Pnt PL(PL2d.X(),PL2d.Y(),0.);
2129
2130   Handle(Geom_BoundedCurve) ExtC = Handle(Geom_BoundedCurve)::DownCast(CC);
2131   if (ExtC.IsNull()) return;
2132
2133   GeomLib::ExtendCurveToPoint(ExtC,PF,1,0);
2134   GeomLib::ExtendCurveToPoint(ExtC,PL,1,1); 
2135
2136   Handle(Geom2d_Curve) CNE2d = GeomAPI::To2d(ExtC,gp_Pln(gp::XOY()));
2137
2138   //Construction de la nouvelle arrete;
2139   BRep_Builder B;
2140   B.MakeEdge(NE);
2141 //  B.UpdateEdge (NE,CNE2d,F,BRep_Tool::Tolerance(E));
2142   B.UpdateEdge (NE,CNE2d,EF,BRep_Tool::Tolerance(E));
2143   B.Range (NE,CNE2d->FirstParameter(), CNE2d->LastParameter());
2144   NE.Orientation(E.Orientation());
2145 #ifdef DRAW
2146   if (AffichExtent) {
2147     char name[256];
2148     sprintf (name,"F_%d",NbExtE);
2149     DBRep::Set(name,EF);
2150     sprintf (name,"OE_%d",NbExtE);
2151     DBRep::Set (name,E);
2152     sprintf (name,"ExtE_%d",NbExtE++);
2153     DBRep::Set(name,NE);
2154   }
2155 #endif
2156 }
2157
2158 //=======================================================================
2159 //function : ProjectVertexOnEdge
2160 //purpose  : 
2161 //=======================================================================
2162
2163 static Standard_Boolean  ProjectVertexOnEdge(TopoDS_Vertex&     V,
2164                                              const TopoDS_Edge& E,
2165                                              Standard_Real      TolConf)
2166
2167 #ifdef DRAW
2168   if (AffichExtent) {
2169     DBRep::Set("V",V); 
2170     DBRep::Set("E",E);
2171   }
2172 #endif
2173   BRep_Builder    B;
2174   Standard_Real   f,l;
2175   Standard_Real U = 0.;
2176   TopLoc_Location L;
2177   Standard_Boolean found = Standard_False;
2178
2179   gp_Pnt            P = BRep_Tool::Pnt  (V);  
2180   BRepAdaptor_Curve C = BRepAdaptor_Curve(E);
2181   f = C.FirstParameter(); l = C.LastParameter();
2182
2183   if (V.Orientation() == TopAbs_FORWARD) {
2184     if (Abs(f) < Precision::Infinite()) { 
2185       gp_Pnt PF = C.Value (f);
2186       if (PF.IsEqual(P,TolConf)) {
2187         U = f;
2188         found = Standard_True;
2189       }
2190     }
2191   }
2192   if (V.Orientation() == TopAbs_REVERSED) {
2193     if (!found && Abs(l) < Precision::Infinite()) {
2194       gp_Pnt PL = C.Value (l);
2195       if (PL.IsEqual(P,TolConf)) {
2196         U = l;
2197         found = Standard_True;
2198       }
2199     }
2200   }
2201   if (!found) {
2202     Extrema_ExtPC Proj(P,C);
2203     if (Proj.IsDone() && Proj.NbExt() > 0) {
2204       Standard_Real Dist2,Dist2Min = Proj.SquareDistance(1);
2205       U = Proj.Point(1).Parameter();
2206       for (Standard_Integer i = 2; i <= Proj.NbExt(); i++) {
2207         Dist2 = Proj.SquareDistance(i);
2208         if (Dist2 < Dist2Min) {
2209           Dist2Min = Dist2;
2210           U = Proj.Point(i).Parameter();
2211         }
2212       }
2213       found = Standard_True;
2214     }
2215   }
2216
2217 #ifdef OCCT_DEBUG
2218   if (AffichExtent) {
2219     Standard_Real Dist = P.Distance(C.Value(U));
2220     if (Dist > TolConf) {
2221       cout << " ProjectVertexOnEdge :distance vertex edge :"<<Dist<<endl;
2222     }
2223     if (U < f - Precision::Confusion() || 
2224         U > l + Precision::Confusion()) {
2225       cout << " ProjectVertexOnEdge : hors borne :"<<endl;
2226       cout << " f = "<<f<<" l ="<<l<< " U ="<<U<<endl;
2227     }
2228   }
2229   if (!found) {
2230     cout <<"BRepOffset_Tool::ProjectVertexOnEdge Parameter no found"<<endl;
2231     if (Abs(f) < Precision::Infinite() && 
2232         Abs(l) < Precision::Infinite()) {
2233 #ifdef DRAW
2234       DBRep::Set("E",E);
2235 #endif
2236     }
2237   }    
2238 #endif 
2239   if (found) {
2240     TopoDS_Shape aLocalShape = E.Oriented(TopAbs_FORWARD);
2241     TopoDS_Edge EE = TopoDS::Edge(aLocalShape);
2242     aLocalShape = V.Oriented(TopAbs_INTERNAL);
2243 //    TopoDS_Edge EE = TopoDS::Edge(E.Oriented(TopAbs_FORWARD));
2244     B.UpdateVertex(TopoDS::Vertex(aLocalShape),
2245                    U,EE,BRep_Tool::Tolerance(E));
2246     
2247   }
2248   return found;
2249 }
2250
2251 //=======================================================================
2252 //function : Inter2d                                    
2253 //purpose  : 
2254 //=======================================================================
2255
2256 void BRepOffset_Tool::Inter2d (const TopoDS_Face&    F,
2257                                const TopoDS_Edge&    E1,
2258                                const TopoDS_Edge&    E2,
2259                                TopTools_ListOfShape& LV,
2260                                const Standard_Real   TolConf) 
2261 {
2262 #ifdef DRAW
2263   if (AffichExtent) {
2264     DBRep::Set("E1",E1); 
2265     DBRep::Set("E2",E2);
2266     DBRep::Set("F",F);
2267   }
2268 #endif
2269   BRep_Builder  B;
2270   Standard_Real fl1[2],fl2[2];
2271   LV.Clear();
2272   
2273   // Si l edge a ete etendu les pcurves ne sont pas forcement 
2274   // a jour.
2275   BuildPCurves(E1,F);
2276   BuildPCurves(E2,F);
2277   
2278
2279   // Construction des curves 3d si elles n existent pas 
2280   // utile pour coder correctement les parametres des vertex 
2281   // d intersection sur les edges.
2282   //TopLoc_Location L;
2283   //Standard_Real   f,l;
2284   //Handle(Geom_Curve) C3d1 = BRep_Tool::Curve(E1,L,f,l);
2285   //if (C3d1.IsNull()) {
2286   //  BRepLib::BuildCurve3d(E1,BRep_Tool::Tolerance(E1));
2287   //}
2288   //Handle(Geom_Curve) C3d2 = BRep_Tool::Curve(E2,L,f,l);
2289   //if (C3d2.IsNull()) {
2290   //  BRepLib::BuildCurve3d(E2,BRep_Tool::Tolerance(E2));
2291   //}
2292   
2293   Standard_Integer NbPC1 = 1, NbPC2 = 1;
2294   if (BRep_Tool::IsClosed(E1,F)) NbPC1++;
2295   if (BRep_Tool::IsClosed(E2,F)) NbPC2++;
2296   
2297   Handle(Geom_Surface) S  = BRep_Tool::Surface(F);
2298   Handle(Geom2d_Curve) C1, C2;
2299   Standard_Boolean YaSol = Standard_False;
2300   Standard_Integer itry  = 0;
2301
2302   while (!YaSol && itry < 2) {
2303     for ( Standard_Integer i = 1; i <= NbPC1 ; i++) {
2304         TopoDS_Shape aLocalEdge = E1.Reversed();
2305       if (i == 1)  C1 = BRep_Tool::CurveOnSurface(E1,F,fl1[0],fl1[1]);
2306       else         C1 = BRep_Tool::CurveOnSurface(TopoDS::Edge(aLocalEdge),
2307                                                   F,fl1[0],fl1[1]);
2308 //      if (i == 1)  C1 = BRep_Tool::CurveOnSurface(E1,F,fl1[0],fl1[1]);
2309 //     else         C1 = BRep_Tool::CurveOnSurface(TopoDS::Edge(E1.Reversed()),
2310 //                                                F,fl1[0],fl1[1]);
2311       for ( Standard_Integer j = 1; j <= NbPC2; j++ ) {
2312         TopoDS_Shape aLocalEdge = E2.Reversed();
2313         if (j == 1)  C2 = BRep_Tool::CurveOnSurface(E2,F,fl2[0],fl2[1]);
2314         else         C2 = BRep_Tool::CurveOnSurface(TopoDS::Edge(aLocalEdge),
2315                                                     F,fl2[0],fl2[1]);
2316 //      if (j == 1)  C2 = BRep_Tool::CurveOnSurface(E2,F,fl2[0],fl2[1]);
2317 //      else         C2 = BRep_Tool::CurveOnSurface(TopoDS::Edge(E2.Reversed()),
2318 //                                                  F,fl2[0],fl2[1]);
2319 #ifdef OCCT_DEBUG
2320         if (C1.IsNull() || C2.IsNull()) {
2321           cout <<"Inter2d : Pas de pcurve"<<endl;
2322 #ifdef DRAW
2323           DBRep::Set("E1",E1); 
2324           DBRep::Set("E2",E2);
2325           DBRep::Set("F",F);
2326 #endif
2327           return;
2328         }
2329 #endif
2330         Standard_Real    U1 = 0.,U2 = 0.;
2331         gp_Pnt2d         P2d;   
2332         if (itry == 1) {
2333           fl1[0] = C1->FirstParameter(); fl1[1] = C1->LastParameter();
2334           fl2[0] = C2->FirstParameter(); fl2[1] = C2->LastParameter();
2335         }
2336         Geom2dAdaptor_Curve   AC1(C1,fl1[0],fl1[1]);
2337         Geom2dAdaptor_Curve   AC2(C2,fl2[0],fl2[1]);
2338
2339         if (itry == 0) {
2340           gp_Pnt2d P1[2],P2[2];
2341           P1[0] = C1->Value(fl1[0]); P1[1] = C1->Value(fl1[1]);
2342           P2[0] = C2->Value(fl2[0]); P2[1] = C2->Value(fl2[1]);
2343
2344           Standard_Integer i1 ;
2345           for ( i1 = 0; i1 < 2; i1++) {
2346             for (Standard_Integer i2 = 0; i2 < 2; i2++) {
2347               if (Abs(fl1[i1]) < Precision::Infinite() &&
2348                   Abs(fl2[i2]) < Precision::Infinite()   ) {
2349                 if (P1[i1].IsEqual(P2[i2],TolConf)) {
2350                   YaSol = Standard_True;
2351                   U1  = fl1[i1]; U2 = fl2[i2];
2352                   P2d = C1->Value(U1);
2353                 }
2354               }
2355             }
2356           }
2357           if (!YaSol)
2358             for (i1 = 0; i1 < 2; i1++)
2359               {
2360                 Extrema_ExtPC2d extr( P1[i1], AC2 );
2361                 if (extr.IsDone() && extr.NbExt() > 0)
2362                   {
2363                     Standard_Real Dist2, Dist2Min = extr.SquareDistance(1);
2364                     Standard_Integer IndexMin = 1;
2365                     for (Standard_Integer ind = 2; ind <= extr.NbExt(); ind++)
2366                       {
2367                         Dist2 = extr.SquareDistance(ind);
2368                         if (Dist2 < Dist2Min)
2369                           {
2370                             Dist2Min = Dist2;
2371                             IndexMin = ind;
2372                           }
2373                       }
2374             if (Dist2Min <= Precision::SquareConfusion())
2375                       {
2376                         YaSol = Standard_True;
2377                         P2d = P1[i1];
2378                         U1 = fl1[i1];
2379                         U2 = (extr.Point(IndexMin)).Parameter();
2380                         break;
2381                       }
2382                   }
2383               }
2384           if (!YaSol)
2385             for (Standard_Integer i2 = 0; i2 < 2; i2++)
2386               {
2387                 Extrema_ExtPC2d extr( P2[i2], AC1 );
2388                 if (extr.IsDone() && extr.NbExt() > 0)
2389                   {
2390                     Standard_Real Dist2, Dist2Min = extr.SquareDistance(1);
2391                     Standard_Integer IndexMin = 1;
2392                     for (Standard_Integer ind = 2; ind <= extr.NbExt(); ind++)
2393                       {
2394                         Dist2 = extr.SquareDistance(ind);
2395                         if (Dist2 < Dist2Min)
2396                           {
2397                             Dist2Min = Dist2;
2398                             IndexMin = ind;
2399                           }
2400                       }
2401             if (Dist2Min <= Precision::SquareConfusion())
2402                       {
2403                         YaSol = Standard_True;
2404                         P2d = P2[i2];
2405                         U2 = fl2[i2];
2406                         U1 = (extr.Point(IndexMin)).Parameter();
2407                         break;
2408                       }
2409                   }
2410               }
2411         }
2412         
2413         if (!YaSol) {
2414           Geom2dInt_GInter Inter (AC1,AC2,TolConf,TolConf);
2415           
2416           if (!Inter.IsEmpty() && Inter.NbPoints() > 0) {
2417             YaSol = Standard_True;
2418             U1  = Inter.Point(1).ParamOnFirst();
2419             U2  = Inter.Point(1).ParamOnSecond();
2420             P2d = Inter.Point(1).Value();
2421           }
2422           else if (!Inter.IsEmpty() && Inter.NbSegments() > 0) {
2423             YaSol = Standard_True;
2424             IntRes2d_IntersectionSegment Seg = Inter.Segment(1);
2425             IntRes2d_IntersectionPoint IntP1 = Seg.FirstPoint();
2426             IntRes2d_IntersectionPoint IntP2 = Seg.LastPoint();
2427             Standard_Real U1on1 = IntP1.ParamOnFirst();
2428             Standard_Real U1on2 = IntP2.ParamOnFirst();
2429             Standard_Real U2on1 = IntP1.ParamOnSecond();
2430             Standard_Real U2on2 = IntP2.ParamOnSecond();
2431 #ifdef OCCT_DEBUG
2432             cout << " BRepOffset_Tool::Inter2d SEGMENT d intersection" << endl;
2433             cout << "     ===> Parametres sur Curve1 : ";
2434             cout << U1on1 << " " << U1on2 << endl;
2435             cout << "     ===> Parametres sur Curve2 : ";
2436             cout << U2on1 << " " << U2on2 << endl;
2437 #endif
2438             U1 = (U1on1 + U1on2)/2.;
2439             U2 = (U2on1 + U2on2)/2.;
2440             gp_Pnt2d P2d1 = C1->Value(U1);
2441             gp_Pnt2d P2d2 = C2->Value(U2);
2442             P2d.SetX( (P2d1.X() + P2d2.X()) / 2.);
2443             P2d.SetY( (P2d1.Y() + P2d2.Y()) / 2.);
2444           }
2445         }
2446         if (YaSol) {
2447           gp_Pnt        P   = S->Value(P2d.X(),P2d.Y());
2448           TopoDS_Vertex V = BRepLib_MakeVertex(P);
2449           V.Orientation(TopAbs_INTERNAL);
2450           TopoDS_Shape aLocalEdge = E1.Oriented(TopAbs_FORWARD);
2451           B.UpdateVertex(V,U1,TopoDS::Edge(aLocalEdge),TolConf);
2452           aLocalEdge = E2.Oriented(TopAbs_FORWARD);
2453           B.UpdateVertex(V,U2,TopoDS::Edge(aLocalEdge),TolConf);
2454 //        B.UpdateVertex(V,U1,TopoDS::Edge(E1.Oriented(TopAbs_FORWARD)),TolConf);
2455 //        B.UpdateVertex(V,U2,TopoDS::Edge(E2.Oriented(TopAbs_FORWARD)),TolConf);
2456           LV.Append(V);
2457         }
2458       }
2459     }
2460     itry++;
2461   }
2462
2463   if (LV.Extent() > 1) {
2464     //------------------------------------------------
2465     // garde seulement les vertex les plus proches du 
2466     //debut et de la fin. 
2467     //------------------------------------------------
2468     TopTools_ListIteratorOfListOfShape it(LV);
2469     TopoDS_Vertex         VF,VL;
2470     Standard_Real         UMin =  Precision::Infinite();
2471     Standard_Real         UMax = -Precision::Infinite();
2472     Standard_Real         U;
2473
2474     for ( ; it.More(); it.Next()) {
2475       TopoDS_Vertex CV = TopoDS::Vertex(it.Value());
2476       TopoDS_Shape aLocalEdge = E1.Oriented(TopAbs_FORWARD);
2477       U = BRep_Tool::Parameter(CV,TopoDS::Edge(aLocalEdge));
2478 //      U = BRep_Tool::Parameter(CV,TopoDS::Edge(E1.Oriented(TopAbs_FORWARD)));
2479       if ( U < UMin) {
2480         VF = CV; UMin = U;
2481       }
2482       if ( U > UMax) {
2483         VL = CV; UMax = U;
2484       }
2485     }
2486     LV.Clear();LV.Append(VF); LV.Append(VL);
2487   }
2488
2489 #ifdef OCCT_DEBUG
2490   if (!YaSol) {
2491     cout <<"Inter2d : Pas de solution"<<endl;
2492 #ifdef DRAW
2493     DBRep::Set("E1",E1); 
2494     DBRep::Set("E2",E2);
2495     DBRep::Set("F",F);
2496 #endif
2497   }
2498 #endif    
2499 }
2500
2501 //=======================================================================
2502 //function : SelectEdge
2503 //purpose  : 
2504 //=======================================================================
2505
2506 static void SelectEdge (const TopoDS_Face& /*F*/,
2507                         const TopoDS_Face& /*EF*/,
2508                         const TopoDS_Edge& E,
2509                         TopTools_ListOfShape& LInt)
2510 {
2511  //------------------------------------------------------------
2512   // detrompeur sur les intersections sur les faces periodiques
2513   //------------------------------------------------------------
2514    TopTools_ListIteratorOfListOfShape it(LInt);
2515   Standard_Real dU = 1.0e100;
2516   TopoDS_Edge   GE;
2517
2518   Standard_Real Fst, Lst, tmp;
2519   BRep_Tool::Range(E, Fst, Lst);
2520   BRepAdaptor_Curve  Ad1(E);
2521  
2522   gp_Pnt PFirst = Ad1.Value( Fst );  
2523   gp_Pnt PLast  = Ad1.Value( Lst );  
2524
2525   //----------------------------------------------------------------------
2526   // Selection de l edge qui couvre le plus le domaine de l edge initiale.
2527   //---------------------------------------------------------------------- 
2528   for (; it.More(); it.Next()) {
2529     const TopoDS_Edge& EI = TopoDS::Edge(it.Value());
2530
2531     BRep_Tool::Range(EI, Fst, Lst);
2532     BRepAdaptor_Curve  Ad2(EI);
2533     gp_Pnt P1 = Ad2.Value(Fst);
2534     gp_Pnt P2 = Ad2.Value(Lst);
2535        
2536     tmp = P1.Distance(PFirst) + P2.Distance(PLast);
2537     if( tmp <= dU ) {
2538       dU = tmp;
2539       GE = EI;
2540     } 
2541
2542   }
2543   LInt.Clear(); 
2544   LInt.Append(GE);
2545 }
2546
2547
2548 //=======================================================================
2549 //function : Init
2550 //purpose  : 
2551 //=======================================================================
2552
2553 static void MakeFace(const Handle(Geom_Surface)& S,
2554                      const Standard_Real Um,
2555                      const Standard_Real UM,
2556                      const Standard_Real Vm,
2557                      const Standard_Real VM,
2558                      const Standard_Boolean isVminDegen,
2559                      const Standard_Boolean isVmaxDegen,
2560                      TopoDS_Face&        F)
2561 {
2562   Standard_Real UMin = Um;
2563   Standard_Real UMax = UM;
2564   Standard_Real VMin = Vm;
2565   Standard_Real VMax = VM;
2566   Standard_Real epsilon = Precision::Confusion();
2567
2568   Standard_Real umin,umax,vmin,vmax;
2569   S->Bounds(umin,umax,vmin,vmax);
2570
2571
2572   // compute infinite flags
2573   Standard_Boolean umininf = Precision::IsNegativeInfinite(UMin);
2574   Standard_Boolean umaxinf = Precision::IsPositiveInfinite(UMax);
2575   Standard_Boolean vmininf = Precision::IsNegativeInfinite(VMin);
2576   Standard_Boolean vmaxinf = Precision::IsPositiveInfinite(VMax);
2577   
2578   // closed flag
2579   Standard_Boolean IsSuclosed = S->IsUClosed(), IsSvclosed = S->IsVClosed();
2580   if (S->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface))
2581     {
2582       Handle(Geom_Surface) BasisSurf = (*((Handle(Geom_OffsetSurface)*)&S))->BasisSurface();
2583       IsSuclosed = BasisSurf->IsUClosed();
2584       IsSvclosed = BasisSurf->IsVClosed();
2585     }
2586
2587   Standard_Boolean uclosed = 
2588     IsSuclosed && 
2589       Abs(UMin - umin) < epsilon && 
2590         Abs(UMax - umax) < epsilon;
2591   
2592   Standard_Boolean vclosed = 
2593     IsSvclosed && 
2594       Abs(VMin - vmin) < epsilon && 
2595         Abs(VMax - vmax) < epsilon;
2596   
2597   // degenerated flags (for cones)
2598   Standard_Boolean vmindegen = isVminDegen, vmaxdegen = isVmaxDegen;
2599   Handle(Geom_Surface) theSurf = S;
2600   if (S->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
2601     theSurf = (*(Handle(Geom_RectangularTrimmedSurface)*)&S)->BasisSurface();
2602   if (theSurf->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface))
2603     {
2604       Handle(Geom_ConicalSurface) ConicalS = *((Handle(Geom_ConicalSurface)*) &theSurf);
2605       gp_Cone theCone = ConicalS->Cone();
2606       gp_Pnt theApex = theCone.Apex();
2607       Standard_Real Uapex, Vapex;
2608       ElSLib::Parameters( theCone, theApex, Uapex, Vapex );
2609       if (Abs(VMin - Vapex) <= Precision::Confusion())
2610         vmindegen = Standard_True;
2611       if (Abs(VMax - Vapex) <= Precision::Confusion())
2612         vmaxdegen = Standard_True;
2613     }
2614   
2615   // compute vertices
2616   BRep_Builder B;
2617   Standard_Real tol = Precision::Confusion();
2618   
2619   TopoDS_Vertex V00,V10,V11,V01;
2620   
2621   if (!umininf) {
2622     if (!vmininf) B.MakeVertex(V00,S->Value(UMin,VMin),tol);
2623     if (!vmaxinf) B.MakeVertex(V01,S->Value(UMin,VMax),tol);
2624   }
2625   if (!umaxinf) {
2626     if (!vmininf) B.MakeVertex(V10,S->Value(UMax,VMin),tol);
2627     if (!vmaxinf) B.MakeVertex(V11,S->Value(UMax,VMax),tol);
2628   }
2629
2630   if (uclosed) {
2631     V10 = V00;
2632     V11 = V01;
2633   }
2634
2635   if (vclosed) {
2636     V01 = V00;
2637     V11 = V10;
2638   }
2639
2640   if (vmindegen)
2641     V10 = V00;
2642   if (vmaxdegen)
2643     V11 = V01;
2644
2645   // make the lines
2646   Handle(Geom2d_Line) Lumin,Lumax,Lvmin,Lvmax;
2647   if (!umininf)
2648     Lumin = new Geom2d_Line(gp_Pnt2d(UMin,0),gp_Dir2d(0,1));
2649   if (!umaxinf)
2650     Lumax = new Geom2d_Line(gp_Pnt2d(UMax,0),gp_Dir2d(0,1));
2651   if (!vmininf)
2652     Lvmin = new Geom2d_Line(gp_Pnt2d(0,VMin),gp_Dir2d(1,0));
2653   if (!vmaxinf)
2654     Lvmax = new Geom2d_Line(gp_Pnt2d(0,VMax),gp_Dir2d(1,0));
2655   
2656   Handle(Geom_Curve) Cumin,Cumax,Cvmin,Cvmax;
2657   Standard_Real TolApex = 1.e-5;
2658   //Standard_Boolean hasiso = ! S->IsKind(STANDARD_TYPE(Geom_OffsetSurface));
2659   Standard_Boolean hasiso = S->IsKind(STANDARD_TYPE(Geom_ElementarySurface));
2660   if (hasiso) {
2661     if (!umininf)
2662       Cumin = S->UIso(UMin);
2663     if (!umaxinf)
2664       Cumax = S->UIso(UMax);
2665     if (!vmininf)
2666       {
2667         Cvmin = S->VIso(VMin);
2668         if (BRepOffset_Tool::Gabarit( Cvmin ) <= TolApex)
2669           vmindegen = Standard_True;
2670       }
2671     if (!vmaxinf)
2672       {
2673         Cvmax = S->VIso(VMax);
2674         if (BRepOffset_Tool::Gabarit( Cvmax ) <= TolApex)
2675           vmaxdegen = Standard_True;
2676       }
2677   }
2678
2679   // make the face
2680   B.MakeFace(F,S,tol);
2681
2682   // make the edges
2683   TopoDS_Edge eumin,eumax,evmin,evmax;
2684
2685   if (!umininf) {
2686     if (hasiso)
2687       B.MakeEdge(eumin,Cumin,tol);
2688     else
2689       B.MakeEdge(eumin);
2690     if (uclosed) 
2691       B.UpdateEdge(eumin,Lumax,Lumin,F,tol);
2692     else
2693       B.UpdateEdge(eumin,Lumin,F,tol);
2694     if (!vmininf) {
2695       V00.Orientation(TopAbs_FORWARD);
2696       B.Add(eumin,V00);
2697     }
2698     if (!vmaxinf) {
2699       V01.Orientation(TopAbs_REVERSED);
2700       B.Add(eumin,V01);
2701     }
2702     B.Range(eumin,VMin,VMax);
2703   }
2704
2705   if (!umaxinf) {
2706     if (uclosed)
2707       eumax = eumin;
2708     else {
2709       if (hasiso)
2710         B.MakeEdge(eumax,Cumax,tol);
2711       else
2712         B.MakeEdge(eumax);
2713       B.UpdateEdge(eumax,Lumax,F,tol);
2714       if (!vmininf) {
2715         V10.Orientation(TopAbs_FORWARD);
2716         B.Add(eumax,V10);
2717       }
2718       if (!vmaxinf) {
2719         V11.Orientation(TopAbs_REVERSED);
2720         B.Add(eumax,V11);
2721       }
2722       B.Range(eumax,VMin,VMax);
2723     }
2724   }
2725
2726   if (!vmininf) {
2727     if (hasiso && !vmindegen)
2728       B.MakeEdge(evmin,Cvmin,tol);
2729     else
2730       B.MakeEdge(evmin);
2731     if (vclosed)
2732       B.UpdateEdge(evmin,Lvmin,Lvmax,F,tol);
2733     else
2734       B.UpdateEdge(evmin,Lvmin,F,tol);
2735     if (!umininf) {
2736       V00.Orientation(TopAbs_FORWARD);
2737       B.Add(evmin,V00);
2738     }
2739     if (!umaxinf) {
2740       V10.Orientation(TopAbs_REVERSED);
2741       B.Add(evmin,V10);
2742     }
2743     B.Range(evmin,UMin,UMax);
2744     if (vmindegen)
2745       B.Degenerated(evmin, Standard_True);
2746   }
2747
2748   if (!vmaxinf) {
2749     if (vclosed)
2750       evmax = evmin;
2751     else {
2752       if (hasiso && !vmaxdegen)
2753         B.MakeEdge(evmax,Cvmax,tol);
2754       else
2755         B.MakeEdge(evmax);
2756       B.UpdateEdge(evmax,Lvmax,F,tol);
2757       if (!umininf) {
2758         V01.Orientation(TopAbs_FORWARD);
2759         B.Add(evmax,V01);
2760       }
2761       if (!umaxinf) {
2762         V11.Orientation(TopAbs_REVERSED);
2763         B.Add(evmax,V11);
2764       }
2765       B.Range(evmax,UMin,UMax);
2766       if (vmaxdegen)
2767         B.Degenerated(evmax, Standard_True);
2768     }
2769   }
2770
2771   // make the wires and add them to the face
2772   eumin.Orientation(TopAbs_REVERSED);
2773   evmax.Orientation(TopAbs_REVERSED);
2774   
2775   TopoDS_Wire W;
2776
2777   if (!umininf && !umaxinf && vmininf && vmaxinf) {
2778     // two wires in u
2779     B.MakeWire(W);
2780     B.Add(W,eumin);
2781     B.Add(F,W);
2782     B.MakeWire(W);
2783     B.Add(W,eumax);
2784     B.Add(F,W);
2785     F.Closed(uclosed);
2786   }
2787     
2788   else if (umininf && umaxinf && !vmininf && !vmaxinf) {
2789     // two wires in v
2790     B.MakeWire(W);
2791     B.Add(W,evmin);
2792     B.Add(F,W);
2793     B.MakeWire(W);
2794     B.Add(W,evmax);
2795     B.Add(F,W);
2796     F.Closed(vclosed);
2797   }
2798     
2799   else if (!umininf || !umaxinf || !vmininf || !vmaxinf) {
2800     // one wire
2801     B.MakeWire(W);
2802     if (!umininf) B.Add(W,eumin);
2803     if (!vmininf) B.Add(W,evmin);
2804     if (!umaxinf) B.Add(W,eumax);
2805     if (!vmaxinf) B.Add(W,evmax);
2806     B.Add(F,W);
2807     W.Closed(!umininf && !umaxinf && !vmininf && !vmaxinf);
2808     F.Closed(uclosed && vclosed);
2809   }
2810 }
2811
2812 //=======================================================================
2813 //function : EnLargeGeometry
2814 //purpose  : 
2815 //=======================================================================
2816
2817 static Standard_Boolean EnlargeGeometry(Handle(Geom_Surface)& S,
2818                                         Standard_Real&        U1,
2819                                         Standard_Real&        U2,
2820                                         Standard_Real&        V1,
2821                                         Standard_Real&        V2,
2822                                         Standard_Boolean&     IsV1degen,
2823                                         Standard_Boolean&     IsV2degen,
2824                                         const Standard_Real   uf1,
2825                                         const Standard_Real   uf2,
2826                                         const Standard_Real   vf1,
2827                                         const Standard_Real   vf2,
2828                                         const Standard_Boolean GlobalEnlargeU,
2829                                         const Standard_Boolean GlobalEnlargeVfirst,
2830                                         const Standard_Boolean GlobalEnlargeVlast)
2831 {
2832   const Standard_Real coeff = 4.;
2833   const Standard_Real TolApex = 1.e-5;
2834
2835   Standard_Boolean SurfaceChange = Standard_False;
2836   if ( S->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
2837     Handle(Geom_Surface) BS = (*((Handle(Geom_RectangularTrimmedSurface)*)&S))->BasisSurface();
2838     EnlargeGeometry(BS,U1,U2,V1,V2,IsV1degen,IsV2degen,
2839                     uf1,uf2,vf1,vf2,GlobalEnlargeU,GlobalEnlargeVfirst,GlobalEnlargeVlast);
2840     if (!GlobalEnlargeVfirst)
2841       V1 = vf1;
2842     if (!GlobalEnlargeVlast)
2843       V2 = vf2;
2844     if (!GlobalEnlargeVfirst || !GlobalEnlargeVlast)
2845       //(*((Handle(Geom_RectangularTrimmedSurface)*)&S))->SetTrim( U1, U2, V1, V2 );
2846       S = new Geom_RectangularTrimmedSurface( BS, U1, U2, V1, V2 );
2847     else
2848       S = BS;
2849     SurfaceChange = Standard_True;
2850   }
2851   else if (S->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface)) {
2852     Handle(Geom_Surface) Surf = (*((Handle(Geom_OffsetSurface)*)&S))->BasisSurface();
2853     SurfaceChange = EnlargeGeometry(Surf,U1,U2,V1,V2,IsV1degen,IsV2degen,
2854                                     uf1,uf2,vf1,vf2,GlobalEnlargeU,GlobalEnlargeVfirst,GlobalEnlargeVlast);
2855     Handle(Geom_OffsetSurface)::DownCast(S)->SetBasisSurface(Surf);
2856   }
2857   else if (S->DynamicType() == STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion) ||
2858            S->DynamicType() == STANDARD_TYPE(Geom_SurfaceOfRevolution))
2859     {
2860       Standard_Real du=0., dv=0.;
2861       Handle( Geom_Curve ) uiso, viso, uiso1, uiso2, viso1, viso2;
2862       Standard_Real u1, u2, v1, v2;
2863       Standard_Boolean enlargeU = GlobalEnlargeU, enlargeV = Standard_True;
2864       Standard_Boolean enlargeUfirst = enlargeU, enlargeUlast = enlargeU;
2865       Standard_Boolean enlargeVfirst = GlobalEnlargeVfirst, enlargeVlast = GlobalEnlargeVlast;
2866       S->Bounds( u1, u2, v1, v2 );
2867       if (Precision::IsInfinite(u1) || Precision::IsInfinite(u2))
2868         {
2869           du = uf2-uf1;
2870           u1 = uf1-du;
2871           u2 = uf2+du;
2872           enlargeU = Standard_False;
2873         }
2874       else if (S->IsUClosed())
2875         enlargeU = Standard_False;
2876       else
2877         {
2878           viso = S->VIso( vf1 );
2879           GeomAdaptor_Curve gac( viso );
2880           du = GCPnts_AbscissaPoint::Length( gac ) / coeff;
2881           uiso1 = S->UIso( uf1 );
2882           uiso2 = S->UIso( uf2 );
2883           if (BRepOffset_Tool::Gabarit( uiso1 ) <= TolApex)
2884             enlargeUfirst = Standard_False;
2885           if (BRepOffset_Tool::Gabarit( uiso2 ) <= TolApex)
2886             enlargeUlast = Standard_False;
2887         }
2888       if (Precision::IsInfinite(v1) || Precision::IsInfinite(v2))
2889         {
2890           dv = vf2-vf1;
2891           v1 = vf1-dv;
2892           v2 = vf2+dv;
2893           enlargeV = Standard_False;
2894         }
2895       else if (S->IsVClosed())
2896         enlargeV = Standard_False;
2897       else
2898         {
2899           uiso = S->UIso( uf1 );
2900           GeomAdaptor_Curve gac( uiso );
2901           dv = GCPnts_AbscissaPoint::Length( gac ) / coeff;
2902           viso1 = S->VIso( vf1 );
2903           viso2 = S->VIso( vf2 );
2904           if (BRepOffset_Tool::Gabarit( viso1 ) <= TolApex)
2905             {
2906               enlargeVfirst = Standard_False;
2907               IsV1degen = Standard_True;
2908             }
2909           if (BRepOffset_Tool::Gabarit( viso2 ) <= TolApex)
2910             {
2911               enlargeVlast = Standard_False;
2912               IsV2degen = Standard_True;
2913             }
2914         }
2915       S = new Geom_RectangularTrimmedSurface( S, u1, u2, v1, v2 );
2916       if (enlargeU)
2917         {
2918           if (enlargeUfirst)
2919             GeomLib::ExtendSurfByLength( *((Handle(Geom_BoundedSurface)*)&S), du, 1, Standard_True, Standard_False );
2920           if (enlargeUlast)
2921             GeomLib::ExtendSurfByLength( *((Handle(Geom_BoundedSurface)*)&S), du, 1, Standard_True, Standard_True );
2922         }
2923       if (enlargeV)
2924         {
2925           if (enlargeVfirst)
2926             GeomLib::ExtendSurfByLength( *((Handle(Geom_BoundedSurface)*)&S), dv, 1, Standard_False, Standard_False );
2927           if (enlargeVlast)
2928             GeomLib::ExtendSurfByLength( *((Handle(Geom_BoundedSurface)*)&S), dv, 1, Standard_False, Standard_True );
2929         }
2930       S->Bounds( U1, U2, V1, V2 );
2931       SurfaceChange = Standard_True;
2932     }
2933   else if (S->DynamicType() == STANDARD_TYPE(Geom_BezierSurface) ||
2934            S->DynamicType() == STANDARD_TYPE(Geom_BSplineSurface))
2935     {
2936       Standard_Boolean enlargeU = GlobalEnlargeU, enlargeV = Standard_True;
2937       Standard_Boolean enlargeUfirst = enlargeU, enlargeUlast = enlargeU;
2938       Standard_Boolean enlargeVfirst = GlobalEnlargeVfirst, enlargeVlast = GlobalEnlargeVlast;
2939       if (S->IsUClosed())
2940         enlargeU = Standard_False;
2941       if (S->IsVClosed())
2942         enlargeV = Standard_False;
2943
2944       Standard_Real duf = uf2-uf1, dvf = vf2-vf1;
2945       Standard_Real u1, u2, v1, v2;
2946       S->Bounds( u1, u2, v1, v2 );
2947
2948       Standard_Real du=0., dv=0.;
2949       Handle( Geom_Curve ) uiso, viso, uiso1, uiso2, viso1, viso2;
2950       GeomAdaptor_Curve gac;
2951       if (enlargeU)
2952         {
2953           viso = S->VIso( v1 );
2954           gac.Load( viso );
2955           du = GCPnts_AbscissaPoint::Length( gac ) / coeff;
2956           uiso1 = S->UIso( u1 );
2957           uiso2 = S->UIso( u2 );
2958           if (BRepOffset_Tool::Gabarit( uiso1 ) <= TolApex)
2959             enlargeUfirst = Standard_False;
2960           if (BRepOffset_Tool::Gabarit( uiso2 ) <= TolApex)
2961             enlargeUlast = Standard_False;
2962         }
2963       if (enlargeV)
2964         {
2965           uiso = S->UIso( u1 );
2966           gac.Load( uiso );
2967           dv = GCPnts_AbscissaPoint::Length( gac ) / coeff;
2968           viso1 = S->VIso( v1 );
2969           viso2 = S->VIso( v2 );
2970           if (BRepOffset_Tool::Gabarit( viso1 ) <= TolApex)
2971             {
2972               enlargeVfirst = Standard_False;
2973               IsV1degen = Standard_True;
2974             }
2975           if (BRepOffset_Tool::Gabarit( viso2 ) <= TolApex)
2976             {
2977               enlargeVlast = Standard_False;
2978               IsV2degen = Standard_True;
2979             }
2980         }
2981
2982       if (enlargeU)
2983         {
2984           if (enlargeUfirst && uf1-u1 < duf)
2985             GeomLib::ExtendSurfByLength( *((Handle(Geom_BoundedSurface)*)&S), du, 1, Standard_True, Standard_False );
2986           if (enlargeUlast && u2-uf2 < duf)
2987             GeomLib::ExtendSurfByLength( *((Handle(Geom_BoundedSurface)*)&S), du, 1, Standard_True, Standard_True );
2988         }
2989       if (enlargeV)
2990         {
2991           if (enlargeVfirst && vf1-v1 < dvf)
2992             GeomLib::ExtendSurfByLength( *((Handle(Geom_BoundedSurface)*)&S), dv, 1, Standard_False, Standard_False );
2993           if (enlargeVlast && v2-vf2 < dvf)
2994             GeomLib::ExtendSurfByLength( *((Handle(Geom_BoundedSurface)*)&S), dv, 1, Standard_False, Standard_True );
2995         }
2996
2997       S->Bounds( U1, U2, V1, V2 );
2998       SurfaceChange = Standard_True;
2999     }
3000 //  else if (S->DynamicType() == STANDARD_TYPE(Geom_BezierSurface) ||
3001 //         S->DynamicType() == STANDARD_TYPE(Geom_BSplineSurface)) {
3002 //    S->Bounds(U1,U2,V1,V2);
3003 //  }
3004   else { 
3005     Standard_Real UU1,UU2,VV1,VV2;
3006     S->Bounds(UU1,UU2,VV1,VV2);
3007     // Pas d extension au dela des bornes de la surface.
3008     U1 = Max(UU1,U1);    
3009     V1 = Max(VV1,V1);
3010     U2 = Min(UU2,U2);    
3011     V2 = Min(VV2,V2);
3012   }
3013   return SurfaceChange;
3014 }
3015
3016 //=======================================================================
3017 //function : UpDatePCurve
3018 //purpose  :  Mise a jour des pcurves de F sur la surface de de BF.
3019 //            F and BF has to be FORWARD,
3020 //=======================================================================
3021
3022 static void UpdatePCurves (const TopoDS_Face& F,
3023                                  TopoDS_Face& BF)
3024 {
3025   Standard_Real   f,l;
3026   Standard_Integer i;
3027   BRep_Builder    B;
3028   TopTools_IndexedMapOfShape Emap;
3029   Handle(Geom2d_Curve) NullPCurve;
3030
3031   TopExp::MapShapes( F, TopAbs_EDGE, Emap );
3032   
3033   for (i = 1; i <= Emap.Extent(); i++)
3034     {
3035       TopoDS_Edge CE = TopoDS::Edge( Emap(i) );
3036       CE.Orientation( TopAbs_FORWARD );
3037       Handle(Geom2d_Curve) C2 = BRep_Tool::CurveOnSurface( CE, F, f, l );
3038       if (!C2.IsNull())
3039         {
3040           if (BRep_Tool::IsClosed( CE, F ))
3041             {
3042               CE.Reverse();
3043               Handle(Geom2d_Curve) C2R = BRep_Tool::CurveOnSurface( CE, F, f, l );
3044               B.UpdateEdge( CE, NullPCurve, NullPCurve, F, BRep_Tool::Tolerance(CE) );
3045               B.UpdateEdge( CE, C2, C2R, BF, BRep_Tool::Tolerance(CE) );
3046             }
3047           else
3048             {
3049               B.UpdateEdge( CE, NullPCurve, F, BRep_Tool::Tolerance(CE) );
3050               B.UpdateEdge( CE, C2, BF, BRep_Tool::Tolerance(CE) );
3051             }
3052
3053           B.Range(CE,f,l);
3054         }
3055     }
3056 }
3057
3058 //=======================================================================
3059 //function :CompactUVBounds
3060 //purpose  : 
3061 //=======================================================================
3062
3063 static void CompactUVBounds (const TopoDS_Face& F,
3064                                  Standard_Real& UMin,
3065                                  Standard_Real& UMax,
3066                                  Standard_Real& VMin,
3067                                  Standard_Real& VMax)
3068 {
3069   // Calcul serre pour que les bornes ne couvrent pas plus d une periode
3070   Standard_Real U1,U2;
3071   Standard_Real N = 33;
3072   Bnd_Box2d B;
3073   
3074   TopExp_Explorer exp;  
3075   for (exp.Init(F, TopAbs_EDGE); exp.More(); exp.Next()) {
3076     const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
3077     BRepAdaptor_Curve2d C(E,F);
3078     BRep_Tool::Range(E,U1,U2);
3079     gp_Pnt2d P;
3080     Standard_Real U  = U1;
3081     Standard_Real DU = (U2-U1)/(N-1);
3082     for (Standard_Integer j=1;j<N;j++) {
3083       C.D0(U,P);
3084       U+=DU;
3085       B.Add(P);
3086     }
3087     C.D0(U2,P);
3088     B.Add(P);
3089   }
3090   B.Get(UMin,VMin,UMax,VMax);
3091 }
3092
3093 //=======================================================================
3094 //function : CheckBounds
3095 //purpose  : 
3096 //=======================================================================
3097
3098 void BRepOffset_Tool::CheckBounds(const TopoDS_Face& F,
3099                                   const BRepOffset_Analyse& Analyse,
3100                                   Standard_Boolean& enlargeU,
3101                                   Standard_Boolean& enlargeVfirst,
3102                                   Standard_Boolean& enlargeVlast)
3103 {
3104   enlargeU = Standard_True;
3105   enlargeVfirst = Standard_True; enlargeVlast = Standard_True;
3106
3107   Standard_Integer Ubound = 0, Vbound = 0;
3108   Standard_Real Ufirst = RealLast(), Ulast = RealFirst();
3109   Standard_Real Vfirst = RealLast(), Vlast = RealFirst();
3110
3111   Standard_Real UF1,UF2,VF1,VF2;
3112   CompactUVBounds(F,UF1,UF2,VF1,VF2);
3113
3114   Handle(Geom_Surface) theSurf = BRep_Tool::Surface(F);
3115   if (theSurf->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
3116     theSurf = (*((Handle(Geom_RectangularTrimmedSurface)*)&theSurf))->BasisSurface();
3117
3118   if (theSurf->DynamicType() == STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion) ||
3119       theSurf->DynamicType() == STANDARD_TYPE(Geom_SurfaceOfRevolution) ||
3120       theSurf->DynamicType() == STANDARD_TYPE(Geom_BezierSurface) ||
3121       theSurf->DynamicType() == STANDARD_TYPE(Geom_BSplineSurface))
3122     {
3123       TopExp_Explorer Explo(F, TopAbs_EDGE);
3124       for (; Explo.More(); Explo.Next())
3125         {
3126           const TopoDS_Edge& anEdge = TopoDS::Edge(Explo.Current());
3127           const BRepOffset_ListOfInterval& L = Analyse.Type(anEdge);
3128           if (!L.IsEmpty() || BRep_Tool::Degenerated(anEdge))
3129             {
3130               BRepOffset_Type OT = L.First().Type();
3131               if (OT == BRepOffset_Tangent || BRep_Tool::Degenerated(anEdge))
3132                 {
3133                   Standard_Real fpar, lpar;
3134                   Handle(Geom2d_Curve) aCurve = BRep_Tool::CurveOnSurface(anEdge, F, fpar, lpar);
3135                   if (aCurve->DynamicType() == STANDARD_TYPE(Geom2d_TrimmedCurve))
3136                     aCurve = (*((Handle(Geom2d_TrimmedCurve)*)&aCurve))->BasisCurve();
3137                   
3138                   Handle(Geom2d_Line) theLine;
3139                   if (aCurve->DynamicType() == STANDARD_TYPE(Geom2d_Line))
3140                     theLine = *((Handle(Geom2d_Line)*)&aCurve);
3141                   else if (aCurve->DynamicType() == STANDARD_TYPE(Geom2d_BezierCurve) ||
3142                            aCurve->DynamicType() == STANDARD_TYPE(Geom2d_BSplineCurve))
3143                     {
3144                       Standard_Real newFpar, newLpar, deviation;
3145                       theLine = ShapeCustom_Curve2d::ConvertToLine2d(aCurve, fpar, lpar, Precision::Confusion(),
3146                                                                      newFpar, newLpar, deviation);
3147                     }
3148
3149                   if (!theLine.IsNull())
3150                     {
3151                       gp_Dir2d theDir = theLine->Direction();
3152                       if (theDir.IsParallel( gp::DX2d(), Precision::Angular() ))
3153                         {
3154                           Vbound++;
3155                           if (BRep_Tool::Degenerated(anEdge))
3156                             {
3157                               if (Abs(theLine->Location().Y() - VF1) <= Precision::Confusion())
3158                                 enlargeVfirst = Standard_False;
3159                               else //theLine->Location().Y() is near VF2
3160                                 enlargeVlast  = Standard_False;
3161                             }
3162                           else
3163                             {
3164                               if (theLine->Location().Y() < Vfirst)
3165                                 Vfirst = theLine->Location().Y();
3166                               if (theLine->Location().Y() > Vlast)
3167                                 Vlast  = theLine->Location().Y();
3168                             }
3169                         }
3170                       else if (theDir.IsParallel( gp::DY2d(), Precision::Angular() ))
3171                         {
3172                           Ubound++;
3173                           if (theLine->Location().X() < Ufirst)
3174                             Ufirst = theLine->Location().X();
3175                           if (theLine->Location().X() > Ulast)
3176                             Ulast  = theLine->Location().X();
3177                         }
3178                     }
3179                 }
3180             }
3181         }
3182     }
3183
3184   if (Ubound >= 2 || Vbound >= 2)
3185     {
3186       if (Ubound >= 2 &&
3187           Abs(UF1-Ufirst) <= Precision::Confusion() &&
3188           Abs(UF2-Ulast)  <= Precision::Confusion())
3189         enlargeU = Standard_False;
3190       if (Vbound >= 2 &&
3191           Abs(VF1-Vfirst) <= Precision::Confusion() &&
3192           Abs(VF2-Vlast)  <= Precision::Confusion())
3193         {
3194           enlargeVfirst = Standard_False;
3195           enlargeVlast  = Standard_False;
3196         }
3197     }
3198 }
3199
3200 //=======================================================================
3201 //function : EnLargeFace
3202 //purpose  : 
3203 //=======================================================================
3204
3205 Standard_Boolean BRepOffset_Tool::EnLargeFace 
3206 (const TopoDS_Face&       F,
3207  TopoDS_Face&             BF,
3208  const Standard_Boolean   CanExtentSurface,
3209  const Standard_Boolean   UpdatePCurve,
3210  const Standard_Boolean   enlargeU,
3211  const Standard_Boolean   enlargeVfirst,
3212  const Standard_Boolean   enlargeVlast)
3213 {
3214   //---------------------------
3215   // extension de la geometrie.
3216   //---------------------------
3217   TopLoc_Location       L;
3218   Handle (Geom_Surface) S = BRep_Tool::Surface(F,L);
3219   Standard_Real         UU1,VV1,UU2,VV2;
3220   Standard_Boolean      isVV1degen = Standard_False, isVV2degen = Standard_False;
3221   Standard_Real         US1,VS1,US2,VS2;
3222   Standard_Real         UF1,VF1,UF2,VF2;
3223   Standard_Real         infini = 1.e8;
3224   Standard_Boolean      SurfaceChange = Standard_False;
3225
3226   if (S->IsUPeriodic() || S->IsVPeriodic()) {
3227     // Calcul serre pour que les bornes ne couvre pas plus d une periode
3228     CompactUVBounds(F,UF1,UF2,VF1,VF2);                                        
3229   }
3230   else {
3231     BRepTools::UVBounds(F,UF1,UF2,VF1,VF2);
3232   }
3233
3234   S->Bounds            (US1,US2,VS1,VS2);
3235   UU1 = VV1 = - infini;
3236   UU2 = VV2 =   infini;
3237   
3238   if (CanExtentSurface) {
3239     SurfaceChange = EnlargeGeometry( S, UU1, UU2, VV1, VV2, isVV1degen, isVV2degen, UF1, UF2, VF1, VF2,
3240                                      enlargeU, enlargeVfirst, enlargeVlast );
3241   }
3242   else {
3243     UU1 = Max(US1,UU1); UU2 = Min(UU2,US2); 
3244     VV1 = Max(VS1,VV1); VV2 = Min(VS2,VV2);
3245   }
3246
3247   if (S->IsUPeriodic()) {
3248     Standard_Real    Period = S->UPeriod(); 
3249     Standard_Real    Delta  = Period - (UF2 - UF1);
3250     Standard_Real    alpha  = 0.1;
3251     UU1 = UF1 - alpha*Delta; UU2 = UF2 + alpha*Delta;
3252     if ((UU2 - UU1) > Period) {
3253       UU2 = UU1 + Period;
3254     }
3255   }
3256   if (S->IsVPeriodic()) {
3257     Standard_Real    Period = S->VPeriod(); 
3258     Standard_Real    Delta  = Period - (VF2 - VF1);
3259     Standard_Real    alpha  = 0.1;
3260     VV1 = VF1 - alpha*Delta; VV2 = VF2 + alpha*Delta;
3261     if ((VV2 - VV1) > Period) {
3262       VV2 = VV1 + Period;
3263     }
3264   }
3265
3266   //Special treatment for conical surfaces
3267   Handle(Geom_Surface) theSurf = S;
3268   if (S->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface))
3269     theSurf = (*(Handle(Geom_RectangularTrimmedSurface)*)&S)->BasisSurface();
3270   if (theSurf->DynamicType() == STANDARD_TYPE(Geom_ConicalSurface))
3271     {
3272       Handle(Geom_ConicalSurface) ConicalS = *((Handle(Geom_ConicalSurface)*) &theSurf);
3273       gp_Cone theCone = ConicalS->Cone();
3274       gp_Pnt theApex = theCone.Apex();
3275       Standard_Real Uapex, Vapex;
3276       ElSLib::Parameters( theCone, theApex, Uapex, Vapex );
3277       if (VV1 < Vapex && Vapex < VV2)
3278         {
3279           //consider that VF1 and VF2 are on the same side from apex
3280           Standard_Real TolApex = 1.e-5;
3281           if (Vapex - VF1 >= TolApex ||
3282               Vapex - VF2 >= TolApex)   //if (VF1 < Vapex || VF2 < Vapex)
3283             VV2 = Vapex;
3284           else
3285             VV1 = Vapex;
3286         }
3287     }
3288
3289   if (!enlargeU)
3290     {
3291       UU1 = UF1; UU2 = UF2;
3292     }
3293   if (!enlargeVfirst)
3294     VV1 = VF1;
3295   if (!enlargeVlast)
3296     VV2 = VF2;
3297
3298   MakeFace(S,UU1,UU2,VV1,VV2,isVV1degen,isVV2degen,BF);
3299   BF.Location(L);
3300 /*
3301   if (S->DynamicType() == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
3302     BRep_Builder B;
3303     //----------------------------------------------------------------
3304     // utile pour les bouchons on ne doit pas changer leur geometrie.
3305     // (Ce que fait BRepLib_MakeFace si S est restreinte).
3306     // On remet S et on update les pcurves.
3307     //----------------------------------------------------------------
3308     TopExp_Explorer exp;
3309     exp.Init(BF,TopAbs_EDGE);
3310     Standard_Real f=0.,l=0.;
3311     for (; exp.More(); exp.Next()) {
3312       TopoDS_Edge   CE  = TopoDS::Edge(exp.Current());
3313       Handle(Geom2d_Curve) C2 = BRep_Tool::CurveOnSurface(CE,BF,f,l); 
3314       B.UpdateEdge (CE,C2,S,L,BRep_Tool::Tolerance(CE));
3315     }    
3316     B.UpdateFace(BF,S,L,BRep_Tool::Tolerance(F)); 
3317   }
3318 */  
3319   if (SurfaceChange && UpdatePCurve) {
3320     TopoDS_Shape aLocalFace = F.Oriented(TopAbs_FORWARD);
3321     UpdatePCurves(TopoDS::Face(aLocalFace),BF);
3322     //UpdatePCurves(TopoDS::Face(F.Oriented(TopAbs_FORWARD)),BF);
3323     BRep_Builder BB;
3324     BB.UpdateFace( F, S, L, BRep_Tool::Tolerance(F) );
3325   }
3326
3327   BF.Orientation(F.Orientation());
3328   return SurfaceChange;
3329 }
3330
3331 //=======================================================================
3332 //function : TryParameter
3333 //purpose  : 
3334 //=======================================================================
3335
3336 static Standard_Boolean TryParameter (const TopoDS_Edge& OE,
3337                                       TopoDS_Vertex&     V,
3338                                       const TopoDS_Edge& NE,
3339                                       Standard_Real      TolConf)
3340 {
3341   BRepAdaptor_Curve OC(OE);
3342   BRepAdaptor_Curve NC(NE);
3343   Standard_Real Of = OC.FirstParameter(); Standard_Real Ol = OC.LastParameter();
3344   Standard_Real Nf = NC.FirstParameter(); Standard_Real Nl = NC.LastParameter();
3345   Standard_Real U = 0.;
3346   gp_Pnt           P  = BRep_Tool::Pnt(V);
3347   Standard_Boolean OK = Standard_False;
3348
3349   if (P.Distance(OC.Value(Of)) < TolConf) {
3350     if (Of > Nf && Of < Nl  && P.Distance(NC.Value(Of)) < TolConf) {
3351       OK = Standard_True;
3352       U    = Of;
3353     }
3354   }
3355   if (P.Distance(OC.Value(Ol)) < TolConf) {
3356     if (Ol > Nf && Ol < Nl  && P.Distance(NC.Value(Ol)) < TolConf) {
3357       OK = Standard_True;
3358       U    = Ol;
3359     }
3360   }
3361   if (OK) {
3362     BRep_Builder B;
3363     TopoDS_Shape aLocalShape = NE.Oriented(TopAbs_FORWARD);
3364     TopoDS_Edge EE = TopoDS::Edge(aLocalShape);
3365 //    TopoDS_Edge EE = TopoDS::Edge(NE.Oriented(TopAbs_FORWARD));
3366     aLocalShape = V.Oriented(TopAbs_INTERNAL);
3367     B.UpdateVertex(TopoDS::Vertex(aLocalShape),
3368                    U,NE,BRep_Tool::Tolerance(NE));
3369 //    B.UpdateVertex(TopoDS::Vertex(V.Oriented(TopAbs_INTERNAL)),
3370 //                 U,NE,BRep_Tool::Tolerance(NE));
3371   }
3372   return OK;  
3373 }
3374
3375 //=======================================================================
3376 //function : 
3377 //purpose  : 
3378 //=======================================================================
3379
3380 void BRepOffset_Tool::MapVertexEdges (const TopoDS_Shape& S,
3381                                       TopTools_DataMapOfShapeListOfShape& MEV)
3382 {
3383   TopExp_Explorer      exp;
3384   exp.Init(S.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
3385   TopTools_MapOfShape  DejaVu;
3386   for ( ; exp.More(); exp.Next()) {
3387     const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
3388     if (DejaVu.Add(E)) {
3389       TopoDS_Vertex     V1,V2;
3390       TopExp::Vertices (E,V1,V2);
3391       if (!MEV.IsBound(V1)) {
3392         TopTools_ListOfShape empty;
3393         MEV.Bind(V1,empty);
3394       }
3395       MEV(V1).Append(E);
3396       if (!V1.IsSame(V2)) {
3397         if (!MEV.IsBound(V2)) {
3398           TopTools_ListOfShape empty;
3399           MEV.Bind(V2,empty);
3400         }
3401         MEV(V2).Append(E);
3402       }
3403     }
3404   }
3405 }
3406
3407 //=======================================================================
3408 //function : 
3409 //purpose  : 
3410 //=======================================================================
3411
3412 void BRepOffset_Tool::BuildNeighbour (const TopoDS_Wire& W,
3413                                       const TopoDS_Face& F,
3414                                       TopTools_DataMapOfShapeShape& NOnV1,
3415                                       TopTools_DataMapOfShapeShape& NOnV2)
3416 {
3417   TopoDS_Vertex V1,V2,VP1,VP2,FV1,FV2;
3418   TopoDS_Edge   CurE,FirstE,PrecE;
3419   BRepTools_WireExplorer         wexp;
3420   
3421   TopoDS_Shape aLocalFace = F.Oriented(TopAbs_FORWARD);
3422   TopoDS_Shape aLocalWire = W.Oriented(TopAbs_FORWARD);
3423   wexp.Init(TopoDS::Wire(aLocalWire),TopoDS::Face(aLocalFace));
3424 //  wexp.Init(TopoDS::Wire(W.Oriented(TopAbs_FORWARD)),
3425 //          TopoDS::Face(F.Oriented(TopAbs_FORWARD)));
3426   CurE = FirstE = PrecE = wexp.Current();
3427   TopExp::Vertices(CurE,V1,V2);
3428   FV1 = VP1 = V1; FV2 = VP2 = V2;
3429   wexp.Next();
3430   while (wexp.More()) {
3431     CurE = wexp.Current();
3432     TopExp::Vertices(CurE,V1,V2);
3433     if (V1.IsSame(VP1)) { NOnV1.Bind(PrecE,CurE); NOnV1.Bind(CurE,PrecE);}
3434     if (V1.IsSame(VP2)) { NOnV2.Bind(PrecE,CurE); NOnV1.Bind(CurE,PrecE);}
3435     if (V2.IsSame(VP1)) { NOnV1.Bind(PrecE,CurE); NOnV2.Bind(CurE,PrecE);}
3436     if (V2.IsSame(VP2)) { NOnV2.Bind(PrecE,CurE); NOnV2.Bind(CurE,PrecE);}
3437     PrecE = CurE;
3438     VP1 = V1; VP2 = V2;
3439     wexp.Next();
3440   }
3441   if (V1.IsSame(FV1)) { NOnV1.Bind(FirstE,CurE); NOnV1.Bind(CurE,FirstE);}
3442   if (V1.IsSame(FV2)) { NOnV2.Bind(FirstE,CurE); NOnV1.Bind(CurE,FirstE);}
3443   if (V2.IsSame(FV1)) { NOnV1.Bind(FirstE,CurE); NOnV2.Bind(CurE,FirstE);}
3444   if (V2.IsSame(FV2)) { NOnV2.Bind(FirstE,CurE); NOnV2.Bind(CurE,FirstE);}
3445 }
3446
3447 //=======================================================================
3448 //function : ExtentFace