0028643: Coding rules - eliminate GCC compiler warnings -Wmisleading-indentation
[occt.git] / src / BRepOffsetAPI / BRepOffsetAPI_ThruSections.cxx
1 // Created on: 1995-07-18
2 // Created by: Joelle CHAUVET
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:    Mon Jan 12 10:50:10 1998
18 //              gestion automatique de l'origine et de l'orientation
19 //              avec la methode ArrangeWires
20 // Modified:    Mon Jan 19 10:11:56 1998
21 //              traitement des cas particuliers cylindre, cone, plan 
22 //              (methodes DetectKPart et CreateKPart)
23 // Modified:    Mon Feb 23 09:28:46 1998
24 //              traitement des sections avec nombre d'elements different
25 //              + quelques ameliorations pour les cas particuliers
26 //              + cas de la derniere section ponctuelle
27 // Modified:    Mon Apr  6 15:47:44 1998
28 //              traitement des cas particuliers deplace dans BRepFill 
29 // Modified:    Thu Apr 30 15:24:17 1998
30 //              separation sections fermees / sections ouvertes + debug 
31 // Modified:    Fri Jul 10 11:23:35 1998
32 //              surface de CreateSmoothed par concatenation,approximation
33 //              et segmentation (PRO13924, CTS21295)
34 // Modified:    Tue Jul 21 16:48:35 1998
35 //              pb de ratio (BUC60281) 
36 // Modified:    Thu Jul 23 11:38:36 1998
37 //              sections bouclantes
38 // Modified:    Fri Aug 28 10:13:44 1998
39 //              traitement des sections ponctuelles
40 //              dans l'historique (cf. loft06 et loft09)
41 //              et dans le cas des solides
42 // Modified:    Tue Nov  3 10:06:15 1998
43 //              utilisation de BRepFill_CompatibleWires
44
45 #include <BRep_Builder.hxx>
46 #include <BRep_Tool.hxx>
47 #include <BRepBuilderAPI_FindPlane.hxx>
48 #include <BRepBuilderAPI_MakeFace.hxx>
49 #include <BRepClass3d_SolidClassifier.hxx>
50 #include <BRepFill_CompatibleWires.hxx>
51 #include <BRepFill_Generator.hxx>
52 #include <BRepLib.hxx>
53 #include <BRepOffsetAPI_ThruSections.hxx>
54 #include <BRepTools_WireExplorer.hxx>
55 #include <BSplCLib.hxx>
56 #include <Geom2d_Line.hxx>
57 #include <Geom_BezierCurve.hxx>
58 #include <Geom_BSplineCurve.hxx>
59 #include <Geom_BSplineSurface.hxx>
60 #include <Geom_Conic.hxx>
61 #include <Geom_Curve.hxx>
62 #include <Geom_Plane.hxx>
63 #include <Geom_TrimmedCurve.hxx>
64 #include <GeomAbs_Shape.hxx>
65 #include <GeomConvert.hxx>
66 #include <GeomConvert_ApproxCurve.hxx>
67 #include <GeomConvert_CompCurveToBSplineCurve.hxx>
68 #include <GeomFill_AppSurf.hxx>
69 #include <GeomFill_Line.hxx>
70 #include <GeomFill_SectionGenerator.hxx>
71 #include <gp_Dir2d.hxx>
72 #include <gp_Pnt.hxx>
73 #include <gp_Pnt2d.hxx>
74 #include <Precision.hxx>
75 #include <Standard_DomainError.hxx>
76 #include <Standard_NullObject.hxx>
77 #include <TColgp_Array1OfPnt.hxx>
78 #include <TopAbs.hxx>
79 #include <TopExp.hxx>
80 #include <TopLoc_Location.hxx>
81 #include <TopoDS.hxx>
82 #include <TopoDS_Edge.hxx>
83 #include <TopoDS_Face.hxx>
84 #include <TopoDS_Iterator.hxx>
85 #include <TopoDS_Shape.hxx>
86 #include <TopoDS_Solid.hxx>
87 #include <TopoDS_Vertex.hxx>
88 #include <TopoDS_Wire.hxx>
89 #include <TopTools_Array1OfShape.hxx>
90 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
91 #include <TopTools_ListIteratorOfListOfShape.hxx>
92 #include <BRepAdaptor_Surface.hxx>
93
94 //=======================================================================
95 //function : PreciseUpar
96 //purpose  : pins the u-parameter of surface close to U-knot
97 //           to this U-knot
98 //=======================================================================
99 static Standard_Real PreciseUpar(const Standard_Real anUpar,
100   const Handle(Geom_BSplineSurface)& aSurface)
101 {
102   Standard_Real Tol = Precision::PConfusion();
103   Standard_Integer i1, i2;
104
105   aSurface->LocateU(anUpar, Tol, i1, i2);
106   Standard_Real U1 = aSurface->UKnot(i1);
107   Standard_Real U2 = aSurface->UKnot(i2);
108
109   Standard_Real NewU = anUpar;
110
111   NewU = (anUpar - U1 < U2 - anUpar)? U1 : U2;
112   return NewU;
113 }
114
115 //=======================================================================
116 //function :  PerformPlan
117 //purpose  : Construct a plane of filling if exists
118 //=======================================================================
119
120 static Standard_Boolean PerformPlan(const TopoDS_Wire& W,
121   const Standard_Real presPln,
122   TopoDS_Face& theFace)
123 {
124   Standard_Boolean isDegen = Standard_True;
125   TopoDS_Iterator iter(W);
126   for (; iter.More(); iter.Next())
127   {
128     const TopoDS_Edge& anEdge = TopoDS::Edge(iter.Value());
129     if (!BRep_Tool::Degenerated(anEdge))
130       isDegen = Standard_False;
131   }
132   if (isDegen)
133     return Standard_True;
134
135   Standard_Boolean Ok = Standard_False;
136   if (!W.IsNull()) {
137     BRepBuilderAPI_FindPlane Searcher( W, presPln );
138     if (Searcher.Found())
139     {
140       theFace = BRepBuilderAPI_MakeFace(Searcher.Plane(), W);
141       Ok = Standard_True;
142     }
143     else // try to find another surface
144     {
145       BRepBuilderAPI_MakeFace MF( W );
146       if (MF.IsDone())
147       {
148         theFace = MF.Face();
149         Ok = Standard_True;
150       }
151     }
152   }
153
154   return Ok;
155 }
156
157 //=============================================================================
158 //function :  IsSameOriented
159 //purpose  : Checks whether aFace is oriented to the same side as aShell or not
160 //=============================================================================
161
162 static Standard_Boolean IsSameOriented(const TopoDS_Shape& aFace,
163   const TopoDS_Shape& aShell)
164 {
165   TopExp_Explorer Explo(aFace, TopAbs_EDGE);
166   TopoDS_Shape anEdge = Explo.Current();
167   TopAbs_Orientation Or1 = anEdge.Orientation();
168
169   TopTools_IndexedDataMapOfShapeListOfShape EFmap;
170   TopExp::MapShapesAndAncestors( aShell, TopAbs_EDGE, TopAbs_FACE, EFmap );
171
172   const TopoDS_Shape& AdjacentFace = EFmap.FindFromKey(anEdge).First();
173   TopoDS_Shape theEdge;
174   for (Explo.Init(AdjacentFace, TopAbs_EDGE); Explo.More(); Explo.Next())
175   {
176     theEdge = Explo.Current();
177     if (theEdge.IsSame(anEdge))
178       break;
179   }
180
181   TopAbs_Orientation Or2 = theEdge.Orientation();
182   if (Or1 == Or2)
183     return Standard_False;
184   return Standard_True;
185 }
186
187 //=======================================================================
188 //function : MakeSolid
189 //purpose  : 
190 //=======================================================================
191
192 static TopoDS_Solid MakeSolid(TopoDS_Shell& shell, const TopoDS_Wire& wire1,
193   const TopoDS_Wire& wire2, const Standard_Real presPln,
194   TopoDS_Face& face1, TopoDS_Face& face2)
195 {
196   if (shell.IsNull())
197     throw StdFail_NotDone("Thrusections is not build");
198   Standard_Boolean B = shell.Closed();
199   BRep_Builder BB;
200
201   if (!B)
202   {
203     // It is necessary to close the extremities 
204     B =  PerformPlan(wire1, presPln, face1);
205     if (B) {
206       B =  PerformPlan(wire2, presPln, face2);
207       if (B) {
208         if (!face1.IsNull() && !IsSameOriented( face1, shell ))
209           face1.Reverse();
210         if (!face2.IsNull() && !IsSameOriented( face2, shell ))
211           face2.Reverse();
212
213         if (!face1.IsNull())
214           BB.Add(shell, face1);
215         if (!face2.IsNull())
216           BB.Add(shell, face2);
217
218         shell.Closed(Standard_True);
219       }
220     }
221   }
222
223   TopoDS_Solid solid;
224   BB.MakeSolid(solid); 
225   BB.Add(solid, shell);
226
227   // verify the orientation the solid
228   BRepClass3d_SolidClassifier clas3d(solid);
229   clas3d.PerformInfinitePoint(Precision::Confusion());
230   if (clas3d.State() == TopAbs_IN) {
231     BB.MakeSolid(solid); 
232     TopoDS_Shape aLocalShape = shell.Reversed();
233     BB.Add(solid, TopoDS::Shell(aLocalShape));
234     //    B.Add(solid, TopoDS::Shell(newShell.Reversed()));
235   }
236
237   solid.Closed(Standard_True);
238   return solid;
239 }
240
241
242 //=======================================================================
243 //function : BRepOffsetAPI_ThruSections
244 //purpose  : 
245 //=======================================================================
246
247 BRepOffsetAPI_ThruSections::BRepOffsetAPI_ThruSections(const Standard_Boolean isSolid,
248                                                        const Standard_Boolean ruled,
249                                                        const Standard_Real pres3d):
250   myNbEdgesInSection(0),
251   myIsSolid(isSolid), myIsRuled(ruled),
252   myPres3d(pres3d),
253   myDegen1(Standard_False), myDegen2(Standard_False)
254 {
255   myWCheck = Standard_True;
256   //----------------------------
257   myParamType = Approx_ChordLength; 
258   myDegMax    = 8; 
259   myContinuity = GeomAbs_C2;
260   myCritWeights[0] = .4; 
261   myCritWeights[1] = .2; 
262   myCritWeights[2] = .4; 
263   myUseSmoothing = Standard_False;
264 }
265
266
267 //=======================================================================
268 //function : Init
269 //purpose  : 
270 //=======================================================================
271
272 void BRepOffsetAPI_ThruSections::Init(const Standard_Boolean isSolid, const Standard_Boolean ruled,
273   const Standard_Real pres3d)
274 {
275   myIsSolid = isSolid;
276   myIsRuled = ruled;
277   myPres3d = pres3d;
278   myWCheck = Standard_True;
279   //----------------------------
280   myParamType = Approx_ChordLength; 
281   myDegMax    = 6; 
282   myContinuity = GeomAbs_C2;
283   myCritWeights[0] = .4; 
284   myCritWeights[1] = .2; 
285   myCritWeights[2] = .4; 
286   myUseSmoothing = Standard_False;
287
288 }
289
290
291 //=======================================================================
292 //function : AddWire
293 //purpose  : 
294 //=======================================================================
295
296 void BRepOffsetAPI_ThruSections::AddWire(const TopoDS_Wire& wire)
297 {
298   myWires.Append(wire);
299 }
300
301 //=======================================================================
302 //function : AddVertex
303 //purpose  : 
304 //=======================================================================
305
306 void BRepOffsetAPI_ThruSections::AddVertex(const TopoDS_Vertex& aVertex)
307 {
308   BRep_Builder BB;
309
310   TopoDS_Edge DegEdge;
311   BB.MakeEdge( DegEdge );
312   BB.Add( DegEdge, aVertex.Oriented(TopAbs_FORWARD) );
313   BB.Add( DegEdge, aVertex.Oriented(TopAbs_REVERSED) );
314   BB.Degenerated( DegEdge, Standard_True );
315
316   TopoDS_Wire DegWire;
317   BB.MakeWire( DegWire );
318   BB.Add( DegWire, DegEdge );
319   DegWire.Closed( Standard_True );
320
321   myWires.Append( DegWire );
322 }
323
324 //=======================================================================
325 //function : CheckCompatibility
326 //purpose  : 
327 //=======================================================================
328
329 void BRepOffsetAPI_ThruSections::CheckCompatibility(const Standard_Boolean check)
330 {
331   myWCheck = check;
332 }
333
334
335 //=======================================================================
336 //function : Build
337 //purpose  : 
338 //=======================================================================
339
340 void BRepOffsetAPI_ThruSections::Build()
341 {
342   //Check set of section for right configuration of punctual sections
343   Standard_Integer i;
344   TopExp_Explorer explo;
345   for (i = 2; i <= myWires.Length()-1; i++)
346   {
347     Standard_Boolean wdeg = Standard_True;
348     for (explo.Init(myWires(i), TopAbs_EDGE); explo.More(); explo.Next())
349     {
350       const TopoDS_Edge& anEdge = TopoDS::Edge(explo.Current());
351       wdeg = wdeg && (BRep_Tool::Degenerated(anEdge));
352     }
353     if (wdeg)
354       throw Standard_Failure("Wrong usage of punctual sections");
355   }
356   if (myWires.Length() <= 2)
357   {
358     Standard_Boolean wdeg = Standard_True;
359     for (i = 1; i <= myWires.Length(); i++)
360     {
361       for (explo.Init(myWires(i), TopAbs_EDGE); explo.More(); explo.Next())
362       {
363         const TopoDS_Edge& anEdge = TopoDS::Edge(explo.Current());
364         wdeg = wdeg && (BRep_Tool::Degenerated(anEdge));
365       }
366     }
367     if (wdeg)
368     {
369       throw Standard_Failure("Wrong usage of punctual sections");
370     }
371   }
372
373   myNbEdgesInSection = 0;
374   
375   if (myWCheck) {
376     // compute origin and orientation on wires to avoid twisted results
377     // and update wires to have same number of edges
378
379     // use BRepFill_CompatibleWires
380     TopTools_SequenceOfShape WorkingSections;
381     WorkingSections.Clear();
382     TopTools_DataMapOfShapeListOfShape WorkingMap;
383     WorkingMap.Clear();
384
385     // Calculate the working sections
386     BRepFill_CompatibleWires Georges(myWires);
387     Georges.Perform();
388     if (Georges.IsDone()) {
389       WorkingSections = Georges.Shape();
390       WorkingMap = Georges.Generated();
391       myDegen1 = Georges.IsDegeneratedFirstSection();
392       myDegen2 = Georges.IsDegeneratedLastSection();
393       //For each sub-edge of each section
394       //we save its splits
395       Standard_Integer IndFirstSec = 1;
396       if (Georges.IsDegeneratedFirstSection())
397         IndFirstSec = 2;
398       TopoDS_Shape aWorkingSection = WorkingSections(IndFirstSec);
399       TopoDS_Iterator itw(aWorkingSection);
400       for (; itw.More(); itw.Next())
401         myNbEdgesInSection++;
402       for (Standard_Integer ii = 1; ii <= myWires.Length(); ii++)
403       {
404         TopExp_Explorer Explo(myWires(ii), TopAbs_EDGE);
405         for (; Explo.More(); Explo.Next())
406         {
407           const TopoDS_Edge& anEdge = TopoDS::Edge(Explo.Current());
408           Standard_Integer aSign = 1;
409           TopoDS_Vertex Vfirst, Vlast;
410           TopExp::Vertices(anEdge, Vfirst, Vlast);
411           TopTools_ListOfShape aNewEdges = Georges.GeneratedShapes(anEdge);
412           TColStd_ListOfInteger IList;
413           aWorkingSection = WorkingSections(ii);
414           Standard_Integer NbNewEdges = aNewEdges.Extent();
415           TopTools_ListIteratorOfListOfShape itl(aNewEdges);
416           for (Standard_Integer kk = 1; itl.More(); itl.Next(),kk++)
417           {
418             const TopoDS_Edge& aNewEdge = TopoDS::Edge(itl.Value());
419             Standard_Integer inde = 1;
420             for (itw.Initialize(aWorkingSection); itw.More(); itw.Next(),inde++)
421             {
422               const TopoDS_Shape& aWorkingEdge = itw.Value();
423               if (aWorkingEdge.IsSame(aNewEdge))
424               {
425                 aSign = (aWorkingEdge.Orientation() == TopAbs_FORWARD)? 1 : -1;
426                 break;
427               }
428             }
429             IList.Append(inde);
430             if (kk == 1 || kk == NbNewEdges)
431             {
432               //For each sub-vertex of each section
433               //we save its index of new edge
434               TopoDS_Vertex NewVfirst, NewVlast;
435               TopExp::Vertices(aNewEdge, NewVfirst, NewVlast);
436               if (NewVfirst.IsSame(Vfirst) && !myVertexIndex.IsBound(Vfirst))
437                 myVertexIndex.Bind(Vfirst, aSign*inde);
438               if (NewVlast.IsSame(Vlast) && !myVertexIndex.IsBound(Vlast))
439                 myVertexIndex.Bind(Vlast, aSign*(-inde));
440             }
441           }
442           myEdgeNewIndices.Bind(anEdge, IList);
443         }
444       }
445     }
446     myWires = WorkingSections;
447   } //if (myWCheck)
448   else //no check
449   {
450     TopoDS_Edge anEdge;
451     for (Standard_Integer ii = 1; ii <= myWires.Length(); ii++)
452     {
453       TopExp_Explorer Explo(myWires(ii), TopAbs_EDGE);
454       Standard_Integer inde = 1;
455       for (; Explo.More(); Explo.Next(),inde++)
456       {
457         anEdge = TopoDS::Edge(Explo.Current());
458         TColStd_ListOfInteger IList;
459         IList.Append(inde);
460         myEdgeNewIndices.Bind(anEdge, IList);
461         TopoDS_Vertex V1, V2;
462         TopExp::Vertices(anEdge, V1, V2);
463         if (!myVertexIndex.IsBound(V1))
464           myVertexIndex.Bind(V1, inde);
465         if (!myVertexIndex.IsBound(V2))
466           myVertexIndex.Bind(V2, -inde);
467       }
468       inde--;
469       if (inde > myNbEdgesInSection)
470         myNbEdgesInSection = inde;
471       if (inde == 1 && BRep_Tool::Degenerated(anEdge))
472       {
473         if (ii == 1)
474           myDegen1 = Standard_True;
475         else
476           myDegen2 = Standard_True;
477       }
478     }
479   }
480
481   try {
482     // Calculate the resulting shape
483     if (myWires.Length() == 2 || myIsRuled) {
484       // create a ruled shell
485       CreateRuled();
486     }
487     else {
488       // create a smoothed shell
489       CreateSmoothed();
490     }
491   }
492   catch (Standard_Failure)
493   {
494     NotDone();
495     return;
496   }
497   // Encode the Regularities
498   BRepLib::EncodeRegularity(myShape);
499 }
500
501
502 //=======================================================================
503 //function : CreateRuled
504 //purpose  : 
505 //=======================================================================
506
507 void BRepOffsetAPI_ThruSections::CreateRuled()
508 {
509   Standard_Integer nbSects = myWires.Length();
510   BRepFill_Generator aGene;
511   //  for (Standard_Integer i=1; i<=nbSects; i++) {
512   Standard_Integer i;
513   for (i=1; i<=nbSects; i++) {
514     aGene.AddWire(TopoDS::Wire(myWires(i)));
515   }
516   aGene.Perform();
517   TopoDS_Shell shell = aGene.Shell();
518
519   if (myIsSolid) {
520
521     // check if the first wire is the same as the last
522     Standard_Boolean vClosed = (myWires(1).IsSame(myWires(nbSects))) ;
523
524     if (vClosed) {
525
526       TopoDS_Solid solid;      
527       BRep_Builder B;
528       B.MakeSolid(solid); 
529       B.Add(solid, shell);
530
531       // verify the orientation of the solid
532       BRepClass3d_SolidClassifier clas3d(solid);
533       clas3d.PerformInfinitePoint(Precision::Confusion());
534       if (clas3d.State() == TopAbs_IN) {
535         B.MakeSolid(solid); 
536         TopoDS_Shape aLocalShape = shell.Reversed();
537         B.Add(solid, TopoDS::Shell(aLocalShape));
538         //      B.Add(solid, TopoDS::Shell(shell.Reversed()));
539       }
540       myShape = solid;
541
542     }
543
544     else {
545
546       TopoDS_Wire wire1 = TopoDS::Wire(myWires.First());
547       TopoDS_Wire wire2 = TopoDS::Wire(myWires.Last());
548       myShape = MakeSolid(shell, wire1, wire2, myPres3d, myFirst, myLast);
549
550     }
551
552     Done();
553   }
554
555   else {
556     myShape = shell;
557     Done();
558   }
559
560   // history
561   BRepTools_WireExplorer anExp1, anExp2;
562   TopTools_IndexedDataMapOfShapeListOfShape M;
563   TopExp::MapShapesAndAncestors(shell, TopAbs_EDGE, TopAbs_FACE, M);
564   TopTools_ListIteratorOfListOfShape it;
565
566   TopTools_IndexedDataMapOfShapeListOfShape MV;
567   TopExp::MapShapesAndAncestors(shell, TopAbs_VERTEX, TopAbs_FACE, MV);
568
569   for (i=1; i<=nbSects-1; i++) {
570
571     const TopoDS_Wire& wire1 = TopoDS::Wire(myWires(i));
572     const TopoDS_Wire& wire2 = TopoDS::Wire(myWires(i+1));
573
574     anExp1.Init(wire1);
575     anExp2.Init(wire2);
576
577     Standard_Boolean tantque = anExp1.More() && anExp2.More();
578
579     while (tantque) {
580
581       const TopoDS_Shape& edge1 = anExp1.Current();
582       const TopoDS_Shape& edge2 = anExp2.Current();
583       Standard_Boolean degen1 = BRep_Tool::Degenerated(anExp1.Current());
584       Standard_Boolean degen2 = BRep_Tool::Degenerated(anExp2.Current());
585
586       TopTools_MapOfShape MapFaces;
587       if (degen2){
588         TopoDS_Vertex Vdegen = TopExp::FirstVertex(TopoDS::Edge(edge2));
589         for (it.Initialize(MV.FindFromKey(Vdegen)); it.More(); it.Next()) {
590           MapFaces.Add(it.Value());
591         }
592       }
593       else {
594         for (it.Initialize(M.FindFromKey(edge2)); it.More(); it.Next()) {
595           MapFaces.Add(it.Value());
596         }
597       }
598
599       if (degen1) {
600         TopoDS_Vertex Vdegen = TopExp::FirstVertex(TopoDS::Edge(edge1));
601         for (it.Initialize(MV.FindFromKey(Vdegen)); it.More(); it.Next()) {
602           const TopoDS_Shape& Face = it.Value();
603           if (MapFaces.Contains(Face)) {
604             myEdgeFace.Bind(edge1, Face);
605             break;
606           }
607         }
608       }
609       else {
610         for (it.Initialize(M.FindFromKey(edge1)); it.More(); it.Next()) {
611           const TopoDS_Shape& Face = it.Value();
612           if (MapFaces.Contains(Face)) {
613             myEdgeFace.Bind(edge1, Face);
614             break;
615           }
616         }
617       }
618
619       if (!degen1) anExp1.Next();
620       if (!degen2) anExp2.Next();
621
622       tantque = anExp1.More() && anExp2.More();
623       if (degen1) tantque = anExp2.More();
624       if (degen2) tantque = anExp1.More();
625
626     }
627
628   }
629
630 }
631
632 //=======================================================================
633 //function : CreateSmoothed
634 //purpose  : 
635 //=======================================================================
636
637 void BRepOffsetAPI_ThruSections::CreateSmoothed()
638 {
639   // initialisation
640   Standard_Integer nbSects = myWires.Length();
641   BRepTools_WireExplorer anExp;
642
643   Standard_Boolean w1Point = Standard_True;
644   // check if the first wire is punctual
645   for(anExp.Init(TopoDS::Wire(myWires(1))); anExp.More(); anExp.Next()) {
646     w1Point = w1Point && (BRep_Tool::Degenerated(anExp.Current()));
647   }
648
649   Standard_Boolean w2Point = Standard_True;
650   // check if the last wire is punctual
651   for(anExp.Init(TopoDS::Wire(myWires(nbSects))); anExp.More(); anExp.Next()) {
652     w2Point = w2Point && (BRep_Tool::Degenerated(anExp.Current()));
653   }
654
655   Standard_Boolean vClosed = Standard_False;
656   // check if the first wire is the same as last
657   if (myWires(1).IsSame(myWires(myWires.Length()))) vClosed = Standard_True;
658
659   // find the dimension
660   Standard_Integer nbEdges=0;
661   if (!w1Point) {
662     for(anExp.Init(TopoDS::Wire(myWires(1))); anExp.More(); anExp.Next()) {
663       nbEdges++;
664     }
665   }
666   else {
667     for(anExp.Init(TopoDS::Wire(myWires(2))); anExp.More(); anExp.Next()) {
668       nbEdges++;
669     }
670   }
671
672   // recover the shapes
673   Standard_Boolean uClosed = Standard_True;
674   TopTools_Array1OfShape shapes(1, nbSects*nbEdges);
675   Standard_Integer nb=0, i, j;
676
677   for (i=1; i<=nbSects; i++) {
678     const TopoDS_Wire& wire = TopoDS::Wire(myWires(i));
679     if (!wire.Closed()) {
680       // check if the vertices are the same
681       TopoDS_Vertex V1, V2;
682       TopExp::Vertices(wire,V1,V2);
683       if ( !V1.IsSame(V2)) uClosed = Standard_False;
684     }
685     if ( (i==1 && w1Point) || (i==nbSects && w2Point) ) {
686       // if the wire is punctual
687       anExp.Init(TopoDS::Wire(wire));
688       for(j=1; j<=nbEdges; j++) {
689         nb++;
690         shapes(nb) = anExp.Current();
691       }
692     }
693     else {
694       // otherwise
695       for(anExp.Init(TopoDS::Wire(wire)); anExp.More(); anExp.Next()) {
696         nb++;
697         shapes(nb) = anExp.Current();
698       }
699     }
700   }
701
702   // create the new surface
703   TopoDS_Shell shell;
704   TopoDS_Face face;
705   TopoDS_Wire W;
706   TopoDS_Edge edge, edge1, edge2, edge3, edge4, couture;
707   TopTools_Array1OfShape vcouture(1, nbEdges);
708
709   BRep_Builder B;
710   B.MakeShell(shell);
711
712   TopoDS_Wire newW1, newW2;
713   BRep_Builder BW1, BW2;
714   BW1.MakeWire(newW1);
715   BW2.MakeWire(newW2);
716
717   TopLoc_Location loc;
718   TopoDS_Vertex v1f,v1l,v2f,v2l;
719
720   Standard_Integer nbPnts = 21;
721   TColgp_Array2OfPnt points(1, nbPnts, 1, nbSects);
722
723   // concatenate each section to get a total surface that will be segmented
724   Handle(Geom_BSplineSurface) TS;
725   TS = TotalSurf(shapes,nbSects,nbEdges,w1Point,w2Point,vClosed);
726
727   if(TS.IsNull()) {
728     return;
729   }
730
731   TopoDS_Shape firstEdge;
732   for (i=1; i<=nbEdges; i++) {  
733
734     // segmentation of TS
735     Handle(Geom_BSplineSurface) surface;
736     surface = Handle(Geom_BSplineSurface)::DownCast(TS->Copy());
737     Standard_Real Ui1,Ui2,V0,V1;
738     Ui1 = i-1;
739     Ui2 = i;
740     Ui1 = PreciseUpar(Ui1, surface);
741     Ui2 = PreciseUpar(Ui2, surface);
742     V0  = surface->VKnot(surface->FirstVKnotIndex());
743     V1  = surface->VKnot(surface->LastVKnotIndex());
744     surface->Segment(Ui1,Ui2,V0,V1);
745
746     // return vertices
747     edge =  TopoDS::Edge(shapes(i));
748     TopExp::Vertices(edge,v1f,v1l);
749     if (edge.Orientation() == TopAbs_REVERSED)
750       TopExp::Vertices(edge,v1l,v1f);
751     firstEdge = edge;
752
753     edge =  TopoDS::Edge(shapes((nbSects-1)*nbEdges+i));
754     TopExp::Vertices(edge,v2f,v2l);
755     if (edge.Orientation() == TopAbs_REVERSED)
756       TopExp::Vertices(edge,v2l,v2f);
757
758     // make the face
759     B.MakeFace(face, surface, Precision::Confusion());
760
761     // make the wire
762     B.MakeWire(W);
763
764     // make the missing edges
765     Standard_Real f1, f2, l1, l2;
766     surface->Bounds(f1,l1,f2,l2);
767
768     // --- edge 1
769     if ( w1Point ) {
770       // copy the degenerated edge
771       TopoDS_Shape aLocalShape = shapes(1).EmptyCopied();
772       edge1 =  TopoDS::Edge(aLocalShape);
773       //      edge1 =  TopoDS::Edge(shapes(1).EmptyCopied());
774       edge1.Orientation(TopAbs_FORWARD);
775     }
776     else {
777       B.MakeEdge(edge1, surface->VIso(f2), Precision::Confusion());
778     }
779     v1f.Orientation(TopAbs_FORWARD);
780     B.Add(edge1, v1f);
781     v1l.Orientation(TopAbs_REVERSED);
782     B.Add(edge1, v1l);
783     B.Range(edge1, f1, l1);
784     // processing of looping sections
785     // store edges of the 1st section
786     if (vClosed)
787       vcouture(i) = edge1;
788
789
790     // --- edge 2
791     if (vClosed)
792       edge2 = TopoDS::Edge(vcouture(i));
793     else {
794       if ( w2Point ) {
795         // copy of the degenerated edge
796         TopoDS_Shape aLocalShape = shapes(nbSects*nbEdges).EmptyCopied();
797         edge2 =  TopoDS::Edge(aLocalShape);
798         //      edge2 =  TopoDS::Edge(shapes(nbSects*nbEdges).EmptyCopied());
799         edge2.Orientation(TopAbs_FORWARD);
800       }
801       else {
802         B.MakeEdge(edge2, surface->VIso(l2), Precision::Confusion());
803       }
804       v2f.Orientation(TopAbs_FORWARD);
805       B.Add(edge2, v2f);
806       v2l.Orientation(TopAbs_REVERSED);
807       B.Add(edge2, v2l);
808       B.Range(edge2, f1, l1);
809     }
810     edge2.Reverse();
811
812
813     // --- edge 3
814     if (i==1) {
815       B.MakeEdge(edge3, surface->UIso(f1), Precision::Confusion());
816       v1f.Orientation(TopAbs_FORWARD);
817       B.Add(edge3, v1f);
818       v2f.Orientation(TopAbs_REVERSED);
819       B.Add(edge3, v2f);
820       B.Range(edge3, f2, l2);
821       if (uClosed) {
822         couture = edge3;
823       }
824     }
825     else {
826       edge3 = edge4;
827     }
828     edge3.Reverse();
829
830     // --- edge 4
831     if ( uClosed && i==nbEdges) {
832       edge4 = couture;
833     }
834     else {
835       B.MakeEdge(edge4, surface->UIso(l1), Precision::Confusion());
836       v1l.Orientation(TopAbs_FORWARD);
837       B.Add(edge4, v1l);
838       v2l.Orientation(TopAbs_REVERSED);
839       B.Add(edge4, v2l);
840       B.Range(edge4, f2, l2);
841     }
842
843     B.Add(W,edge1);
844     B.Add(W,edge4);
845     B.Add(W,edge2);
846     B.Add(W,edge3);
847
848     // set PCurve
849     if (vClosed) {
850       B.UpdateEdge(edge1,
851         new Geom2d_Line(gp_Pnt2d(0,f2),gp_Dir2d(1,0)),
852         new Geom2d_Line(gp_Pnt2d(0,l2),gp_Dir2d(1,0)),face,
853         Precision::Confusion());
854       B.Range(edge1,face,f1,l1);
855     }
856     else {
857       B.UpdateEdge(edge1,new Geom2d_Line(gp_Pnt2d(0,f2),gp_Dir2d(1,0)),face,
858         Precision::Confusion());
859       B.Range(edge1,face,f1,l1);
860       B.UpdateEdge(edge2,new Geom2d_Line(gp_Pnt2d(0,l2),gp_Dir2d(1,0)),face,
861         Precision::Confusion());
862       B.Range(edge2,face,f1,l1);
863     }
864
865     if ( uClosed && nbEdges ==1 )  {
866       B.UpdateEdge(edge3,
867         new Geom2d_Line(gp_Pnt2d(l1,0),gp_Dir2d(0,1)),
868         new Geom2d_Line(gp_Pnt2d(f1,0),gp_Dir2d(0,1)),face,
869         Precision::Confusion());
870       B.Range(edge3,face,f2,l2);
871
872     }
873     else {
874       B.UpdateEdge(edge3,new Geom2d_Line(gp_Pnt2d(f1,0),gp_Dir2d(0,1)),face,
875         Precision::Confusion());
876       B.Range(edge3,face,f2,l2);
877       B.UpdateEdge(edge4,new Geom2d_Line(gp_Pnt2d(l1,0),gp_Dir2d(0,1)),face,
878         Precision::Confusion());
879       B.Range(edge4,face,f2,l2);
880     }
881     B.Add(face,W);
882     B.Add(shell, face);
883
884     // complete newW1 newW2
885     TopoDS_Edge edge12 = edge1;
886     TopoDS_Edge edge22 = edge2;
887     edge12.Reverse();
888     edge22.Reverse();
889     BW1.Add(newW1, edge12);
890     BW2.Add(newW2, edge22);
891
892     // history
893     myEdgeFace.Bind(firstEdge, face);
894   }
895
896   if (uClosed && w1Point && w2Point)
897     shell.Closed(Standard_True);
898
899   if (myIsSolid) {
900
901     if (vClosed) {
902
903       TopoDS_Solid solid;
904       B.MakeSolid(solid); 
905       B.Add(solid, shell);
906
907       // verify the orientation the solid
908       BRepClass3d_SolidClassifier clas3d(solid);
909       clas3d.PerformInfinitePoint(Precision::Confusion());
910       if (clas3d.State() == TopAbs_IN) {
911         B.MakeSolid(solid); 
912         TopoDS_Shape aLocalShape = shell.Reversed();
913         B.Add(solid, TopoDS::Shell(aLocalShape));
914         //      B.Add(solid, TopoDS::Shell(shell.Reversed()));
915       }
916       myShape = solid;
917
918     }
919
920     else {
921       myShape = MakeSolid(shell, newW1, newW2, myPres3d, myFirst, myLast);
922     }
923
924     Done();
925   }
926
927   else {
928     myShape = shell;
929     Done();
930   }
931
932   TopExp_Explorer ex(myShape,TopAbs_EDGE);
933   while (ex.More()) {
934     const TopoDS_Edge& CurE = TopoDS::Edge(ex.Current());
935     B.SameRange(CurE, Standard_False);
936     B.SameParameter(CurE, Standard_False);
937     Standard_Real tol = BRep_Tool::Tolerance(CurE);
938     BRepLib::SameParameter(CurE,tol);
939     ex.Next();
940   }
941 }
942
943 //=======================================================================
944 //function : EdgeToBSpline
945 //purpose  : auxiliary -- get curve from edge and convert it to bspline
946 //           parameterized from 0 to 1
947 //=======================================================================
948
949 // NOTE: this code duplicates the same function in BRepFill_NSections.cxx
950 static Handle(Geom_BSplineCurve) EdgeToBSpline (const TopoDS_Edge& theEdge)
951 {
952   Handle(Geom_BSplineCurve) aBSCurve;
953   if (BRep_Tool::Degenerated(theEdge)) {
954     // degenerated edge : construction of a point curve
955     TColStd_Array1OfReal aKnots (1,2);
956     aKnots(1) = 0.;
957     aKnots(2) = 1.;
958
959     TColStd_Array1OfInteger aMults (1,2);
960     aMults(1) = 2;
961     aMults(2) = 2;
962
963     TColgp_Array1OfPnt aPoles(1,2);
964     TopoDS_Vertex vf, vl;
965     TopExp::Vertices(theEdge,vl,vf);
966     aPoles(1) = BRep_Tool::Pnt(vf);
967     aPoles(2) = BRep_Tool::Pnt(vl);
968
969     aBSCurve = new Geom_BSplineCurve (aPoles, aKnots, aMults, 1);
970   }
971   else
972   {
973     // get the curve of the edge
974     TopLoc_Location aLoc;
975     Standard_Real aFirst, aLast;
976     Handle(Geom_Curve) aCurve = BRep_Tool::Curve (theEdge, aLoc, aFirst, aLast);
977     if (aCurve.IsNull())
978       throw Standard_NullObject("Null 3D curve in edge");
979
980     // convert its part used by edge to bspline; note that if edge curve is bspline,
981     // conversion made via trimmed curve is still needed -- it will copy it, segment 
982     // as appropriate, and remove periodicity if it is periodic (deadly for approximator)
983     Handle(Geom_TrimmedCurve) aTrimCurve = new Geom_TrimmedCurve (aCurve, aFirst, aLast);
984
985     // special treatment of conic curve
986     if (aTrimCurve->BasisCurve()->IsKind(STANDARD_TYPE(Geom_Conic)))
987     {
988       const Handle(Geom_Curve)& aCurveTrimmed = aTrimCurve; // to avoid ambiguity
989       GeomConvert_ApproxCurve anAppr (aCurveTrimmed, Precision::Confusion(), GeomAbs_C1, 16, 14);
990       if (anAppr.HasResult())
991         aBSCurve = anAppr.Curve();
992     }
993
994     // general case
995     if (aBSCurve.IsNull())
996       aBSCurve = GeomConvert::CurveToBSplineCurve (aTrimCurve);
997
998     // apply transformation if needed
999     if (! aLoc.IsIdentity())
1000       aBSCurve->Transform (aLoc.Transformation());
1001
1002     // reparameterize to [0,1]
1003     TColStd_Array1OfReal aKnots (1, aBSCurve->NbKnots());
1004     aBSCurve->Knots (aKnots);
1005     BSplCLib::Reparametrize (0., 1., aKnots);
1006     aBSCurve->SetKnots (aKnots);
1007   }
1008
1009   // reverse curve if edge is reversed
1010   if (theEdge.Orientation() == TopAbs_REVERSED)
1011     aBSCurve->Reverse();
1012
1013   return aBSCurve;
1014 }
1015
1016 //=======================================================================
1017 //function : TotalSurf
1018 //purpose  : 
1019 //=======================================================================
1020
1021 Handle(Geom_BSplineSurface) BRepOffsetAPI_ThruSections::
1022                           TotalSurf(const TopTools_Array1OfShape& shapes,
1023                                     const Standard_Integer NbSects,
1024                                     const Standard_Integer NbEdges,
1025                                     const Standard_Boolean w1Point,
1026                                     const Standard_Boolean w2Point,
1027                                     const Standard_Boolean vClosed) const
1028 {
1029   Standard_Integer i,j,jdeb=1,jfin=NbSects;
1030   TopoDS_Vertex vf,vl;
1031
1032   GeomFill_SectionGenerator section;
1033   Handle(Geom_BSplineSurface) surface;
1034   Handle(Geom_BSplineCurve) BS, BS1;
1035   Handle(Geom_TrimmedCurve) curvTrim;
1036
1037   if (w1Point) {
1038     jdeb++;
1039     TopoDS_Edge edge =  TopoDS::Edge(shapes(1));
1040     TopExp::Vertices(edge,vl,vf);
1041     TColgp_Array1OfPnt Extremities(1,2);
1042     Extremities(1) = BRep_Tool::Pnt(vf);
1043     Extremities(2) = BRep_Tool::Pnt(vl);
1044     TColStd_Array1OfReal Bounds(1,2);
1045     Bounds(1) = 0.;
1046     Bounds(2) = 1.;
1047     TColStd_Array1OfInteger Mult(1,2);
1048     Mult(1) = 2;
1049     Mult(2) = 2;
1050     Handle(Geom_BSplineCurve) BSPoint
1051       = new Geom_BSplineCurve(Extremities,Bounds,Mult,1);
1052     section.AddCurve(BSPoint);
1053   }
1054
1055   if (w2Point) {
1056     jfin--;
1057   }
1058
1059   for (j=jdeb; j<=jfin; j++) {
1060
1061     // case of looping sections 
1062     if (j==jfin && vClosed) {
1063       section.AddCurve(BS1);
1064     }
1065
1066     else {
1067       // read the first edge to initialise CompBS;
1068       TopoDS_Edge aPrevEdge = TopoDS::Edge (shapes((j-1)*NbEdges+1));
1069       Handle(Geom_BSplineCurve) curvBS = EdgeToBSpline (aPrevEdge);
1070
1071       // initialization
1072       GeomConvert_CompCurveToBSplineCurve CompBS(curvBS);
1073
1074       for (i=2; i<=NbEdges; i++) {  
1075         // read the edge
1076         TopoDS_Edge aNextEdge = TopoDS::Edge (shapes((j-1)*NbEdges+i));
1077         Standard_Real aTolV = Precision::Confusion();  
1078         TopExp::Vertices(aNextEdge,vf,vl);
1079         aTolV = Max(aTolV, BRep_Tool::Tolerance(vf));
1080         aTolV = Max(aTolV, BRep_Tool::Tolerance(vl));
1081         aTolV = Min(aTolV, 1.e-3);
1082         curvBS = EdgeToBSpline (aNextEdge);
1083
1084         // concatenation
1085         CompBS.Add(curvBS, aTolV, Standard_True, Standard_False, 1);
1086       }
1087
1088       // return the final section
1089       BS = CompBS.BSplineCurve();
1090       section.AddCurve(BS);
1091
1092       // case of looping sections
1093       if (j==jdeb && vClosed) {
1094         BS1 = BS;
1095       }
1096
1097     }
1098   }
1099
1100   if (w2Point) {
1101     TopoDS_Edge edge =  TopoDS::Edge(shapes(NbSects*NbEdges));
1102     TopExp::Vertices(edge,vl,vf);
1103     TColgp_Array1OfPnt Extremities(1,2);
1104     Extremities(1) = BRep_Tool::Pnt(vf);
1105     Extremities(2) = BRep_Tool::Pnt(vl);
1106     TColStd_Array1OfReal Bounds(1,2);
1107     Bounds(1) = 0.;
1108     Bounds(2) = 1.;
1109     TColStd_Array1OfInteger Mult(1,2);
1110     Mult(1) = 2;
1111     Mult(2) = 2;
1112     Handle(Geom_BSplineCurve) BSPoint
1113       = new Geom_BSplineCurve(Extremities,Bounds,Mult,1);
1114     section.AddCurve(BSPoint);
1115   }
1116
1117   section.Perform(Precision::PConfusion());
1118   Handle(GeomFill_Line) line = new GeomFill_Line(NbSects);
1119
1120   Standard_Integer nbIt = 3;
1121   if(myPres3d <= 1.e-3) nbIt = 0;
1122
1123   Standard_Integer degmin = 2, degmax = Max(myDegMax, degmin);
1124   Standard_Boolean SpApprox = Standard_True;
1125
1126   GeomFill_AppSurf anApprox(degmin, degmax, myPres3d, myPres3d, nbIt);
1127   anApprox.SetContinuity(myContinuity);
1128
1129   if(myUseSmoothing) {
1130     anApprox.SetCriteriumWeight(myCritWeights[0], myCritWeights[1], myCritWeights[2]);
1131     anApprox.PerformSmoothing(line, section);
1132   } 
1133   else {
1134     anApprox.SetParType(myParamType);
1135     anApprox.Perform(line, section, SpApprox);
1136   }
1137
1138   if(anApprox.IsDone()) {
1139     surface = 
1140       new Geom_BSplineSurface(anApprox.SurfPoles(), anApprox.SurfWeights(),
1141       anApprox.SurfUKnots(), anApprox.SurfVKnots(),
1142       anApprox.SurfUMults(), anApprox.SurfVMults(),
1143       anApprox.UDegree(), anApprox.VDegree());
1144   }
1145
1146   return surface;
1147
1148 }
1149
1150 //=======================================================================
1151 //function : FirstShape
1152 //purpose  : 
1153 //=======================================================================
1154
1155 const TopoDS_Shape& BRepOffsetAPI_ThruSections::FirstShape() const
1156 {
1157   return myFirst;
1158 }
1159
1160 //=======================================================================
1161 //function : LastShape
1162 //purpose  : 
1163 //=======================================================================
1164
1165 const TopoDS_Shape& BRepOffsetAPI_ThruSections::LastShape() const
1166 {
1167   return myLast;
1168 }
1169
1170 //=======================================================================
1171 //function : Generated
1172 //purpose  : 
1173 //=======================================================================
1174 const TopTools_ListOfShape& 
1175 BRepOffsetAPI_ThruSections::Generated(const TopoDS_Shape& S) 
1176 {
1177   myGenerated.Clear();
1178
1179   TopTools_SequenceOfShape AllFaces;
1180   TopExp_Explorer Explo(myShape, TopAbs_FACE);
1181   for (; Explo.More(); Explo.Next())
1182     AllFaces.Append(Explo.Current());
1183
1184   if (S.ShapeType() == TopAbs_EDGE)
1185   {
1186     if (!myEdgeNewIndices.IsBound(S))
1187       return myGenerated;
1188
1189     const TColStd_ListOfInteger& Indices = myEdgeNewIndices(S);
1190     //Append the faces corresponding to <Indices>
1191     //These faces "grow" from the first section
1192     TColStd_ListIteratorOfListOfInteger itl(Indices);
1193     for (; itl.More(); itl.Next())
1194     {
1195       Standard_Integer IndOfFace = itl.Value();
1196       myGenerated.Append(AllFaces(IndOfFace));
1197     }
1198
1199     if (myIsRuled)
1200       //Append the next faces corresponding to <Indices>
1201       for (Standard_Integer i = 2; i < myWires.Length(); i++)
1202         for (itl.Initialize(Indices); itl.More(); itl.Next())
1203         {
1204           Standard_Integer IndOfFace = itl.Value();
1205           IndOfFace += (i-1)*myNbEdgesInSection;
1206           myGenerated.Append(AllFaces(IndOfFace));
1207         }
1208   }
1209   else if (S.ShapeType() == TopAbs_VERTEX)
1210   {
1211     if (!myVertexIndex.IsBound(S))
1212       return myGenerated;
1213
1214     TopTools_IndexedDataMapOfShapeListOfShape VEmap;
1215     
1216     Standard_Boolean IsDegen [2] = {Standard_False, Standard_False};
1217     if (myDegen1 || myDegen2)
1218     {
1219       TopoDS_Shape EndSections [2];
1220       EndSections[0] = myWires(1);
1221       EndSections[1] = myWires(myWires.Length());
1222       for (Standard_Integer i = 0; i < 2; i++)
1223       {
1224         if (i == 0 && !myDegen1)
1225           continue;
1226         if (i == 1 && !myDegen2)
1227           continue;
1228         
1229         Explo.Init(EndSections[i], TopAbs_VERTEX);
1230         const TopoDS_Shape& aVertex = Explo.Current();
1231         if (S.IsSame(aVertex))
1232         {
1233           IsDegen[i] = Standard_True;
1234           break;
1235         }
1236       }
1237     }
1238     // Only one of <IsDegen> can be True:
1239     // in case of one vertex for start and end degenerated sections
1240     // IsDegen[0] is True;
1241     if (IsDegen[0] || IsDegen[1])
1242     {
1243       //For start or end degenerated section
1244       //we return the whole bunch of longitudinal edges
1245       TopExp::MapShapesAndAncestors(myShape, TopAbs_VERTEX, TopAbs_EDGE, VEmap);
1246       TopTools_IndexedMapOfShape Emap;
1247       const TopTools_ListOfShape& Elist = VEmap.FindFromKey(S);
1248       TopTools_ListIteratorOfListOfShape itl(Elist);
1249       for (; itl.More(); itl.Next())
1250       {
1251         const TopoDS_Edge& anEdge = TopoDS::Edge(itl.Value());
1252         if (!BRep_Tool::Degenerated(anEdge))
1253         {
1254           TopoDS_Vertex VV [2];
1255           TopExp::Vertices(anEdge, VV[0], VV[1]);
1256           //Comprehensive check for possible case of
1257           //one vertex for start and end degenerated sections:
1258           //we must take only outgoing or only ingoing edges
1259           if ((IsDegen[0] && S.IsSame(VV[0])) ||
1260               (IsDegen[1] && S.IsSame(VV[1])))
1261             Emap.Add(anEdge);
1262         }
1263       }
1264       for (Standard_Integer j = 1; j <= Emap.Extent(); j++)
1265       {
1266         TopoDS_Edge anEdge = TopoDS::Edge(Emap(j));
1267         myGenerated.Append(anEdge);
1268         if (myIsRuled)
1269         {
1270           Standard_Integer i,k;
1271           for (i = 2,k = myWires.Length()-1; i < myWires.Length(); i++,k--)
1272           {
1273             Standard_Integer IndOfSec = (IsDegen[0])? i : k;
1274             TopoDS_Vertex aVertex = (IsDegen[0])?
1275               TopExp::LastVertex(anEdge) : TopExp::FirstVertex(anEdge);
1276             const TopTools_ListOfShape& EElist = VEmap.FindFromKey(aVertex);
1277             TopTools_IndexedMapOfShape EmapOfSection;
1278             TopExp::MapShapes(myWires(IndOfSec), TopAbs_EDGE, EmapOfSection);
1279             TopoDS_Edge NextEdge;
1280             for (itl.Initialize(EElist); itl.More(); itl.Next())
1281             {
1282               NextEdge = TopoDS::Edge(itl.Value());
1283               if (!NextEdge.IsSame(anEdge) &&
1284                   !EmapOfSection.Contains(NextEdge))
1285                 break;
1286             }
1287             myGenerated.Append(NextEdge);
1288             anEdge = NextEdge;
1289           }
1290         }
1291       }
1292       return myGenerated;
1293     } //end of if (IsDegen[0] || IsDegen[1])
1294     
1295     Standard_Integer Eindex = myVertexIndex(S);
1296     Standard_Integer Vindex = (Eindex > 0)? 0 : 1;
1297     Eindex = Abs(Eindex);
1298     const TopoDS_Shape& FirstSection = myWires(1);
1299     TopoDS_Edge FirstEdge;
1300     TopoDS_Iterator itw(FirstSection);
1301     for (Standard_Integer inde = 1; itw.More(); itw.Next(),inde++)
1302     {
1303       FirstEdge = TopoDS::Edge(itw.Value());
1304       if (inde == Eindex)
1305         break;
1306     }
1307
1308     //Find the first longitudinal edge
1309     TopoDS_Face FirstFace = TopoDS::Face(AllFaces(Eindex));
1310     FirstFace.Orientation(TopAbs_FORWARD);
1311     Explo.Init(FirstFace, TopAbs_EDGE);
1312     TopoDS_Edge anEdge;
1313     BRepAdaptor_Surface BAsurf(FirstFace, Standard_False);
1314     TopoDS_Vertex FirstVertex;
1315     TopExp::MapShapesAndAncestors(FirstFace, TopAbs_VERTEX, TopAbs_EDGE, VEmap);
1316     if (myDegen1 && BAsurf.GetType() == GeomAbs_Plane)
1317     {
1318       //There are only 3 edges in the face in this case:
1319       //we take 1-st or 3-rd edge
1320       if (Vindex == 0)
1321       {
1322         Explo.Next();
1323         Explo.Next();
1324       }
1325       anEdge = TopoDS::Edge(Explo.Current());
1326     }
1327     else
1328     {
1329       TopoDS_Shape FirstEdgeInFace;
1330       FirstEdgeInFace = Explo.Current();
1331       TopoDS_Vertex VV [2];
1332       TopExp::Vertices(FirstEdge, VV[0], VV[1]);
1333       FirstVertex = VV[Vindex];
1334       const TopTools_ListOfShape& Elist = VEmap.FindFromKey(FirstVertex);
1335       TopTools_ListIteratorOfListOfShape itl(Elist);
1336       TopAbs_Orientation anEdgeOr = (Vindex == 0)? TopAbs_REVERSED : TopAbs_FORWARD;
1337       for (; itl.More(); itl.Next())
1338       {
1339         anEdge = TopoDS::Edge(itl.Value());
1340         if (!anEdge.IsSame(FirstEdgeInFace) &&
1341             !BRep_Tool::Degenerated(anEdge) &&
1342             anEdge.Orientation() == anEdgeOr)
1343           break;
1344       }
1345     }
1346     myGenerated.Append(anEdge);
1347     if (myIsRuled)
1348       //Find the chain of longitudinal edges from first to last
1349       for (Standard_Integer i = 2; i < myWires.Length(); i++)
1350       {
1351         FirstVertex = TopExp::LastVertex(anEdge);
1352         const TopTools_ListOfShape& Elist1 = VEmap.FindFromKey(FirstVertex);
1353         FirstEdge = (anEdge.IsSame(Elist1.First()))?
1354           TopoDS::Edge(Elist1.Last()) : TopoDS::Edge(Elist1.First());
1355         Eindex += myNbEdgesInSection;
1356         FirstFace = TopoDS::Face(AllFaces(Eindex));
1357         FirstFace.Orientation(TopAbs_FORWARD);
1358         VEmap.Clear();
1359         TopExp::MapShapesAndAncestors(FirstFace, TopAbs_VERTEX, TopAbs_EDGE, VEmap);
1360         const TopTools_ListOfShape& Elist2 = VEmap.FindFromKey(FirstVertex);
1361         anEdge = (FirstEdge.IsSame(Elist2.First()))?
1362           TopoDS::Edge(Elist2.Last()) : TopoDS::Edge(Elist2.First());
1363         myGenerated.Append(anEdge);
1364       }
1365   }
1366
1367   return myGenerated;
1368 }
1369
1370 //=======================================================================
1371 //function : GeneratedFace
1372 //purpose  : 
1373 //=======================================================================
1374
1375 TopoDS_Shape BRepOffsetAPI_ThruSections::GeneratedFace(const TopoDS_Shape& edge) const
1376 {
1377   TopoDS_Shape bid;
1378   if (myEdgeFace.IsBound(edge)) {
1379     return myEdgeFace(edge);
1380   }
1381   else {
1382     return bid;
1383   }
1384 }
1385
1386
1387 //=======================================================================
1388 //function : CriteriumWeight
1389 //purpose  : returns the Weights associated  to the criterium used in
1390 //           the  optimization.
1391 //=======================================================================
1392 //
1393 void BRepOffsetAPI_ThruSections::CriteriumWeight(Standard_Real& W1, Standard_Real& W2, Standard_Real& W3) const 
1394 {
1395   W1 = myCritWeights[0];
1396   W2 = myCritWeights[1];
1397   W3 = myCritWeights[2];
1398 }
1399 //=======================================================================
1400 //function : SetCriteriumWeight
1401 //purpose  : 
1402 //=======================================================================
1403
1404 void BRepOffsetAPI_ThruSections::SetCriteriumWeight(const Standard_Real W1, const Standard_Real W2, const Standard_Real W3)
1405 {
1406   if (W1 < 0 || W2 < 0 || W3 < 0 ) throw Standard_DomainError();
1407   myCritWeights[0] = W1;
1408   myCritWeights[1] = W2;
1409   myCritWeights[2] = W3;
1410 }
1411 //=======================================================================
1412 //function : SetContinuity
1413 //purpose  : 
1414 //=======================================================================
1415
1416 void BRepOffsetAPI_ThruSections::SetContinuity (const GeomAbs_Shape TheCont)
1417 {
1418   myContinuity = TheCont;
1419 }
1420
1421 //=======================================================================
1422 //function : Continuity
1423 //purpose  : 
1424 //=======================================================================
1425
1426 GeomAbs_Shape BRepOffsetAPI_ThruSections::Continuity () const
1427 {
1428   return myContinuity;
1429 }
1430
1431 //=======================================================================
1432 //function : SetParType
1433 //purpose  : 
1434 //=======================================================================
1435
1436 void BRepOffsetAPI_ThruSections::SetParType (const Approx_ParametrizationType ParType)
1437 {
1438   myParamType = ParType;
1439 }
1440
1441 //=======================================================================
1442 //function : ParType
1443 //purpose  : 
1444 //=======================================================================
1445
1446 Approx_ParametrizationType BRepOffsetAPI_ThruSections::ParType () const
1447 {
1448   return myParamType;
1449 }
1450
1451 //=======================================================================
1452 //function : SetMaxDegree
1453 //purpose  : 
1454 //=======================================================================
1455
1456 void BRepOffsetAPI_ThruSections:: SetMaxDegree(const Standard_Integer MaxDeg)
1457 {
1458   myDegMax = MaxDeg;
1459 }
1460
1461 //=======================================================================
1462 //function : MaxDegree
1463 //purpose  : 
1464 //=======================================================================
1465
1466 Standard_Integer  BRepOffsetAPI_ThruSections::MaxDegree () const
1467 {
1468   return myDegMax;
1469 }
1470
1471 //=======================================================================
1472 //function : SetSmoothing
1473 //purpose  : 
1474 //=======================================================================
1475
1476 void BRepOffsetAPI_ThruSections::SetSmoothing(const Standard_Boolean UseVar)
1477 {
1478   myUseSmoothing = UseVar;
1479 }
1480
1481 //=======================================================================
1482 //function : UseSmoothing
1483 //purpose  : 
1484 //=======================================================================
1485
1486 Standard_Boolean BRepOffsetAPI_ThruSections::UseSmoothing () const
1487 {
1488   return myUseSmoothing;
1489 }
1490
1491
1492
1493
1494