0024624: Lost word in license statement in source files
[occt.git] / src / BRepOffset / BRepOffset_MakeOffset.cxx
1 // Created on: 1995-10-27
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 //  Modified by skv - Tue Mar 15 16:20:43 2005
18 // Add methods for supporting history.
19
20 //  Modified by skv - Mon Jan 12 11:50:02 2004 OCC4455
21
22 #include <BRepOffset_MakeOffset.ixx>
23 #include <BRepOffset_Analyse.hxx>
24 #include <BRepOffset_DataMapOfShapeOffset.hxx> 
25 #include <BRepOffset_DataMapOfShapeMapOfShape.hxx>
26 #include <BRepOffset_DataMapIteratorOfDataMapOfShapeOffset.hxx>
27 #include <BRepOffset_Interval.hxx>
28 #include <BRepOffset_ListOfInterval.hxx>
29 #include <BRepOffset_Offset.hxx>
30 #include <BRepOffset_Tool.hxx>
31 #include <BRepOffset_Inter2d.hxx>
32 #include <BRepOffset_Inter3d.hxx>
33 #include <BRepOffset_MakeLoops.hxx>
34
35
36 #include <BRepAdaptor_Surface.hxx>
37 #include <BRepCheck_Edge.hxx>
38 #include <BRepCheck_Vertex.hxx>
39 #include <BRepLib.hxx>
40 #include <BRepLib_MakeVertex.hxx>
41 #include <BRep_Builder.hxx>
42 #include <BRep_Tool.hxx>
43 #include <BRep_TVertex.hxx>
44 #include <BRepTools_Quilt.hxx>
45 #include <BRepClass3d_SolidClassifier.hxx>
46 #include <gp_Pnt.hxx>
47
48 #include <TopExp.hxx>
49 #include <TopExp_Explorer.hxx>
50 #include <TopoDS.hxx>
51 #include <TopoDS_Solid.hxx>
52 #include <TopoDS_Shell.hxx>
53 #include <TopoDS_Compound.hxx>
54 #include <TopoDS_Face.hxx>
55 #include <TopoDS_Edge.hxx>
56 #include <TopoDS_Vertex.hxx>
57
58 #include <TopTools_MapOfShape.hxx>
59 #include <TopTools_MapIteratorOfMapOfShape.hxx>
60 #include <TopTools_ListOfShape.hxx>
61 #include <TopTools_ListIteratorOfListOfShape.hxx>
62 #include <TopTools_DataMapOfShapeShape.hxx>
63 #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
64 #include <TopTools_DataMapIteratorOfDataMapOfShapeReal.hxx>
65 #include <TColStd_ListIteratorOfListOfInteger.hxx>
66
67 #include <Standard_NotImplemented.hxx>
68 #include <Standard_ConstructionError.hxx>
69 #include <Precision.hxx>
70
71 #include <TopTools_SequenceOfShape.hxx>
72 #include <Geom_OffsetSurface.hxx>
73 #include <Geom_ConicalSurface.hxx>
74 #include <TopTools_IndexedMapOfShape.hxx>
75 #include <BRep_TEdge.hxx>
76 #include <BRepTools.hxx>
77 #include <gp_Cone.hxx>
78 #include <ElSLib.hxx>
79 #include <ElCLib.hxx>
80 #include <gp_Lin2d.hxx>
81 #include <GCE2d_MakeLine.hxx>
82 #include <Geom2d_Line.hxx>
83 #include <TopoDS_Iterator.hxx>
84 #include <BRepLib_MakeFace.hxx>
85 #include <Geom_Circle.hxx>
86
87 #include <BRep_PointRepresentation.hxx>
88 #include <BRep_ListIteratorOfListOfPointRepresentation.hxx>
89 #include <GeomAPI_ProjectPointOnCurve.hxx>
90
91 #include <BRepAdaptor_Curve.hxx>
92 #include <BRepAdaptor_Curve2d.hxx>
93 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
94 #include <Geom_SphericalSurface.hxx>
95 #include <TopoDS_Wire.hxx>
96 #include <BRepTools_Substitution.hxx>
97 #include <Geom_TrimmedCurve.hxx>
98 #include <Geom2d_TrimmedCurve.hxx>
99
100 #include <BRepTools_WireExplorer.hxx>
101 #include <BRepLib_MakeEdge.hxx>
102 #include <gce_MakeDir.hxx>
103 #include <GC_MakeCylindricalSurface.hxx>
104 #include <gce_MakeCone.hxx>
105 #include <Geom_SurfaceOfLinearExtrusion.hxx>
106
107 #include <Geom2dAdaptor_HCurve.hxx>
108 #include <GeomAdaptor_HSurface.hxx>
109 #include <Adaptor3d_CurveOnSurface.hxx>
110 #include <GeomLib.hxx>
111 #include <GeomFill_Generator.hxx>
112 #include <Geom_Plane.hxx>
113 #include <IntTools_FClass2d.hxx>
114 #include <BRepLib_FindSurface.hxx>
115
116
117 // POP for NT
118 #include <stdio.h>
119
120 #ifdef DRAW
121
122 #include <DBRep.hxx>
123 #endif
124 #ifdef DEB
125 #include <OSD_Chronometer.hxx>
126 //#define DEB_VERB
127   Standard_Boolean AffichInt2d = Standard_False;       
128   Standard_Boolean AffichOffC  = Standard_False;       
129   Standard_Boolean ChronBuild  = Standard_False;
130   Standard_Integer NbAE        = 0;
131   Standard_Integer NbAF        = 0;  
132   static OSD_Chronometer  Clock;
133   char name[100];
134
135
136
137
138 //=======================================================================
139 //function :  DEBVerticesControl
140 //purpose  : 
141 //=======================================================================
142
143 static void DEBVerticesControl (const TopTools_IndexedMapOfShape& NewEdges,
144                                       Handle(BRepAlgo_AsDes)      AsDes)
145 {
146   TopTools_ListOfShape               LVP;
147   TopTools_ListIteratorOfListOfShape it1LE ;    
148   TopTools_ListIteratorOfListOfShape it2LE ;
149   
150   Standard_Integer i;
151   for (i = 1; i <= NewEdges.Extent(); i++) {
152     const TopoDS_Edge& NE = TopoDS::Edge(NewEdges(i));
153     if (AsDes->HasDescendant(NE)) {
154       for (it1LE.Initialize(AsDes->Descendant(NE)); it1LE.More(); it1LE.Next()) {
155         if (AsDes->Ascendant(it1LE.Value()).Extent() < 3) {
156           LVP.Append(it1LE.Value());
157           cout <<"Vertex on at least 3 edges."<<endl;
158 #ifdef DRAW
159           if (AffichInt2d) {
160             sprintf (name,"VP_%d",NVP++);
161             DBRep::Set(name,it1LE.Value());
162           }
163 #endif
164         }
165         else if (AsDes->Ascendant(it1LE.Value()).Extent() > 3) {
166           cout <<"Vertex on more than 3 edges."<<endl;
167 #ifdef DRAW
168           if (AffichInt2d) {
169             sprintf (name,"VM_%d",NVM++);
170             DBRep::Set(name,it1LE.Value());
171           }
172 #endif
173           
174         }
175         else {
176 #ifdef DRAW
177           if (AffichInt2d) {
178             sprintf (name,"VN_%d",NVN++);
179             DBRep::Set(name,it1LE.Value());
180           }
181 #endif
182         }
183       }
184     }
185   }
186   //------------------------------------------------
187   // Try to mix spoiled vertices.
188   //------------------------------------------------
189   BRep_Builder B;
190   TopTools_ListIteratorOfListOfShape it1(LVP);
191   Standard_Real                      TolConf = 1.e-5;
192   Standard_Real                      Tol     = Precision::Confusion();
193   //Standard_Integer                   i = 1;
194   
195   i = 1;
196   for ( ; it1.More(); it1.Next()) {
197     TopoDS_Shape   V1 = it1.Value();
198     gp_Pnt         P1 = BRep_Tool::Pnt(TopoDS::Vertex(V1));
199     Standard_Real  distmin = Precision::Infinite();
200     TopTools_ListIteratorOfListOfShape it2(LVP);
201     Standard_Integer j = 1;
202
203     for ( ; it2.More(); it2.Next()) {
204       if (j > i) {
205         TopoDS_Shape V2 = it2.Value();
206         gp_Pnt       P2 = BRep_Tool::Pnt(TopoDS::Vertex(V2));
207         if (!V1.IsSame(V2)) {
208           Standard_Real       dist    = P1.Distance(P2);
209           if (dist < distmin) distmin = dist;
210           if (dist < TolConf) {
211             Standard_Real UV2;
212             TopoDS_Edge   EWE2;
213             const TopTools_ListOfShape& EdgeWithV2 = AsDes->Ascendant(V2);
214             TopTools_ListIteratorOfListOfShape itAsDes;
215             for (itAsDes.Initialize(EdgeWithV2); itAsDes.More(); itAsDes.Next()) {
216               EWE2  = TopoDS::Edge(itAsDes.Value());
217               TopoDS_Shape aLocalShape = V2.Oriented(TopAbs_INTERNAL);
218               UV2   = BRep_Tool::Parameter(TopoDS::Vertex(aLocalShape),EWE2);
219               aLocalShape = V1.Oriented(TopAbs_INTERNAL) ;
220               B.UpdateVertex(TopoDS::Vertex(aLocalShape),UV2,EWE2,Tol);
221 //            UV2   = 
222 //              BRep_Tool::Parameter(TopoDS::Vertex(),EWE2);
223 //            B.UpdateVertex(TopoDS::Vertex(V1.Oriented(TopAbs_INTERNAL)),
224 //                           UV2,EWE2,Tol);
225             }
226             AsDes->Replace(V2,V1);
227           }
228         }
229       }
230       j++;
231     }
232     i++;
233     cout <<" distmin between VP : "<<distmin<<endl;
234   }
235 }  
236 #endif
237
238
239 static void UpdateTolerance (      TopoDS_Shape&               myShape,
240                              const TopTools_IndexedMapOfShape& myFaces);
241
242
243 static Standard_Boolean FindParameter(const TopoDS_Vertex& V, 
244                                       const TopoDS_Edge& E,
245                                       Standard_Real& U)
246 {
247   // Search the vertex in the edge
248
249   Standard_Boolean rev = Standard_False;
250   TopoDS_Shape VF;
251   TopAbs_Orientation orient = TopAbs_INTERNAL;
252
253   TopoDS_Iterator itv(E.Oriented(TopAbs_FORWARD));
254
255   // if the edge has no vertices
256   // and is degenerated use the vertex orientation
257   // RLE, june 94
258
259   if (!itv.More() && BRep_Tool::Degenerated(E)) {
260     orient = V.Orientation();
261   }
262
263   while (itv.More()) {
264     const TopoDS_Shape& Vcur = itv.Value();
265     if (V.IsSame(Vcur)) {
266       if (VF.IsNull()) {
267         VF = Vcur;
268       }
269       else {
270         rev = E.Orientation() == TopAbs_REVERSED;
271         if (Vcur.Orientation() == V.Orientation()) {
272           VF = Vcur;
273         }
274       }
275     }
276     itv.Next();
277   }
278   
279   if (!VF.IsNull()) orient = VF.Orientation();
280  
281   Standard_Real f,l;
282
283   if (orient ==  TopAbs_FORWARD) {
284     BRep_Tool::Range(E,f,l);
285     //return (rev) ? l : f;
286     U = (rev) ? l : f;
287     return Standard_True;
288   }
289  
290   else if (orient ==  TopAbs_REVERSED) {
291     BRep_Tool::Range(E,f,l);
292     //return (rev) ? f : l;
293     U = (rev) ? f : l;
294     return Standard_True;
295    }
296
297   else {
298     TopLoc_Location L;
299     const Handle(Geom_Curve)& C = BRep_Tool::Curve(E,L,f,l);
300     L = L.Predivided(V.Location());
301     if (!C.IsNull() || BRep_Tool::Degenerated(E)) {
302       BRep_ListIteratorOfListOfPointRepresentation itpr
303         ((*((Handle(BRep_TVertex)*) &V.TShape()))->Points());
304
305       while (itpr.More()) {
306         const Handle(BRep_PointRepresentation)& pr = itpr.Value();
307         if (pr->IsPointOnCurve(C,L)) {
308           Standard_Real p = pr->Parameter();
309           Standard_Real res = p;// SVV 4 nov 99 - to avoid warnings on Linux
310           if (!C.IsNull()) {
311             // Closed curves RLE 16 june 94
312             if (Precision::IsNegativeInfinite(f))
313               {
314                 //return pr->Parameter();//p;
315                 U = pr->Parameter();
316                 return Standard_True;
317               }
318             if (Precision::IsPositiveInfinite(l))
319               {
320                 //return pr->Parameter();//p;
321                 U = pr->Parameter();
322                 return Standard_True;
323               }
324             gp_Pnt Pf = C->Value(f).Transformed(L.Transformation());
325             gp_Pnt Pl = C->Value(l).Transformed(L.Transformation());
326             Standard_Real tol = BRep_Tool::Tolerance(V);
327             if (Pf.Distance(Pl) < tol) {
328               if (Pf.Distance(BRep_Tool::Pnt(V)) < tol) {
329                 if (V.Orientation() == TopAbs_FORWARD) res = f;//p = f;
330                 else                                   res = l;//p = l;
331               }
332             }
333           }
334           //return res;//p;
335           U = res;
336           return Standard_True;
337         }
338         itpr.Next();
339       }
340     }
341     else {
342       // no 3d curve !!
343       // let us try with the first pcurve
344       Handle(Geom2d_Curve) PC;
345       Handle(Geom_Surface) S;
346       BRep_Tool::CurveOnSurface(E,PC,S,L,f,l);
347       L = L.Predivided(V.Location()); 
348       BRep_ListIteratorOfListOfPointRepresentation itpr
349         ((*((Handle(BRep_TVertex)*) &V.TShape()))->Points());
350
351       while (itpr.More()) {
352         const Handle(BRep_PointRepresentation)& pr = itpr.Value();
353         if (pr->IsPointOnCurveOnSurface(PC,S,L)) {
354           Standard_Real p = pr->Parameter();
355           // Closed curves RLE 16 june 94
356           if (PC->IsClosed()) {
357             if ((p == PC->FirstParameter()) || 
358                 (p == PC->LastParameter())) {
359               if (V.Orientation() == TopAbs_FORWARD) p = PC->FirstParameter();
360               else                                   p = PC->LastParameter();
361             }
362           }
363           //return p;
364           U = p;
365           return Standard_True;
366         }
367         itpr.Next();
368       }
369     }
370   }
371   
372   //Standard_NoSuchObject::Raise("BRep_Tool:: no parameter on edge");
373   return Standard_False;
374 }
375
376 //=======================================================================
377 //function : GetEdgePoints
378 //purpose  : gets the first, last and middle points of the edge
379 //=======================================================================
380 static void GetEdgePoints(const TopoDS_Edge& anEdge,
381                                       const TopoDS_Face& aFace,
382                                       gp_Pnt& fPnt, gp_Pnt& mPnt,
383                                       gp_Pnt& lPnt)
384 {
385   Standard_Real f, l;
386   Handle(Geom2d_Curve) theCurve = BRep_Tool::CurveOnSurface( anEdge, aFace, f, l );
387   gp_Pnt2d fPnt2d = theCurve->Value(f);
388   gp_Pnt2d lPnt2d = theCurve->Value(l);
389   gp_Pnt2d mPnt2d = theCurve->Value(0.5*(f + l));
390   Handle(Geom_Surface) aSurf = BRep_Tool::Surface(aFace);
391   fPnt = aSurf->Value(fPnt2d.X(),fPnt2d.Y());
392   lPnt = aSurf->Value(lPnt2d.X(),lPnt2d.Y());
393   mPnt = aSurf->Value(mPnt2d.X(), mPnt2d.Y());
394 }
395
396 //=======================================================================
397 //function : FillContours
398 //purpose  : fills free boundary contours and faces connected (MapEF)
399 //=======================================================================
400 static void FillContours(const TopoDS_Shape& aShape,
401                          const BRepOffset_Analyse& Analyser,
402                          TopTools_DataMapOfShapeListOfShape& Contours,
403                          TopTools_DataMapOfShapeShape& MapEF)
404 {
405   TopTools_ListOfShape Edges;
406
407   TopExp_Explorer Explo(aShape, TopAbs_FACE);
408   BRepTools_WireExplorer Wexp;
409
410   for (; Explo.More(); Explo.Next())
411     {
412       TopoDS_Face aFace = TopoDS::Face(Explo.Current());
413       TopoDS_Iterator itf(aFace);
414       for (; itf.More(); itf.Next())
415         {
416           TopoDS_Wire aWire = TopoDS::Wire(itf.Value());
417           for (Wexp.Init(aWire, aFace); Wexp.More(); Wexp.Next())
418             {
419               TopoDS_Edge anEdge = Wexp.Current();
420               if (BRep_Tool::Degenerated(anEdge))
421                 continue;
422               const BRepOffset_ListOfInterval& Lint = Analyser.Type(anEdge);
423               if (!Lint.IsEmpty() && Lint.First().Type() == BRepOffset_FreeBoundary)
424                 {
425                   MapEF.Bind(anEdge, aFace);
426                   Edges.Append(anEdge);
427                 }
428             }
429         }
430     }
431
432   TopTools_ListIteratorOfListOfShape itl;
433   while (!Edges.IsEmpty())
434     {
435       TopoDS_Edge StartEdge = TopoDS::Edge(Edges.First());
436       Edges.RemoveFirst();
437       TopoDS_Vertex StartVertex, CurVertex;
438       TopExp::Vertices(StartEdge, StartVertex, CurVertex, Standard_True);
439       TopTools_ListOfShape aContour;
440       aContour.Append(StartEdge);
441       while (!CurVertex.IsSame(StartVertex))
442         for (itl.Initialize(Edges); itl.More(); itl.Next())
443           {
444             TopoDS_Edge anEdge = TopoDS::Edge(itl.Value());
445             TopoDS_Vertex V1, V2;
446             TopExp::Vertices(anEdge, V1, V2);
447             if (V1.IsSame(CurVertex) || V2.IsSame(CurVertex))
448               {
449                 aContour.Append(anEdge);
450                 CurVertex = (V1.IsSame(CurVertex))? V2 : V1;
451                 Edges.Remove(itl);
452                 break;
453               }
454           }
455       Contours.Bind(StartVertex, aContour);
456     }
457 }
458
459 //=======================================================================
460 //function : BRepOffset_MakeOffset
461 //purpose  : 
462 //=======================================================================
463
464 BRepOffset_MakeOffset::BRepOffset_MakeOffset()
465 {
466   myAsDes = new BRepAlgo_AsDes();
467 }
468
469
470 //=======================================================================
471 //function : BRepOffset_MakeOffset
472 //purpose  : 
473 //=======================================================================
474
475 BRepOffset_MakeOffset::BRepOffset_MakeOffset(const TopoDS_Shape&    S, 
476                                              const Standard_Real    Offset, 
477                                              const Standard_Real    Tol, 
478                                              const BRepOffset_Mode  Mode, 
479                                              const Standard_Boolean Inter, 
480                                              const Standard_Boolean SelfInter, 
481                                              const GeomAbs_JoinType Join,
482                                              const Standard_Boolean Thickening)
483
484 myOffset     (Offset),
485 myTol        (Tol),
486 myShape      (S),
487 myMode       (Mode),
488 myInter      (Inter),
489 mySelfInter  (SelfInter),
490 myJoin       (Join),
491 myThickening (Thickening),
492 myDone     (Standard_False)
493
494 {
495   myAsDes = new BRepAlgo_AsDes();
496   MakeOffsetShape();
497 }
498
499
500 //=======================================================================
501 //function : Initialize
502 //purpose  : 
503 //=======================================================================
504
505 void BRepOffset_MakeOffset::Initialize(const TopoDS_Shape&    S, 
506                                        const Standard_Real    Offset, 
507                                        const Standard_Real    Tol, 
508                                        const BRepOffset_Mode  Mode,
509                                        const Standard_Boolean Inter,
510                                        const Standard_Boolean SelfInter,
511                                        const GeomAbs_JoinType Join,
512                                        const Standard_Boolean Thickening)
513 {
514   myOffset     = Offset;
515   myShape      = S;
516   myTol        = Tol;
517   myMode       = Mode;
518   myInter      = Inter;
519   mySelfInter  = SelfInter;
520   myJoin       = Join;
521   myThickening = Thickening;
522   myDone     = Standard_False;
523   Clear();
524 }
525
526
527 //=======================================================================
528 //function : Clear
529 //purpose  : 
530 //=======================================================================
531
532 void BRepOffset_MakeOffset::Clear()
533 {
534   myOffsetShape.Nullify();
535   myInitOffsetFace .Clear();
536   myInitOffsetEdge .Clear();
537   myImageOffset    .Clear();
538   myFaces          .Clear();  
539   myFaceOffset     .Clear();
540   myAsDes          ->Clear();
541   myDone     = Standard_False;
542 }
543
544 //=======================================================================
545 //function : AddFace
546 //purpose  : 
547 //=======================================================================
548
549 void BRepOffset_MakeOffset::AddFace(const TopoDS_Face& F) {
550   myFaces.Add(F);    
551   //-------------
552   // MAJ SD.
553   //-------------
554   myInitOffsetFace.SetRoot (F)  ;    
555   myInitOffsetFace.Bind    (F,F);
556   myImageOffset.SetRoot    (F)  ;  
557 }
558
559 //=======================================================================
560 //function : SetOffsetOnFace
561 //purpose  : 
562 //=======================================================================
563
564 void BRepOffset_MakeOffset::SetOffsetOnFace(const TopoDS_Face&  F, 
565                                             const Standard_Real Off)
566 {
567   if ( myFaceOffset.IsBound(F)) myFaceOffset.UnBind(F);
568   myFaceOffset.Bind(F,Off);
569 }
570
571 //=======================================================================
572 //function : RemoveCorks
573 //purpose  : 
574 //=======================================================================
575
576 static void RemoveCorks (TopoDS_Shape&               S,
577                          TopTools_IndexedMapOfShape& Faces)
578 {  
579   TopoDS_Compound SS;
580   BRep_Builder    B;
581   B.MakeCompound (SS);
582   //-----------------------------------------------------
583   // Construction of a shape without caps.
584   // and Orientation of caps as in shape S.
585   //-----------------------------------------------------
586   TopExp_Explorer exp(S,TopAbs_FACE);
587   for (; exp.More(); exp.Next()) {
588     const TopoDS_Shape& Cork = exp.Current(); 
589     if (!Faces.Contains(Cork)) {
590       B.Add(SS,Cork);
591     }
592     else {
593       //Faces.Remove (Cork);
594       //begin instead of Remove//
595       TopoDS_Shape LastShape = Faces(Faces.Extent());
596       Faces.RemoveLast();
597       if (Faces.FindIndex(Cork) != 0)
598         Faces.Substitute(Faces.FindIndex(Cork), LastShape);
599       //end instead of Remove  //
600       Faces.Add(Cork); // to reset it with proper orientation.
601     }
602   }
603   S = SS;
604 #ifdef DRAW
605   if ( AffichOffC) 
606     DBRep::Set("myInit", SS);
607 #endif
608
609 }
610
611 static Standard_Boolean IsConnectedShell( const TopoDS_Shape& S )
612 {  
613   BRepTools_Quilt Glue;
614   Glue.Add( S );
615
616   TopoDS_Shape SS = Glue.Shells();
617   TopExp_Explorer Explo( SS, TopAbs_SHELL );
618   Explo.Next();
619   if (Explo.More())
620     return Standard_False;
621   
622   return Standard_True;
623 }
624
625
626 //=======================================================================
627 //function : MakeList
628 //purpose  : 
629 //=======================================================================
630
631 static void MakeList (TopTools_ListOfShape&             OffsetFaces,
632                       const BRepAlgo_Image&             myInitOffsetFace,
633                       const TopTools_IndexedMapOfShape& myFaces)
634 {
635   TopTools_ListIteratorOfListOfShape itLOF(myInitOffsetFace.Roots());
636   for ( ; itLOF.More(); itLOF.Next()) {
637     const TopoDS_Shape& Root = itLOF.Value();
638     if (!myFaces.Contains(Root))
639       OffsetFaces.Append(myInitOffsetFace.Image(Root).First());
640   }
641 }
642
643 //=======================================================================
644 //function : EvalMax
645 //purpose  : 
646 //=======================================================================
647
648 static void EvalMax(const TopoDS_Shape& S, Standard_Real& Tol)
649 {
650   TopExp_Explorer exp;
651   for (exp.Init(S,TopAbs_VERTEX); exp.More(); exp.Next()) {
652     const TopoDS_Vertex& V    = TopoDS::Vertex(exp.Current());
653     Standard_Real        TolV = BRep_Tool::Tolerance(V); 
654     if (TolV > Tol) Tol = TolV;
655   }
656   //Patch
657   Tol *= 5.;
658 }
659
660 //=======================================================================
661 //function : MakeOffsetShape
662 //purpose  : 
663 //=======================================================================
664
665 void BRepOffset_MakeOffset::MakeOffsetShape()
666 {  
667   myDone     = Standard_False;
668   //------------------------------------------
669   // Construction of myShape without caps.
670   //------------------------------------------
671   RemoveCorks (myShape,myFaces);
672   
673   if (! IsConnectedShell(myShape))
674     Standard_ConstructionError::Raise("BRepOffset_MakeOffset : Incorrect set of faces to remove, the remaining shell is not connected");
675
676   if (Abs(myOffset) < myTol) return;
677
678   TopAbs_State       Side = TopAbs_IN;
679   if (myOffset < 0.) Side = TopAbs_OUT;
680   // ------------
681   // Preanalyse.
682   // ------------
683   EvalMax(myShape,myTol);
684   if (myTol > Abs(myOffset*0.5)) {
685     Standard_ConstructionError::Raise("BRepOffset_MakeOffset : Tol > Offset");
686   }
687   Standard_Real TolAngle = 4*ASin(myTol/Abs(myOffset*0.5));
688   myAnalyse.Perform(myShape,TolAngle);
689   //---------------------------------------------------
690   // Construction of Offset from preanalysis.
691   //---------------------------------------------------  
692   //----------------------------
693   // MaJ of SD Face - Offset
694   //----------------------------
695   UpdateFaceOffset();
696
697   if (myJoin == GeomAbs_Arc)          
698     BuildOffsetByArc();
699   else if (myJoin == GeomAbs_Intersection) 
700     BuildOffsetByInter();
701   //-----------------
702   // Auto unwinding.
703   //-----------------
704   // if (mySelfInter)  SelfInter(Modif);
705   //-----------------
706   // Intersection 3d .
707   //-----------------
708   BRepOffset_Inter3d Inter(myAsDes,Side,myTol);
709   Intersection3D (Inter);
710   //-----------------
711   // Intersection2D
712   //-----------------
713   TopTools_IndexedMapOfShape& Modif    = Inter.TouchedFaces(); 
714   TopTools_IndexedMapOfShape& NewEdges = Inter.NewEdges();
715
716   if (!Modif.IsEmpty()) Intersection2D (Modif,NewEdges);
717   //-------------------------------------------------------
718   // Unwinding 2D and reconstruction of modified faces
719   //----------------------------------------------------
720   MakeLoops (Modif);
721   //-----------------------------------------------------
722   // Reconstruction of non modified faces sharing 
723   // reconstructed edges
724   //------------------------------------------------------
725   if (!Modif.IsEmpty()) MakeFaces (Modif);
726
727   if (myThickening)
728     MakeMissingWalls();
729
730   //-------------------------
731   // Construction of shells.
732   //-------------------------
733   MakeShells ();
734   //--------------
735   // Unwinding 3D.
736   //--------------
737   SelectShells ();
738   //----------------------------------
739   // Coding of regularities.
740   //----------------------------------
741   EncodeRegularity();
742   //----------------------
743   // Creation of solids.
744   //----------------------
745   MakeSolid ();
746
747   //-----------------------------
748   // MAJ Tolerance edge and Vertex
749   // ----------------------------
750   if (!myOffsetShape.IsNull()) {
751     UpdateTolerance (myOffsetShape,myFaces);
752     BRepLib::UpdateTolerances( myOffsetShape );
753   }
754
755   CorrectConicalFaces();
756
757   myDone = Standard_True;
758 }
759
760
761
762 //=======================================================================
763 //function : MakeThickSolid
764 //purpose  : 
765 //=======================================================================
766
767 void BRepOffset_MakeOffset::MakeThickSolid() 
768 {
769   //--------------------------------------------------------------
770   // Construction of shell parallel to shell (initial without cap).
771   //--------------------------------------------------------------
772   MakeOffsetShape ();
773
774   //--------------------------------------------------------------------
775   // Construction of a solid with the initial shell, parallel shell 
776   // limited by caps.
777   //--------------------------------------------------------------------
778   if (!myFaces.IsEmpty()) {
779     TopoDS_Solid    Res;
780     TopExp_Explorer exp;
781     BRep_Builder    B;
782     Standard_Integer NbF = myFaces.Extent();
783
784     B.MakeSolid(Res);
785
786     BRepTools_Quilt Glue;
787     for (exp.Init(myShape,TopAbs_FACE); exp.More(); exp.Next()) {
788       NbF++;
789       Glue.Add (exp.Current());
790     } 
791     Standard_Boolean YaResult = 0;
792     if (!myOffsetShape.IsNull())
793       {
794       for (exp.Init(myOffsetShape,TopAbs_FACE);exp.More(); exp.Next())
795         {
796         YaResult = 1;
797         Glue.Add (exp.Current().Reversed());
798         }
799 #ifdef DEB
800       if(YaResult == 0)
801         {
802         cout << "OffsetShape does not contain a FACES." << endl;
803         }
804 #endif
805       }
806 #ifdef DEB
807     else
808       {
809       cout << "OffsetShape is null!" << endl;
810       }
811 #endif
812
813     if (YaResult == 0)
814       {
815       myDone = Standard_False;
816       return;
817       }
818
819     myOffsetShape = Glue.Shells();
820     for (exp.Init(myOffsetShape,TopAbs_SHELL); exp.More(); exp.Next()) {
821       B.Add(Res,exp.Current());
822     }
823     Res.Closed(Standard_True);
824     myOffsetShape = Res;
825
826     // Test of Validity of the result of thick Solid 
827     // more face than the initial solid.
828         
829     Standard_Integer NbOF = 0;
830     for (exp.Init(myOffsetShape,TopAbs_FACE);exp.More(); exp.Next()) {
831       NbOF++;
832     }
833     if (NbOF <= NbF) {
834       myDone = Standard_False;
835       return;
836     }
837   }
838
839   if (myOffset > 0 ) myOffsetShape.Reverse();  
840
841   myDone = Standard_True;
842 }
843
844 //=======================================================================
845 //function : IsDone
846 //purpose  : 
847 //=======================================================================
848
849 Standard_Boolean BRepOffset_MakeOffset::IsDone() const
850 {
851   return myDone;
852 }
853
854 //=======================================================================
855 //function : Error
856 //purpose  : 
857 //=======================================================================
858
859 BRepOffset_Error BRepOffset_MakeOffset::Error() const
860 {
861   return myError;
862 }
863
864 //=======================================================================
865 //function : Shape
866 //purpose  : 
867 //=======================================================================
868
869 const TopoDS_Shape&  BRepOffset_MakeOffset::Shape() const 
870 {
871   return myOffsetShape;
872 }
873
874 //=======================================================================
875 //function : TrimEdge
876 //purpose  : Trim the edge of the largest of descendants in AsDes2d.
877 //           Order in AsDes two vertices that have trimmed the edge.
878 //=======================================================================
879
880 static void TrimEdge (TopoDS_Edge&                  NE,
881                       const Handle(BRepAlgo_AsDes)& AsDes2d,
882                             Handle(BRepAlgo_AsDes)& AsDes)
883 {
884   Standard_Real aSameParTol = Precision::Confusion();
885   
886   TopoDS_Vertex V1,V2;
887   Standard_Real U;
888   Standard_Real UMin =  Precision::Infinite();
889   Standard_Real UMax = -UMin;
890
891   const TopTools_ListOfShape& LE = AsDes2d->Descendant(NE);
892   
893   if (LE.Extent() > 1) {
894     TopTools_ListIteratorOfListOfShape it (LE);
895     for (; it.More(); it.Next()) {
896       TopoDS_Vertex V = TopoDS::Vertex(it.Value());
897       if (NE.Orientation() == TopAbs_REVERSED)
898         V.Reverse();
899       //V.Orientation(TopAbs_INTERNAL);
900       if (!FindParameter(V, NE, U))
901         {
902           Standard_Real f, l;
903           Handle(Geom_Curve) theCurve = BRep_Tool::Curve(NE, f, l);
904           gp_Pnt thePoint = BRep_Tool::Pnt(V);
905           GeomAPI_ProjectPointOnCurve Projector(thePoint, theCurve);
906           if (Projector.NbPoints() == 0)
907             Standard_ConstructionError::Raise("BRepOffset_MakeOffset::TrimEdge no projection");
908           U = Projector.LowerDistanceParameter();
909         }
910       if (U < UMin) {
911         UMin = U; V1   = V;
912       }
913       if (U > UMax) {
914         UMax = U; V2   = V;
915       }
916     }
917     if (V1.IsNull() || V2.IsNull()) {
918       Standard_ConstructionError::Raise("BRepOffset_MakeOffset::TrimEdge");
919     }
920     if (!V1.IsSame(V2)) {
921       NE.Free( Standard_True );
922       BRep_Builder B;
923       TopAbs_Orientation Or = NE.Orientation();
924       NE.Orientation(TopAbs_FORWARD);
925       TopoDS_Vertex VF,VL;
926       TopExp::Vertices (NE,VF,VL);
927       B.Remove(NE,VF);
928       B.Remove(NE,VL);
929       B.Add  (NE,V1.Oriented(TopAbs_FORWARD));
930       B.Add  (NE,V2.Oriented(TopAbs_REVERSED));
931       B.Range(NE,UMin,UMax);
932       NE.Orientation(Or);
933       AsDes->Add(NE,V1.Oriented(TopAbs_FORWARD));
934       AsDes->Add(NE,V2.Oriented(TopAbs_REVERSED));
935       BRepLib::SameParameter(NE, aSameParTol, Standard_True);
936     }
937   }
938 }
939
940 //=======================================================================
941 //function : BuildOffsetByInter
942 //purpose  : 
943 //=======================================================================
944 void BRepOffset_MakeOffset::BuildOffsetByInter()
945 {
946 #ifdef  DEB
947   if ( ChronBuild) {
948     cout << " CONSTRUCTION OF OFFSETS :" << endl;
949     Clock.Reset();
950     Clock.Start();
951   }
952 #endif
953
954   BRepOffset_DataMapOfShapeOffset MapSF;
955   TopTools_MapOfShape             Done;
956   Standard_Boolean OffsetOutside = (myOffset > 0.)? Standard_True : Standard_False;
957   //--------------------------------------------------------
958   // Construction of faces parallel to initial faces
959   //--------------------------------------------------------
960   TopExp_Explorer Exp;
961   TopTools_ListOfShape LF;
962   TopTools_ListIteratorOfListOfShape itLF;
963
964   BRepLib::SortFaces(myShape,LF);
965
966   TopTools_DataMapOfShapeShape ShapeTgt;
967   for (itLF.Initialize(LF); itLF.More(); itLF.Next()) {
968     const TopoDS_Face&   F = TopoDS::Face(itLF.Value());
969     Standard_Real CurOffset = myOffset;
970     if (myFaceOffset.IsBound(F)) CurOffset = myFaceOffset(F);
971     BRepOffset_Offset    OF(F,CurOffset,ShapeTgt,OffsetOutside,myJoin);
972     TopTools_ListOfShape Let;
973     myAnalyse.Edges(F,BRepOffset_Tangent,Let);
974     TopTools_ListIteratorOfListOfShape itl(Let);
975     
976     for ( ; itl.More(); itl.Next()) {
977       const TopoDS_Edge& Cur = TopoDS::Edge(itl.Value());
978       if ( !ShapeTgt.IsBound(Cur)) {
979         TopoDS_Shape aLocalShape = OF.Generated(Cur);
980         const TopoDS_Edge& OTE = TopoDS::Edge(aLocalShape);
981 //      const TopoDS_Edge& OTE = TopoDS::Edge(OF.Generated(Cur));
982         ShapeTgt.Bind(Cur,OF.Generated(Cur));
983         TopoDS_Vertex V1,V2,OV1,OV2;
984         TopExp::Vertices (Cur,V1,V2);
985         TopExp::Vertices (OTE,OV1,OV2);      
986         TopTools_ListOfShape LE;
987         if (!ShapeTgt.IsBound(V1)) {
988           myAnalyse.Edges(V1,BRepOffset_Tangent,LE);
989           const TopTools_ListOfShape& LA =myAnalyse.Ancestors(V1);
990           if (LE.Extent() == LA.Extent())
991             ShapeTgt.Bind(V1,OV1);
992         }
993         if (!ShapeTgt.IsBound(V2)) {
994           LE.Clear();
995           myAnalyse.Edges(V2,BRepOffset_Tangent,LE);
996           const TopTools_ListOfShape& LA =myAnalyse.Ancestors(V2);
997           if (LE.Extent() == LA.Extent())
998             ShapeTgt.Bind(V2,OV2);
999         }
1000       }
1001     }
1002     MapSF.Bind(F,OF);
1003   }
1004   //--------------------------------------------------------------------
1005   // MES   : Map of OffsetShape -> Extended Shapes.
1006   // Build : Map of Initial SS  -> OffsetShape build by Inter.
1007   //                               can be an edge or a compound of edges       
1008   //---------------------------------------------------------------------
1009   TopTools_DataMapOfShapeShape MES;  
1010   TopTools_DataMapOfShapeShape Build; 
1011   TopTools_ListOfShape         Failed;
1012   TopAbs_State                 Side = TopAbs_IN;  
1013   Handle(BRepAlgo_AsDes)       AsDes = new BRepAlgo_AsDes();
1014
1015   //-------------------------------------------------------------------
1016   // Extension of faces and calculation of new edges of intersection.
1017   //-------------------------------------------------------------------
1018   Standard_Boolean  ExtentContext = 0;
1019   if (myOffset > 0) ExtentContext = 1;
1020
1021   BRepOffset_Inter3d Inter3 (AsDes,Side,myTol);
1022   // Intersection between parallel faces
1023   Inter3.ConnexIntByInt(myShape,MapSF,myAnalyse,MES,Build,Failed );
1024   // Intersection with caps.
1025   Inter3.ContextIntByInt(myFaces,ExtentContext,MapSF,myAnalyse,MES,Build,Failed );
1026
1027
1028   //---------------------------------------------------------------------------------
1029   // Extension of neighbor edges of new edges and intersection between neighbors.
1030   //--------------------------------------------------------------------------------
1031   Handle(BRepAlgo_AsDes) AsDes2d = new BRepAlgo_AsDes();
1032   for (Exp.Init(myShape,TopAbs_FACE) ; Exp.More(); Exp.Next()) {
1033     const TopoDS_Face& FI = TopoDS::Face(Exp.Current());
1034 //  Modified by skv - Mon Jan 12 11:50:02 2004 OCC4455 Begin
1035 //    BRepOffset_Inter2d::ConnexIntByInt (FI,MapSF(FI),MES,Build,AsDes2d,myTol);
1036     BRepOffset_Inter2d::ConnexIntByInt (FI,MapSF(FI),MES,Build,AsDes2d,myOffset, myTol);
1037 //  Modified by skv - Mon Jan 12 11:50:03 2004 OCC4455 End
1038   }
1039   //-----------------------------------------------------------
1040   // Great restriction of new edges and update of AsDes.
1041   //------------------------------------------ ----------------
1042   TopTools_IndexedMapOfShape NewEdges;
1043   TopExp_Explorer Exp2,ExpC;
1044   TopoDS_Shape    NE;
1045   TopoDS_Edge     TNE;
1046   TopoDS_Face     NF;
1047   
1048   for (Exp.Init(myShape,TopAbs_FACE) ; Exp.More(); Exp.Next()) {
1049     const TopoDS_Face& FI = TopoDS::Face(Exp.Current());
1050     NF = MapSF(FI).Face();
1051     if (MES.IsBound(NF)) {NF = TopoDS::Face(MES(NF));}
1052     TopTools_MapOfShape View;
1053     for (Exp2.Init(FI.Oriented(TopAbs_FORWARD),TopAbs_EDGE); Exp2.More(); Exp2.Next()) {
1054       const TopoDS_Edge& EI = TopoDS::Edge(Exp2.Current());
1055       if (View.Add(EI)) {
1056         if (Build.IsBound(EI)) {
1057           NE = Build(EI);
1058           if (NE.ShapeType() == TopAbs_EDGE) {
1059             if (NewEdges.Add(NE)) {TrimEdge (TopoDS::Edge(NE),AsDes2d,AsDes);}
1060           }
1061           else {
1062             //------------------------------------------------------------
1063             // The Intersections are on several edges.
1064             // The pieces without intersections with neighbors  
1065             // are removed from AsDes.
1066             //------------------------------------------------------------
1067             for (ExpC.Init(NE,TopAbs_EDGE); ExpC.More(); ExpC.Next()) {
1068               if (NewEdges.Add(ExpC.Current())) {
1069                 TopoDS_Edge NEC = TopoDS::Edge(ExpC.Current());
1070                 NEC.Free(Standard_True);
1071                 if (!AsDes2d->Descendant(NEC).IsEmpty()) {
1072                   TrimEdge (NEC,AsDes2d,AsDes);
1073                 }
1074                 else {
1075                   AsDes->Remove(NEC);
1076                 }
1077               }
1078             }
1079           }
1080         }
1081         else {
1082           NE = MapSF(FI).Generated(EI);
1083           //// modified by jgv, 19.12.03 for OCC4455 ////
1084           NE.Orientation( EI.Orientation() );
1085           ///////////////////////////////////////////////
1086           if (MES.IsBound(NE)) {
1087             NE = MES(NE);
1088             NE.Orientation(EI.Orientation());
1089             if (NewEdges.Add(NE)) {TrimEdge (TopoDS::Edge(NE),AsDes2d,AsDes);} 
1090           }
1091           AsDes->Add(NF,NE);
1092         } 
1093       }
1094     }
1095   }
1096   
1097   //--------------------------------- 
1098   // Intersection 2D on //
1099   //---------------------------------  
1100   TopTools_ListOfShape LFE; 
1101   BRepAlgo_Image     IMOE;
1102   for (Exp.Init(myShape,TopAbs_FACE) ; Exp.More(); Exp.Next()) {
1103     const TopoDS_Shape& FI  = Exp.Current();
1104     const TopoDS_Shape& OFI = MapSF(FI).Face();
1105     if (MES.IsBound(OFI)) {
1106       const TopoDS_Face& NF = TopoDS::Face(MES(OFI));
1107       LFE.Append(NF);
1108       IMOE.SetRoot(NF);
1109     }
1110   }
1111   
1112   TopTools_ListIteratorOfListOfShape itLFE(LFE);
1113   for (; itLFE.More(); itLFE.Next()) {
1114     const TopoDS_Face& NEF = TopoDS::Face(itLFE.Value());
1115     BRepOffset_Inter2d::Compute(AsDes,NEF,NewEdges,myTol);
1116   }
1117   //----------------------------------------------
1118   // Intersections 2d on caps.
1119   //----------------------------------------------
1120   Standard_Integer i;
1121   for (i = 1; i <= myFaces.Extent(); i++) {
1122     const TopoDS_Face& Cork = TopoDS::Face(myFaces(i));
1123     BRepOffset_Inter2d::Compute(AsDes,Cork,NewEdges,myTol);
1124   }
1125
1126   //-------------------------------
1127   // Unwinding of extended Faces.
1128   //-------------------------------
1129   myMakeLoops.Build(LFE  ,AsDes,IMOE);
1130
1131 #ifdef DEB
1132   TopTools_IndexedMapOfShape COES;
1133 #endif
1134   //---------------------------
1135   // MAJ SD. for faces //
1136   //---------------------------
1137   for (Exp.Init(myShape,TopAbs_FACE) ; Exp.More(); Exp.Next()) {
1138     const TopoDS_Shape& FI   = Exp.Current();
1139     myInitOffsetFace.SetRoot(FI);
1140     TopoDS_Face  OF  = MapSF(FI).Face();
1141     if (MES.IsBound(OF)) {
1142       OF = TopoDS::Face(MES(OF));
1143       if (IMOE.HasImage(OF)) {
1144         const TopTools_ListOfShape& LOFE = IMOE.Image(OF);
1145         myInitOffsetFace.Bind(FI,LOFE);
1146         for (itLF.Initialize(LOFE); itLF.More(); itLF.Next()) {
1147           const TopoDS_Shape& OFE =  itLF.Value();
1148           myImageOffset.SetRoot(OFE);
1149 #ifdef DRAW
1150           if (AffichInt2d) {
1151             sprintf(name,"AF_%d",NbAF++);
1152             DBRep::Set(name,OFE);
1153           }
1154 #endif
1155           TopTools_MapOfShape View;
1156           for (Exp2.Init(OFE.Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
1157                Exp2.More(); Exp2.Next()) {
1158             const TopoDS_Edge& COE = TopoDS::Edge(Exp2.Current());
1159             
1160             myAsDes->Add (OFE,COE);
1161 #ifdef DRAW
1162             if (AffichInt2d) {
1163               sprintf(name,"AE_%d",NbAE++);
1164               DBRep::Set(name,COE);
1165               COES.Add(COE);
1166             }
1167 #endif
1168             if (View.Add(COE)){
1169               if (!myAsDes->HasDescendant(COE)) {
1170                 TopoDS_Vertex CV1,CV2;
1171                 TopExp::Vertices(COE,CV1,CV2);
1172                 if (!CV1.IsNull()) myAsDes->Add(COE,CV1.Oriented(TopAbs_FORWARD));
1173                 if (!CV2.IsNull()) myAsDes->Add(COE,CV2.Oriented(TopAbs_REVERSED));     
1174               }
1175             }
1176           }
1177         }
1178       }
1179       else {
1180         myInitOffsetFace.Bind(FI,OF);
1181         myImageOffset.SetRoot(OF);
1182 #ifdef DRAW 
1183         if (AffichInt2d) {
1184           sprintf(name,"AF_%d",NbAF++);
1185           DBRep::Set(name,OF);
1186         }
1187 #endif
1188         const TopTools_ListOfShape& LE = AsDes->Descendant(OF);
1189         for (itLF.Initialize(LE) ; itLF.More(); itLF.Next()) {
1190           const TopoDS_Edge& OE = TopoDS::Edge(itLF.Value());
1191           if (IMOE.HasImage(OE)) {
1192             const TopTools_ListOfShape& LOE = IMOE.Image(OE);
1193             TopTools_ListIteratorOfListOfShape itLOE(LOE);
1194             for (; itLOE.More(); itLOE.Next()) {
1195               TopoDS_Shape aLocalShape = itLOE.Value().Oriented(OE.Orientation());
1196               const TopoDS_Edge& COE = TopoDS::Edge(aLocalShape);
1197 //            const TopoDS_Edge& COE = TopoDS::Edge(itLOE.Value().Oriented(OE.Orientation()));
1198               myAsDes->Add(OF,COE);
1199 #ifdef DRAW
1200               if (AffichInt2d) {
1201                 sprintf(name,"AE_%d",NbAE++);
1202                 DBRep::Set(name,COE);
1203                 COES.Add(COE);
1204               }
1205 #endif
1206               
1207               if (!myAsDes->HasDescendant(COE)) {
1208                 TopoDS_Vertex CV1,CV2;
1209                 TopExp::Vertices(COE,CV1,CV2);
1210                 if (!CV1.IsNull()) myAsDes->Add(COE,CV1.Oriented(TopAbs_FORWARD));
1211                 if (!CV2.IsNull()) myAsDes->Add(COE,CV2.Oriented(TopAbs_REVERSED));     
1212               }
1213             }
1214           }
1215           else {
1216             myAsDes->Add(OF,OE);
1217 #ifdef DRAW
1218             if (AffichInt2d) {
1219               sprintf(name,"AE_%d",NbAE++);
1220               DBRep::Set(name,OE);
1221               COES.Add(OE);
1222             }
1223 #endif
1224
1225             const TopTools_ListOfShape& LV = AsDes->Descendant(OE);
1226             myAsDes->Add(OE,LV);
1227           }
1228         }
1229       }
1230     }
1231     else {
1232       myInitOffsetFace.Bind(FI,OF);
1233       myImageOffset.SetRoot(OF);
1234       TopTools_MapOfShape View;
1235       for (Exp2.Init(OF.Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
1236            Exp2.More(); Exp2.Next()) {
1237
1238         const TopoDS_Edge& COE = TopoDS::Edge(Exp2.Current());
1239         myAsDes->Add (OF,COE);
1240 #ifdef DRAW
1241         if (AffichInt2d) {
1242           sprintf(name,"AE_%d",NbAE++);
1243           DBRep::Set(name,COE);
1244           COES.Add(COE);
1245         }
1246 #endif
1247         
1248         if (View.Add(Exp2.Current())) {
1249           if (!myAsDes->HasDescendant(COE)) {
1250             TopoDS_Vertex CV1,CV2;
1251             TopExp::Vertices(COE,CV1,CV2);
1252             if (!CV1.IsNull()) myAsDes->Add(COE,CV1.Oriented(TopAbs_FORWARD));
1253             if (!CV2.IsNull()) myAsDes->Add(COE,CV2.Oriented(TopAbs_REVERSED)); 
1254           }
1255         }
1256       } 
1257     }
1258   }
1259   //  Modified by skv - Tue Mar 15 16:20:43 2005
1260   // Add methods for supporting history.
1261   TopTools_MapOfShape aMapEdges;
1262
1263   for (Exp.Init(myShape,TopAbs_FACE) ; Exp.More(); Exp.Next()) {
1264     const TopoDS_Shape& aFaceRef = Exp.Current();
1265
1266     Exp2.Init(aFaceRef.Oriented(TopAbs_FORWARD), TopAbs_EDGE);
1267
1268     for (; Exp2.More(); Exp2.Next()) {
1269       const TopoDS_Shape& anEdgeRef = Exp2.Current();
1270
1271       if (aMapEdges.Add(anEdgeRef)) {
1272         myInitOffsetEdge.SetRoot(anEdgeRef);
1273         if (Build.IsBound(anEdgeRef)) {
1274           TopoDS_Shape aNewShape = Build(anEdgeRef);
1275           
1276           if (aNewShape.ShapeType() == TopAbs_EDGE) {
1277             if (IMOE.HasImage(aNewShape)) {
1278               const TopTools_ListOfShape& aListNewE = IMOE.Image(aNewShape);
1279               
1280               myInitOffsetEdge.Bind (anEdgeRef, aListNewE);
1281             } else
1282               myInitOffsetEdge.Bind (anEdgeRef, aNewShape);
1283           } else { // aNewShape != TopAbs_EDGE
1284             TopTools_ListOfShape aListNewEdge;
1285             
1286             for (ExpC.Init(aNewShape, TopAbs_EDGE); ExpC.More(); ExpC.Next()) {
1287               const TopoDS_Shape &aResEdge = ExpC.Current();
1288               
1289               if (IMOE.HasImage(aResEdge)) {
1290                 const TopTools_ListOfShape& aListNewE = IMOE.Image(aResEdge);
1291                 TopTools_ListIteratorOfListOfShape aNewEIter(aListNewE);
1292                 
1293                 for (; aNewEIter.More(); aNewEIter.Next())
1294                   aListNewEdge.Append(aNewEIter.Value());
1295               } else
1296                 aListNewEdge.Append(aResEdge);
1297             }
1298             
1299             myInitOffsetEdge.Bind (anEdgeRef, aListNewEdge);
1300           }
1301         } 
1302         else { // Free boundary.
1303           TopoDS_Shape aNewEdge = MapSF(aFaceRef).Generated(anEdgeRef);
1304
1305           if (MES.IsBound(aNewEdge))
1306             aNewEdge = MES(aNewEdge);
1307
1308           if (IMOE.HasImage(aNewEdge)) {
1309             const TopTools_ListOfShape& aListNewE = IMOE.Image(aNewEdge);
1310
1311             myInitOffsetEdge.Bind (anEdgeRef, aListNewE);
1312           } else
1313             myInitOffsetEdge.Bind (anEdgeRef, aNewEdge);
1314         }
1315       }
1316     }
1317   }
1318 //  Modified by skv - Tue Mar 15 16:20:43 2005
1319
1320   //---------------------------
1321   // MAJ SD. for caps 
1322   //---------------------------
1323   //TopTools_MapOfShape View; 
1324   for (i = 1; i <= myFaces.Extent(); i++) {
1325     const TopoDS_Shape& Cork = myFaces(i);
1326     const TopTools_ListOfShape& LE = AsDes->Descendant(Cork);
1327     for (itLF.Initialize(LE) ; itLF.More(); itLF.Next()) {
1328       const TopoDS_Edge& OE = TopoDS::Edge(itLF.Value());
1329       if (IMOE.HasImage(OE)) {
1330         const TopTools_ListOfShape& LOE = IMOE.Image(OE);
1331         TopTools_ListIteratorOfListOfShape itLOE(LOE);
1332         for (; itLOE.More(); itLOE.Next()) {
1333           const TopoDS_Edge& COE = TopoDS::Edge(itLOE.Value());
1334           myAsDes->Add(Cork,COE.Oriented(OE.Orientation())) ;
1335 #ifdef DRAW
1336           if (AffichInt2d) {
1337             sprintf(name,"AE_%d",NbAE++);
1338             DBRep::Set(name,COE);
1339             COES.Add(COE);
1340           }
1341 #endif
1342           
1343           if (!myAsDes->HasDescendant(COE)) {
1344             TopoDS_Vertex CV1,CV2;
1345             TopExp::Vertices(COE,CV1,CV2);
1346             if (!CV1.IsNull()) myAsDes->Add(COE,CV1.Oriented(TopAbs_FORWARD));
1347             if (!CV2.IsNull()) myAsDes->Add(COE,CV2.Oriented(TopAbs_REVERSED));   
1348           }
1349         }
1350       }
1351       else {
1352         myAsDes->Add(Cork,OE);
1353         if (AsDes->HasDescendant(OE)) {
1354           myAsDes->Add(OE,AsDes->Descendant(OE));
1355         }
1356 #ifdef DRAW
1357         if (AffichInt2d) {
1358           sprintf(name,"AE_%d",NbAE++);
1359           DBRep::Set(name,OE);
1360           COES.Add(OE);
1361         }
1362 #endif
1363       }
1364     }
1365   }
1366   
1367 #ifdef DEB
1368   DEBVerticesControl (COES,myAsDes);
1369   if ( ChronBuild) Clock.Show();
1370 #endif
1371 }
1372
1373
1374 //=======================================================================
1375 //function : BuildOffsetByArc
1376 //purpose  : 
1377 //=======================================================================
1378 void BRepOffset_MakeOffset::BuildOffsetByArc()
1379 {
1380 #ifdef  DEB
1381   if ( ChronBuild) {
1382     cout << " CONSTRUCTION OF OFFSETS :" << endl;
1383     Clock.Reset();
1384     Clock.Start();
1385   }
1386 #endif
1387
1388   BRepOffset_DataMapOfShapeOffset MapSF;
1389   TopTools_MapOfShape             Done;
1390   Standard_Boolean OffsetOutside = (myOffset > 0.)? Standard_True : Standard_False;
1391   //--------------------------------------------------------
1392   // Construction of faces parallel to initial faces
1393   //--------------------------------------------------------
1394   TopExp_Explorer Exp;
1395   TopTools_ListOfShape LF;
1396   TopTools_ListIteratorOfListOfShape itLF;
1397
1398   BRepLib::SortFaces(myShape,LF);
1399
1400   TopTools_DataMapOfShapeShape EdgeTgt;
1401   for (itLF.Initialize(LF); itLF.More(); itLF.Next()) {
1402     const TopoDS_Face&   F = TopoDS::Face(itLF.Value());
1403     Standard_Real CurOffset = myOffset;
1404     if (myFaceOffset.IsBound(F)) CurOffset = myFaceOffset(F);
1405     BRepOffset_Offset    OF(F,CurOffset,EdgeTgt,OffsetOutside,myJoin);
1406     TopTools_ListOfShape Let;
1407     myAnalyse.Edges(F,BRepOffset_Tangent,Let);
1408     TopTools_ListIteratorOfListOfShape itl(Let);
1409     
1410     for ( ; itl.More(); itl.Next()) {
1411       const TopoDS_Edge& Cur = TopoDS::Edge(itl.Value());
1412       if ( !EdgeTgt.IsBound(Cur)) {
1413         TopoDS_Shape aLocalShape = OF.Generated(Cur);
1414         const TopoDS_Edge& OTE = TopoDS::Edge(aLocalShape);
1415 //      const TopoDS_Edge& OTE = TopoDS::Edge(OF.Generated(Cur));
1416         EdgeTgt.Bind(Cur,OF.Generated(Cur));
1417         TopoDS_Vertex V1,V2,OV1,OV2;
1418         TopExp::Vertices (Cur,V1,V2);
1419         TopExp::Vertices (OTE,OV1,OV2);      
1420         TopTools_ListOfShape LE;
1421         if (!EdgeTgt.IsBound(V1)) {
1422           myAnalyse.Edges(V1,BRepOffset_Tangent,LE);
1423           const TopTools_ListOfShape& LA =myAnalyse.Ancestors(V1);
1424           if (LE.Extent() == LA.Extent())
1425             EdgeTgt.Bind(V1,OV1);
1426         }
1427         if (!EdgeTgt.IsBound(V2)) {
1428           LE.Clear();
1429           myAnalyse.Edges(V2,BRepOffset_Tangent,LE);
1430           const TopTools_ListOfShape& LA =myAnalyse.Ancestors(V2);
1431           if (LE.Extent() == LA.Extent())
1432               EdgeTgt.Bind(V2,OV2);
1433         }
1434       }
1435     }
1436     MapSF.Bind(F,OF);
1437   }
1438   //--------------------------------------------------------
1439   // Construction of tubes on edge.
1440   //--------------------------------------------------------
1441   BRepOffset_Type    OT = BRepOffset_Convex;
1442   if (myOffset < 0.) OT = BRepOffset_Concave; 
1443    
1444   for (Exp.Init(myShape,TopAbs_EDGE); Exp.More(); Exp.Next()) {
1445     const TopoDS_Edge& E = TopoDS::Edge(Exp.Current());
1446     if (Done.Add(E)) {
1447       const TopTools_ListOfShape& Anc = myAnalyse.Ancestors(E);
1448       if (Anc.Extent() == 2) {
1449         const BRepOffset_ListOfInterval& L = myAnalyse.Type(E);
1450         if (!L.IsEmpty() && L.First().Type() == OT) {
1451           Standard_Real CurOffset = myOffset;
1452           if ( myFaceOffset.IsBound(Anc.First()))
1453             CurOffset = myFaceOffset(Anc.First());
1454           TopoDS_Shape aLocalShape = MapSF(Anc.First()).Generated(E);
1455           TopoDS_Edge EOn1 = TopoDS::Edge(aLocalShape);
1456           aLocalShape = MapSF(Anc.Last()).Generated(E);
1457           TopoDS_Edge EOn2 = TopoDS::Edge(aLocalShape);
1458 //        TopoDS_Edge EOn1 = TopoDS::Edge(MapSF(Anc.First()).Generated(E));
1459 //        TopoDS_Edge EOn2 = TopoDS::Edge(MapSF(Anc.Last()) .Generated(E));
1460           // find if exits tangent edges in the original shape
1461           TopoDS_Edge E1f, E1l;
1462           TopoDS_Vertex V1f, V1l;
1463           TopExp::Vertices(E,V1f,V1l);
1464           TopTools_ListOfShape TangE;
1465           myAnalyse.TangentEdges(E,V1f,TangE);
1466           // find if the pipe on the tangent edges are soon created.
1467           TopTools_ListIteratorOfListOfShape itl(TangE);
1468           Standard_Boolean Find = Standard_False;
1469           for ( ; itl.More() && !Find; itl.Next()) {
1470             if ( MapSF.IsBound(itl.Value())) {
1471               TopoDS_Shape aLocalShape = MapSF(itl.Value()).Generated(V1f);
1472               E1f  = TopoDS::Edge(aLocalShape);
1473 //            E1f  = TopoDS::Edge(MapSF(itl.Value()).Generated(V1f));
1474               Find = Standard_True;
1475             }
1476           }
1477           TangE.Clear();
1478           myAnalyse.TangentEdges(E,V1l,TangE);
1479           // find if the pipe on the tangent edges are soon created.
1480           itl.Initialize(TangE);
1481           Find = Standard_False;
1482           for ( ; itl.More() && !Find; itl.Next()) {
1483             if ( MapSF.IsBound(itl.Value())) {
1484               TopoDS_Shape aLocalShape = MapSF(itl.Value()).Generated(V1l);
1485               E1l  = TopoDS::Edge(aLocalShape);
1486 //            E1l  = TopoDS::Edge(MapSF(itl.Value()).Generated(V1l));
1487               Find = Standard_True;
1488             }
1489           }
1490           BRepOffset_Offset OF (E,EOn1,EOn2,CurOffset,E1f, E1l);
1491           MapSF.Bind(E,OF);
1492         }
1493       }
1494       else {
1495         // ----------------------
1496         // free border.
1497         // ----------------------
1498         TopoDS_Shape aLocalShape = MapSF(Anc.First()).Generated(E);
1499         TopoDS_Edge EOn1 = TopoDS::Edge(aLocalShape);
1500 ///     TopoDS_Edge EOn1 = TopoDS::Edge(MapSF(Anc.First()).Generated(E));
1501         myInitOffsetEdge.SetRoot(E); // skv: supporting history.
1502         myInitOffsetEdge.Bind (E,EOn1);      
1503       }
1504     }
1505   }
1506
1507   //--------------------------------------------------------
1508   // Construction of spheres on vertex.
1509   //--------------------------------------------------------
1510   Done.Clear();
1511   TopTools_ListIteratorOfListOfShape it;
1512
1513   for (Exp.Init(myShape,TopAbs_VERTEX); Exp.More(); Exp.Next()) {
1514     const TopoDS_Vertex& V = TopoDS::Vertex (Exp.Current());
1515     if (Done.Add(V)) {
1516       const TopTools_ListOfShape& LA = myAnalyse.Ancestors(V);
1517       TopTools_ListOfShape LE;
1518       myAnalyse.Edges(V,OT,LE);
1519
1520       if (LE.Extent() >= 3 && LE.Extent() == LA.Extent()) {
1521         TopTools_ListOfShape LOE;
1522         //--------------------------------------------------------
1523         // Return connected edges on tubes.
1524         //--------------------------------------------------------
1525         for (it.Initialize(LE) ; it.More(); it.Next()) {
1526           LOE.Append(MapSF(it.Value()).Generated(V).Reversed());
1527         }
1528         //----------------------
1529         // construction sphere.
1530         //-----------------------
1531         const TopTools_ListOfShape& LLA = myAnalyse.Ancestors(LA.First());
1532         const TopoDS_Shape& FF = LLA.First();
1533         Standard_Real CurOffset = myOffset;
1534         if ( myFaceOffset.IsBound(FF))
1535           CurOffset = myFaceOffset(FF);
1536         
1537         BRepOffset_Offset OF(V,LOE,CurOffset);
1538         MapSF.Bind(V,OF);
1539       }
1540       //--------------------------------------------------------------
1541       // Particular processing if V is at least a free border.
1542       //-------------------------------------------------------------
1543       TopTools_ListOfShape LBF;
1544       myAnalyse.Edges(V,BRepOffset_FreeBoundary,LBF);
1545       if (!LBF.IsEmpty()) {     
1546         Standard_Boolean First = Standard_True;
1547         for (it.Initialize(LE) ; it.More(); it.Next()) {
1548           if (First) {
1549             myInitOffsetEdge.SetRoot(V); // skv: supporting history.
1550             myInitOffsetEdge.Bind(V,MapSF(it.Value()).Generated(V));
1551             First = Standard_False;
1552           }
1553           else {
1554             myInitOffsetEdge.Add(V,MapSF(it.Value()).Generated(V));
1555           }
1556         } 
1557       }
1558     }
1559   }
1560
1561   //------------------------------------------------------------
1562   // Extension of parallel faces to the context.
1563   // Extended faces are ordered in DS and removed from MapSF.
1564   //------------------------------------------------------------
1565   if (!myFaces.IsEmpty()) ToContext (MapSF);
1566
1567   //------------------------------------------------------
1568   // MAJ SD.
1569   //------------------------------------------------------
1570   BRepOffset_Type    RT = BRepOffset_Concave;
1571   if (myOffset < 0.) RT = BRepOffset_Convex;
1572   BRepOffset_DataMapIteratorOfDataMapOfShapeOffset It(MapSF);
1573   for ( ; It.More(); It.Next()) {
1574     const TopoDS_Shape& SI = It.Key(); 
1575     const BRepOffset_Offset& SF = It.Value();
1576     if (SF.Status() == BRepOffset_Reversed ||
1577         SF.Status() == BRepOffset_Degenerated ) {
1578       //------------------------------------------------
1579       // Degenerated or returned faces are not stored.
1580       //------------------------------------------------
1581       continue; 
1582     }   
1583
1584     const TopoDS_Face&  OF = It.Value().Face();
1585     myInitOffsetFace.Bind    (SI,OF);      
1586     myInitOffsetFace.SetRoot (SI);      // Initial<-> Offset
1587     myImageOffset.SetRoot    (OF);      // FaceOffset root of images
1588     
1589     if (SI.ShapeType() == TopAbs_FACE) {
1590       for (Exp.Init(SI.Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
1591            Exp.More(); Exp.Next()) {
1592         //--------------------------------------------------------------------
1593         // To each face are associatedthe edges that restrict that 
1594         // The edges that do not generate tubes or are not tangent
1595         // to two faces are removed.
1596         //--------------------------------------------------------------------
1597         const TopoDS_Edge& E = TopoDS::Edge(Exp.Current());
1598         const BRepOffset_ListOfInterval& L  = myAnalyse.Type(E);
1599         if (!L.IsEmpty() && L.First().Type() != RT) {
1600           TopAbs_Orientation OO  = E.Orientation();
1601           TopoDS_Shape aLocalShape = It.Value().Generated(E);
1602           TopoDS_Edge        OE  = TopoDS::Edge(aLocalShape);
1603 //        TopoDS_Edge        OE  = TopoDS::Edge(It.Value().Generated(E));
1604           myAsDes->Add (OF,OE.Oriented(OO));
1605         }
1606       }
1607     }
1608     else {
1609       for (Exp.Init(OF.Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
1610            Exp.More(); Exp.Next()) {
1611         myAsDes->Add (OF,Exp.Current());
1612       }
1613     }
1614   }
1615
1616 #ifdef DEB
1617   if ( ChronBuild) Clock.Show();
1618 #endif
1619 }
1620
1621
1622
1623 //=======================================================================
1624 //function : SelfInter
1625 //purpose  : 
1626 //=======================================================================
1627
1628 void BRepOffset_MakeOffset::SelfInter(TopTools_MapOfShape& /*Modif*/)
1629 {
1630 #ifdef DEB
1631   if ( ChronBuild) {
1632     cout << " AUTODEBOUCLAGE:" << endl;
1633     Clock.Reset();
1634     Clock.Start();
1635   }    
1636 #endif  
1637
1638   Standard_NotImplemented::Raise();
1639
1640 #ifdef DEB
1641   if ( ChronBuild) Clock.Show();
1642 #endif
1643 }
1644
1645
1646 //=======================================================================
1647 //function : ToContext
1648 //purpose  : 
1649 //=======================================================================
1650
1651 void BRepOffset_MakeOffset::ToContext (BRepOffset_DataMapOfShapeOffset& MapSF)
1652 {
1653   TopTools_DataMapOfShapeShape        Created;   
1654   TopTools_DataMapOfShapeShape        MEF;
1655   TopTools_IndexedMapOfShape          FacesToBuild;
1656   TopTools_ListIteratorOfListOfShape  itl;
1657   TopExp_Explorer                     exp;
1658
1659 //  TopAbs_State       Side = TopAbs_IN;  
1660 //  if (myOffset < 0.) Side = TopAbs_OUT;
1661
1662   TopAbs_State       Side = TopAbs_OUT; 
1663
1664   /*
1665   Standard_Integer i;
1666   for (i = 1; i <= myFaces.Extent(); i++) {
1667     const TopoDS_Face& CF = TopoDS::Face(myFaces(i));
1668     for (exp.Init(CF.Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
1669          exp.More(); exp.Next()) {
1670       const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
1671       if (!myAnalyse.HasAncestor(E)) {
1672         //----------------------------------------------------------------
1673         // The edges of context faces that are not in the initial shape
1674         // can appear in the result.
1675         //----------------------------------------------------------------
1676         //myAsDes->Add(CF,E);
1677       }  
1678     }
1679   }
1680   */
1681   
1682   //--------------------------------------------------------
1683   // Determine the edges and faces reconstructed by  
1684   // intersection.
1685   //---------------------------------------------------------
1686   Standard_Integer j;
1687   for (j = 1; j <= myFaces.Extent(); j++) {
1688     const TopoDS_Face& CF = TopoDS::Face(myFaces(j));
1689     for (exp.Init(CF.Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
1690          exp.More(); exp.Next()) {
1691       const TopoDS_Edge& E = TopoDS::Edge(exp.Current()); 
1692       if (myAnalyse.HasAncestor(E)) {
1693         const TopTools_ListOfShape& LEA = myAnalyse.Ancestors(E);
1694         for (itl.Initialize(LEA); itl.More(); itl.Next()) {
1695           const BRepOffset_Offset& OF = MapSF(itl.Value());
1696           FacesToBuild.Add(itl.Value());
1697           MEF.Bind(OF.Generated(E),CF);
1698         }
1699         TopoDS_Vertex V[2];
1700         TopExp::Vertices(E,V[0],V[1]);
1701         for (Standard_Integer i = 0; i < 2; i++) {
1702           const TopTools_ListOfShape& LVA =  myAnalyse.Ancestors(V[i]);
1703           for ( itl.Initialize(LVA); itl.More(); itl.Next()) {
1704             const TopoDS_Edge& EV = TopoDS::Edge(itl.Value());
1705             if (MapSF.IsBound(EV)) {
1706               const BRepOffset_Offset& OF = MapSF(EV);
1707               FacesToBuild.Add(EV);
1708               MEF.Bind(OF.Generated(V[i]),CF);
1709             }
1710           }
1711         }
1712       }
1713     }
1714   }
1715   //---------------------------
1716   // Reconstruction of faces.
1717   //---------------------------
1718   TopoDS_Face        F,NF;
1719   BRepOffset_Type    RT = BRepOffset_Concave;
1720   if (myOffset < 0.) RT = BRepOffset_Convex;
1721   TopoDS_Shape       OE,NE;
1722   TopAbs_Orientation Or;
1723
1724   for (j = 1; j <= FacesToBuild.Extent(); j++) {
1725     const TopoDS_Shape& S   = FacesToBuild(j);
1726     BRepOffset_Offset   BOF;
1727     BOF = MapSF(S);
1728     F = TopoDS::Face(BOF.Face());
1729     BRepOffset_Tool::ExtentFace(F,Created,MEF,Side,myTol,NF);
1730     MapSF.UnBind(S);
1731     //--------------
1732     // MAJ SD.
1733     //--------------
1734     myInitOffsetFace.Bind    (S,NF);      
1735     myInitOffsetFace.SetRoot (S);      // Initial<-> Offset
1736     myImageOffset.SetRoot    (NF);
1737
1738     if (S.ShapeType() == TopAbs_FACE) {
1739       for (exp.Init(S.Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
1740            exp.More(); exp.Next()) {
1741         
1742         const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
1743         const BRepOffset_ListOfInterval& L  = myAnalyse.Type(E);
1744         OE = BOF.Generated(E);
1745         Or = E.Orientation();
1746         OE.Orientation(Or);
1747         if (!L.IsEmpty() && L.First().Type() != RT) {
1748           if (Created.IsBound(OE)) {
1749             NE = Created(OE); 
1750             if (NE.Orientation() == TopAbs_REVERSED) 
1751               NE.Orientation(TopAbs::Reverse(Or));
1752             else
1753               NE.Orientation(Or);
1754             myAsDes->Add(NF,NE);
1755           }
1756           else {
1757             myAsDes->Add(NF,OE);
1758           }
1759         }
1760       }
1761     }
1762     else {
1763       //------------------
1764       // Tube
1765       //---------------------
1766       for (exp.Init(NF.Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
1767            exp.More(); exp.Next()) {
1768         myAsDes->Add (NF,exp.Current());
1769       }
1770     }    
1771     MapSF.UnBind(S);
1772   }
1773
1774   //------------------
1775   // MAJ free borders
1776   //------------------
1777   TopTools_DataMapIteratorOfDataMapOfShapeShape itc;
1778   for (itc.Initialize(Created); itc.More(); itc.Next()) {
1779     OE = itc.Key();
1780     NE = itc.Value();
1781     if (myInitOffsetEdge.IsImage(OE)) {
1782       TopoDS_Shape E = myInitOffsetEdge.ImageFrom (OE);
1783       Or = myInitOffsetEdge.Image(E).First().Orientation();
1784       if (NE.Orientation() == TopAbs_REVERSED) 
1785         NE.Orientation(TopAbs::Reverse(Or));
1786       else
1787         NE.Orientation(Or);
1788       myInitOffsetEdge.Remove(OE);
1789       myInitOffsetEdge.Bind(E,NE);
1790     }
1791   }
1792 }
1793
1794
1795 //=======================================================================
1796 //function : UpdateFaceOffset
1797 //purpose  : 
1798 //=======================================================================
1799
1800 void BRepOffset_MakeOffset::UpdateFaceOffset()
1801 {
1802   TopTools_MapOfShape M;
1803   TopTools_DataMapOfShapeReal CopiedMap;
1804   CopiedMap.Assign(myFaceOffset);
1805   TopTools_DataMapIteratorOfDataMapOfShapeReal it(CopiedMap);
1806
1807   BRepOffset_Type    RT = BRepOffset_Convex;
1808   if (myOffset < 0.) RT = BRepOffset_Concave;
1809
1810   for ( ; it.More(); it.Next()) {
1811     const TopoDS_Face& F = TopoDS::Face(it.Key());
1812     Standard_Real CurOffset = CopiedMap(F);
1813     if ( !M.Add(F)) continue;
1814     TopoDS_Compound Co;
1815     BRep_Builder Build;
1816     Build.MakeCompound(Co);
1817     TopTools_MapOfShape Dummy;
1818     Build.Add(Co,F);
1819     if (myJoin == GeomAbs_Arc)
1820       myAnalyse.AddFaces(F,Co,Dummy,BRepOffset_Tangent,RT);
1821     else   
1822       myAnalyse.AddFaces(F,Co,Dummy,BRepOffset_Tangent);
1823
1824     TopExp_Explorer exp(Co,TopAbs_FACE);
1825     for (; exp.More(); exp.Next()) {
1826       const TopoDS_Face& FF = TopoDS::Face(exp.Current());
1827       if ( !M.Add(FF)) continue;
1828       if ( myFaceOffset.IsBound(FF))
1829         myFaceOffset.UnBind(FF);
1830       myFaceOffset.Bind(FF,CurOffset);
1831     }
1832   }
1833 }
1834
1835 //=======================================================================
1836 //function : CorrectConicalFaces
1837 //purpose  : 
1838 //=======================================================================
1839
1840 void BRepOffset_MakeOffset::CorrectConicalFaces()
1841 {
1842   TopTools_SequenceOfShape Cones;
1843   TopTools_SequenceOfShape Circs;
1844   TopTools_SequenceOfShape Seams;
1845   Standard_Real TolApex = 1.e-5;
1846
1847   Standard_Integer i;
1848
1849   TopTools_DataMapOfShapeListOfShape FacesOfCone;
1850   //TopTools_DataMapOfShapeShape DegEdges;
1851   TopExp_Explorer Explo( myOffsetShape, TopAbs_FACE );
1852   if (myJoin == GeomAbs_Arc)
1853     {
1854       for (; Explo.More(); Explo.Next())
1855         {
1856           TopoDS_Face aFace = TopoDS::Face( Explo.Current() );
1857           Handle(Geom_Surface) aSurf = BRep_Tool::Surface( aFace );
1858           //if (aSurf->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface))
1859           //aSurf = (Handle(Geom_OffsetSurface)::DownCast(aSurf))->BasisSurface(); //???
1860           
1861           TopTools_IndexedMapOfShape Emap;
1862           TopExp::MapShapes( aFace, TopAbs_EDGE, Emap );
1863           for (i = 1; i <= Emap.Extent(); i++)
1864             {
1865               TopoDS_Edge anEdge = TopoDS::Edge( Emap(i) );
1866               //Standard_Real f, l;
1867               //Handle(Geom_Curve) theCurve = BRep_Tool::Curve( anEdge, f, l );
1868               //Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &anEdge.TShape());
1869               if (BRep_Tool::Degenerated(anEdge))
1870                 {
1871                   //Check if anEdge is a really degenerated edge or not
1872                   BRepAdaptor_Curve BACurve(anEdge, aFace);
1873                   gp_Pnt Pfirst, Plast, Pmid;
1874                   Pfirst = BACurve.Value(BACurve.FirstParameter());
1875                   Plast  = BACurve.Value(BACurve.LastParameter());
1876                   Pmid   = BACurve.Value((BACurve.FirstParameter()+BACurve.LastParameter())/2.);
1877                   if (Pfirst.Distance(Plast) <= TolApex &&
1878                       Pfirst.Distance(Pmid)  <= TolApex)
1879                     continue;
1880                   //Cones.Append( aFace );
1881                   //Circs.Append( anEdge );
1882                   //TopoDS_Vertex Vdeg = TopExp::FirstVertex( anEdge );
1883                   TopoDS_Edge OrEdge = 
1884                     TopoDS::Edge( myInitOffsetEdge.Root( anEdge) );
1885                   TopoDS_Vertex VF = TopExp::FirstVertex( OrEdge );
1886                   if ( FacesOfCone.IsBound(VF) )
1887                     {
1888                       //add a face to the existing list
1889                       TopTools_ListOfShape& aFaces = FacesOfCone.ChangeFind(VF);
1890                       aFaces.Append (aFace);
1891                       //DegEdges.Bind(aFace, anEdge);
1892                     }
1893                   else
1894                     {
1895                       //the vertex is not in the map => create a new key and items
1896                       TopTools_ListOfShape aFaces;
1897                       aFaces.Append (aFace);
1898                       FacesOfCone.Bind(VF, aFaces);
1899                       //DegEdges.Bind(aFace, anEdge);
1900                     }
1901                 }
1902             } //for (i = 1; i <= Emap.Extent(); i++)
1903         } //for (; fexp.More(); fexp.Next())
1904     } //if (myJoin == GeomAbs_Arc)
1905
1906   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape Cone(FacesOfCone);
1907   BRep_Builder BB;
1908   TopLoc_Location L;
1909   for (; Cone.More(); Cone.Next() ) {
1910     gp_Sphere theSphere;
1911     Handle(Geom_SphericalSurface) aSphSurf;
1912     TopoDS_Wire SphereWire;
1913     BB.MakeWire(SphereWire);
1914     TopoDS_Vertex anApex = TopoDS::Vertex(Cone.Key());
1915     const TopTools_ListOfShape& Faces = Cone.Value(); //FacesOfCone(anApex);
1916     TopTools_ListIteratorOfListOfShape itFaces(Faces);
1917     Standard_Boolean isFirstFace = Standard_True;
1918     gp_Pnt FirstPoint;
1919     TopoDS_Vertex theFirstVertex, CurFirstVertex;
1920     for (; itFaces.More(); itFaces.Next())
1921       {
1922         TopoDS_Face aFace = TopoDS::Face(itFaces.Value()); //TopoDS::Face(Faces.First());
1923         TopoDS_Edge DegEdge; // = TopoDS::Edge(DegEdges(aFace));
1924         for (Explo.Init(aFace, TopAbs_EDGE); Explo.More(); Explo.Next())
1925           {
1926             DegEdge = TopoDS::Edge(Explo.Current());
1927             if (BRep_Tool::Degenerated(DegEdge))
1928               {
1929                 TopoDS_Edge OrEdge = TopoDS::Edge( myInitOffsetEdge.Root( DegEdge) );
1930                 TopoDS_Vertex VF = TopExp::FirstVertex( OrEdge );
1931                 if (VF.IsSame(anApex))
1932                   break;
1933               }
1934           }
1935         TopoDS_Shape aLocalDegShape = DegEdge.Oriented(TopAbs_FORWARD);
1936         TopoDS_Edge CurEdge = TopoDS::Edge(aLocalDegShape);
1937         BB.Degenerated(CurEdge, Standard_False);
1938         BB.SameRange(CurEdge, Standard_False);
1939         BB.SameParameter(CurEdge, Standard_False);
1940         gp_Pnt fPnt, lPnt, mPnt;
1941         GetEdgePoints(CurEdge, aFace, fPnt, mPnt, lPnt);
1942         Standard_Real f, l;
1943         BRep_Tool::Range(CurEdge, f, l);
1944         if (isFirstFace)
1945           {
1946             gp_Vec aVec1(fPnt, mPnt);
1947             gp_Vec aVec2(fPnt, lPnt);
1948             gp_Vec aNorm = aVec1.Crossed(aVec2);
1949             gp_Pnt theApex = BRep_Tool::Pnt(anApex);
1950             gp_Vec ApexToFpnt(theApex, fPnt);
1951             gp_Vec Ydir = aNorm ^ ApexToFpnt;
1952             gp_Vec Xdir = Ydir ^ aNorm;
1953             //Xdir.Rotate(gp_Ax1(theApex, aNorm), -f);
1954             gp_Ax2 anAx2(theApex, gp_Dir(aNorm), gp_Dir(Xdir));
1955             theSphere.SetRadius(myOffset);
1956             theSphere.SetPosition(gp_Ax3(anAx2) /*gp_Ax3(theApex, gp_Dir(aNorm))*/);
1957             aSphSurf = new Geom_SphericalSurface(theSphere);
1958             FirstPoint = fPnt;
1959             theFirstVertex = BRepLib_MakeVertex(fPnt);
1960             CurFirstVertex = theFirstVertex;
1961           }
1962
1963         TopoDS_Vertex v1, v2, FirstVert, EndVert;
1964         TopExp::Vertices(CurEdge, v1, v2);
1965         FirstVert = CurFirstVertex;
1966         if (lPnt.Distance(FirstPoint) <= Precision::Confusion())
1967           EndVert = theFirstVertex;
1968         else
1969           EndVert = BRepLib_MakeVertex(lPnt);
1970         CurEdge.Free( Standard_True );
1971         BB.Remove(CurEdge, v1);
1972         BB.Remove(CurEdge, v2);
1973         BB.Add(CurEdge, FirstVert.Oriented(TopAbs_FORWARD));
1974         BB.Add(CurEdge, EndVert.Oriented(TopAbs_REVERSED));
1975         //take the curve from sphere an put it to the edge
1976         Standard_Real Uf, Vf, Ul, Vl;
1977         ElSLib::Parameters( theSphere, fPnt, Uf, Vf );
1978         ElSLib::Parameters( theSphere, lPnt, Ul, Vl );
1979         if (Abs(Ul) <= Precision::Confusion())
1980           Ul = 2.*M_PI;
1981         Handle(Geom_Curve) aCurv = aSphSurf->VIso(Vf);
1982         /*
1983         if (!isFirstFace)
1984           {
1985             gp_Circ aCircle = (Handle(Geom_Circle)::DownCast(aCurv))->Circ();
1986             if (Abs(Uf - f) > Precision::Confusion())
1987               {
1988                 aCircle.Rotate(aCircle.Axis(), f - Uf);
1989                 aCurv = new Geom_Circle(aCircle);
1990               }
1991           }
1992         */
1993         Handle(Geom_TrimmedCurve) aTrimCurv = new Geom_TrimmedCurve(aCurv, Uf, Ul);
1994         BB.UpdateEdge(CurEdge, aTrimCurv, Precision::Confusion());
1995         BB.Range(CurEdge, Uf, Ul, Standard_True);
1996         Handle(Geom2d_Line) theLin2d = new Geom2d_Line( gp_Pnt2d( 0., Vf ), gp::DX2d() );
1997         Handle(Geom2d_TrimmedCurve) theTrimLin2d = new Geom2d_TrimmedCurve(theLin2d, Uf, Ul);
1998         BB.UpdateEdge(CurEdge, theTrimLin2d, aSphSurf, L, Precision::Confusion());
1999         BB.Range(CurEdge, aSphSurf, L, Uf, Ul);
2000         BRepLib::SameParameter(CurEdge);
2001         BB.Add(SphereWire, CurEdge);
2002         //Modifying correspondent edges in aFace: substitute vertices common with CurEdge
2003         BRepAdaptor_Curve2d BAc2d(CurEdge, aFace);
2004         gp_Pnt2d fPnt2d, lPnt2d;
2005         fPnt2d = BAc2d.Value(BAc2d.FirstParameter());
2006         lPnt2d = BAc2d.Value(BAc2d.LastParameter());
2007         TopTools_IndexedMapOfShape Emap;
2008         TopExp::MapShapes(aFace, TopAbs_EDGE, Emap);
2009         TopoDS_Edge EE [2];
2010         Standard_Integer j = 0, k;
2011         for (k = 1; k <= Emap.Extent(); k++)
2012           {
2013             const TopoDS_Edge& anEdge = TopoDS::Edge(Emap(k));
2014             if (!BRep_Tool::Degenerated(anEdge))
2015               {
2016                 TopoDS_Vertex V1, V2;
2017                 TopExp::Vertices(anEdge, V1, V2);
2018                 if (V1.IsSame(v1) || V2.IsSame(v1))
2019                   EE[j++] = anEdge;
2020               }
2021           }
2022         for (k = 0; k < j; k++)
2023           {
2024             TopoDS_Shape aLocalShape = EE[k].Oriented(TopAbs_FORWARD);
2025             TopoDS_Edge Eforward = TopoDS::Edge(aLocalShape);
2026             Eforward.Free(Standard_True);
2027             TopoDS_Vertex V1, V2;
2028             TopExp::Vertices( Eforward, V1, V2 );
2029             BRepAdaptor_Curve2d EEc( Eforward, aFace );
2030             gp_Pnt2d p2d1, p2d2;
2031             p2d1 = EEc.Value(EEc.FirstParameter());
2032             p2d2 = EEc.Value(EEc.LastParameter());
2033             if (V1.IsSame(v1))
2034               {
2035                 TopoDS_Vertex NewV = (p2d1.Distance(fPnt2d) <= Precision::Confusion())?
2036                   FirstVert : EndVert;
2037                 BB.Remove( Eforward, V1 );
2038                 BB.Add( Eforward, NewV.Oriented(TopAbs_FORWARD) );
2039               }
2040             else
2041               {
2042                 TopoDS_Vertex NewV = (p2d2.Distance(fPnt2d) <= Precision::Confusion())?
2043                   FirstVert : EndVert;
2044                 BB.Remove( Eforward, V2 );
2045                 BB.Add( Eforward, NewV.Oriented(TopAbs_REVERSED) );
2046               }
2047           }
2048
2049         isFirstFace = Standard_False;
2050         CurFirstVertex = EndVert;
2051       }
2052     //Building new spherical face
2053     Standard_Real Ufirst = RealLast(), Ulast = RealFirst();
2054     gp_Pnt2d p2d1, p2d2;
2055     TopTools_ListOfShape EdgesOfWire;
2056     TopoDS_Iterator itw(SphereWire);
2057     for (; itw.More(); itw.Next())
2058       {
2059         const TopoDS_Edge& anEdge = TopoDS::Edge(itw.Value());
2060         EdgesOfWire.Append(anEdge);
2061         Standard_Real f, l;
2062         Handle(Geom2d_Curve) aC2d = BRep_Tool::CurveOnSurface(anEdge, aSphSurf, L, f, l);
2063         p2d1 = aC2d->Value(f);
2064         p2d2 = aC2d->Value(l);
2065         if (p2d1.X() < Ufirst)
2066           Ufirst = p2d1.X();
2067         if (p2d1.X() > Ulast)
2068           Ulast = p2d1.X();
2069         if (p2d2.X() < Ufirst)
2070           Ufirst = p2d2.X();
2071         if (p2d2.X() > Ulast)
2072           Ulast = p2d2.X();
2073       }
2074     TopTools_ListOfShape NewEdges;
2075     TopoDS_Edge FirstEdge;
2076     TopTools_ListIteratorOfListOfShape itl(EdgesOfWire);
2077     for (; itl.More(); itl.Next())
2078       {
2079         FirstEdge = TopoDS::Edge(itl.Value());
2080         Standard_Real f, l;
2081         Handle(Geom2d_Curve) aC2d = BRep_Tool::CurveOnSurface(FirstEdge, aSphSurf, L, f, l);
2082         p2d1 = aC2d->Value(f);
2083         p2d2 = aC2d->Value(l);
2084         if (Abs(p2d1.X() - Ufirst) <= Precision::Confusion())
2085           {
2086             EdgesOfWire.Remove(itl);
2087             break;
2088           }
2089       }
2090     NewEdges.Append(FirstEdge);
2091     TopoDS_Vertex Vf1, CurVertex;
2092     TopExp::Vertices(FirstEdge, Vf1, CurVertex);
2093     itl.Initialize(EdgesOfWire);
2094     while (itl.More())
2095       {
2096         const TopoDS_Edge& anEdge = TopoDS::Edge(itl.Value());
2097         TopoDS_Vertex V1, V2;
2098         TopExp::Vertices(anEdge, V1, V2);
2099         if (V1.IsSame(CurVertex) || V2.IsSame(CurVertex))
2100           {
2101             NewEdges.Append(anEdge);
2102             CurVertex = (V1.IsSame(CurVertex))? V2 : V1;
2103             EdgesOfWire.Remove(itl);
2104           }
2105         else
2106           itl.Next();
2107       }
2108
2109     Standard_Real Vfirst, Vlast;
2110     if (p2d1.Y() > 0.)
2111       {
2112         Vfirst = p2d1.Y(); Vlast = M_PI/2.;
2113       }
2114     else
2115       {
2116         Vfirst = -M_PI/2.; Vlast = p2d1.Y();
2117       }
2118     TopoDS_Face NewSphericalFace = BRepLib_MakeFace(aSphSurf, Ufirst, Ulast, Vfirst, Vlast, Precision::Confusion());
2119     TopoDS_Edge OldEdge;
2120     for (Explo.Init(NewSphericalFace, TopAbs_EDGE); Explo.More(); Explo.Next())
2121       {
2122         OldEdge = TopoDS::Edge(Explo.Current());
2123         if (!BRep_Tool::Degenerated(OldEdge))
2124           {
2125             BRepAdaptor_Curve2d BAc2d(OldEdge, NewSphericalFace);
2126             p2d1 = BAc2d.Value(BAc2d.FirstParameter());
2127             p2d2 = BAc2d.Value(BAc2d.LastParameter());
2128             if (Abs(p2d1.X() - Ufirst) <= Precision::Confusion() &&
2129                 Abs(p2d2.X() - Ulast)  <= Precision::Confusion())
2130               break;
2131           }
2132       }
2133     TopoDS_Vertex V1, V2;
2134     TopExp::Vertices(OldEdge, V1, V2);
2135     TopTools_ListOfShape LV1, LV2;
2136     LV1.Append(Vf1);
2137     LV2.Append(CurVertex);
2138     BRepTools_Substitution theSubstitutor;
2139     theSubstitutor.Substitute(V1, LV1);
2140     if (!V1.IsSame(V2))
2141       theSubstitutor.Substitute(V2, LV2);
2142     theSubstitutor.Substitute(OldEdge, NewEdges);
2143     theSubstitutor.Build(NewSphericalFace);
2144     if (theSubstitutor.IsCopied(NewSphericalFace))
2145       {
2146         const TopTools_ListOfShape& listSh = theSubstitutor.Copy(NewSphericalFace);
2147         NewSphericalFace = TopoDS::Face(listSh.First());
2148       }
2149
2150     //Adding NewSphericalFace to the shell
2151     Explo.Init( myOffsetShape, TopAbs_SHELL );
2152     TopoDS_Shape theShell = Explo.Current();
2153     theShell.Free( Standard_True );
2154     BB.Add( theShell, NewSphericalFace );
2155   }
2156
2157   Explo.Init( myOffsetShape, TopAbs_SHELL );
2158
2159   if (Explo.More()) {
2160     TopoDS_Shape theShell = Explo.Current();
2161     theShell.Closed( Standard_True );
2162   }
2163
2164 /*
2165   //Reconstructing
2166   BRep_Builder BB;
2167   for (i = 1; i <= Cones.Length(); i++)
2168     {
2169       TopoDS_Face Cone = TopoDS::Face( Cones(i) );
2170       TopoDS_Edge Circ = TopoDS::Edge( Circs(i) );
2171       TopoDS_Edge Seam = TopoDS::Edge( Seams(i) );
2172       if (Circ.IsNull()) //case 1 with big offset
2173         {
2174           //ExtraFace is absent
2175           
2176           Handle(Geom_Surface) aSurf = BRep_Tool::Surface( Cone ), OffSurf = aSurf;
2177
2178           if (aSurf->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface))
2179             aSurf = (Handle(Geom_OffsetSurface)::DownCast(aSurf))->BasisSurface();
2180           gp_Cone theCone = (Handle(Geom_ConicalSurface)::DownCast(aSurf))->Cone();
2181           gp_Pnt apex = theCone.Apex();
2182           Standard_Real Uapex, Vapex;
2183           ElSLib::Parameters( theCone, apex, Uapex, Vapex );
2184           if (aSurf->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface))
2185             apex = OffSurf->Value( Uapex, Vapex );
2186
2187           //Making new degenerated edge
2188           Handle(Geom2d_Line) theLine = GCE2d_MakeLine( gp_Pnt2d( 0., Vapex ), gp_Pnt2d( 2.*M_PI, Vapex ) );
2189           TopoDS_Edge NewEdge;
2190           BB.MakeEdge( NewEdge );
2191           NewEdge.Orientation(TopAbs_FORWARD);
2192           BB.UpdateEdge( NewEdge, theLine, Cone, Precision::Confusion() );
2193           BB.Range( NewEdge, 0., 2.*M_PI );
2194           BB.SameParameter( NewEdge, Standard_True );
2195           BB.SameRange( NewEdge, Standard_True );
2196           BB.Degenerated( NewEdge, Standard_True );
2197           TopoDS_Vertex Apex = BRepLib_MakeVertex( apex );
2198           BB.Add( NewEdge, Apex.Oriented(TopAbs_FORWARD) );
2199           BB.Add( NewEdge, Apex.Oriented(TopAbs_REVERSED) );
2200
2201           //Reconstructing Seam
2202           Standard_Real f, l, par, cpar;
2203           Handle(Geom2d_Curve) theCurve = BRep_Tool::CurveOnSurface( Seam, Cone, f, l );
2204           gp_Lin2d aLine = (Handle(Geom2d_Line)::DownCast(theCurve))->Lin2d();
2205           par = ElCLib::Parameter( aLine, gp_Pnt2d( Uapex, Vapex ) );
2206           TopoDS_Shape aLocalShape = Seam.Oriented(TopAbs_FORWARD);
2207           TopoDS_Vertex cver = TopExp::LastVertex( TopoDS::Edge(aLocalShape) );
2208           cpar = BRep_Tool::Parameter( cver, Seam, Cone );
2209           if (Abs(f-cpar) < Abs(l-cpar))
2210             BB.Range( Seam, par, l );
2211           else
2212             BB.Range( Seam, f, par );
2213           Seam.Free( Standard_True );
2214           TopoDS_Shape cver1;
2215           TopoDS_Iterator iter( Seam );
2216           for (; iter.More(); iter.Next())
2217             {
2218               cver1 = iter.Value();
2219               if (cver1.IsSame(cver))
2220                 break;
2221             }
2222           BB.Remove( Seam, cver1 );
2223           if (Abs(f-cpar) < Abs(l-cpar))
2224             BB.Add( Seam, Apex.Oriented( TopAbs::Compose(Seam.Orientation(),TopAbs_FORWARD) ) );
2225           else
2226             BB.Add( Seam, Apex.Oriented( TopAbs::Compose(Seam.Orientation(),TopAbs_REVERSED) ) );
2227
2228           //Adding NewEdge into Cone
2229           TopoDS_Shape theWire;
2230           for (fexp.Init( Cone, TopAbs_WIRE ); fexp.More(); fexp.Next())
2231             {
2232               theWire = fexp.Current();
2233               Standard_Boolean found = Standard_False;
2234               for (iter.Initialize( theWire ); iter.More(); iter.Next())
2235                 {
2236                   if (Seam.IsSame( iter.Value() ))
2237                     {
2238                       found = Standard_True;
2239                       break;
2240                     }
2241                 }
2242               if (found)
2243                 break;
2244             }
2245           theWire.Free( Standard_True );
2246           NewEdge.Orientation( TopAbs::Compose(theWire.Orientation(),TopAbs_REVERSED) );
2247           BB.Add( theWire, NewEdge );
2248         } //end of case 1 with big offset
2249       else
2250         {
2251           Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &Circ.TShape());
2252           if (! TE->Degenerated()) //case 1
2253             {
2254               //Find ExtraFace
2255               TopoDS_Face ExtraFace;
2256               for (fexp.Init( myOffsetShape, TopAbs_FACE ); fexp.More(); fexp.Next())
2257                 {
2258                   ExtraFace = TopoDS::Face( fexp.Current() );
2259                   if (ExtraFace.IsSame( Cone ))
2260                     continue;
2261                   Standard_Boolean found = Standard_False;
2262                   TopExp_Explorer eexp( ExtraFace, TopAbs_EDGE );
2263                   for (; eexp.More(); eexp.Next())
2264                     if (Circ.IsSame( eexp.Current() ))
2265                       {
2266                         found = Standard_True;
2267                         break;
2268                       }
2269                   if (found)
2270                     break;
2271                 }
2272               
2273               Handle(Geom_Surface) aSurf = BRep_Tool::Surface( Cone ), OffSurf = aSurf;
2274               if (aSurf->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface))
2275                 aSurf = (Handle(Geom_OffsetSurface)::DownCast(aSurf))->BasisSurface();
2276               gp_Cone theCone = (Handle(Geom_ConicalSurface)::DownCast(aSurf))->Cone();
2277               gp_Pnt apex = theCone.Apex();
2278               Standard_Real Uapex, Vapex;
2279               ElSLib::Parameters( theCone, apex, Uapex, Vapex );
2280               if (aSurf->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface))
2281                 apex = OffSurf->Value( Uapex, Vapex );
2282               
2283               //Making new degenerated edge
2284               Handle(Geom2d_Line) theLine = GCE2d_MakeLine( gp_Pnt2d( 0., Vapex ), gp_Pnt2d( 2.*M_PI, Vapex ) );
2285               TopoDS_Edge NewEdge;
2286               BB.MakeEdge( NewEdge );
2287               NewEdge.Orientation(TopAbs_FORWARD);
2288               BB.UpdateEdge( NewEdge, theLine, Cone, BRep_Tool::Tolerance( Circ ) );
2289               BB.Range( NewEdge, 0., 2.*M_PI );
2290               BB.SameParameter( NewEdge, Standard_True );
2291               BB.SameRange( NewEdge, Standard_True );
2292               BB.Degenerated( NewEdge, Standard_True );
2293               TopoDS_Vertex Apex = BRepLib_MakeVertex( apex );
2294               BB.Add( NewEdge, Apex.Oriented(TopAbs_FORWARD) );
2295               BB.Add( NewEdge, Apex.Oriented(TopAbs_REVERSED) );
2296               
2297               TopoDS_Vertex cver = TopExp::FirstVertex( Circ );
2298               
2299               //Reconstructing Seam
2300               Standard_Real f, l, par, cpar;
2301               Handle(Geom2d_Curve) theCurve = BRep_Tool::CurveOnSurface( Seam, Cone, f, l );
2302               gp_Lin2d aLine = (Handle(Geom2d_Line)::DownCast(theCurve))->Lin2d();
2303               par = ElCLib::Parameter( aLine, gp_Pnt2d( Uapex, Vapex ) );
2304               cpar = BRep_Tool::Parameter( cver, Seam, Cone );
2305               if (Abs(f-cpar) < Abs(l-cpar))
2306                 BB.Range( Seam, par, l );
2307               else
2308                 BB.Range( Seam, f, par );
2309               Seam.Free( Standard_True );
2310               TopoDS_Shape cver1;
2311               TopoDS_Iterator iter( Seam );
2312               for (; iter.More(); iter.Next())
2313                 {
2314                   cver1 = iter.Value();
2315                   if (cver1.IsSame(cver))
2316                     break;
2317                 }
2318               BB.Remove( Seam, cver1 );
2319               if (Abs(f-cpar) < Abs(l-cpar))
2320                 BB.Add( Seam, Apex.Oriented( TopAbs::Compose(Seam.Orientation(),TopAbs_FORWARD) ) );
2321               else
2322                 BB.Add( Seam, Apex.Oriented( TopAbs::Compose(Seam.Orientation(),TopAbs_REVERSED) ) );
2323               
2324               //Removing ExtraFace from the shell
2325               fexp.Init( myOffsetShape, TopAbs_SHELL );
2326               TopoDS_Shape theShell = fexp.Current();
2327               theShell.Free( Standard_True );
2328               TopoDS_Shape ExtraFace1;
2329               for (iter.Initialize( theShell ); iter.More(); iter.Next())
2330                 {
2331                   ExtraFace1 = iter.Value();
2332                   if (ExtraFace1.IsSame(ExtraFace))
2333                     break;
2334                 }
2335               BB.Remove( theShell, ExtraFace1 );
2336               
2337               //Substitute Circ by NewEdge in Cone
2338               TopoDS_Shape theWire;
2339               TopoDS_Shape Circ1;
2340               for (fexp.Init( Cone, TopAbs_WIRE ); fexp.More(); fexp.Next())
2341                 {
2342                   theWire = fexp.Current();
2343                   Standard_Boolean found = Standard_False;
2344                   for (iter.Initialize( theWire ); iter.More(); iter.Next())
2345                     {
2346                       Circ1 = iter.Value();
2347                       if (Circ1.IsSame(Circ))
2348                         {
2349                           found = Standard_True;
2350                           break;
2351                         }
2352                     }
2353                   if (found)
2354                     break;
2355                 }
2356               TopAbs_Orientation Or = Circ1.Orientation();
2357               theWire.Free( Standard_True );
2358               BB.Remove( theWire, Circ1 );
2359               BB.Add( theWire, NewEdge.Oriented(Or) );
2360             } //end of case 1
2361           else // Circ is degenerated
2362             {
2363               if (myOffset > 0. && myJoin == GeomAbs_Arc) //case 2
2364                 {
2365                   TopoDS_Vertex cver = TopExp::FirstVertex( Circ );
2366                   
2367                   TopoDS_Face OrCone = TopoDS::Face( myInitOffsetFace.Root( Cone ) );
2368                   Handle(Geom_Surface) aSurf = BRep_Tool::Surface( OrCone ), OffSurf = aSurf;
2369                   if (aSurf->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface))
2370                     aSurf = (Handle(Geom_OffsetSurface)::DownCast(aSurf))->BasisSurface();
2371                   gp_Cone theCone = (Handle(Geom_ConicalSurface)::DownCast(aSurf))->Cone();
2372                   gp_Pnt apex = theCone.Apex();
2373                   if (aSurf->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface))
2374                     {
2375                       Standard_Real Uapex, Vapex;
2376                       ElSLib::Parameters( theCone, apex, Uapex, Vapex );
2377                       apex = OffSurf->Value( Uapex, Vapex );
2378                     }
2379
2380                   Standard_Real f, l;
2381                   Handle(Geom_Curve) ccur = BRep_Tool::Curve( Circ, f, l );
2382                   gp_Ax2 Axe2 = (Handle(Geom_Circle)::DownCast(ccur))->Circ().Position();
2383                   gp_Ax3 Axe3( Axe2 );
2384                   Axe3.SetLocation( apex );
2385                   gp_Sphere theSphere( Axe3, myOffset );
2386
2387                   gp_Pnt OrPnt = BRep_Tool::Pnt(cver);
2388                   Standard_Real Uor, Vor;
2389                   ElSLib::Parameters( theSphere, OrPnt, Uor, Vor );
2390                   TopoDS_Face NewFace;
2391                   if (Vor > 0.)
2392                     NewFace = BRepLib_MakeFace( theSphere, 0., 2.*M_PI, Vor, M_PI/2. );
2393                   else
2394                     NewFace = BRepLib_MakeFace( theSphere, 0., 2.*M_PI, -M_PI/2., Vor );
2395                   
2396                   //Updating the bound of NewFace
2397                   TopoDS_Edge Bound;
2398                   TopExp_Explorer eexp( NewFace, TopAbs_EDGE );
2399                   for (; eexp.More(); eexp.Next())
2400                     {
2401                       Bound = TopoDS::Edge( eexp.Current() );
2402                       Handle(BRep_TEdge)& TE = *((Handle(BRep_TEdge)*) &Bound.TShape());
2403                       if (!TE->Degenerated() && !BRepTools::IsReallyClosed( Bound, NewFace ))
2404                         break;
2405                     }
2406                   Handle(Geom2d_Curve) pcurve = BRep_Tool::CurveOnSurface( Circ, Cone, f, l );
2407                   BB.UpdateEdge( Bound, pcurve, Cone, BRep_Tool::Tolerance(Circ) );
2408                   TopoDS_Vertex bver = TopExp::FirstVertex( Bound );
2409                   BB.UpdateVertex( bver, BRep_Tool::Tolerance(cver) );
2410                   
2411                   //Updating cver in Seam
2412                   TopoDS_Vertex cver1;
2413                   TopoDS_Iterator iter( Seam );
2414                   for (; iter.More(); iter.Next())
2415                     {
2416                       cver1 = TopoDS::Vertex( iter.Value() );
2417                       if (cver1.IsSame(cver))
2418                         break;
2419                     }
2420                   TopAbs_Orientation Or = cver1.Orientation();
2421                   Seam.Free( Standard_True );
2422                   BB.Remove( Seam, cver1 );
2423                   BB.Add( Seam, bver.Oriented(Or) );
2424                   
2425                   //Substitute Circ by Bound in Cone
2426                   TopoDS_Shape theWire;
2427                   TopoDS_Shape Circ1;
2428                   for (fexp.Init( Cone, TopAbs_WIRE ); fexp.More(); fexp.Next())
2429                     {
2430                       theWire = fexp.Current();
2431                       Standard_Boolean found = Standard_False;
2432                       for (iter.Initialize( theWire ); iter.More(); iter.Next())
2433                         {
2434                           Circ1 = iter.Value();
2435                           if (Circ1.IsSame(Circ))
2436                             {
2437                               found = Standard_True;
2438                               break;
2439                             }
2440                         }
2441                       if (found)
2442                         break;
2443                     }
2444                   Or = Circ1.Orientation();
2445                   theWire.Free( Standard_True );
2446                   BB.Remove( theWire, Circ1 );
2447                   BB.Add( theWire, Bound.Oriented(Or) );
2448                   
2449                   //Adding NewFace to the shell
2450                   fexp.Init( myOffsetShape, TopAbs_SHELL );
2451                   TopoDS_Shape theShell = fexp.Current();
2452                   theShell.Free( Standard_True );
2453                   BB.Add( theShell, NewFace );
2454                   
2455                   theShell.Closed( Standard_True );
2456                 } //end of case 2
2457               else // if ((myOffset > 0. && myJoin == GeomAbs_Intersection) || myOffset < 0.) //case 3, 4
2458                 {
2459                   Handle(Geom_Surface) aSurf = BRep_Tool::Surface( Cone ), OffSurf = aSurf;
2460                   if (aSurf->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface))
2461                     aSurf = (Handle(Geom_OffsetSurface)::DownCast(aSurf))->BasisSurface();
2462                   gp_Cone theCone = (Handle(Geom_ConicalSurface)::DownCast(aSurf))->Cone();
2463                   gp_Pnt apex = theCone.Apex();
2464                   Standard_Real Uapex, Vapex;
2465                   ElSLib::Parameters( theCone, apex, Uapex, Vapex );
2466                   if (aSurf->DynamicType() == STANDARD_TYPE(Geom_OffsetSurface))
2467                     apex = OffSurf->Value( Uapex, Vapex );
2468                   
2469                   //Making new degenerated edge
2470                   Handle(Geom2d_Line) theLine = GCE2d_MakeLine( gp_Pnt2d( 0., Vapex ), gp_Pnt2d( 2.*M_PI, Vapex ) );
2471                   TopoDS_Edge NewEdge;
2472                   BB.MakeEdge( NewEdge );
2473                   NewEdge.Orientation(TopAbs_FORWARD);
2474                   BB.UpdateEdge( NewEdge, theLine, Cone, BRep_Tool::Tolerance( Circ ) );
2475                   BB.Range( NewEdge, 0., 2.*M_PI );
2476                   BB.SameParameter( NewEdge, Standard_True );
2477                   BB.SameRange( NewEdge, Standard_True );
2478                   BB.Degenerated( NewEdge, Standard_True );
2479                   TopoDS_Vertex Apex = BRepLib_MakeVertex( apex );
2480                   BB.Add( NewEdge, Apex.Oriented(TopAbs_FORWARD) );
2481                   BB.Add( NewEdge, Apex.Oriented(TopAbs_REVERSED) );
2482                   
2483                   TopoDS_Vertex cver = TopExp::FirstVertex( Circ );
2484                   
2485                   //Reconstructing Seam
2486                   Standard_Real f, l, par, cpar;
2487                   Handle(Geom2d_Curve) theCurve = BRep_Tool::CurveOnSurface( Seam, Cone, f, l );
2488                   gp_Lin2d aLine = (Handle(Geom2d_Line)::DownCast(theCurve))->Lin2d();
2489                   par = ElCLib::Parameter( aLine, gp_Pnt2d( Uapex, Vapex ) );
2490                   cpar = BRep_Tool::Parameter( cver, Seam, Cone );
2491                   if (Abs(f-cpar) < Abs(l-cpar))
2492                     BB.Range( Seam, par, l );
2493                   else
2494                     BB.Range( Seam, f, par );
2495                   Seam.Free( Standard_True );
2496                   TopoDS_Shape cver1;
2497                   TopoDS_Iterator iter( Seam );
2498                   for (; iter.More(); iter.Next())
2499                     {
2500                       cver1 = iter.Value();
2501                       if (cver1.IsSame(cver))
2502                         break;
2503                     }
2504                   BB.Remove( Seam, cver1 );
2505                   if (Abs(f-cpar) < Abs(l-cpar))
2506                     BB.Add( Seam, Apex.Oriented( TopAbs::Compose(Seam.Orientation(),TopAbs_FORWARD) ) );
2507                   else
2508                     BB.Add( Seam, Apex.Oriented( TopAbs::Compose(Seam.Orientation(),TopAbs_REVERSED) ) );
2509                   
2510                   //Substitute Circ by NewEdge in Cone
2511                   TopoDS_Shape theWire;
2512                   TopoDS_Shape Circ1;
2513                   for (fexp.Init( Cone, TopAbs_WIRE ); fexp.More(); fexp.Next())
2514                     {
2515                       theWire = fexp.Current();
2516                       Standard_Boolean found = Standard_False;
2517                       for (iter.Initialize( theWire ); iter.More(); iter.Next())
2518                         {
2519                           Circ1 = iter.Value();
2520                           if (Circ1.IsSame(Circ))
2521                             {
2522                               found = Standard_True;
2523                               break;
2524                             }
2525                         }
2526                       if (found)
2527                         break;
2528                     }
2529                   TopAbs_Orientation Or = Circ1.Orientation();
2530                   theWire.Free( Standard_True );
2531                   BB.Remove( theWire, Circ1 );
2532                   BB.Add( theWire, NewEdge.Oriented(Or) );
2533                   
2534                   fexp.Init( myOffsetShape, TopAbs_SHELL );
2535                   TopoDS_Shape theShell = fexp.Current();
2536                   theShell.Closed( Standard_True );
2537                 } //end of case 3, 4
2538             }
2539         } //else (! Circ.IsNull())
2540     }
2541 */
2542
2543   Standard_Integer            NbShell = 0;
2544   TopoDS_Compound             NC;
2545   TopoDS_Shape                S1;
2546   BB.MakeCompound (NC);
2547   
2548   for (Explo.Init(myOffsetShape,TopAbs_SHELL); Explo.More(); Explo.Next()) {
2549     const TopoDS_Shell& Sh = TopoDS::Shell(Explo.Current());
2550     NbShell++;
2551     if (Sh.Closed()) {
2552       TopoDS_Solid  Sol;
2553       BB.MakeSolid  (Sol);
2554       BB.Add        (Sol,Sh);
2555       Sol.Closed(Standard_True);
2556       BB.Add (NC,Sol);
2557       if (NbShell == 1) S1 = Sol;
2558     }
2559     else {
2560       BB.Add (NC,Sh);
2561       if (NbShell == 1) S1 = Sh;
2562     }
2563   }
2564   if (NbShell == 1) myOffsetShape = S1;
2565   else              myOffsetShape = NC;
2566 }
2567
2568
2569 //=======================================================================
2570 //function : Intersection3D
2571 //purpose  : 
2572 //=======================================================================
2573
2574 void BRepOffset_MakeOffset::Intersection3D(BRepOffset_Inter3d& Inter)
2575 {
2576 #ifdef DEB
2577   if (ChronBuild) {
2578     cout << " INTERSECTION 3D:" << endl;
2579     Clock.Reset();
2580     Clock.Start();  
2581   }
2582 #endif
2583   TopTools_ListOfShape OffsetFaces;  // list of faces // created.
2584   MakeList (OffsetFaces,myInitOffsetFace,myFaces);
2585
2586   if (!myFaces.IsEmpty()) {     
2587     Standard_Boolean InSide = (myOffset < 0.); // Temporary
2588     // it is necessary to calculate Inside taking account of the concavity or convexity of edges
2589     // between the cap and the part.
2590
2591     if (myJoin == GeomAbs_Arc) 
2592       Inter.ContextIntByArc (myFaces,InSide,myAnalyse,myInitOffsetFace,myInitOffsetEdge);
2593   }
2594   if (myInter) {
2595     //-------------
2596     //Complete.
2597     //-------------
2598     Inter.CompletInt (OffsetFaces,myInitOffsetFace);
2599     TopTools_IndexedMapOfShape& NewEdges = Inter.NewEdges();
2600     if (myJoin == GeomAbs_Intersection) {
2601       BRepOffset_Tool::CorrectOrientation (myShape,NewEdges,myAsDes,myInitOffsetFace,myOffset);
2602     }
2603   }
2604   else {
2605     //--------------------------------
2606     // Only between neighbor faces.
2607     //--------------------------------
2608     Inter.ConnexIntByArc(OffsetFaces,myShape,myAnalyse,myInitOffsetFace);
2609   }
2610 #ifdef DEB
2611   if ( ChronBuild) Clock.Show();
2612 #endif
2613 }
2614
2615 //=======================================================================
2616 //function : Intersection2D
2617 //purpose  : 
2618 //=======================================================================
2619
2620 void BRepOffset_MakeOffset::Intersection2D(const TopTools_IndexedMapOfShape& Modif,
2621                                            const TopTools_IndexedMapOfShape& NewEdges)
2622 {
2623 #ifdef DEB
2624   if (ChronBuild) {
2625     cout << " INTERSECTION 2D:" << endl;
2626     Clock.Reset();
2627     Clock.Start();  
2628   }
2629 #endif
2630   //--------------------------------------------------------
2631   // calculate intersections2d on faces concerned by 
2632   // intersection3d
2633   //---------------------------------------------------------
2634   //TopTools_MapIteratorOfMapOfShape it(Modif);
2635   //-----------------------------------------------
2636   // Intersection of edges 2 by 2.
2637   //-----------------------------------------------
2638   Standard_Integer i;
2639   for (i = 1; i <= Modif.Extent(); i++) {
2640     const TopoDS_Face& F  = TopoDS::Face(Modif(i));
2641     BRepOffset_Inter2d::Compute(myAsDes,F,NewEdges,myTol);
2642   }
2643
2644 #ifdef DEB
2645   if (AffichInt2d) {
2646     DEBVerticesControl (NewEdges,myAsDes);
2647   }
2648   if ( ChronBuild) Clock.Show();
2649 #endif
2650 }
2651
2652
2653 //=======================================================================
2654 //function : MakeLoops
2655 //purpose  : 
2656 //=======================================================================
2657
2658 void BRepOffset_MakeOffset::MakeLoops(TopTools_IndexedMapOfShape& Modif)
2659 {
2660 #ifdef DEB
2661   if (ChronBuild) {
2662      cout << " DEBOUCLAGE 2D:" << endl;
2663      Clock.Reset();
2664      Clock.Start(); 
2665   }
2666 #endif
2667   //TopTools_MapIteratorOfMapOfShape    it(Modif);
2668   TopTools_ListOfShape                LF,LC;
2669   //-----------------------------------------
2670   // unwinding of faces // modified.
2671   //-----------------------------------------
2672   Standard_Integer i;
2673   for (i = 1; i <= Modif.Extent(); i++) { 
2674     if (!myFaces.Contains(Modif(i)))
2675       LF.Append(Modif(i));
2676   }
2677   myMakeLoops.Build(LF,myAsDes,myImageOffset);
2678
2679   //-----------------------------------------
2680   // unwinding of caps.
2681   //-----------------------------------------
2682   for (i = 1; i <= myFaces.Extent(); i++)
2683     LC.Append(myFaces(i));
2684
2685   Standard_Boolean   InSide = 1;
2686   if (myOffset > 0 ) InSide = 0;
2687   myMakeLoops.BuildOnContext(LC,myAnalyse,myAsDes,myImageOffset,InSide);
2688
2689 #ifdef DEB
2690   if ( ChronBuild) Clock.Show();
2691 #endif
2692 }
2693
2694 //=======================================================================
2695 //function : MakeFaces
2696 //purpose  : Reconstruction of topologically unchanged faces that
2697 //           share edges that were reconstructed.
2698 //=======================================================================
2699
2700 void BRepOffset_MakeOffset::MakeFaces(TopTools_IndexedMapOfShape& /*Modif*/)
2701 {
2702 #ifdef DEb
2703   if (ChronBuild) {  
2704     cout << " RECONSTRUCTION OF FACES:" << endl;
2705     Clock.Reset();
2706     Clock.Start();
2707   }
2708 #endif
2709   TopTools_ListIteratorOfListOfShape itr;
2710   const TopTools_ListOfShape& Roots = myInitOffsetFace.Roots();
2711   TopTools_ListOfShape        LOF;
2712   //----------------------------------
2713   // Loop on all faces //.
2714   //----------------------------------
2715   for (itr.Initialize(Roots); itr.More(); itr.Next()) {
2716     TopoDS_Face F = TopoDS::Face(myInitOffsetFace.Image(itr.Value()).First());
2717     LOF.Append(F);
2718   }
2719   myMakeLoops.BuildFaces(LOF,myAsDes,myImageOffset);
2720   
2721 #ifdef DEB
2722   if ( ChronBuild) Clock.Show();
2723 #endif
2724 }
2725
2726 //=======================================================================
2727 //function : UpdateInitOffset
2728 //purpose  : Update and cleaning of myInitOffset 
2729 //=======================================================================
2730
2731 static void UpdateInitOffset (BRepAlgo_Image&         myInitOffset,
2732                               BRepAlgo_Image&         myImageOffset,
2733                               const TopoDS_Shape&     myOffsetShape,
2734                               const TopAbs_ShapeEnum &theShapeType) // skv
2735 {
2736   BRepAlgo_Image NIOF;
2737   const TopTools_ListOfShape& Roots = myInitOffset.Roots();
2738   TopTools_ListIteratorOfListOfShape it(Roots);
2739   for (; it.More(); it.Next()) {
2740     NIOF.SetRoot (it.Value());    
2741   }
2742   for (it.Initialize(Roots); it.More(); it.Next()) {
2743     const TopoDS_Shape& SI = it.Value();
2744     TopTools_ListOfShape LI;
2745     TopTools_ListOfShape L1;
2746     myInitOffset.LastImage(SI,L1);
2747     TopTools_ListIteratorOfListOfShape itL1(L1);
2748     for (; itL1.More(); itL1.Next()) {
2749       const TopoDS_Shape& O1 = itL1.Value();
2750       TopTools_ListOfShape L2;
2751       myImageOffset.LastImage(O1,L2);
2752       LI.Append(L2);
2753     }
2754     NIOF.Bind(SI,LI);
2755   }
2756 //  Modified by skv - Mon Apr  4 18:17:27 2005 Begin
2757 //  Supporting history.
2758 //   NIOF.Filter(myOffsetShape,TopAbs_FACE);
2759   NIOF.Filter(myOffsetShape, theShapeType);
2760 //  Modified by skv - Mon Apr  4 18:17:27 2005 End
2761   myInitOffset = NIOF;
2762 }
2763
2764 //=======================================================================
2765 //function : MakeMissingWalls
2766 //purpose  : 
2767 //=======================================================================
2768
2769 void BRepOffset_MakeOffset::MakeMissingWalls ()
2770 {
2771   TopTools_DataMapOfShapeListOfShape Contours; //Start vertex + list of connected edges (free boundary)
2772   TopTools_DataMapOfShapeShape MapEF; //Edges of contours: edge + face
2773   Standard_Real OffsetVal = Abs(myOffset);
2774
2775   FillContours(myShape, myAnalyse, Contours, MapEF);
2776
2777   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape iter(Contours);
2778   for (; iter.More(); iter.Next())
2779     {
2780       TopoDS_Vertex StartVertex = TopoDS::Vertex(iter.Key());
2781       TopoDS_Edge StartEdge;
2782       const TopTools_ListOfShape& aContour = iter.Value();
2783       TopTools_ListIteratorOfListOfShape itl(aContour);
2784       Standard_Boolean FirstStep = Standard_True;
2785       TopoDS_Edge PrevEdge;
2786       TopoDS_Vertex PrevVertex = StartVertex;
2787       for (; itl.More(); itl.Next())
2788         {
2789           TopoDS_Edge anEdge = TopoDS::Edge(itl.Value());
2790           if (!myInitOffsetEdge.HasImage(anEdge))
2791             continue;
2792           //if (BRep_Tool::Degenerated(anEdge))
2793             //continue;
2794           TopoDS_Face aFace = TopoDS::Face(MapEF(anEdge));
2795           //TopoDS_Edge OE = TopoDS::Edge(myInitOffsetEdge.Image(anEdge).First());
2796           TopTools_ListOfShape LOE, LOE2;
2797           myInitOffsetEdge.LastImage( anEdge, LOE );
2798           myImageOffset.LastImage( LOE.Last(), LOE2 );
2799           TopoDS_Edge OE = TopoDS::Edge( LOE2.Last() );
2800           ////////////////////////////////////////////////////////////////////////
2801           TopoDS_Vertex V1, V2, V3, V4;
2802           TopExp::Vertices(anEdge, V1, V2/*, Standard_True*/);
2803           TopExp::Vertices(OE,     V4, V3/*, Standard_True*/);
2804           Standard_Boolean ToReverse = Standard_False;
2805           if (!V1.IsSame(PrevVertex))
2806             {
2807               TopoDS_Vertex aVtx = V1; V1 = V2; V2 = aVtx;
2808               aVtx = V3; V3 = V4; V4 = aVtx;
2809               ToReverse = Standard_True;
2810             }
2811           //Temporary
2812           //anEdge.Reverse();
2813           OE.Orientation(TopAbs::Reverse(anEdge.Orientation()));
2814           TopoDS_Edge E3, E4;
2815           if (FirstStep)
2816             {
2817               E4 = BRepLib_MakeEdge( V1, V4 );
2818               StartEdge = E4;
2819             }
2820           else
2821             E4 = PrevEdge;
2822           Standard_Boolean ArcOnV2 = ((myJoin == GeomAbs_Arc) && (myInitOffsetEdge.HasImage(V2)));
2823           if (V2.IsSame(StartVertex) && !ArcOnV2)
2824             E3 = StartEdge;
2825           else
2826             E3 = BRepLib_MakeEdge( V2, V3 );
2827           E4.Reverse();
2828           TopoDS_Shape localAnEdge = anEdge.Oriented(TopAbs_FORWARD);
2829           const TopoDS_Edge& anEdgeFWD = TopoDS::Edge(localAnEdge);
2830           Standard_Real ParV1 = BRep_Tool::Parameter(V1, anEdgeFWD);
2831           Standard_Real ParV2 = BRep_Tool::Parameter(V2, anEdgeFWD);
2832           BRep_Builder BB;
2833           TopoDS_Wire theWire;
2834           BB.MakeWire(theWire);
2835           if (ToReverse)
2836             {
2837               BB.Add(theWire, anEdge.Reversed());
2838               BB.Add(theWire, E3.Reversed());
2839               BB.Add(theWire, OE.Reversed());
2840               BB.Add(theWire, E4.Reversed());
2841             }
2842           else
2843             {
2844               BB.Add(theWire, anEdge);
2845               BB.Add(theWire, E3);
2846               BB.Add(theWire, OE);
2847               BB.Add(theWire, E4);
2848             }
2849           BRepLib::BuildCurves3d( theWire, myTol );
2850           theWire.Closed(Standard_True);
2851           TopoDS_Face NewFace;
2852           Handle(Geom_Surface) theSurf;
2853           BRepAdaptor_Curve BAcurve(anEdge);
2854           BRepAdaptor_Curve BAcurveOE(OE);
2855           Standard_Real fpar = BAcurve.FirstParameter();
2856           Standard_Real lpar = BAcurve.LastParameter();
2857           gp_Pnt PonE  = BAcurve.Value(fpar);
2858           gp_Pnt PonOE = BAcurveOE.Value(fpar);
2859           gp_Dir OffsetDir = gce_MakeDir( PonE, PonOE );
2860           Handle(Geom2d_Line) EdgeLine2d, OELine2d, aLine2d, aLine2d2;
2861           Standard_Boolean IsPlanar = Standard_False;
2862           if (BAcurve.GetType() == GeomAbs_Circle &&
2863               BAcurveOE.GetType() == GeomAbs_Circle)
2864           {
2865             gp_Circ aCirc = BAcurve.Circle();
2866             gp_Circ aCircOE = BAcurveOE.Circle();
2867             gp_Lin anAxisLine(aCirc.Axis());
2868             gp_Dir CircAxisDir = aCirc.Axis().Direction();
2869             if (aCirc.Axis().IsParallel(aCircOE.Axis(), Precision::Confusion()) &&
2870                 anAxisLine.Contains(aCircOE.Location(), Precision::Confusion()))
2871             { //cylinder, plane or cone
2872               if (Abs(aCirc.Radius() - aCircOE.Radius()) <= Precision::Confusion()) //case of cylinder
2873                 theSurf = GC_MakeCylindricalSurface(aCirc).Value();
2874               else if (aCirc.Location().Distance(aCircOE.Location()) <= Precision::Confusion()) {//case of plane
2875                 IsPlanar = Standard_True;
2876                 //
2877                 gp_Pnt PonEL = BAcurve.Value(lpar);
2878                 if (PonEL.Distance(PonE) <= Precision::PConfusion()) {
2879                   Standard_Boolean bIsHole;
2880                   TopoDS_Edge aE1, aE2;
2881                   TopoDS_Wire aW1, aW2;
2882                   Handle(Geom_Plane) aPL;
2883                   IntTools_FClass2d aClsf;
2884                   //
2885                   if (aCirc.Radius()>aCircOE.Radius()) {
2886                     aE1 = anEdge;
2887                     aE2 = OE;
2888                   } else {
2889                     aE1 = OE;
2890                     aE2 = anEdge;
2891                   }
2892                   //
2893                   BB.MakeWire(aW1);
2894                   BB.Add(aW1, aE1);
2895                   BB.MakeWire(aW2);
2896                   BB.Add(aW2, aE2);
2897                   //
2898                   aPL = new Geom_Plane(aCirc.Location(), CircAxisDir);
2899                   for (Standard_Integer i = 0; i < 2; ++i) {
2900                     TopoDS_Wire& aW = (i==0) ? aW1 : aW2;
2901                     TopoDS_Edge& aE = (i==0) ? aE1 : aE2;
2902                     //
2903                     TopoDS_Face aFace;
2904                     BB.MakeFace(aFace, aPL, Precision::Confusion());
2905                     BB.Add (aFace, aW);
2906                     aClsf.Init(aFace, Precision::Confusion());
2907                     bIsHole=aClsf.IsHole();
2908                     if ((bIsHole && !i) || (!bIsHole && i)) {
2909                       aW.Nullify();
2910                       BB.MakeWire(aW);
2911                       BB.Add(aW, aE.Reversed());
2912                     }
2913                   }
2914                   //
2915                   BB.MakeFace(NewFace, aPL, Precision::Confusion());
2916                   BB.Add(NewFace, aW1);
2917                   BB.Add(NewFace, aW2);
2918                 }
2919               }
2920               else //case of cone
2921               {
2922                 gp_Cone theCone = gce_MakeCone(aCirc.Location(), aCircOE.Location(),
2923                                                aCirc.Radius(), aCircOE.Radius());
2924                 gp_Ax3 theAx3(aCirc.Position());
2925                 if (CircAxisDir * theCone.Axis().Direction() < 0.)
2926                 {
2927                   theAx3.ZReverse();
2928                   CircAxisDir.Reverse();
2929                 }
2930                 theCone.SetPosition(theAx3);
2931                 theSurf = new Geom_ConicalSurface(theCone);
2932               }
2933               if (!IsPlanar) {
2934                 TopLoc_Location Loc;
2935                 EdgeLine2d = new Geom2d_Line(gp_Pnt2d(0., 0.), gp_Dir2d(1., 0.));
2936                 BB.UpdateEdge(anEdge, EdgeLine2d, theSurf, Loc, Precision::Confusion());
2937                 Standard_Real Coeff = (OffsetDir * CircAxisDir > 0.)? 1. : -1.;
2938                 OELine2d = new Geom2d_Line(gp_Pnt2d(0., OffsetVal*Coeff), gp_Dir2d(1., 0.));
2939                 BB.UpdateEdge(OE, OELine2d, theSurf, Loc, Precision::Confusion());
2940                 aLine2d  = new Geom2d_Line(gp_Pnt2d(ParV2, 0.), gp_Dir2d(0., Coeff));
2941                 aLine2d2 = new Geom2d_Line(gp_Pnt2d(ParV1, 0.), gp_Dir2d(0., Coeff));
2942                 if (E3.IsSame(E4))
2943                 {
2944                   if (Coeff > 0.)
2945                     BB.UpdateEdge(E3, aLine2d, aLine2d2, theSurf, Loc, Precision::Confusion());
2946                   else
2947                   {
2948                     BB.UpdateEdge(E3, aLine2d2, aLine2d, theSurf, Loc, Precision::Confusion());
2949                     theWire.Nullify();
2950                     BB.MakeWire(theWire);
2951                     BB.Add(theWire, anEdge.Oriented(TopAbs_REVERSED));
2952                     BB.Add(theWire, E4);
2953                     BB.Add(theWire, OE.Oriented(TopAbs_FORWARD));
2954                     BB.Add(theWire, E3);
2955                     theWire.Closed(Standard_True);
2956                   }
2957                 }
2958                 else
2959                 {
2960                   BB.SameParameter(E3, Standard_False);
2961                   BB.SameRange(E3, Standard_False);
2962                   BB.SameParameter(E4, Standard_False);
2963                   BB.SameRange(E4, Standard_False);
2964                   BB.UpdateEdge(E3, aLine2d,  theSurf, Loc, Precision::Confusion());
2965                   BB.Range(E3, theSurf, Loc, 0., OffsetVal);
2966                   BB.UpdateEdge(E4, aLine2d2, theSurf, Loc, Precision::Confusion());
2967                   BB.Range(E4, theSurf, Loc, 0., OffsetVal);
2968                 }
2969                 NewFace = BRepLib_MakeFace(theSurf, theWire);
2970               }
2971             } //cylinder or cone
2972           } //if both edges are arcs of circles
2973           if (NewFace.IsNull())
2974             {
2975               BRepLib_MakeFace MF(theWire, Standard_True); //Only plane
2976               if (MF.Error() == BRepLib_FaceDone)
2977                 {
2978                   NewFace = MF.Face();
2979                   IsPlanar = Standard_True;
2980                 }
2981               else //Extrusion (by thrusections)
2982                 {
2983                   Handle(Geom_Curve) EdgeCurve = BRep_Tool::Curve(anEdge, fpar, lpar);
2984                   Handle(Geom_TrimmedCurve) TrEdgeCurve =
2985                     new Geom_TrimmedCurve( EdgeCurve, fpar, lpar );
2986                   Standard_Real fparOE, lparOE;
2987                   Handle(Geom_Curve) OffsetCurve = BRep_Tool::Curve(OE, fparOE, lparOE);
2988                   Handle(Geom_TrimmedCurve) TrOffsetCurve =
2989                     new Geom_TrimmedCurve( OffsetCurve, fparOE, lparOE );
2990                   GeomFill_Generator ThrusecGenerator;
2991                   ThrusecGenerator.AddCurve( TrEdgeCurve );
2992                   ThrusecGenerator.AddCurve( TrOffsetCurve );
2993                   ThrusecGenerator.Perform( Precision::PConfusion() );
2994                   theSurf = ThrusecGenerator.Surface();
2995                   //theSurf = new Geom_SurfaceOfLinearExtrusion( TrOffsetCurve, OffsetDir );
2996                   Standard_Real Uf, Ul, Vf, Vl;
2997                   theSurf->Bounds(Uf, Ul, Vf, Vl);
2998                   TopLoc_Location Loc;
2999                   EdgeLine2d = new Geom2d_Line(gp_Pnt2d(0., Vf), gp_Dir2d(1., 0.));
3000                   BB.UpdateEdge(anEdge, EdgeLine2d, theSurf, Loc, Precision::Confusion());
3001                   OELine2d = new Geom2d_Line(gp_Pnt2d(0., Vl), gp_Dir2d(1., 0.));
3002                   BB.UpdateEdge(OE, OELine2d, theSurf, Loc, Precision::Confusion());
3003                   Standard_Real UonV1 = (ToReverse)? Ul : Uf;
3004                   Standard_Real UonV2 = (ToReverse)? Uf : Ul;
3005                   aLine2d  = new Geom2d_Line(gp_Pnt2d(UonV2, 0.), gp_Dir2d(0., 1.));
3006                   aLine2d2 = new Geom2d_Line(gp_Pnt2d(UonV1, 0.), gp_Dir2d(0., 1.));
3007                   if (E3.IsSame(E4))
3008                     {
3009                       BB.UpdateEdge(E3, aLine2d, aLine2d2, theSurf, Loc, Precision::Confusion());
3010                       Handle(Geom_Curve) BSplC34 = theSurf->UIso( Uf );
3011                       BB.UpdateEdge(E3, BSplC34, Precision::Confusion());
3012                       BB.Range(E3, Vf, Vl);
3013                     }
3014                   else
3015                     {
3016                       BB.SameParameter(E3, Standard_False);
3017                       BB.SameRange(E3, Standard_False);
3018                       BB.SameParameter(E4, Standard_False);
3019                       BB.SameRange(E4, Standard_False);
3020                       BB.UpdateEdge(E3, aLine2d,  theSurf, Loc, Precision::Confusion());
3021                       BB.Range(E3, theSurf, Loc, Vf, Vl);
3022                       BB.UpdateEdge(E4, aLine2d2, theSurf, Loc, Precision::Confusion());
3023                       BB.Range(E4, theSurf, Loc, Vf, Vl);
3024                       Handle(Geom_Curve) BSplC3 = theSurf->UIso( UonV2 );
3025                       BB.UpdateEdge(E3, BSplC3, Precision::Confusion());
3026                       BB.Range(E3, Vf, Vl, Standard_True); //only for 3d curve
3027                       Handle(Geom_Curve) BSplC4 = theSurf->UIso( UonV1 );
3028                       BB.UpdateEdge(E4, BSplC4, Precision::Confusion());
3029                       BB.Range(E4, Vf, Vl, Standard_True); //only for 3d curve
3030                     }
3031                   NewFace = BRepLib_MakeFace(theSurf, theWire);
3032                 }
3033             }
3034           if (!IsPlanar)
3035             {
3036               Standard_Real fparOE = BAcurveOE.FirstParameter();
3037               Standard_Real lparOE = BAcurveOE.LastParameter();
3038               TopLoc_Location Loc;
3039               if (Abs(fpar - fparOE) > Precision::Confusion())
3040                 {
3041                   const TopoDS_Edge& anE4 = (ToReverse)? E3 : E4;
3042                   gp_Pnt2d fp2d   = EdgeLine2d->Value(fpar);
3043                   gp_Pnt2d fp2dOE = OELine2d->Value(fparOE);
3044                   aLine2d2 = GCE2d_MakeLine( fp2d, fp2dOE ).Value();
3045                   Handle(Geom_Curve) aCurve;
3046                   Standard_Real FirstPar = 0., LastPar = fp2d.Distance(fp2dOE);
3047                   Geom2dAdaptor_Curve AC2d( aLine2d2, FirstPar, LastPar );
3048                   GeomAdaptor_Surface GAsurf( theSurf );
3049                   Handle(Geom2dAdaptor_HCurve) HC2d  = new Geom2dAdaptor_HCurve( AC2d );
3050                   Handle(GeomAdaptor_HSurface) HSurf = new GeomAdaptor_HSurface( GAsurf );
3051                   Adaptor3d_CurveOnSurface ConS( HC2d, HSurf );
3052                   Standard_Real max_deviation = 0., average_deviation;
3053                   GeomLib::BuildCurve3d(Precision::Confusion(),
3054                                         ConS, FirstPar, LastPar,
3055                                         aCurve, max_deviation, average_deviation);
3056                   BB.UpdateEdge( anE4, aCurve, max_deviation );
3057                   BB.UpdateEdge( anE4, aLine2d2, theSurf, Loc, max_deviation );
3058                   BB.Range( anE4, FirstPar, LastPar );
3059                 }
3060               if (Abs(lpar - lparOE) > Precision::Confusion())
3061                 {
3062                   const TopoDS_Edge& anE3 = (ToReverse)? E4 : E3;
3063                   gp_Pnt2d lp2d   = EdgeLine2d->Value(lpar);
3064                   gp_Pnt2d lp2dOE = OELine2d->Value(lparOE);
3065                   aLine2d = GCE2d_MakeLine( lp2d, lp2dOE ).Value();
3066                   Handle(Geom_Curve) aCurve;
3067                   Standard_Real FirstPar = 0., LastPar = lp2d.Distance(lp2dOE);
3068                   Geom2dAdaptor_Curve AC2d( aLine2d, FirstPar, LastPar );
3069                   GeomAdaptor_Surface GAsurf( theSurf );
3070                   Handle(Geom2dAdaptor_HCurve) HC2d  = new Geom2dAdaptor_HCurve( AC2d );
3071                   Handle(GeomAdaptor_HSurface) HSurf = new GeomAdaptor_HSurface( GAsurf );
3072                   Adaptor3d_CurveOnSurface ConS( HC2d, HSurf );
3073                   Standard_Real max_deviation = 0., average_deviation;
3074                   GeomLib::BuildCurve3d(Precision::Confusion(),
3075                                         ConS, FirstPar, LastPar,
3076                                         aCurve, max_deviation, average_deviation);
3077                   BB.UpdateEdge( anE3, aCurve, max_deviation );
3078                   BB.UpdateEdge( anE3, aLine2d, theSurf, Loc, max_deviation );
3079                   BB.Range( anE3, FirstPar, LastPar );
3080                 }
3081             }
3082           BRepLib::SameParameter(NewFace);
3083           BRepTools::Update(NewFace);
3084           myWalls.Append(NewFace);
3085           if (ArcOnV2)
3086             {
3087               TopoDS_Edge anArc = TopoDS::Edge(myInitOffsetEdge.Image(V2).First());
3088               TopoDS_Vertex arcV1, arcV2;
3089               TopExp::Vertices(anArc, arcV1, arcV2);
3090               Standard_Boolean ArcReverse = Standard_False;
3091               if (!arcV1.IsSame(V3))
3092                 {
3093                   TopoDS_Vertex aVtx = arcV1; arcV1 = arcV2; arcV2 = aVtx;
3094                   ArcReverse = Standard_True;
3095                 }
3096               TopoDS_Edge EA1, EA2;
3097               //EA1 = (ToReverse)? E3 : TopoDS::Edge(E3.Reversed());
3098               EA1 = E3;
3099               EA1.Reverse();
3100               if (ToReverse)
3101                 EA1.Reverse();
3102               //////////////////////////////////////////////////////
3103               if (V2.IsSame(StartVertex))
3104                 EA2 = StartEdge;
3105               else
3106                 EA2 = BRepLib_MakeEdge( V2, arcV2 );
3107               anArc.Orientation( ((ArcReverse)? TopAbs_REVERSED : TopAbs_FORWARD) );
3108               if (EA1.Orientation() == TopAbs_REVERSED)
3109                 anArc.Reverse();
3110               EA2.Orientation(TopAbs::Reverse(EA1.Orientation()));
3111               TopoDS_Wire arcWire;
3112               BB.MakeWire(arcWire);
3113               BB.Add(arcWire, EA1);
3114               BB.Add(arcWire, anArc);
3115               BB.Add(arcWire, EA2);
3116               BRepLib::BuildCurves3d( arcWire, myTol );
3117               arcWire.Closed(Standard_True);
3118               TopoDS_Face arcFace = BRepLib_MakeFace(arcWire, Standard_True);
3119               BRepTools::Update(arcFace);
3120               myWalls.Append(arcFace);
3121               TopoDS_Shape localEA2 = EA2.Oriented(TopAbs_FORWARD);
3122               const TopoDS_Edge& CEA2 = TopoDS::Edge(localEA2);
3123               PrevEdge = CEA2;
3124               PrevVertex = V2;
3125             }
3126           else
3127             {
3128               PrevEdge = E3;
3129               PrevVertex = V2;
3130             }
3131           FirstStep = Standard_False;
3132         }
3133     }
3134 }
3135
3136 //=======================================================================
3137 //function : MakeShells
3138 //purpose  : 
3139 //=======================================================================
3140
3141 void BRepOffset_MakeOffset::MakeShells ()
3142 {
3143 #ifdef DEB
3144   if (ChronBuild) {  
3145     cout << " RECONSTRUCTION OF SHELLS:" << endl;
3146     Clock.Reset();
3147     Clock.Start();
3148   }
3149 #endif
3150   BRepTools_Quilt Glue;
3151   const TopTools_ListOfShape& R = myImageOffset.Roots();
3152   TopTools_ListIteratorOfListOfShape it(R);
3153
3154   for ( ; it.More(); it.Next()) {
3155     TopTools_ListOfShape Image;
3156     myImageOffset.LastImage(it.Value(),Image);
3157     TopTools_ListIteratorOfListOfShape it2(Image);
3158     for ( ; it2.More(); it2.Next()) {
3159       Glue.Add(it2.Value());
3160     }
3161   }
3162
3163   if (myThickening)
3164     {
3165       TopExp_Explorer Explo(myShape, TopAbs_FACE);
3166       for (; Explo.More(); Explo.Next())
3167         Glue.Add(Explo.Current());
3168       
3169       for (it.Initialize(myWalls); it.More(); it.Next())
3170         Glue.Add(it.Value());
3171     }
3172
3173   myOffsetShape = Glue.Shells();
3174 }
3175
3176 //=======================================================================
3177 //function : MakeSolid
3178 //purpose  : 
3179 //=======================================================================
3180
3181 void BRepOffset_MakeOffset::MakeSolid ()
3182 {
3183  if (myOffsetShape.IsNull()) return;
3184
3185 //  Modified by skv - Mon Apr  4 18:17:27 2005 Begin
3186 //  Supporting history.
3187   UpdateInitOffset (myInitOffsetFace,myImageOffset,myOffsetShape, TopAbs_FACE);
3188   UpdateInitOffset (myInitOffsetEdge,myImageOffset,myOffsetShape, TopAbs_EDGE);
3189 //  Modified by skv - Mon Apr  4 18:17:27 2005 End
3190   TopExp_Explorer             exp;
3191   BRep_Builder                B;
3192   Standard_Integer            NbShell = 0;
3193   TopoDS_Compound             NC;
3194   TopoDS_Shape                S1;
3195   B.MakeCompound (NC);
3196
3197   for (exp.Init(myOffsetShape,TopAbs_SHELL); exp.More(); exp.Next()) {
3198     TopoDS_Shell Sh = TopoDS::Shell(exp.Current());
3199     if (myThickening && myOffset > 0.)
3200       Sh.Reverse();
3201     NbShell++;
3202     if (Sh.Closed()) {
3203       TopoDS_Solid  Sol;
3204       B.MakeSolid  (Sol);
3205       B.Add        (Sol,Sh);
3206       Sol.Closed(Standard_True);
3207       B.Add (NC,Sol);
3208       if (NbShell == 1) S1 = Sol;
3209     }
3210     else {
3211       B.Add (NC,Sh);
3212       if (NbShell == 1) S1 = Sh;
3213     }
3214   }
3215   if (NbShell == 1) myOffsetShape = S1;
3216   else              myOffsetShape = NC;
3217 }
3218
3219 //=======================================================================
3220 //function : SelectShells
3221 //purpose  : 
3222 //=======================================================================
3223
3224 void BRepOffset_MakeOffset::SelectShells ()
3225 {  
3226   TopTools_MapOfShape FreeEdges;
3227   TopExp_Explorer exp(myShape,TopAbs_EDGE);
3228   //-------------------------------------------------------------
3229   // FreeEdges all edges that can have free border in the  
3230   // parallel shell
3231   // 1 - free borders of myShape .
3232   //-------------------------------------------------------------
3233   for ( ; exp.More(); exp.Next()) {
3234     const TopoDS_Edge& E = TopoDS::Edge(exp.Current());
3235     const TopTools_ListOfShape& LA = myAnalyse.Ancestors(E);
3236     if (LA.Extent() < 2) {
3237       if (myAnalyse.Type(E).First().Type() == BRepOffset_FreeBoundary) {
3238         FreeEdges.Add(E);                       
3239       }
3240     }  
3241   }
3242   // myShape has free borders and there are no caps
3243   // no unwinding 3d.
3244   if (!FreeEdges.IsEmpty() && myFaces.IsEmpty()) return;
3245
3246   myOffsetShape = BRepOffset_Tool::Deboucle3D(myOffsetShape,FreeEdges);
3247 }
3248
3249 //=======================================================================
3250 //function : OffsetFacesFromShapes
3251 //purpose  : 
3252 //=======================================================================
3253
3254 const BRepAlgo_Image& BRepOffset_MakeOffset::OffsetFacesFromShapes() const
3255 {
3256   return myInitOffsetFace;
3257 }
3258
3259 //  Modified by skv - Tue Mar 15 16:20:43 2005 Begin
3260
3261 //=======================================================================
3262 //function : GetJoinType
3263 //purpose  : Query offset join type.
3264 //=======================================================================
3265
3266 GeomAbs_JoinType BRepOffset_MakeOffset::GetJoinType() const
3267 {
3268   return myJoin;
3269 }
3270
3271 //=======================================================================
3272 //function : OffsetEdgesFromShapes
3273 //purpose  : 
3274 //=======================================================================
3275
3276 const BRepAlgo_Image& BRepOffset_MakeOffset::OffsetEdgesFromShapes() const
3277 {
3278   return myInitOffsetEdge;
3279 }
3280
3281 //  Modified by skv - Tue Mar 15 16:20:43 2005 End
3282
3283 //=======================================================================
3284 //function : ClosingFaces
3285 //purpose  : 
3286 //=======================================================================
3287
3288 const TopTools_IndexedMapOfShape& BRepOffset_MakeOffset::ClosingFaces () const