0024624: Lost word in license statement in source files
[occt.git] / src / BRepOffsetAPI / BRepOffsetAPI_MiddlePath.cxx
1 // Created on: 2012-08-06
2 // Created by: jgv@ROLEX
3 // Copyright (c) 2012-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement.
15
16 #include <BRepOffsetAPI_MiddlePath.ixx>
17 #include <BRepOffsetAPI_MiddlePath.hxx>
18
19 #include <ShapeUpgrade_UnifySameDomain.hxx>
20
21 #include <gp_Lin.hxx>
22 #include <Geom_Curve.hxx>
23 #include <Geom_TrimmedCurve.hxx>
24 #include <Geom_Line.hxx>
25 #include <Geom_BezierCurve.hxx>
26 #include <Geom_BSplineCurve.hxx>
27 #include <BRep_Tool.hxx>
28 #include <gce_MakeLin.hxx>
29
30 #include <BRepLib_MakeWire.hxx>
31
32 #include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
33 #include <TopTools_MapIteratorOfMapOfShape.hxx>
34 #include <TopExp.hxx>
35 #include <TopTools_ListIteratorOfListOfShape.hxx>
36 #include <TopoDS.hxx>
37 #include <BRepTools.hxx>
38 #include <TopTools_SequenceOfShape.hxx>
39 #include <BRepTools_WireExplorer.hxx>
40 #include <TopoDS_Iterator.hxx>
41 #include <BRep_Builder.hxx>
42 #include <Precision.hxx>
43 #include <TopExp_Explorer.hxx>
44 #include <BRepExtrema_DistShapeShape.hxx>
45 #include <Geom2d_Curve.hxx>
46 #include <Geom2d_Line.hxx>
47 #include <GCE2d_MakeLine.hxx>
48 #include <BRepLib_MakeEdge.hxx>
49 #include <BRepLib.hxx>
50 #include <GeomAbs_CurveType.hxx>
51 #include <BRepAdaptor_Curve.hxx>
52 #include <TopTools_Array1OfShape.hxx>
53 #include <BRepLib_MakeFace.hxx>
54 #include <TColgp_Array1OfPnt.hxx>
55 #include <TColgp_HArray1OfPnt.hxx>
56 #include <TColgp_Array1OfVec.hxx>
57 #include <TColStd_HArray1OfBoolean.hxx>
58 #include <GProp_GProps.hxx>
59 #include <BRepGProp.hxx>
60 #include <Geom_Circle.hxx>
61 #include <gp_Circ.hxx>
62 #include <GC_MakeCircle.hxx>
63 #include <TColgp_SequenceOfPnt.hxx>
64 #include <GeomLib.hxx>
65 #include <GeomAPI_Interpolate.hxx>
66
67 static Standard_Boolean IsLinear(const TopoDS_Edge& anEdge,
68                                  gp_Lin& aLine)
69 {
70   Standard_Real fpar, lpar;
71   Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, fpar, lpar);
72   if (aCurve->IsInstance(STANDARD_TYPE(Geom_TrimmedCurve)))
73     aCurve = ((Handle(Geom_TrimmedCurve)&) aCurve)->BasisCurve();
74
75   gp_Pnt Pnt1, Pnt2;
76   if (aCurve->IsKind(STANDARD_TYPE(Geom_Line)))
77   {
78     aLine = ((Handle(Geom_Line)&) aCurve)->Lin();
79     return Standard_True;
80   }
81   else if (aCurve->IsKind(STANDARD_TYPE(Geom_BezierCurve)))
82   {
83     Handle(Geom_BezierCurve) theBezier = (Handle(Geom_BezierCurve)&) aCurve;
84     if (theBezier->NbPoles() == 2)
85     {
86       Pnt1 = theBezier->Pole(1);
87       Pnt2 = theBezier->Pole(2);
88       aLine = gce_MakeLin(Pnt1, Pnt2);
89       return Standard_True;
90     }
91   }
92   else if (aCurve->IsKind(STANDARD_TYPE(Geom_BSplineCurve)))
93   {
94     Handle(Geom_BSplineCurve) theBSpline = (Handle(Geom_BSplineCurve)&) aCurve;
95     if (theBSpline->NbPoles() == 2)
96     {
97       Pnt1 = theBSpline->Pole(1);
98       Pnt2 = theBSpline->Pole(2);
99       aLine = gce_MakeLin(Pnt1, Pnt2);
100       return Standard_True;
101     }
102   }
103
104   return Standard_False;
105 }
106
107 static GeomAbs_CurveType TypeOfEdge(const TopoDS_Edge& anEdge)
108 {
109   gp_Lin aLin;
110   if (IsLinear(anEdge, aLin))
111     return GeomAbs_Line;
112
113   BRepAdaptor_Curve BAcurve(anEdge);
114   return BAcurve.GetType();
115 }
116
117 static gp_Vec TangentOfEdge(const TopoDS_Shape& aShape,
118                             const Standard_Boolean OnFirst)
119 {
120   TopoDS_Edge anEdge = TopoDS::Edge(aShape);
121   TopAbs_Orientation anOr = anEdge.Orientation();
122   
123   Standard_Real fpar, lpar;
124   Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, fpar, lpar);
125   Standard_Real thePar;
126   if (OnFirst)
127     thePar = (anOr == TopAbs_FORWARD)? fpar : lpar;
128   else
129     thePar = (anOr == TopAbs_FORWARD)? lpar : fpar;
130
131   gp_Pnt thePoint;
132   gp_Vec theTangent;
133   aCurve->D1(thePar, thePoint, theTangent);
134   if (anOr == TopAbs_REVERSED)
135     theTangent.Reverse();
136
137   return theTangent;
138 }
139
140
141 static Standard_Boolean IsValidEdge(const TopoDS_Edge& theEdge,
142                                     const TopoDS_Face& theFace)
143 {
144   TopoDS_Vertex V1, V2;
145   TopExp::Vertices(theEdge, V1, V2);
146
147   Standard_Real Tol = Precision::Confusion();
148   Standard_Integer i;
149   
150   TopExp_Explorer Explo(theFace, TopAbs_EDGE);
151   for (; Explo.More(); Explo.Next())
152   {
153     const TopoDS_Shape& anEdge = Explo.Current();
154     BRepExtrema_DistShapeShape DistMini(theEdge, anEdge);
155     if (DistMini.Value() <= Tol)
156     {
157       for (i = 1; i <= DistMini.NbSolution(); i++)
158       {
159         BRepExtrema_SupportType theType = DistMini.SupportTypeShape2(i);
160         if (theType == BRepExtrema_IsOnEdge)
161           return Standard_False;
162         //theType is "IsVertex"
163         TopoDS_Shape aVertex = DistMini.SupportOnShape2(i);
164         if (!(aVertex.IsSame(V1) || aVertex.IsSame(V2)))
165           return Standard_False;
166       }
167     }
168   }
169
170   return Standard_True;
171 }
172
173 /*
174 //=======================================================================
175 //function : BRepOffsetAPI_MiddlePath
176 //purpose  : Constructor
177 //=======================================================================
178
179 BRepOffsetAPI_MiddlePath::BRepOffsetAPI_MiddlePath(const TopoDS_Shape& aShape,
180                                                    const TopoDS_Wire&  StartWire)
181 {
182   myInitialShape = aShape;
183   myStartWire    = StartWire;
184   myClosedSection = myStartWire.Closed();
185 }
186
187 //=======================================================================
188 //function : BRepOffsetAPI_MiddlePath
189 //purpose  : Constructor
190 //=======================================================================
191
192 BRepOffsetAPI_MiddlePath::BRepOffsetAPI_MiddlePath(const TopoDS_Shape& aShape,
193                                                    const TopoDS_Edge&  StartEdge)
194 {
195   myInitialShape = aShape;
196
197   BRepLib_MakeWire MW(StartEdge);
198   
199   //BB.Add(myStartWire, StartEdge);
200
201   TopTools_IndexedDataMapOfShapeListOfShape EFmap;
202   TopTools_IndexedDataMapOfShapeListOfShape VEmap;
203   TopExp::MapShapesAndAncestors(myInitialShape, TopAbs_EDGE,   TopAbs_FACE, EFmap);
204   TopExp::MapShapesAndAncestors(myInitialShape, TopAbs_VERTEX, TopAbs_EDGE, VEmap);
205   
206   //Standard_Boolean Start = Standard_True;
207   //if (Start)
208   //{
209   //TopExp::Vertices(CurEdge, V1, V2);
210   //  StartVertex = V1;
211   //  CurVertex   = V2;
212   //  if (VEmap(CurVertex).Extent() == 2) //end: two free edges
213   //  {
214   //    StartVertex = V2;
215   //    CurVertex   = V1;
216   //    if (VEmap(CurVertex).Extent() == 2) //end: two free edges
217   //      break;
218   //  }
219   //  Start = Standard_False;
220   //  continue;
221   //}
222
223   TopoDS_Vertex StartVertex, CurVertex, V1, V2;
224   TopExp::Vertices(StartEdge, StartVertex, CurVertex);
225   TopoDS_Edge CurEdge = StartEdge;
226   Standard_Integer i;
227   for (i = 1; i <= 2; i++)
228   {
229     for (;;)
230     {
231       const TopTools_ListOfShape& LE = VEmap.FindFromKey(CurVertex);
232       if (LE.Extent() == 2) //end: two free edges or one closed free edge
233         break;
234       TopTools_ListIteratorOfListOfShape itl(LE);
235       TopoDS_Edge anEdge;
236       for (; itl.More(); itl.Next())
237       {
238         anEdge = TopoDS::Edge(itl.Value());
239         if (anEdge.IsSame(CurEdge))
240           continue;
241         if (EFmap.FindFromKey(anEdge).Extent() == 1) //another free edge found
242           break;
243       }
244       //BB.Add(myStartWire, anEdge);
245       MW.Add(anEdge);
246       TopExp::Vertices(anEdge, V1, V2);
247       CurVertex = (V1.IsSame(CurVertex))? V2 : V1;
248       CurEdge = anEdge;
249       if (CurVertex.IsSame(StartVertex))
250         break;
251     }
252     if (CurVertex.IsSame(StartVertex))
253       break;
254     CurVertex = StartVertex;
255     CurEdge = StartEdge;
256   }
257   
258   myStartWire = MW.Wire();
259   myClosedSection = myStartWire.Closed();
260 }
261 */
262
263 //=======================================================================
264 //function : BRepOffsetAPI_MiddlePath
265 //purpose  : Constructor
266 //=======================================================================
267
268 BRepOffsetAPI_MiddlePath::BRepOffsetAPI_MiddlePath(const TopoDS_Shape& aShape,
269                                                    const TopoDS_Shape& StartShape,
270                                                    const TopoDS_Shape& EndShape)
271 {
272   ShapeUpgrade_UnifySameDomain Unifier(aShape);
273   Unifier.Build();
274   myInitialShape = Unifier.Shape();
275
276   TopoDS_Wire aStartWire, anEndWire;
277   if (StartShape.ShapeType() == TopAbs_FACE)
278   {
279     const TopoDS_Face& StartFace = TopoDS::Face(StartShape);
280     aStartWire = BRepTools::OuterWire(StartFace);
281   }
282   else
283     aStartWire = TopoDS::Wire(StartShape);
284   
285   if (EndShape.ShapeType() == TopAbs_FACE)
286   {
287     const TopoDS_Face& EndFace = TopoDS::Face(EndShape);
288     anEndWire = BRepTools::OuterWire(EndFace);
289   }
290   else
291     anEndWire = TopoDS::Wire(EndShape);
292
293   BRepLib_MakeWire MWstart;
294   //TopTools_MapOfShape MapEdges;
295   BRepTools_WireExplorer wexp(aStartWire);
296   for (; wexp.More(); wexp.Next())
297   {
298     TopoDS_Shape anEdge = wexp.Current();
299     TopoDS_Shape NewEdge = Unifier.Generated(anEdge);
300     if (!NewEdge.IsNull())
301       MWstart.Add(TopoDS::Edge(NewEdge));
302   }
303   myStartWire = MWstart.Wire();
304
305   BRepLib_MakeWire MWend;
306   //MapEdges.Clear();
307   for (wexp.Init(anEndWire); wexp.More(); wexp.Next())
308   {
309     TopoDS_Shape anEdge = wexp.Current();
310     TopoDS_Shape NewEdge = Unifier.Generated(anEdge);
311     if (!NewEdge.IsNull())
312       MWend.Add(TopoDS::Edge(NewEdge));
313   }
314   myEndWire = MWend.Wire();
315
316   myClosedSection = myStartWire.Closed();
317   myClosedRing    = myStartWire.IsSame(myEndWire);
318 }
319
320 //=======================================================================
321 //function : Build
322 //purpose  : 
323 //=======================================================================
324
325 void BRepOffsetAPI_MiddlePath::Build()
326 {
327   TopTools_ListIteratorOfListOfShape itl;
328   
329   TopTools_SequenceOfShape StartVertices;
330   TopTools_MapOfShape EndVertices;
331   TopTools_MapOfShape EndEdges;
332   BRepOffsetAPI_SequenceOfSequenceOfShape SectionsEdges;
333   
334   BRepTools_WireExplorer wexp(myStartWire);
335   TopTools_SequenceOfShape EdgeSeq;
336   for (; wexp.More(); wexp.Next())
337   {
338     StartVertices.Append(wexp.CurrentVertex());
339     EdgeSeq.Append(wexp.Current());
340   }
341   if (!myClosedSection)
342     StartVertices.Append(wexp.CurrentVertex());
343   SectionsEdges.Append(EdgeSeq);
344   
345   for (wexp.Init(myEndWire); wexp.More(); wexp.Next())
346   {
347     EndVertices.Add(wexp.CurrentVertex());
348     EndEdges.Add(wexp.Current());
349   }
350   if (!myClosedSection)
351     EndVertices.Add(wexp.CurrentVertex());
352   
353
354   TopoDS_Iterator itw(myStartWire);
355   for (; itw.More(); itw.Next())
356     myStartWireEdges.Add(itw.Value());
357   for (itw.Initialize(myEndWire); itw.More(); itw.Next())
358     myEndWireEdges.Add(itw.Value());
359
360   TopTools_IndexedDataMapOfShapeListOfShape VEmap;
361   TopTools_IndexedDataMapOfShapeListOfShape EFmap;
362   TopExp::MapShapesAndAncestors(myInitialShape, TopAbs_VERTEX, TopAbs_EDGE, VEmap);
363   TopExp::MapShapesAndAncestors(myInitialShape, TopAbs_EDGE,   TopAbs_FACE, EFmap);
364
365   TopTools_MapOfShape CurVertices;
366   
367   Standard_Integer i, j, k;
368   TopoDS_Edge anEdge;
369   TopoDS_Vertex V1, V2, NextVertex;
370   //Initialization of <myPaths>
371   for (i = 1; i <= StartVertices.Length(); i++)
372   {
373     TopTools_SequenceOfShape Edges;
374     const TopTools_ListOfShape& LE = VEmap.FindFromKey(StartVertices(i));
375     for (itl.Initialize(LE); itl.More(); itl.Next())
376     {
377       anEdge = TopoDS::Edge(itl.Value());
378       if (!myStartWireEdges.Contains(anEdge))
379       {
380         TopExp::Vertices(anEdge, V1, V2, Standard_True);
381         if (V1.IsSame(StartVertices(i)))
382           CurVertices.Add(V2);
383         else
384         {
385           anEdge.Reverse();
386           CurVertices.Add(V1);
387         }
388         Edges.Append(anEdge);
389         break;
390       }
391     }
392     myPaths.Append(Edges);
393   }
394
395   //Filling of "myPaths"
396   TopTools_ListOfShape NextVertices;
397   for (;;)
398   {
399     for (i = 1; i <= myPaths.Length(); i++)
400     {
401       const TopoDS_Shape& theShape = myPaths(i).Last();
402       TopoDS_Edge theEdge;
403       TopoDS_Vertex theVertex;
404       if (theShape.ShapeType() == TopAbs_EDGE)
405       {
406         theEdge = TopoDS::Edge(theShape);
407         theVertex = TopExp::LastVertex(theEdge, Standard_True);
408       }
409       else //last segment of path was punctual
410       {
411         theEdge = TopoDS::Edge(myPaths(i)(myPaths(i).Length()-1));
412         theVertex = TopoDS::Vertex(theShape);
413       }
414       
415       if (EndVertices.Contains(theVertex))
416         continue;
417       const TopTools_ListOfShape& LE = VEmap.FindFromKey(theVertex);
418       TopTools_MapOfShape NextEdgeCandidates;
419       for (itl.Initialize(LE); itl.More(); itl.Next())
420       {
421         anEdge = TopoDS::Edge(itl.Value());
422         if (anEdge.IsSame(theEdge))
423           continue;
424         TopExp::Vertices(anEdge, V1, V2, Standard_True);
425         if (V1.IsSame(theVertex))
426           NextVertex = V2;
427         else
428         {
429           anEdge.Reverse();
430           NextVertex = V1;
431         }
432         if (!CurVertices.Contains(NextVertex))
433           NextEdgeCandidates.Add(anEdge);
434       }
435       if (!NextEdgeCandidates.IsEmpty())
436       {
437         if (NextEdgeCandidates.Extent() > 1)
438           myPaths(i).Append(theVertex); //punctual segment of path
439         else
440         {
441           TopTools_MapIteratorOfMapOfShape mapit(NextEdgeCandidates);
442           anEdge = TopoDS::Edge(mapit.Key());
443           myPaths(i).Append(anEdge);
444           NextVertex = TopExp::LastVertex(anEdge, Standard_True);
445           NextVertices.Append(NextVertex);
446         }
447       }
448     }
449     if (NextVertices.IsEmpty())
450       break;
451     for (itl.Initialize(NextVertices); itl.More(); itl.Next())
452       CurVertices.Add(itl.Value());
453     NextVertices.Clear();
454   }
455
456   //Temporary
457   /*
458   TopoDS_Compound aCompound, aCmp1;
459   BRep_Builder BB;
460   BB.MakeCompound(aCompound);
461   BB.MakeCompound(aCmp1);
462   for (i = 1; i <= myPaths.Length(); i++)
463   {
464     TopoDS_Compound aCmp;
465     BB.MakeCompound(aCmp);
466     for (j = 1; j <= myPaths(i).Length(); j++)
467       BB.Add(aCmp, myPaths(i)(j));
468     BB.Add(aCmp1, aCmp);
469   }
470   BB.Add(aCompound, aCmp1);
471          
472   myShape = aCompound;
473
474   Done();
475   return;
476   */
477   ////////////
478   
479   //Building of set of sections
480   Standard_Integer NbE = EdgeSeq.Length();
481   Standard_Integer NbPaths = myPaths.Length();
482   Standard_Integer NbVer = myPaths.Length();
483   if (myClosedSection)
484     NbVer++;
485   i = 1;
486   for (;;)
487   {
488     for (j = 1; j <= EdgeSeq.Length(); j++)
489       EdgeSeq(j).Nullify();
490
491     Standard_Boolean ToInsertVertex = Standard_False;
492     
493     for (j = 2; j <= NbVer; j++)
494     {
495       if (!EdgeSeq(j-1).IsNull())
496         continue;
497
498       //for the end of initial shape
499       if (myPaths(j-1).Length() < i)
500       {
501         TopoDS_Edge aE1 = TopoDS::Edge(myPaths(j-1)(i-1));
502         TopoDS_Shape LastVer = TopExp::LastVertex(aE1, Standard_True);
503         myPaths(j-1).Append(LastVer);
504       }
505       if (myPaths((j<=NbPaths)? j : 1).Length() < i)
506       {
507         TopoDS_Edge aE2 = TopoDS::Edge(myPaths((j<=NbPaths)? j : 1)(i-1));
508         TopoDS_Shape LastVer = TopExp::LastVertex(aE2, Standard_True);
509         myPaths((j<=NbPaths)? j : 1).Append(LastVer);
510       }
511       //////////////////////////////
512       
513       if (ToInsertVertex)
514       {
515         if (myPaths(j-1)(i).ShapeType() == TopAbs_EDGE)
516         {
517           TopoDS_Edge aE1 = TopoDS::Edge(myPaths(j-1)(i));
518           TopoDS_Shape fver = TopExp::FirstVertex(aE1, Standard_True);
519           myPaths(j-1).InsertBefore(i, fver);
520         }
521         if (myPaths((j<=NbPaths)? j : 1)(i).ShapeType() == TopAbs_EDGE)
522         {
523           TopoDS_Edge aE2 = TopoDS::Edge(myPaths((j<=NbPaths)? j : 1)(i));
524           TopoDS_Shape fver = TopExp::FirstVertex(aE2, Standard_True);
525           myPaths((j<=NbPaths)? j : 1).InsertBefore(i, fver);
526         }
527         ToInsertVertex = Standard_False;
528       }
529       
530       TopoDS_Edge E1, E2;
531       if (myPaths(j-1)(i).ShapeType() == TopAbs_EDGE)
532         E1 = TopoDS::Edge(myPaths(j-1)(i));
533       if (myPaths((j<=NbPaths)? j : 1)(i).ShapeType() == TopAbs_EDGE)
534         E2 = TopoDS::Edge(myPaths((j<=NbPaths)? j : 1)(i));
535       TopoDS_Edge E12 = TopoDS::Edge(SectionsEdges(i)(j-1));
536       
537       TopoDS_Vertex PrevVertex = (E1.IsNull())? TopoDS::Vertex(myPaths(j-1)(i))
538         : TopExp::LastVertex(E1, Standard_True);
539       TopoDS_Vertex CurVertex = (E2.IsNull())? TopoDS::Vertex(myPaths((j<=NbPaths)? j : 1)(i))
540         : TopExp::LastVertex(E2, Standard_True);
541       
542       TopoDS_Edge ProperEdge;
543       const TopTools_ListOfShape& LE = VEmap.FindFromKey(PrevVertex);
544
545       for (itl.Initialize(LE); itl.More(); itl.Next())
546       {
547         anEdge = TopoDS::Edge(itl.Value());
548         TopExp::Vertices(anEdge, V1, V2);
549         if (((V1.IsSame(PrevVertex) && V2.IsSame(CurVertex)) ||
550              (V1.IsSame(CurVertex) && V2.IsSame(PrevVertex))) &&
551             !anEdge.IsSame(E1))
552         {
553           ProperEdge = anEdge;
554           break;
555         }
556       }
557       
558       if ((myPaths(j-1)(i)).ShapeType() == TopAbs_VERTEX &&
559           (myPaths((j<=NbPaths)? j : 1)(i)).ShapeType() == TopAbs_VERTEX)
560       {
561         EdgeSeq(j-1) = ProperEdge;
562         continue;
563       }
564
565       TopoDS_Vertex PrevPrevVer = (E1.IsNull())? PrevVertex
566         : TopExp::FirstVertex(E1, Standard_True);
567       TopoDS_Vertex PrevCurVer  = (E2.IsNull())? CurVertex
568         : TopExp::FirstVertex(E2, Standard_True);
569       if (ProperEdge.IsNull()) //no connection between these two vertices
570       {
571         //Find the face on which E1, E2 and E12 lie
572         //ToInsertVertex = Standard_False;
573         const TopoDS_Shape& EE1 = (E1.IsNull())?
574           myPaths(j-1)(i-1) : E1;
575         const TopoDS_Shape& EE2 = (E2.IsNull())?
576           myPaths((j<=NbPaths)? j : 1)(i-1) : E2;
577         const TopTools_ListOfShape& LF = EFmap.FindFromKey(EE1);
578         TopoDS_Face theFace;
579         for (itl.Initialize(LF); itl.More(); itl.Next())
580         {
581           const TopoDS_Shape& aFace = itl.Value();
582           TopExp_Explorer Explo(aFace, TopAbs_EDGE);
583           for (; Explo.More(); Explo.Next())
584           {
585             if (EE2.IsSame(Explo.Current()))
586             {
587               const TopTools_ListOfShape& LFsec = EFmap.FindFromKey(E12);
588               TopTools_ListIteratorOfListOfShape itlsec(LFsec);
589               for (; itlsec.More(); itlsec.Next())
590                 if (aFace.IsSame(itlsec.Value()))
591                 {
592                   theFace = TopoDS::Face(aFace);
593                   break;
594                 }
595               if (!theFace.IsNull())
596                 break;
597             }
598           }
599           if (!theFace.IsNull())
600             break;
601         }
602         TopTools_ListOfShape ListOneFace;
603         ListOneFace.Append(theFace);
604
605         if (E1.IsNull() || E2.IsNull())
606         {
607           if (E1.IsNull())
608             E1 = TopoDS::Edge(myPaths(j-1)(i-1));
609           if (E2.IsNull())
610             E2 = TopoDS::Edge(myPaths((j<=NbPaths)? j : 1)(i-1));
611           Standard_Real fpar1, lpar1, fpar2, lpar2;
612           Standard_Real LastPar1, LastPar2;
613           Handle(Geom2d_Curve) PCurve1 = BRep_Tool::CurveOnSurface(E1, theFace, fpar1, lpar1);
614           Handle(Geom2d_Curve) PCurve2 = BRep_Tool::CurveOnSurface(E2, theFace, fpar2, lpar2);
615           if (E1.Orientation() == TopAbs_FORWARD)
616           { LastPar1 = lpar1; }
617           else
618           { LastPar1 = fpar1; }
619           if (E2.Orientation() == TopAbs_FORWARD)
620           { LastPar2 = lpar2; }
621           else
622           { LastPar2 = fpar2; }
623           gp_Pnt2d FirstPnt2d = PCurve1->Value(LastPar1);
624           gp_Pnt2d LastPnt2d  = PCurve2->Value(LastPar2);
625           Handle(Geom_Surface) theSurf = BRep_Tool::Surface(theFace);
626           Handle(Geom2d_Line) theLine = GCE2d_MakeLine(FirstPnt2d, LastPnt2d);
627           Standard_Real len_ne = FirstPnt2d.Distance(LastPnt2d);
628           TopoDS_Edge NewEdge = BRepLib_MakeEdge(theLine, theSurf,
629                                                  PrevVertex, CurVertex,
630                                                  0., len_ne);
631           BRepLib::BuildCurve3d(NewEdge);
632           EdgeSeq(j-1) = NewEdge;
633           EFmap.Add(NewEdge, ListOneFace);
634         }
635         else //E1 is edge
636         {
637           //Extract points 2d
638           Standard_Real fpar1, lpar1, fpar2, lpar2;
639           Standard_Real FirstPar1, LastPar1, FirstPar2, LastPar2;
640           Handle(Geom2d_Curve) PCurve1 = BRep_Tool::CurveOnSurface(E1, theFace, fpar1, lpar1);
641           Handle(Geom2d_Curve) PCurve2 = BRep_Tool::CurveOnSurface(E2, theFace, fpar2, lpar2);
642           if (E1.Orientation() == TopAbs_FORWARD)
643           { FirstPar1 = fpar1; LastPar1 = lpar1; }
644           else
645           { FirstPar1 = lpar1; LastPar1 = fpar1; }
646           if (E2.Orientation() == TopAbs_FORWARD)
647           { FirstPar2 = fpar2; LastPar2 = lpar2; }
648           else
649           { FirstPar2 = lpar2; LastPar2 = fpar2; }
650           gp_Pnt2d FirstPnt2d = PCurve1->Value(LastPar1);
651           gp_Pnt2d LastPnt2d  = PCurve2->Value(LastPar2);
652           Handle(Geom_Surface) theSurf = BRep_Tool::Surface(theFace);
653           Handle(Geom2d_Line) theLine = GCE2d_MakeLine(FirstPnt2d, LastPnt2d);
654           Standard_Real len_ne = FirstPnt2d.Distance(LastPnt2d);
655           TopoDS_Edge NewEdge = BRepLib_MakeEdge(theLine, theSurf,
656                                                  PrevVertex, CurVertex,
657                                                  0., len_ne);
658           BRepLib::BuildCurve3d(NewEdge);
659           gp_Pnt2d PrevFirstPnt2d = PCurve1->Value(FirstPar1);
660           gp_Pnt2d PrevLastPnt2d  = PCurve2->Value(FirstPar2);
661           Handle(Geom2d_Line) Line1 = GCE2d_MakeLine(PrevFirstPnt2d, LastPnt2d);
662           Handle(Geom2d_Line) Line2 = GCE2d_MakeLine(FirstPnt2d, PrevLastPnt2d);
663           Standard_Real len_ne1 = PrevFirstPnt2d.Distance(LastPnt2d);
664           TopoDS_Edge NewEdge1 = BRepLib_MakeEdge(Line1, theSurf,
665                                                   PrevPrevVer, CurVertex,
666                                                   0., len_ne1);
667           BRepLib::BuildCurve3d(NewEdge1);
668           Standard_Real len_ne2 = FirstPnt2d.Distance(PrevLastPnt2d);
669           TopoDS_Edge NewEdge2 = BRepLib_MakeEdge(Line2, theSurf,
670                                                   PrevVertex, PrevCurVer,
671                                                   0., len_ne2);
672           BRepLib::BuildCurve3d(NewEdge2);
673           Standard_Boolean good_ne  = IsValidEdge(NewEdge, theFace);
674           Standard_Boolean good_ne1 = IsValidEdge(NewEdge1, theFace);
675
676           GeomAbs_CurveType type_E1 = TypeOfEdge(E1);
677           GeomAbs_CurveType type_E2 = TypeOfEdge(E2);
678
679           Standard_Integer ChooseEdge = 0;
680           
681           if (!good_ne || type_E1 != type_E2)
682           {
683             if (type_E1 == type_E2) //!good_ne
684             {
685               if (good_ne1)
686                 ChooseEdge = 1;
687               else
688                 ChooseEdge = 2;
689             }
690             else //types are different
691             {
692               if (type_E1 == GeomAbs_Line)
693                 ChooseEdge = 1;
694               else if (type_E2 == GeomAbs_Line)
695                 ChooseEdge = 2;
696               else //to be developed later...
697               {}
698             }
699           }
700           
701           if (ChooseEdge == 0)
702           {
703             EdgeSeq(j-1) = NewEdge;
704             EFmap.Add(NewEdge, ListOneFace);
705           }
706           else if (ChooseEdge == 1)
707           {
708             EdgeSeq(j-1) = NewEdge1;
709             EFmap.Add(NewEdge1, ListOneFace);
710             for (k = 1; k < j-1; k++)
711               EdgeSeq(k).Nullify();
712             for (k = 1; k <= j-1; k++)
713             {
714               TopoDS_Edge aLastEdge = TopoDS::Edge(myPaths(k)(i));
715               TopoDS_Shape VertexAsEdge = TopExp::FirstVertex(aLastEdge, Standard_True);
716               myPaths(k).InsertBefore(i, VertexAsEdge);
717             }
718             j = 1; //start from beginning
719           }
720           else if (ChooseEdge == 2)
721           {
722             EdgeSeq(j-1) = NewEdge2;
723             EFmap.Add(NewEdge2, ListOneFace);
724             ToInsertVertex = Standard_True;
725           }
726         } //else //E1 is edge
727       } //if (ProperEdge.IsNull())
728       else //connecting edge exists
729       {
730         /*
731         if (ToInsertVertex)
732         {
733           myPaths(j-1).InsertBefore(i, PrevPrevVer);
734           myPaths((j<=NbPaths)? j : 1).InsertBefore(i, PrevCurVer);
735           EdgeSeq(j-1) = E12;
736         }
737         else
738         */
739           EdgeSeq(j-1) = ProperEdge;
740       }
741     } //for (j = 2; j <= NbVer; j++)
742     SectionsEdges.Append(EdgeSeq);
743
744     //check for exit from for(;;)
745     Standard_Integer NbEndEdges = 0;
746     for (j = 1; j <= EdgeSeq.Length(); j++)
747       if (EndEdges.Contains(EdgeSeq(j)))
748         NbEndEdges++;
749     if (NbEndEdges == NbE)
750       break;
751     
752     i++;
753   } //for (;;)
754   
755
756   //final phase: building of middle path
757   Standard_Integer NbSecFaces = SectionsEdges.Length();
758   TopTools_Array1OfShape SecFaces(1, NbSecFaces);
759   for (i = 1; i <= NbSecFaces; i++)
760   {
761     BRepLib_MakeWire MW;
762     for (j = 1; j <= NbE; j++)
763     {
764       anEdge = TopoDS::Edge(SectionsEdges(i)(j));
765       MW.Add(anEdge);
766     }
767     if (!myClosedSection)
768     {
769       TopExp::Vertices(MW.Wire(), V1, V2);
770       anEdge = BRepLib_MakeEdge(V2, V1);
771       MW.Add(anEdge);
772     }
773     TopoDS_Wire aWire = MW.Wire();
774     BRepLib_MakeFace MF(aWire, Standard_True); //Only plane
775     if (MF.IsDone())
776       SecFaces(i) = MF.Face();
777     else
778       SecFaces(i) = aWire;
779   }
780
781   TColgp_Array1OfPnt Centers(1, NbSecFaces);
782   for (i = 1; i <= NbSecFaces; i++)
783   {
784     GProp_GProps Properties;
785     if (SecFaces(i).ShapeType() == TopAbs_FACE)
786       BRepGProp::SurfaceProperties(SecFaces(i), Properties);
787     else //wire
788       BRepGProp::LinearProperties(SecFaces(i), Properties);
789       
790     Centers(i) = Properties.CentreOfMass();
791   }
792
793   TopTools_Array1OfShape MidEdges(1, NbSecFaces-1);
794   Standard_Real LinTol = 1.e-5;
795   Standard_Real AngTol = 1.e-7;
796   gp_Pnt Pnt1, Pnt2;
797   for (i = 1; i < NbSecFaces; i++)
798   {
799     GeomAbs_CurveType TypeOfMidEdge = GeomAbs_OtherCurve;
800     for (j = 1; j <= myPaths.Length(); j++)
801     {
802       const TopoDS_Shape& aShape = myPaths(j)(i);
803       if (aShape.ShapeType() == TopAbs_VERTEX)
804       {
805         TypeOfMidEdge = GeomAbs_OtherCurve;
806         break;
807       }
808       anEdge = TopoDS::Edge(aShape);
809       GeomAbs_CurveType aType = TypeOfEdge(anEdge);
810       if (j == 1)
811         TypeOfMidEdge = aType;
812       else
813       {
814         if (aType != TypeOfMidEdge)
815         {
816           TypeOfMidEdge = GeomAbs_OtherCurve;
817           break;
818         }
819       }
820     }
821     if (TypeOfMidEdge == GeomAbs_Line)
822       MidEdges(i) = BRepLib_MakeEdge(Centers(i), Centers(i+1));
823     else if (TypeOfMidEdge == GeomAbs_Circle)
824     {
825       gp_Ax1 theAxis;
826       gp_Dir theDir1, theDir2;
827       Standard_Real theAngle = 0.;
828       gp_Vec theTangent;
829       Standard_Boolean SimilarArcs = Standard_True;
830       for (j = 1; j <= myPaths.Length(); j++)
831       {
832         anEdge = TopoDS::Edge(myPaths(j)(i));
833         Standard_Real fpar, lpar;
834         Handle(Geom_Curve) aCurve = BRep_Tool::Curve(anEdge, fpar, lpar);
835         if (aCurve->IsInstance(STANDARD_TYPE(Geom_TrimmedCurve)))
836           aCurve = ((Handle(Geom_TrimmedCurve)&) aCurve)->BasisCurve();
837         Pnt1 = aCurve->Value(fpar);
838         Pnt2 = aCurve->Value(lpar);
839         Handle(Geom_Circle) aCircle = Handle(Geom_Circle)::DownCast(aCurve);
840         gp_Circ aCirc = aCircle->Circ();
841         if (j == 1)
842         {
843           theAxis = aCirc.Axis();
844           theDir1 = gp_Vec(aCirc.Location(), Pnt1);
845           theDir2 = gp_Vec(aCirc.Location(), Pnt2);
846           theAngle = lpar - fpar;
847           Standard_Real theParam = (anEdge.Orientation() == TopAbs_FORWARD)?
848             fpar : lpar;
849           aCurve->D1(theParam, Pnt1, theTangent);
850           if (anEdge.Orientation() == TopAbs_REVERSED)
851             theTangent.Reverse();
852         }
853         else
854         {
855           gp_Ax1 anAxis = aCirc.Axis();
856           gp_Lin aLin(anAxis);
857           if (!aLin.Contains(theAxis.Location(), LinTol) ||
858               !anAxis.IsParallel(theAxis, AngTol))
859           {
860             SimilarArcs = Standard_False;
861             break;
862           }
863           gp_Dir aDir1 = gp_Vec(aCirc.Location(), Pnt1);
864           gp_Dir aDir2 = gp_Vec(aCirc.Location(), Pnt2);
865           if (!((aDir1.IsEqual(theDir1, AngTol) && aDir2.IsEqual(theDir2, AngTol)) ||
866                 (aDir1.IsEqual(theDir2, AngTol) && aDir2.IsEqual(theDir1, AngTol))))
867           {
868             SimilarArcs = Standard_False;
869             break;
870           }
871         }
872       }
873       if (SimilarArcs)
874       {
875         gp_XYZ AxisLoc = theAxis.Location().XYZ();
876         gp_XYZ AxisDir = theAxis.Direction().XYZ();
877         Standard_Real Parameter = (Centers(i).XYZ() - AxisLoc) * AxisDir;
878         gp_Pnt theCenterOfCirc(AxisLoc + Parameter*AxisDir);
879         
880         gp_Vec Vec1(theCenterOfCirc, Centers(i));
881         gp_Vec Vec2(theCenterOfCirc, Centers(i+1));
882         /*
883         gp_Dir VecProd = Vec1 ^ Vec2;
884         if (theAxis.Direction() * VecProd < 0.)
885           theAxis.Reverse();
886         */
887         
888         Standard_Real anAngle = Vec1.AngleWithRef(Vec2, theAxis.Direction());
889         if (anAngle < 0.)
890           anAngle += 2.*M_PI;
891         if (Abs(anAngle - theAngle) > AngTol)
892           theAxis.Reverse();
893         gp_Ax2 theAx2(theCenterOfCirc, theAxis.Direction(), Vec1);
894         Handle(Geom_Circle) theCircle = GC_MakeCircle(theAx2, Vec1.Magnitude());
895         gp_Vec aTangent;
896         theCircle->D1( 0., Pnt1, aTangent );
897         if (aTangent * theTangent < 0.)
898         {
899           theAxis.Reverse();
900           theAx2 = gp_Ax2(theCenterOfCirc, theAxis.Direction(), Vec1);
901           theCircle = GC_MakeCircle(theAx2, Vec1.Magnitude());
902         }
903         BRepLib_MakeEdge aME (theCircle, 0., theAngle);
904         aME.Build();
905
906         MidEdges(i) = aME.IsDone() ? 
907           aME.Shape() : 
908           TopoDS_Edge();
909       }
910     }
911   }
912
913   //Build missed edges
914   for (i = 1; i < NbSecFaces; i++)
915   {
916     if (MidEdges(i).IsNull())
917     {
918       for (j = i+1; j < NbSecFaces; j++)
919       {
920         if (!MidEdges(j).IsNull())
921           break;
922       }
923       //from i to j-1 all edges are null
924       Handle(TColgp_HArray1OfPnt) thePoints = new TColgp_HArray1OfPnt(1, j-i+1);
925       TColgp_Array1OfVec theTangents(1, j-i+1);
926       Handle(TColStd_HArray1OfBoolean) theFlags = new TColStd_HArray1OfBoolean(1, j-i+1);
927       for (k = i; k <= j; k++)
928         thePoints->SetValue(k-i+1, Centers(k));
929       for (k = i; k <= j; k++)
930       {
931         TColgp_SequenceOfPnt PntSeq;
932         for (Standard_Integer indp = 1; indp <= myPaths.Length(); indp++)
933         {
934           gp_Vec aTangent;
935           if (k == i)
936           {
937             if (myPaths(indp)(k).ShapeType() == TopAbs_VERTEX)
938               continue;
939             aTangent = TangentOfEdge(myPaths(indp)(k), Standard_True); //at begin
940           }
941           else if (k == j)
942           {
943             if (myPaths(indp)(k-1).ShapeType() == TopAbs_VERTEX)
944               continue;
945             aTangent = TangentOfEdge(myPaths(indp)(k-1), Standard_False); //at end
946           }
947           else
948           {
949             if (myPaths(indp)(k-1).ShapeType() == TopAbs_VERTEX ||
950                 myPaths(indp)(k).ShapeType() == TopAbs_VERTEX)
951               continue;
952             gp_Vec Tangent1 = TangentOfEdge(myPaths(indp)(k-1), Standard_False); //at end
953             gp_Vec Tangent2 = TangentOfEdge(myPaths(indp)(k), Standard_True); //at begin
954             aTangent = Tangent1 + Tangent2;
955           }
956           aTangent.Normalize();
957           gp_Pnt aPnt(aTangent.XYZ());
958           PntSeq.Append(aPnt);
959         }
960         TColgp_Array1OfPnt PntArray(1, PntSeq.Length());
961         for (Standard_Integer ip = 1; ip <= PntSeq.Length(); ip++)
962           PntArray(ip) = PntSeq(ip);
963         gp_Pnt theBary;
964         gp_Dir xdir, ydir;
965         Standard_Real xgap, ygap, zgap;
966         GeomLib::Inertia(PntArray, theBary, xdir, ydir, xgap, ygap, zgap);
967         gp_Vec theTangent(theBary.XYZ());
968         theTangents(k-i+1) = theTangent;
969       }
970       theFlags->Init(Standard_True);
971
972       GeomAPI_Interpolate Interpol(thePoints, Standard_False, LinTol);
973       Interpol.Load(theTangents, theFlags);
974       Interpol.Perform();
975       if (!Interpol.IsDone())
976       {
977         cout<<endl<<"Interpolation failed"<<endl;
978       }
979       Handle(Geom_Curve) InterCurve = Interpol.Curve();
980       MidEdges(i) = BRepLib_MakeEdge(InterCurve);
981       i = j;
982     }
983   }  
984
985   BRepLib_MakeWire MakeFinalWire;
986   for (i = 1; i < NbSecFaces; i++)
987     if (!MidEdges(i).IsNull())
988       MakeFinalWire.Add(TopoDS::Edge(MidEdges(i)));
989
990   TopoDS_Wire FinalWire = MakeFinalWire.Wire();
991   myShape = MakeFinalWire.Wire();
992   
993   //Temporary
994   /*
995   TopoDS_Compound aCompound, aCmp1, aCmp2;
996   BRep_Builder BB;
997   BB.MakeCompound(aCompound);
998   BB.MakeCompound(aCmp1);
999   BB.MakeCompound(aCmp2);
1000   for (i = 1; i <= myPaths.Length(); i++)
1001   {
1002     TopoDS_Compound aCmp;
1003     BB.MakeCompound(aCmp);
1004     for (j = 1; j <= myPaths(i).Length(); j++)
1005       BB.Add(aCmp, myPaths(i)(j));
1006     BB.Add(aCmp1, aCmp);
1007   }
1008   for (i = 1; i <= SectionsEdges.Length(); i++)
1009   {
1010     TopoDS_Wire aWire;
1011     BB.MakeWire(aWire);
1012     for (j = 1; j <= SectionsEdges(i).Length(); j++)
1013       BB.Add(aWire, SectionsEdges(i)(j));
1014     BB.Add(aCmp2, aWire);
1015   }
1016   BB.Add(aCompound, aCmp1);
1017   BB.Add(aCompound, aCmp2);
1018   BB.Add(aCompound, FinalWire);
1019          
1020   myShape = aCompound;
1021   */
1022   ////////////
1023
1024   Done();
1025 }