738cb1b915cdc55346bd8575fedcda69a30d6ea3
[occt.git] / src / LocOpe / LocOpe_SplitShape.cxx
1 // Created on: 1995-06-27
2 // Created by: Jacques GOUSSARD
3 // Copyright (c) 1995-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
5 //
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
10 //
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
13 //
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
20
21
22
23 #include <LocOpe_SplitShape.ixx>
24
25 #include <TopTools_ListOfShape.hxx>
26 #include <TopTools_ListIteratorOfListOfShape.hxx>
27 #include <TopTools_MapOfShape.hxx>
28 #include <TopTools_MapOfOrientedShape.hxx>
29 #include <TopTools_DataMapOfShapeListOfShape.hxx>
30 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
31 #include <TopTools_DataMapOfShapeInteger.hxx>
32 #include <TopTools_DataMapOfShapeShape.hxx>
33 #include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
34 #include <TopTools_MapIteratorOfMapOfShape.hxx>
35 #include <TopTools_MapIteratorOfMapOfOrientedShape.hxx>
36 #include <TopoDS_Iterator.hxx>
37 #include <TopExp_Explorer.hxx>
38 #include <BRep_Builder.hxx>
39 #include <TopoDS_Vertex.hxx>
40 #include <BRepLib_MakeFace.hxx>
41 #include <BRepLib_MakeWire.hxx>
42 #include <BRep_Tool.hxx>
43 #include <BRepTools.hxx>
44 #include <BRepTools_WireExplorer.hxx>
45 #include <BRep_Builder.hxx>
46
47 #include <BRepClass_FaceExplorer.hxx>
48 #include <BRepTopAdaptor_FClass2d.hxx>
49 #include <BRepAdaptor_Surface.hxx>
50
51 #include <Geom2d_Curve.hxx>
52 #include <gp_Pnt2d.hxx>
53 #include <gp_Vec2d.hxx>
54 #include <gp_Dir2d.hxx>
55 #include <TopoDS.hxx>
56 #include <TopExp.hxx>
57 #include <Precision.hxx>
58 #include <BRepTools.hxx>
59 #include <LocOpe.hxx>
60 #include <Standard_ErrorHandler.hxx>
61
62 static Standard_Boolean IsInside(const TopoDS_Face&,
63                                  const TopoDS_Wire&,
64                                  const TopoDS_Wire&);
65
66 static Standard_Boolean IsInside(const TopoDS_Face&,
67                                  const TopoDS_Wire&);
68
69 static void ChoixUV(const TopoDS_Edge&,
70                     const TopoDS_Face&,
71                     const TopTools_MapOfShape&,
72                     TopTools_MapIteratorOfMapOfShape&,
73                     gp_Pnt2d&,
74                     gp_Vec2d&,
75                     const Standard_Real tol);
76
77 static TopoDS_Shape ChooseDirection(const TopoDS_Shape&,
78                                     const TopoDS_Vertex&,
79                                     const TopoDS_Face&,
80                                     const TopTools_ListOfShape&);
81
82 inline Standard_Boolean SameUV(const gp_Pnt2d& P1, const gp_Pnt2d& P2, 
83                                const BRepAdaptor_Surface& theBAS)//const Standard_Real tol)
84 {
85   //  Standard_Real tol = Precision::Confusion();
86   //  return P1.SquareDistance(P2) < 10*tol;
87   //gka
88   Standard_Boolean isSame = Standard_True;
89   if(theBAS.IsUPeriodic())
90     isSame = (fabs(P1.X() - P2.X()) < theBAS.UPeriod() *0.5);
91   if(theBAS.IsVPeriodic())
92     isSame = (isSame && (fabs(P1.Y() - P2.Y()) < theBAS.VPeriod() *0.5));
93   return isSame;
94   //return P1.SquareDistance(P2) < tol * tol; //IFV
95 }
96
97
98
99 //=======================================================================
100 //function : Init
101 //purpose  : 
102 //=======================================================================
103
104 void LocOpe_SplitShape::Init(const TopoDS_Shape& S)
105 {
106   myDone = Standard_False;
107   myShape = S;
108   myDblE.Clear();
109   myMap.Clear();
110   Put(myShape);
111 }
112
113
114 //=======================================================================
115 //function : CanSplit
116 //purpose  : 
117 //=======================================================================
118
119 Standard_Boolean LocOpe_SplitShape::CanSplit(const TopoDS_Edge& E) const
120 {
121   if (myDone) {
122     return Standard_False;
123   }
124   if (myMap.IsEmpty()) {
125     return Standard_False;
126   }
127
128   if (!myMap.IsBound(E)) {
129     return Standard_False;
130   }
131
132   // On verifie que l`edge n`appartient pas a un wire deja reconstruit
133   TopExp_Explorer exp;  
134   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itm(myMap);
135   for (; itm.More(); itm.Next()) {
136     if (itm.Key().ShapeType() == TopAbs_WIRE && !itm.Value().IsEmpty()) {
137       for (exp.Init(itm.Key(),TopAbs_EDGE); exp.More(); exp.Next()) {
138         if (exp.Current().IsSame(E)) {
139           return Standard_False;
140         }
141       }
142     }
143   }
144   return Standard_True;
145 }
146
147
148 //=======================================================================
149 //function : Add
150 //purpose  : 
151 //=======================================================================
152
153 void LocOpe_SplitShape::Add(const TopoDS_Vertex& V,
154                             const Standard_Real P,
155                             const TopoDS_Edge& E)
156 {
157   if (!CanSplit(E)) {
158     Standard_ConstructionError::Raise();
159   }
160
161   BRep_Builder B;
162   TopTools_ListOfShape& le = myMap(E);
163   if (le.IsEmpty()) {
164     le.Append(E);
165   }
166   TopTools_ListIteratorOfListOfShape itl(le);
167   Standard_Real f,l;
168
169   for (; itl.More(); itl.Next()) {
170     const TopoDS_Edge& edg = TopoDS::Edge(itl.Value());
171     BRep_Tool::Range(edg,f,l);
172     if (P>f && P <l) {
173       break;
174     }
175   }
176   if (!itl.More()) {
177     Standard_ConstructionError::Raise();
178   }
179   TopoDS_Edge edg = TopoDS::Edge(itl.Value());
180   le.Remove(itl);
181   if (V.Orientation() == TopAbs_FORWARD ||
182     V.Orientation() == TopAbs_REVERSED) {
183
184       TopoDS_Shape aLocalShape = edg.EmptyCopied();
185       TopoDS_Edge E1 = TopoDS::Edge(aLocalShape);
186       aLocalShape = edg.EmptyCopied();
187       TopoDS_Edge E2 = TopoDS::Edge(aLocalShape);
188       //    TopoDS_Edge E1 = TopoDS::Edge(edg.EmptyCopied());
189       //    TopoDS_Edge E2 = TopoDS::Edge(edg.EmptyCopied());
190       E1.Orientation(TopAbs_FORWARD);
191       E2.Orientation(TopAbs_FORWARD);
192       TopoDS_Vertex newVtx = V;
193       newVtx.Orientation(TopAbs_REVERSED);
194       B.Add(E1,newVtx);
195       B.UpdateVertex(newVtx,P,E1,BRep_Tool::Tolerance(V));
196       newVtx.Orientation(TopAbs_FORWARD);
197       B.Add(E2,newVtx);
198       B.UpdateVertex(newVtx,P,E2,BRep_Tool::Tolerance(V));
199       edg.Orientation(TopAbs_FORWARD);
200       TopExp_Explorer exp;
201       for (exp.Init(edg,TopAbs_VERTEX); exp.More(); exp.Next()) {
202         //    for (TopExp_Explorer exp(edg,TopAbs_VERTEX); exp.More(); exp.Next()) {
203         const TopoDS_Vertex& vtx = TopoDS::Vertex(exp.Current());
204         f = BRep_Tool::Parameter(vtx,edg);
205         if (f < P) {
206           B.Add(E1,vtx);
207           B.UpdateVertex(vtx,f,E1,BRep_Tool::Tolerance(vtx));
208         }
209         else {
210           B.Add(E2,vtx);
211           B.UpdateVertex(vtx,f,E2,BRep_Tool::Tolerance(vtx));
212         }
213       }
214       le.Append(E1);
215       le.Append(E2);
216   }
217   else {
218     TopoDS_Shape aLocalShape = edg.EmptyCopied();
219     TopoDS_Edge E1 = TopoDS::Edge(aLocalShape);
220     //    TopoDS_Edge E1 = TopoDS::Edge(edg.EmptyCopied());
221     TopExp_Explorer exp;
222     for (exp.Init(edg,TopAbs_VERTEX); exp.More(); exp.Next()) {
223       //    for (TopExp_Explorer exp(edg,TopAbs_VERTEX); exp.More(); exp.Next()) {
224       const TopoDS_Vertex& vtx = TopoDS::Vertex(exp.Current());
225       f = BRep_Tool::Parameter(vtx,edg);
226       B.Add(E1,vtx);
227       B.UpdateVertex(vtx,f,E1,BRep_Tool::Tolerance(vtx));
228     }
229     B.Add(E1,V);
230     B.UpdateVertex(V,P,E1,BRep_Tool::Tolerance(V));
231     le.Append(E1);
232   }
233 }
234
235 //=======================================================================
236 //function : Add
237 //purpose  : adds the list of wires on the face <F>
238 //=======================================================================
239
240 void LocOpe_SplitShape::Add(const TopTools_ListOfShape& Lwires,
241                             const TopoDS_Face& F)
242 {
243
244   if (myDone) {
245     Standard_ConstructionError::Raise();
246   }
247
248   TopTools_ListOfShape& lf = myMap(F);
249   if (lf.IsEmpty()) {
250     Rebuild(F);
251   }
252
253   // On cherche la face descendante de F qui continent le wire
254   lf = myMap(F);
255   TopTools_ListIteratorOfListOfShape itl(lf);
256   TopoDS_Vertex Vfirst,Vlast;
257
258   BRepTools::Update(F);
259
260   for (; itl.More(); itl.Next())
261   {
262     const TopoDS_Face& fac = TopoDS::Face(itl.Value());
263     Standard_Boolean AllWiresInside = Standard_True;
264     TopTools_ListIteratorOfListOfShape itwires(Lwires);
265     for (; itwires.More(); itwires.Next())
266     {
267       const TopoDS_Wire& aWire = TopoDS::Wire(itwires.Value());
268       if (!IsInside(fac, aWire))
269       {
270         AllWiresInside = Standard_False;
271         break;
272       }
273     }
274     if (AllWiresInside)
275       break;
276   }
277   if (!itl.More()) {
278     Standard_ConstructionError::Raise();
279   }
280
281   TopoDS_Face FaceRef = TopoDS::Face(itl.Value());
282   FaceRef.Orientation(TopAbs_FORWARD);
283   lf.Remove(itl);
284
285   TopTools_ListOfShape NewWires;
286
287   TopTools_DataMapOfShapeInteger SectionsTimes;
288   for (itl.Initialize(Lwires); itl.More(); itl.Next())
289     SectionsTimes.Bind(itl.Value(), 2);
290   
291   TopTools_ListOfShape BreakVertices;
292   TopTools_ListOfShape BreakOnWires;
293
294   TopTools_DataMapOfShapeShape VerWireMap;
295   Standard_Integer i;
296   TopExp_Explorer ExploF, ExploW;
297   for (itl.Initialize(Lwires); itl.More(); itl.Next())
298   {
299     const TopoDS_Wire& aSection = TopoDS::Wire(itl.Value());
300     TopoDS_Vertex Ver [2];
301     TopExp::Vertices(aSection, Ver[0], Ver[1]);
302     for (i = 0; i < 2; i++)
303     {
304       if (VerWireMap.IsBound(Ver[i]))
305         continue;
306       for (ExploF.Init(FaceRef, TopAbs_WIRE); ExploF.More(); ExploF.Next())
307       {
308         const TopoDS_Shape& aWire = ExploF.Current();
309         TopoDS_Shape aVer;
310         for (ExploW.Init(aWire, TopAbs_VERTEX); ExploW.More(); ExploW.Next())
311         {
312           aVer = ExploW.Current();
313           if (aVer.IsSame(Ver[i]))
314             break;
315         }
316         if (aVer.IsSame(Ver[i]))
317         {
318           VerWireMap.Bind(aVer, aWire);
319           break;
320         }
321       }
322     }
323   }  
324   
325   TopTools_DataMapOfShapeListOfShape VerSecMap;
326   for (itl.Initialize(Lwires); itl.More(); itl.Next())
327   {
328     const TopoDS_Wire& aWire = TopoDS::Wire(itl.Value());
329     TopoDS_Vertex V1, V2;
330     TopExp::Vertices(aWire, V1, V2);
331     TopTools_ListOfShape LW1, LW2;
332     if (!VerSecMap.IsBound(V1))
333       VerSecMap.Bind(V1, LW1);
334     VerSecMap(V1).Append(aWire);
335     if (!VerSecMap.IsBound(V2))
336       VerSecMap.Bind(V2, LW2);
337     VerSecMap(V2).Append(aWire);
338   }
339
340   //TopTools_IndexedDataMapOfShapeShape InnerTouchingWiresOnVertex;
341   
342   TopoDS_Wire outerW = BRepTools::OuterWire(FaceRef);
343   TopoDS_Wire CurWire = outerW;
344   BRepLib_MakeWire *MW;
345   MW = new BRepLib_MakeWire();
346   BRepTools_WireExplorer wexp(CurWire, FaceRef);
347   for (;;)
348   {
349     TopoDS_Vertex theStartVertex = wexp.CurrentVertex(), CurVertex;
350     TopoDS_Edge CurEdge = wexp.Current();
351     TopoDS_Edge LastEdge = CurEdge;
352     MW->Add(CurEdge);
353     TopoDS_Wire aSectionWire;
354     TopoDS_Vertex aBreakVertex;
355     wexp.Next();
356     if (!wexp.More())
357       wexp.Init(CurWire, FaceRef);
358     for (;;)
359     {
360       if (MW->Wire().Closed())
361         break;
362       CurVertex = wexp.CurrentVertex();
363       if (VerSecMap.IsBound(CurVertex))
364       {
365         TopoDS_Shape aLocalWire = ChooseDirection(LastEdge, CurVertex, FaceRef, VerSecMap(CurVertex));
366         aSectionWire = TopoDS::Wire(aLocalWire);
367         break;
368       }
369       CurEdge = wexp.Current();
370       MW->Add(CurEdge);
371       LastEdge = CurEdge;
372       wexp.Next();
373       if (!wexp.More())
374         wexp.Init(CurWire, FaceRef);
375     }
376     if (MW->Wire().Closed())
377     {
378       NewWires.Append(MW->Wire());
379       theStartVertex = TopoDS::Vertex(BreakVertices.First());
380       BreakVertices.RemoveFirst();
381       CurWire = TopoDS::Wire(BreakOnWires.First());
382       BreakOnWires.RemoveFirst();
383       wexp.Init(CurWire, FaceRef);
384       while (!wexp.CurrentVertex().IsSame(theStartVertex))
385         wexp.Next();
386       MW = new BRepLib_MakeWire();
387       continue;
388     }
389     aBreakVertex = CurVertex;
390     BreakVertices.Append(aBreakVertex);
391     BreakOnWires.Append(CurWire);
392     for (;;)
393     {
394       MW->Add(aSectionWire);
395       (SectionsTimes(aSectionWire))--;
396       if (SectionsTimes(aSectionWire) == 0)
397         SectionsTimes.UnBind(aSectionWire);
398       if (MW->Wire().Closed())
399       {
400         NewWires.Append(MW->Wire());
401         if (SectionsTimes.IsEmpty())
402           break;
403         theStartVertex = TopoDS::Vertex(BreakVertices.First());
404         BreakVertices.RemoveFirst();
405         CurWire = TopoDS::Wire(BreakOnWires.First());
406         BreakOnWires.RemoveFirst();
407         wexp.Init(CurWire, FaceRef);
408         while (!wexp.CurrentVertex().IsSame(theStartVertex))
409           wexp.Next();
410         MW = new BRepLib_MakeWire();
411         break;
412       }
413       else
414       {
415         TopoDS_Vertex V1, V2, aStartVertex;
416         TopExp::Vertices(aSectionWire, V1, V2);
417         aStartVertex = (V1.IsSame(aBreakVertex))? V2 : V1;
418         CurWire = TopoDS::Wire(VerWireMap(aStartVertex));
419         
420         wexp.Init(CurWire, FaceRef);
421         while (!wexp.CurrentVertex().IsSame(aStartVertex))
422           wexp.Next();
423             
424         const TopTools_ListOfShape& Lsections = VerSecMap(aStartVertex);
425         if (Lsections.Extent() == 1)
426           break;
427         
428         //else: choose the way
429         TopoDS_Wire NextSectionWire =
430           TopoDS::Wire((aSectionWire.IsSame(Lsections.First()))? Lsections.Last() : Lsections.First());
431         
432         Standard_Integer Times = 0;
433         TopTools_DataMapIteratorOfDataMapOfShapeShape itVW(VerWireMap);
434         for (; itVW.More(); itVW.Next())
435           if (itVW.Value().IsSame(CurWire))
436             Times++;
437         if (Times == 1) //it is inner touching wire
438         {
439           //InnerTouchingWiresOnVertex.Bind(aWire, aStartVertex);
440         }
441         else
442           {
443             //we have to choose the direction
444             TopoDS_Edge aStartEdge = wexp.Current();
445             TopTools_ListOfShape Ldirs;
446             Ldirs.Append(aStartEdge);
447             Ldirs.Append(NextSectionWire);
448             TopoDS_Shape theDirection = ChooseDirection(aSectionWire, aStartVertex, FaceRef, Ldirs);
449             if (theDirection.IsSame(aStartEdge))
450               break;
451           }
452         aSectionWire = NextSectionWire;
453         aBreakVertex = aStartVertex;
454       } //end of else (MW is not closed)
455     } //end of for (;;) (loop on section wires)
456     if (SectionsTimes.IsEmpty())
457       break;
458   } //end of global for (;;)
459
460   TopTools_ListOfShape NewFaces;
461   BRep_Builder BB;
462   for (itl.Initialize(NewWires); itl.More(); itl.Next())
463   {
464     TopoDS_Shape aLocalFace = FaceRef.EmptyCopied();
465     TopoDS_Face aNewFace = TopoDS::Face(aLocalFace);
466     aNewFace.Orientation(TopAbs_FORWARD);
467     BB.Add(aNewFace, itl.Value());
468     NewFaces.Append(aNewFace);
469   }
470
471   //Inserting holes
472   TopTools_ListOfShape Holes;
473   for (ExploF.Init(FaceRef, TopAbs_WIRE); ExploF.More(); ExploF.Next())
474   {
475     const TopoDS_Shape& aWire = ExploF.Current();
476     ExploW.Init(aWire, TopAbs_EDGE);
477     TopoDS_Shape anEdge = ExploW.Current();
478     Standard_Boolean found = Standard_False;
479     for (itl.Initialize(NewWires); itl.More(); itl.Next())
480     {
481       const TopoDS_Shape& aNewWire = itl.Value();
482       for (ExploW.Init(aNewWire, TopAbs_EDGE); ExploW.More(); ExploW.Next())
483       {
484         if (anEdge.IsSame(ExploW.Current()))
485         {
486           found = Standard_True;
487           break;
488         }
489       }
490       if (found)
491         break;
492     }
493     if (!found)
494       Holes.Append(aWire);
495   }
496   TopTools_ListIteratorOfListOfShape itlNewF;
497   for (itl.Initialize(Holes); itl.More(); itl.Next())
498   {
499     const TopoDS_Wire& aHole = TopoDS::Wire(itl.Value());
500     for (itlNewF.Initialize(NewFaces); itlNewF.More(); itlNewF.Next())
501     {
502       TopoDS_Face& aNewFace = TopoDS::Face(itlNewF.Value());
503       if (IsInside(aNewFace, aHole))
504       {
505         BB.Add(aNewFace, aHole);
506         break;
507       }
508     }
509   }
510
511   //Update "myMap"
512   lf.Append(NewFaces);
513
514   //Update of descendants of wires
515   for (ExploF.Init(F, TopAbs_WIRE); ExploF.More(); ExploF.Next())
516   {
517     TopTools_ListOfShape& ls = myMap(ExploF.Current());
518     ls.Clear();
519   }
520   ///////////////////
521   
522   // JAG 10.11.95 Codage des regularites
523   for (itl.Initialize(Lwires); itl.More(); itl.Next())
524     for (ExploW.Init(itl.Value(), TopAbs_EDGE); ExploW.More(); ExploW.Next())
525     {
526       const TopoDS_Edge& edg = TopoDS::Edge(ExploW.Current());
527       if (!BRep_Tool::HasContinuity(edg,F,F)) {
528         BB.Continuity(edg,F,F,GeomAbs_CN);
529       }
530     }
531 }
532
533
534 //=======================================================================
535 //function : Add
536 //purpose  : 
537 //=======================================================================
538
539 void LocOpe_SplitShape::Add(const TopoDS_Wire& W,
540                             const TopoDS_Face& F)
541 {
542
543   if (myDone) {
544     Standard_ConstructionError::Raise();
545   }
546
547
548   TopExp_Explorer exp;
549   TopTools_ListOfShape& lf = myMap(F);
550   if (lf.IsEmpty()) {
551     Rebuild(F);
552   }
553   try {
554     OCC_CATCH_SIGNALS
555     if (!LocOpe::Closed(W,F)) {
556       AddOpenWire(W,F);
557     }
558     else {
559       AddClosedWire(W,F);
560     }
561   } catch (Standard_Failure ) {
562 #ifdef DEB
563     cout << "Warning: SpliShape internal problem detected, some faces may be lost. Check input edges/wires" <<endl;
564 #endif
565     return;
566   }
567   // JAG 10.11.95 Codage des regularites
568   BRep_Builder B;
569   for (exp.Init(W,TopAbs_EDGE); exp.More(); exp.Next()) {
570     const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
571     if (!BRep_Tool::HasContinuity(edg,F,F)) {
572       B.Continuity(edg,F,F,GeomAbs_CN);
573     }
574   }
575 }
576
577
578
579 //=======================================================================
580 //function : AddClosedWire
581 //purpose  : 
582 //=======================================================================
583
584 void LocOpe_SplitShape::AddClosedWire(const TopoDS_Wire& W,
585                                       const TopoDS_Face& F)
586 {
587   TopExp_Explorer exp;
588
589   // On cherche la face descendante de F qui continent le wire
590   TopTools_ListOfShape& lf = myMap(F);
591   TopTools_ListIteratorOfListOfShape itl(lf);
592   TopoDS_Wire outerW;
593   for (; itl.More(); itl.Next()) {
594     const TopoDS_Face& fac = TopoDS::Face(itl.Value());
595     /*
596     outerW = BRepTools::OuterWire(fac);
597     if (IsInside(F,W,outerW)) {
598     break;
599     }
600     */
601     if (IsInside(fac,W)) {
602       break;
603     }
604
605   }
606   if (!itl.More()) {
607     Standard_ConstructionError::Raise();
608   }
609
610   BRep_Builder B;
611
612   TopAbs_Orientation orWire = W.Orientation();
613   TopoDS_Shape aLocalFace = F.EmptyCopied();
614   TopoDS_Face newFace = TopoDS::Face(aLocalFace);
615   //  TopoDS_Face newFace = TopoDS::Face(F.EmptyCopied());
616   newFace.Orientation(TopAbs_FORWARD);
617   B.Add(newFace,W);
618   //  GProp_GProps GP;
619   //  BRepGProp::SurfaceProperties (newFace,GP);
620   //  if (GP.Mass() < 0) {
621   BRepTopAdaptor_FClass2d classif(newFace,Precision::PConfusion());
622   if (classif.PerformInfinitePoint() == TopAbs_IN) {
623     //le wire donne defini un trou
624     aLocalFace = F.EmptyCopied();
625     newFace = TopoDS::Face(aLocalFace);
626     //    newFace = TopoDS::Face(F.EmptyCopied());
627     newFace.Orientation(TopAbs_FORWARD);
628     orWire = TopAbs::Reverse(orWire);
629     B.Add(newFace,W.Oriented(orWire));
630   }
631
632   TopoDS_Face FaceRef = TopoDS::Face(itl.Value());
633   FaceRef.Orientation(TopAbs_FORWARD);
634   lf.Remove(itl);
635
636   aLocalFace = FaceRef.EmptyCopied();
637   TopoDS_Face newRef = TopoDS::Face(aLocalFace);
638   //  TopoDS_Face newRef = TopoDS::Face(FaceRef.EmptyCopied());
639   newRef.Orientation(TopAbs_FORWARD);
640
641   // On suppose que les edges du wire ont des courbes 2d. 
642   // Comme on ne change pas de surface de base, pas besoin d`UpdateEdge.
643
644   for (exp.Init(FaceRef.Oriented(TopAbs_FORWARD),TopAbs_WIRE);
645     exp.More(); exp.Next()) {
646       const TopoDS_Wire& wir = TopoDS::Wire(exp.Current());
647       if (IsInside(F,wir,W)) {
648         B.Add(newFace,wir);
649       }
650       else {
651         B.Add(newRef,wir);
652       }
653   }
654   B.Add(newRef,W.Oriented(TopAbs::Reverse(orWire)));
655   lf.Append(newRef);
656   lf.Append(newFace);
657
658 }
659
660
661 //=======================================================================
662 //function : AddOpenWire
663 //purpose  : 
664 //=======================================================================
665
666 void LocOpe_SplitShape::AddOpenWire(const TopoDS_Wire& W,
667                                     const TopoDS_Face& F)
668 {
669   // On cherche la face descendante de F qui continent le wire
670   TopTools_ListOfShape& lf = myMap(F);
671   TopTools_ListIteratorOfListOfShape itl(lf);
672   TopoDS_Vertex Vfirst,Vlast;
673
674   BRepTools::Update(F);
675
676   Standard_Real tolf, toll, tol1;
677
678   TopoDS_Shape aLocalShape = W.Oriented(TopAbs_FORWARD);
679   TopExp::Vertices(TopoDS::Wire(aLocalShape),Vfirst,Vlast);
680
681   tolf = BRep_Tool::Tolerance(Vfirst);
682   toll = BRep_Tool::Tolerance(Vlast);
683   tol1 = Max(tolf, toll);
684
685
686   TopExp_Explorer exp,exp2;  
687
688   TopoDS_Wire wfirst,wlast;
689   for (; itl.More(); itl.Next()) {
690     TopoDS_Face fac = TopoDS::Face(itl.Value());
691     if (!IsInside(fac,W)) {
692       continue;
693     }
694     
695     fac.Orientation(TopAbs_FORWARD);
696     Standard_Boolean ffound = Standard_False;
697     Standard_Boolean lfound = Standard_False;
698     for (exp.Init(fac,TopAbs_WIRE); exp.More(); exp.Next()) {
699       const TopoDS_Wire& wir = TopoDS::Wire(exp.Current());
700       for (exp2.Init(wir,TopAbs_VERTEX); exp2.More(); exp2.Next()) {
701         if (!ffound && exp2.Current().IsSame(Vfirst)) {
702           ffound = Standard_True;
703           wfirst = wir;
704         }
705         else if (!lfound && exp2.Current().IsSame(Vlast)) {
706           lfound = Standard_True;
707           wlast = wir;
708         }
709         if (ffound && lfound) {
710           break;
711         }
712       }
713       if (exp2.More()) {
714         break;
715       }
716     }
717     if (exp.More()) {
718       break;
719     }
720   }
721   if (!itl.More()) {
722     Standard_ConstructionError::Raise();
723   }
724
725   TopoDS_Face FaceRef = TopoDS::Face(itl.Value());
726   FaceRef.Orientation(TopAbs_FORWARD);
727   lf.Remove(itl);
728   BRep_Builder B;
729
730   BRepAdaptor_Surface BAS(FaceRef, Standard_False);
731
732   Standard_Boolean IsPeriodic = BAS.IsUPeriodic() || BAS.IsVPeriodic();
733
734   tol1 = Max(BAS.UResolution(tol1), BAS.VResolution(tol1));
735
736   if (wfirst.IsSame(wlast)) {
737     // on cree 2 faces en remplacement de itl.Value()
738     // Essai JAG
739     TopTools_ListOfShape WiresFirst;
740     for (exp.Init(wfirst,TopAbs_EDGE); exp.More(); exp.Next()) {
741       if (BRep_Tool::IsClosed(TopoDS::Edge(exp.Current()),FaceRef)) {
742         myDblE.Add(exp.Current());
743       }
744       WiresFirst.Append(exp.Current());      
745     }
746
747     TopAbs_Orientation orient;
748     TopoDS_Wire newW1,newW2;
749     B.MakeWire(newW1);
750     newW1.Orientation(TopAbs_FORWARD);
751     B.MakeWire(newW2);
752     newW2.Orientation(TopAbs_FORWARD);
753
754     Standard_Integer nbE = 0;    
755     for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
756          exp.More(); exp.Next()) {
757       nbE++;
758       const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
759       orient = edg.Orientation();      
760       WiresFirst.Append(edg);
761       WiresFirst.Append(edg.Oriented(TopAbs::Reverse(orient)));
762       myDblE.Add(edg);
763     }    
764
765     TopTools_MapOfShape PossE;
766     TopTools_MapOfOrientedShape MapE;
767     TopTools_MapIteratorOfMapOfShape itm;
768     TopoDS_Vertex vdeb,vfin;
769     Standard_Integer nbPoss;
770
771     // On recherche l`edge contenant Vlast
772     TopoDS_Edge LastEdge;
773     gp_Pnt2d pfirst,plast;
774     gp_Vec2d dlast;
775     Handle(Geom2d_Curve) C2d;
776     Standard_Real f,l;
777
778     for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
779          exp.More(); exp.Next()) {
780       const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
781       for (exp2.Init(edg,TopAbs_VERTEX); exp2.More(); exp2.Next()) {
782         if (exp2.Current().IsSame(Vfirst)) {
783           break;
784         }
785       }
786       if (exp2.More()) {
787         LastEdge = edg;
788         LastEdge.Orientation(edg.Orientation());
789         break;
790       }
791     }
792
793     TopoDS_Shape aLocalFace = FaceRef.Oriented(wfirst.Orientation());
794     C2d = BRep_Tool::CurveOnSurface(LastEdge, TopoDS::Face(aLocalFace), f, l);
795
796     if (LastEdge.Orientation() == TopAbs_FORWARD) {
797       pfirst = C2d->Value(f);
798     }
799     else {
800       pfirst = C2d->Value(l);
801     }
802
803     for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE); 
804          exp.More(); exp.Next()) {
805       const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
806       if( nbE>1 && edg.IsSame(LastEdge) )
807         continue;
808       for (exp2.Init(edg,TopAbs_VERTEX); exp2.More(); exp2.Next()) {
809         if (exp2.Current().IsSame(Vlast)) {
810           break;
811         }
812       }
813       if (exp2.More()) {
814         LastEdge = edg;
815         LastEdge.Orientation(edg.Orientation());
816         break;
817       }
818     }
819     aLocalFace  = FaceRef.Oriented(wfirst.Orientation());
820     C2d = BRep_Tool::CurveOnSurface(LastEdge, TopoDS::Face(aLocalFace), f, l);
821  
822     if (LastEdge.Orientation() == TopAbs_FORWARD) {
823       C2d->D1(l,plast,dlast);
824     }
825     else {
826       C2d->D1(f,plast,dlast);
827       dlast.Reverse();
828     }
829
830     Standard_Boolean cond;
831
832     if(IsPeriodic) {
833
834       cond = !(Vfirst.IsSame(Vlast) && SameUV(pfirst,plast,BAS));
835     }
836     else {
837       cond = !(Vfirst.IsSame(Vlast));
838     }
839         
840     while (cond) {      
841       PossE.Clear();
842       
843       // On enchaine par la fin      
844       TopTools_ListIteratorOfListOfShape lexp(WiresFirst);
845       for (; lexp.More(); lexp.Next()) {
846         const TopoDS_Edge& edg = TopoDS::Edge(lexp.Value());        
847
848         orient = edg.Orientation();
849         TopExp::Vertices(edg,vdeb,vfin);
850         if (orient == TopAbs_FORWARD && Vlast.IsSame(vdeb)) {
851           PossE.Add(edg.Oriented(orient));
852         }
853         else if (orient == TopAbs_REVERSED && Vlast.IsSame(vfin)) {
854           PossE.Add(edg.Oriented(orient));
855         }
856       }
857       nbPoss = PossE.Extent();
858       if (nbPoss == 0)
859       {
860         break;
861       }
862
863       if (nbPoss == 1) {
864         itm.Initialize(PossE);
865         TopoDS_Shape aLocalFace  = FaceRef.Oriented(wfirst.Orientation());
866         C2d = BRep_Tool::CurveOnSurface(TopoDS::Edge(itm.Key()),
867                                         TopoDS::Face(aLocalFace), f, l);
868
869         if (itm.Key().Orientation() == TopAbs_FORWARD) {
870           C2d->D1(l,plast,dlast);
871         }
872         else {
873           C2d->D1(f,plast,dlast);
874           dlast.Reverse();
875         }
876       }
877       else if (nbPoss > 1) {
878         // Faire choix en U,V...
879         TopoDS_Shape aLocalFace  = FaceRef.Oriented(wfirst.Orientation());
880         
881         ChoixUV(LastEdge, TopoDS::Face(aLocalFace), PossE,
882                 itm, plast, dlast, toll);
883       }
884
885       if (nbPoss >= 1) {
886         if (MapE.Contains(itm.Key())) 
887           break;
888         B.Add(newW1,itm.Key());
889         MapE.Add(itm.Key());        
890         LastEdge = TopoDS::Edge(itm.Key());
891         
892         if (LastEdge.Orientation() == TopAbs_FORWARD) {
893           Vlast = TopExp::LastVertex(LastEdge);
894         }
895         else {
896           Vlast = TopExp::FirstVertex(LastEdge);
897         }
898         
899         toll = BRep_Tool::Tolerance(Vlast);
900         tol1 = Max(tolf, toll);
901         
902       }
903       //MODIFICATION PIERRE SMEYERS : si pas de possibilite, on sort avec erreur
904       else{
905         cout<<"erreur Spliter : pas de chainage du wire"<<endl;
906         Standard_ConstructionError::Raise();        
907       }
908       //fin MODIF.
909       
910       tol1 = Max(BAS.UResolution(tol1), BAS.VResolution(tol1));
911       
912     }
913     
914     TopTools_ListIteratorOfListOfShape lexp(WiresFirst);
915     for (; lexp.More(); lexp.Next()) {    
916       const TopoDS_Edge& edg = TopoDS::Edge(lexp.Value());
917       if (!MapE.Contains(edg)) {
918         B.Add(newW2,edg);
919         MapE.Add(edg);
920       }
921     }        
922    
923     TopoDS_Face newF1,newF2;
924     aLocalFace = FaceRef.EmptyCopied();
925     newF1 = TopoDS::Face(aLocalFace);
926     newF1.Orientation(TopAbs_FORWARD);
927     aLocalFace = FaceRef.EmptyCopied();
928     newF2 = TopoDS::Face(aLocalFace);
929     newF2.Orientation(TopAbs_FORWARD);
930     
931     // modifs JAG 97.05.28
932 #ifdef DEB
933     TopAbs_Orientation orfila;
934 #else
935     TopAbs_Orientation orfila=TopAbs_FORWARD;
936 #endif
937     for (exp.Init(FaceRef.Oriented(TopAbs_FORWARD),TopAbs_WIRE); 
938          exp.More(); exp.Next()) {
939       const TopoDS_Wire& wir = TopoDS::Wire(exp.Current());
940       if (wir.IsSame(wfirst)) {
941         orfila = exp.Current().Orientation();
942         break;
943       }
944     }
945     
946     newW1.Oriented(orfila);
947     BRepTopAdaptor_FClass2d classif(newF1,Precision::PConfusion());
948     if (classif.PerformInfinitePoint() == TopAbs_OUT) {
949       BRepTopAdaptor_FClass2d classi(newF2,Precision::PConfusion());
950       if (classi.PerformInfinitePoint() == TopAbs_IN) {
951         TopoDS_Face tempF = newF2;
952         newF2 = newF1;
953         newF1 = tempF;
954         newW2.Oriented(orfila);
955         newW1.Oriented(TopAbs_FORWARD);
956       }
957     }
958     B.Add(newF1,newW1);
959     B.Add(newF2,newW2);
960     
961     for (exp.ReInit(); exp.More(); exp.Next()) {
962       const TopoDS_Wire& wir = TopoDS::Wire(exp.Current());
963       if (!wir.IsSame(wfirst)) {
964         if (IsInside(newF1, wir)) {
965           B.Add(newF1,wir);
966         }
967         else if (IsInside(newF2, wir)) {
968           B.Add(newF2,wir);
969         }
970         else {
971           // Ce wire est ni dans newF2 ni dans newF1
972           // Peut etre faut il construire une troisieme face
973           cout << "WARNING: LocOpe_SPlitShape : Ce wire est ni dans newF2 ni dans newF1" << endl;
974         }
975       }
976     }
977     lf.Append(newF1);
978     lf.Append(newF2);
979     
980     // Mise a jour des descendants des wires
981     for (exp.Init(F,TopAbs_WIRE); exp.More(); exp.Next()) {
982       TopTools_ListOfShape& ls = myMap(exp.Current());
983       itl.Initialize(ls);
984       for (; itl.More(); itl.Next()) {
985         if (itl.Value().IsSame(wfirst)) {
986           break;
987         }
988       }
989       if (itl.More()) { // on a trouve le wire
990         ls.Remove(itl);
991         ls.Append(newW1);
992         ls.Append(newW2);
993       }
994     }
995   }
996   else {
997     // on ne cree qu`une seule face
998     TopoDS_Wire outerW = BRepTools::OuterWire(FaceRef);
999     TopoDS_Wire newWire;
1000     TopoDS_Face newFace;
1001     B.MakeWire(newWire);
1002     newWire.Orientation(TopAbs_FORWARD);
1003     TopAbs_Orientation orient,orRelat;
1004
1005     if (wfirst.Orientation() == wlast.Orientation()) {
1006       orRelat = TopAbs_FORWARD;
1007     }
1008     else {
1009       orRelat = TopAbs_REVERSED;
1010     }
1011
1012     if (wlast.IsSame(outerW)) {
1013       wlast = wfirst;
1014       wfirst = outerW;
1015     }
1016     
1017     // Edges de wfirst
1018     for (exp.Init(wfirst.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
1019          exp.More(); exp.Next()) {
1020       B.Add(newWire,TopoDS::Edge(exp.Current()));
1021     }
1022
1023     // Edges de wlast
1024     for (exp.Init(wlast.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
1025          exp.More(); exp.Next()) {
1026       const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
1027       orient = TopAbs::Compose(edg.Orientation(),orRelat);
1028       B.Add(newWire,edg.Oriented(orient));
1029     }
1030     
1031
1032     // Edges du wire ajoute, et dans les 2 sens
1033     for (exp.Init(W.Oriented(TopAbs_FORWARD),TopAbs_EDGE);
1034          exp.More(); exp.Next()) {
1035       const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
1036       orient = edg.Orientation();
1037       B.Add(newWire,edg.Oriented(orient));
1038       B.Add(newWire,edg.Oriented(TopAbs::Reverse(orient)));
1039       myDblE.Add(edg.Oriented(orient));
1040     }
1041     
1042     // on refait une face
1043
1044     TopoDS_Shape aLocalFace = FaceRef.EmptyCopied();
1045     newFace = TopoDS::Face(aLocalFace);
1046     //    newFace = TopoDS::Face(FaceRef.EmptyCopied());
1047     FaceRef.Orientation(TopAbs_FORWARD);
1048     for (exp.Init(FaceRef.Oriented(TopAbs_FORWARD),TopAbs_WIRE); 
1049          exp.More(); exp.Next()) {
1050       const TopoDS_Wire& wir = TopoDS::Wire(exp.Current());
1051       if (wir.IsSame(wfirst)) {
1052         B.Add(newFace,newWire.Oriented(wir.Orientation()));
1053       }
1054       else if (!wir.IsSame(wlast)) {
1055         B.Add(newFace,wir);
1056       }
1057     }
1058     lf.Append(newFace);
1059     
1060     // Mise a jour des descendants des wires
1061     for (exp.Init(F,TopAbs_WIRE); exp.More(); exp.Next()) {
1062       TopTools_ListOfShape& ls = myMap(exp.Current());
1063       itl.Initialize(ls);
1064       Standard_Boolean touch = Standard_False;
1065       while (itl.More()) {
1066         if (itl.Value().IsSame(wfirst) || itl.Value().IsSame(wlast)) {
1067           ls.Remove(itl);
1068           touch = Standard_True;
1069         }
1070         else {
1071           itl.Next();
1072         }
1073       }
1074       if (touch) {
1075         ls.Append(newWire);
1076       }
1077       
1078     }
1079   }
1080 }
1081
1082
1083 //=======================================================================
1084 //function : LeftOf
1085 //purpose  : 
1086 //=======================================================================
1087
1088 const TopTools_ListOfShape& LocOpe_SplitShape::LeftOf(const TopoDS_Wire& W,
1089                                                       const TopoDS_Face& F)
1090 {
1091   if (myShape.IsNull()) {
1092     Standard_NoSuchObject::Raise();
1093   }
1094
1095   TopExp_Explorer exp,expw,expf;
1096   exp.Init(myShape,TopAbs_FACE);
1097   for (; exp.More(); exp.Next()) {
1098     if (exp.Current().IsSame(F)) {
1099       break;
1100     }
1101   }
1102   if (!exp.More()) {
1103     Standard_NoSuchObject::Raise();
1104   }
1105   myLeft.Clear();
1106
1107   const TopoDS_Face& theFace = TopoDS::Face(exp.Current());
1108   TopAbs_Orientation orFace = theFace.Orientation();
1109   TopTools_ListIteratorOfListOfShape itl,itl2;
1110
1111   for (expw.Init(W,TopAbs_EDGE); expw.More(); expw.Next()) {
1112     const TopoDS_Edge& edg = TopoDS::Edge(expw.Current());
1113     for (itl.Initialize(myMap(theFace)); itl.More(); itl.Next()) {
1114       TopoDS_Face fac = TopoDS::Face(itl.Value());
1115       fac.Orientation(orFace);
1116       for (expf.Init(fac,TopAbs_EDGE); expf.More(); expf.Next()) {
1117         const TopoDS_Edge& edgbis = TopoDS::Edge(expf.Current());
1118         if (edgbis.IsSame(edg) && 
1119           edgbis.Orientation() == edg.Orientation()) {
1120             for (itl2.Initialize(myLeft); itl2.More(); itl2.Next()) {
1121               if (itl2.Value().IsSame(fac)) {
1122                 break;
1123               }
1124             }
1125             if (!itl2.More()) { // la face n`est pas deja presente
1126               myLeft.Append(fac);
1127             }
1128             break;
1129         }
1130       }
1131       if (expf.More()) { // face found
1132         break;
1133       }
1134     }
1135   }
1136   return myLeft;
1137 }
1138
1139
1140 //=======================================================================
1141 //function : DescendantShapes
1142 //purpose  : 
1143 //=======================================================================
1144
1145 const TopTools_ListOfShape& LocOpe_SplitShape::DescendantShapes
1146 (const TopoDS_Shape& S)
1147 {
1148   if (!myDone) {
1149     Rebuild(myShape);
1150     myDone = Standard_True;
1151   }
1152 #ifdef DEB
1153   if (!myDblE.IsEmpty()) {
1154     cout << "Le shape comporte des faces invalides" << endl;
1155   }
1156 #endif
1157   return myMap(S);
1158 }
1159
1160
1161
1162 //=======================================================================
1163 //function : Put
1164 //purpose  : 
1165 //=======================================================================
1166
1167 void LocOpe_SplitShape::Put(const TopoDS_Shape& S)
1168 {
1169   if (!myMap.IsBound(S)) {
1170     TopTools_ListOfShape thelist;
1171     myMap.Bind(S, thelist);
1172     if (S.ShapeType() != TopAbs_VERTEX) {
1173       for(TopoDS_Iterator theIterator(S);theIterator.More();
1174         theIterator.Next()) {
1175           Put(theIterator.Value());
1176       }
1177     }
1178     else {
1179       myMap(S).Append(S);
1180     }
1181   }
1182 }
1183
1184
1185 //=======================================================================
1186 //function : Rebuild
1187 //purpose  : 
1188 //=======================================================================
1189
1190 Standard_Boolean LocOpe_SplitShape::Rebuild(const TopoDS_Shape& S)
1191
1192 {
1193
1194   TopTools_ListIteratorOfListOfShape itr(myMap(S));
1195   if (itr.More()) {
1196     if (itr.Value().IsSame(S)) {
1197       return Standard_False;
1198     }
1199     return Standard_True;
1200   }
1201   Standard_Boolean rebuild = Standard_False;
1202   TopoDS_Iterator it;
1203   for(it.Initialize(S); it.More(); it.Next()) {
1204     rebuild = Rebuild(it.Value()) || rebuild;
1205   }
1206
1207   if (rebuild) {
1208     BRep_Builder B;
1209     TopoDS_Shape result = S.EmptyCopied();
1210     TopAbs_Orientation orient;
1211     for(it.Initialize(S); it.More(); it.Next()) {
1212       orient = it.Value().Orientation();
1213       for (itr.Initialize(myMap(it.Value())); itr.More(); itr.Next()) {
1214         B.Add(result,itr.Value().Oriented(orient));
1215       }
1216     }
1217     myMap(S).Append(result);
1218   }
1219   else {
1220     myMap(S).Append(S);
1221   }
1222   return rebuild;
1223 }
1224
1225
1226
1227 //=======================================================================
1228 //function : IsInside
1229 //purpose  : 
1230 //=======================================================================
1231
1232 static Standard_Boolean IsInside(const TopoDS_Face& F,
1233                                  const TopoDS_Wire& W1,
1234                                  const TopoDS_Wire& W2)
1235 {
1236   // Attention, c`est tres boeuf !!!!
1237   BRep_Builder B;
1238   TopoDS_Shape aLocalShape = F.EmptyCopied();
1239   TopoDS_Face newFace = TopoDS::Face(aLocalShape);
1240   //  TopoDS_Face newFace = TopoDS::Face(F.EmptyCopied());
1241
1242   //TopAbs_Orientation orWire = W2.Orientation();
1243     
1244   newFace.Orientation(TopAbs_FORWARD);
1245   B.Add(newFace,W2);
1246   //  GProp_GProps GP;
1247   //  BRepGProp::SurfaceProperties(newFace,GP);
1248   //  if (GP.Mass() < 0) {
1249   BRepTopAdaptor_FClass2d classif(newFace,Precision::PConfusion());
1250   Standard_Boolean Reversed = Standard_False;
1251   if (classif.PerformInfinitePoint() == TopAbs_IN) {
1252     //le wire donne defini un trou
1253     //    newFace = TopoDS::Face(F.EmptyCopied());
1254     //    newFace.Orientation(TopAbs_FORWARD);
1255     //    orWire = TopAbs::Reverse(orWire);
1256     //    B.Add(newFace,W2.Oriented(orWire));
1257     Reversed = Standard_True;
1258   }
1259
1260   //  Standard_Real U,V;
1261   TopExp_Explorer exp(W1,TopAbs_EDGE);
1262   const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
1263   TopExp_Explorer exp2(edg,TopAbs_VERTEX);
1264   const TopoDS_Vertex& vtx = TopoDS::Vertex(exp2.Current());
1265   Standard_Real prm = BRep_Tool::Parameter(vtx,edg);
1266   Standard_Real f,l;
1267   Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(edg,F,f,l);
1268   if(C2d.IsNull()) {
1269 #ifdef DEB
1270           cout << "Edge is not on surface" <<endl;
1271 #endif
1272       return Standard_False;
1273   }
1274   gp_Pnt2d pt2d(C2d->Value(prm));
1275   //  BRepClass_FaceClassifier classif(newFace,pt2d,Precision::PConfusion());
1276   //  return (classif.State() == TopAbs_IN);
1277   if (!Reversed) {
1278     return (classif.Perform(pt2d) == TopAbs_IN);
1279   }
1280   else {
1281     return (classif.Perform(pt2d) == TopAbs_OUT);
1282   }
1283 }
1284
1285
1286 //=======================================================================
1287 //function : IsInside
1288 //purpose  : 
1289 //=======================================================================
1290
1291 static Standard_Boolean IsInside(const TopoDS_Face& F,
1292                                  const TopoDS_Wire& W)
1293 {
1294   // Attention, c`est tres boeuf !!!!
1295   TopExp_Explorer exp(W,TopAbs_EDGE);
1296   for( ; exp.More(); exp.Next()) {
1297     const TopoDS_Edge& edg = TopoDS::Edge(exp.Current());
1298     //  TopExp_Explorer exp2(edg,TopAbs_VERTEX);
1299     //  const TopoDS_Vertex& vtx = TopoDS::Vertex(exp2.Current());
1300     //  Standard_Real prm = BRep_Tool::Parameter(vtx,edg);
1301     Standard_Real f,l,prm;
1302     Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(edg,F,f,l);
1303     if (!Precision::IsNegativeInfinite(f) && 
1304       !Precision::IsPositiveInfinite(l)) {
1305         prm = (f+l)/2.;
1306     }
1307     else {
1308       if (Precision::IsNegativeInfinite(f) && 
1309         Precision::IsPositiveInfinite(l)){
1310           prm = 0.;
1311       }
1312       else if (Precision::IsNegativeInfinite(f)) {
1313         prm = l-1.;
1314       }
1315       else {
1316         prm = f+1.;
1317       }
1318     }
1319
1320     gp_Pnt2d pt2d(C2d->Value(prm));
1321     //  BRepClass_FaceClassifier classif(F,pt2d,Precision::PConfusion());
1322     //  return (classif.State() != TopAbs_OUT);
1323     BRepTopAdaptor_FClass2d classif(F,Precision::PConfusion());
1324     TopAbs_State stat = classif.Perform(pt2d);
1325     //  return (classif.Perform(pt2d) != TopAbs_OUT);
1326     if(stat == TopAbs_OUT) return Standard_False;
1327
1328     if(stat == TopAbs_ON) {
1329       Standard_Integer nbPnt =10;
1330       Standard_Integer nbOut =0,nbIn =0,nbOn=0;
1331       Standard_Integer j =1;
1332       for( ; j<= nbPnt ; j++)
1333       {
1334         //check neighbouring point
1335         //prm = .66 * prm + .34 * l;
1336         prm = f + (l-f)/nbPnt*(j-1);
1337         pt2d = C2d->Value(prm);
1338         stat = classif.Perform(pt2d);
1339         if(stat == TopAbs_OUT ) 
1340           nbOut++;
1341         else if(stat == TopAbs_IN)
1342           nbIn++;
1343         else
1344           nbOn++;
1345       }
1346       if(nbOut > nbIn + nbOn)
1347         return Standard_False;
1348     }
1349   }
1350   return Standard_True;
1351 }
1352
1353
1354 //=======================================================================
1355 //function : ChoixUV
1356 //purpose  : 
1357 //=======================================================================
1358
1359 static void ChoixUV(const TopoDS_Edge& Last,
1360                     const TopoDS_Face& F,
1361                     const TopTools_MapOfShape& Poss,
1362                     TopTools_MapIteratorOfMapOfShape& It,
1363                     gp_Pnt2d& plst,
1364                     gp_Vec2d& dlst,
1365                     const Standard_Real toll)
1366 {
1367
1368   Standard_Real f,l;
1369   gp_Pnt2d p2d;
1370   gp_Vec2d v2d;
1371   gp_Pnt aPCur, aPlst;
1372
1373   BRepAdaptor_Surface surf(F,Standard_False); // no restriction
1374   surf.D0 (plst.X(), plst.Y(), aPlst);
1375
1376   Standard_Real tol;
1377
1378   TopoDS_Vertex vtx;
1379
1380   gp_Dir2d ref2d(dlst);
1381
1382   Handle(Geom2d_Curve) C2d;
1383
1384   Standard_Integer index = 0, imin=0;
1385   Standard_Real  angmax = -M_PI, dist, ang;
1386
1387
1388   for (It.Initialize(Poss); It.More(); It.Next()) {
1389     index++;
1390     C2d = BRep_Tool::CurveOnSurface(TopoDS::Edge(It.Key()),F,f,l);
1391     if (It.Key().Orientation() == TopAbs_FORWARD) {
1392       //      p2d = C2d->Value(f);
1393       C2d->D1(f,p2d,v2d);
1394       vtx = TopExp::FirstVertex(TopoDS::Edge(It.Key()));
1395     }
1396     else {
1397       //      p2d = C2d->Value(l);
1398       C2d->D1(l,p2d,v2d);
1399       v2d.Reverse();
1400       vtx = TopExp::LastVertex(TopoDS::Edge(It.Key()));
1401     }
1402
1403     surf.D0 (p2d.X(), p2d.Y(), aPCur);
1404
1405     tol = BRep_Tool::Tolerance(vtx);
1406     tol = Max(toll, tol); tol *= tol;
1407
1408     dist = aPCur.SquareDistance(aPlst);
1409
1410     if (!Last.IsSame(It.Key())) {
1411       ang = ref2d.Angle(gp_Dir2d(v2d));
1412     }
1413     else {
1414       ang = -M_PI;
1415     }
1416
1417     //if ((dist < dmin - tol) ||
1418     //(dist <= dmin+tol && ang > angmax)) {
1419     if ((dist < tol)  && (ang > angmax)) {
1420       imin = index;
1421       //      dmin = dist;
1422       angmax = ang;
1423     }
1424   }
1425
1426   for (index = 1, It.Initialize(Poss); It.More(); It.Next()) {
1427     if (index == imin) {
1428       C2d = BRep_Tool::CurveOnSurface(TopoDS::Edge(It.Key()),F,f,l);
1429       if (It.Key().Orientation() == TopAbs_FORWARD) {
1430         //      plst = C2d->Value(l);
1431         C2d->D1(l,plst,dlst);
1432       }
1433       else {
1434         //      plst = C2d->Value(f);
1435         C2d->D1(f,plst,dlst);
1436         dlst.Reverse();
1437       }
1438       break;
1439     }
1440     index++;
1441   }
1442
1443 }
1444
1445 //=======================================================================
1446 //function : ChooseDirection
1447 //purpose  : 
1448 //=======================================================================
1449
1450 static TopoDS_Shape ChooseDirection(const TopoDS_Shape& RefDir,
1451                                     const TopoDS_Vertex& RefVertex,
1452                                     const TopoDS_Face& theFace,
1453                                     const TopTools_ListOfShape& Ldirs)
1454 {
1455   TopExp_Explorer Explo(RefDir, TopAbs_EDGE);
1456   TopoDS_Edge RefEdge;
1457   TopoDS_Vertex V1, V2;
1458   TopAbs_Orientation anOr;
1459   for (; Explo.More(); Explo.Next())
1460   {
1461     RefEdge = TopoDS::Edge(Explo.Current());
1462     TopExp::Vertices(RefEdge, V1, V2);
1463     if (V1.IsSame(RefVertex))
1464     {
1465       anOr = TopAbs_REVERSED;
1466       break;
1467     }
1468     else if (V2.IsSame(RefVertex))
1469     {
1470       anOr = TopAbs_FORWARD;
1471       break;
1472     }
1473   }
1474   
1475   Standard_Real RefFirst, RefLast;
1476   Handle(Geom2d_Curve) RefCurve = BRep_Tool::CurveOnSurface(RefEdge, theFace, RefFirst, RefLast);
1477   gp_Pnt2d RefPnt;
1478   gp_Vec2d RefVec;
1479
1480   //Standard_Real RefPar = (RefEdge.Orientation() == TopAbs_FORWARD)? RefLast : RefFirst;
1481   Standard_Real RefPar = (anOr == TopAbs_FORWARD)? RefLast : RefFirst;
1482   RefCurve->D1(RefPar, RefPnt, RefVec);
1483   if (anOr == TopAbs_FORWARD)
1484     RefVec.Reverse();
1485
1486   Handle(Geom2d_Curve) aCurve;
1487   Standard_Real aFirst, aLast, aPar;
1488   gp_Vec2d aVec;
1489   Standard_Real MinAngle = RealLast(), anAngle;
1490   TopoDS_Shape TargetDir;
1491   TopTools_ListIteratorOfListOfShape itl(Ldirs);
1492   for (; itl.More(); itl.Next())
1493   {
1494     const TopoDS_Shape& aShape = itl.Value();
1495     TopoDS_Edge anEdge;
1496     for (Explo.Init(aShape, TopAbs_EDGE); Explo.More(); Explo.Next())
1497     {
1498       anEdge = TopoDS::Edge(Explo.Current());
1499       TopExp::Vertices(anEdge, V1, V2);
1500       if (V1.IsSame(RefVertex))
1501       {
1502         anOr = TopAbs_FORWARD;
1503         break;
1504       }
1505       else if (V2.IsSame(RefVertex))
1506       {
1507         anOr = TopAbs_REVERSED;
1508         break;
1509       }
1510     }
1511     aCurve = BRep_Tool::CurveOnSurface(anEdge, theFace, aFirst, aLast);
1512     aPar = (anOr == TopAbs_FORWARD)? aFirst : aLast;
1513     aCurve->D1(aPar, RefPnt, aVec);
1514     if (anOr == TopAbs_REVERSED)
1515       aVec.Reverse();
1516     anAngle = aVec.Angle(RefVec);
1517     if (anAngle < 0.)
1518       anAngle += 2.*M_PI;
1519
1520     if (anAngle < MinAngle)
1521     {
1522       MinAngle = anAngle;
1523       TargetDir = aShape;
1524     }
1525   }
1526
1527   return TargetDir;
1528 }