0031007: Coding - eliminate warnings issued while compiling with -pedantic flag
[occt.git] / src / TopOpeBRepTool / TopOpeBRepTool_PURGE.cxx
1 // Created on: 1997-11-13
2 // Created by: Xuan PHAM PHU
3 // Copyright (c) 1997-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 #include <TopOpeBRepTool.hxx>
18 #include <TopOpeBRepTool_TOOL.hxx>
19 #include <TopOpeBRepTool_CORRISO.hxx>
20 #include <TopOpeBRepTool_C2DF.hxx>
21 #include <gp_Pnt2d.hxx>
22 #include <gp_Vec2d.hxx>
23 #include <GeomAdaptor_Surface.hxx>
24 #include <Geom2d_Curve.hxx>
25 #include <Geom2d_TrimmedCurve.hxx>
26 #include <Geom2d_Line.hxx>
27 #include <Geom_Surface.hxx>
28 #include <TopoDS.hxx>
29 #include <TopoDS_Wire.hxx>
30 #include <TopTools_Array1OfShape.hxx>
31
32 #include <BRep_Tool.hxx>
33 #include <Precision.hxx>
34 #include <TopExp.hxx>
35 #include <TopExp_Explorer.hxx>
36 #include <BRep_Builder.hxx>
37 #include <BRepAdaptor_Surface.hxx>
38 #include <TopOpeBRepTool_define.hxx>
39 #include <TopOpeBRepTool_EXPORT.hxx>
40 #include <TopOpeBRepTool_2d.hxx>
41 #include <Standard_Failure.hxx>
42 #include <TopOpeBRepTool_PURGE.hxx>
43
44 #ifdef OCCT_DEBUG
45 //Standard_EXPORT Standard_Integer STATIC_PURGE_iwi = 0;
46 //Standard_EXPORT TopTools_IndexedMapOfShape STATIC_PURGE_mapw, STATIC_PURGE_mapv;
47 //Standard_EXPORT TopTools_IndexedMapOfOrientedShape STATIC_PURGE_mapeds, STATIC_CORR_mapeds;
48
49 Standard_EXPORT void debcorrUV(){};
50 extern Standard_Boolean TopOpeBRepTool_GettracePURGE();
51 extern Standard_Boolean TopOpeBRepTool_GettraceCORRISO();
52 #endif
53 // DEB
54
55 #define SPLITEDGE (0)
56 #define INCREASE  (1)
57 #define DECREASE (-1)
58
59 #define M_FORWARD(sta)  (sta == TopAbs_FORWARD)
60 #define M_REVERSED(sta) (sta == TopAbs_REVERSED)
61 #define M_INTERNAL(sta) (sta == TopAbs_INTERNAL)
62 #define M_EXTERNAL(sta) (sta == TopAbs_EXTERNAL)
63
64 static void FUN_addtomap(TopTools_DataMapOfShapeListOfShape& map, const TopoDS_Shape& key, const TopoDS_Shape& item)
65 {
66   if (map.IsBound(key))               map.ChangeFind(key).Append(item);
67   else {TopTools_ListOfShape los; los.Append(item); map.Bind(key,los);}
68 }
69
70 static Standard_Boolean FUN_getv(const TopAbs_Orientation& orivine, const TopoDS_Shape& e, TopoDS_Shape& v)
71 {
72   v.Nullify();
73   // gets <v> oriented <orivine> in <e>
74   TopAbs_Orientation oe = e.Orientation();
75   Standard_Boolean isnonO = M_INTERNAL(oe) || M_EXTERNAL(oe);
76   TopoDS_Shape eO;
77   if (isnonO) {
78     eO = e.Oriented(TopAbs_FORWARD);
79   }
80   else {
81     eO = e;
82   }
83   TopExp_Explorer exv(eO, TopAbs_VERTEX);
84   for (; exv.More(); exv.Next()) {      
85     const TopoDS_Shape& vcur = exv.Current();
86     if (vcur.Orientation() == orivine) {v = vcur; return Standard_True;}    
87   } // exv
88   return Standard_False;
89 }
90
91 Standard_EXPORT Standard_Boolean FUN_tool_ClosedW(const TopoDS_Wire& W)
92 {
93   // !! an edge oriented INTERNAL/EXTERNAL has all its vertices
94   // oriented INTERNAL/EXTERNAL.
95
96   // <mapvedsO> = {(v,loe)} / e is oriented :
97   // <mapvedsO> = {(v,loe)} / e is not oriented (INTERNAL/EXTERNAL) :
98   TopTools_DataMapOfShapeListOfShape mapvFine,mapvRine, mapvIine;
99
100   TopExp_Explorer exe(W, TopAbs_EDGE);
101   for (; exe.More(); exe.Next()){
102     const TopoDS_Shape& e = exe.Current();
103     TopAbs_Orientation oe = e.Orientation();
104     Standard_Boolean isnonO = M_INTERNAL(oe) || M_EXTERNAL(oe);
105     TopoDS_Shape eO;
106     if (isnonO) {
107       eO = e.Oriented(TopAbs_FORWARD);
108     }
109     else {
110       eO = e;
111     }
112
113     TopExp_Explorer exv(eO, TopAbs_VERTEX); 
114     for (; exv.More(); exv.Next()) {    
115       const TopoDS_Shape& v = exv.Current();
116       TopAbs_Orientation oriv = v.Orientation();
117       if (M_FORWARD(oriv))  FUN_addtomap(mapvFine,v,e);
118       if (M_REVERSED(oriv)) FUN_addtomap(mapvRine,v,e);
119       if (M_INTERNAL(oriv)) FUN_addtomap(mapvIine,v,e);
120     }      
121   }
122
123   if (mapvFine.Extent() == 0) return Standard_False;   // empty wire  
124
125   TopTools_MapOfShape mapvok;    
126   // a vertex is found valid if is - an internal vertex
127   //                               - found FORWARD and REVERSED. 
128   TopTools_MapOfShape mapvonlyFine; // {(v,e)} v F in e, v belongs to only one e
129   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itvFine(mapvFine);
130   for (; itvFine.More(); itvFine.Next()){
131     const TopoDS_Shape& vFine = itvFine.Key();
132     Standard_Boolean vIine = mapvIine.IsBound(vFine);
133     if (vIine) {mapvok.Add(vFine); continue;}
134     Standard_Boolean vRine = mapvRine.IsBound(vFine);
135     if (vRine) {mapvok.Add(vFine); continue;}
136     mapvonlyFine.Add(vFine);
137   }  
138   // <mapvRinonee> = {(v,e)} v R in e, v belongs to only one e
139   TopTools_MapOfShape mapvonlyRine; 
140   TopTools_DataMapIteratorOfDataMapOfShapeListOfShape itvRine(mapvRine);
141   for (; itvRine.More(); itvRine.Next()){
142     const TopoDS_Shape& vRine = itvRine.Key();
143     Standard_Boolean vok = mapvok.Contains(vRine);
144     if (vok) continue;
145     Standard_Boolean vIine = mapvIine.IsBound(vRine);
146     if (vIine) {mapvok.Add(vRine); continue;}    
147     mapvonlyRine.Add(vRine);
148   }
149   
150   // checking vertices <mapvonlyFine> and <mapvonlyRine>
151   TopTools_MapIteratorOfMapOfShape itvonlyFRine;
152   Standard_Integer nmap = 0;
153   while (nmap <= 2) {
154     nmap++;
155     Standard_Boolean vFine = (nmap == 1);
156     if (vFine) itvonlyFRine.Initialize(mapvonlyFine);
157     else       itvonlyFRine.Initialize(mapvonlyRine);
158
159     for (; itvonlyFRine.More(); itvonlyFRine.Next()){
160       const TopoDS_Shape& vtocheck = itvonlyFRine.Key();
161       TopTools_ListOfShape edsvFRine;
162       if (vFine) edsvFRine = mapvFine.Find(vtocheck);
163       else       edsvFRine = mapvRine.Find(vtocheck);
164        
165       if (edsvFRine.Extent() > 1) return Standard_False; // faulty wire
166       const TopoDS_Shape& e = edsvFRine.First();
167
168       TopAbs_Orientation ovori = vFine? TopAbs_REVERSED: TopAbs_FORWARD;
169       TopoDS_Shape ov; Standard_Boolean ovfound = FUN_getv(ovori,e,ov);
170       if (!ovfound) return Standard_False; // faulty edge
171
172       // <vtocheck> is on only one edge <e>,
173       // <vtocheck> is FORWARD/REVERSED in <e>,
174       // <ovfound> is REVERSED/FORWARD in <e>.
175       // <vtocheck> is ok if : - <ovfound> is INTERNAL in another edge
176       //                       - <ovfound> is FORWARD and REVERSED in 
177       //                         one or two other edges.
178       //                      and e is not oriented
179       TopAbs_Orientation oe = e.Orientation();
180       if (M_FORWARD(oe) || M_REVERSED(oe)) return Standard_False;
181       if (!mapvok.Contains(ov)) return Standard_False;
182
183       Standard_Boolean ovIine = mapvIine.IsBound(ov); if (ovIine)  continue;
184       Standard_Boolean ovFine = mapvRine.IsBound(ov); if (!ovFine) return Standard_False;
185       Standard_Boolean ovRine = mapvRine.IsBound(ov); if (!ovRine) return Standard_False;
186     
187       const TopTools_ListOfShape& edsovFine = mapvFine.Find(ov);
188       const TopTools_ListOfShape& edsovRine = mapvRine.Find(ov);
189       if (edsovFine.Extent() > 1) continue;
190       if (edsovRine.Extent() > 1) continue;
191       if (edsovFine.First().IsEqual(e)) return Standard_False;
192       if (edsovRine.First().IsEqual(e)) return Standard_False;
193     }
194   } // nmap
195   return Standard_True; 
196 }
197
198 //=======================================================================
199 //function : PurgeClosingEdges
200 //purpose  : 
201 //=======================================================================
202
203 Standard_Boolean TopOpeBRepTool::PurgeClosingEdges(const TopoDS_Face& Fin, const TopoDS_Face& FF, 
204 //                                    const TopTools_DataMapOfShapeInteger& MWisOld,
205                                       const TopTools_DataMapOfShapeInteger& ,
206                                       TopTools_IndexedMapOfOrientedShape& MshNOK)
207 {
208   // Fin is the original face
209   // FF  is the splitted face
210
211   // prequesitory : splitted edges, of edge ancestor a closing edge
212   //                keep in memory the geometry of the ancestor edge,
213   //                they answer True to BRep_Tool::IsClosed.
214   // elsewhere : we have to get this information using geometric 
215   //             criteriums (TopOpeBRepTool_TOOL::IsonCLO)
216
217 #ifdef OCCT_DEBUG
218   Standard_Boolean trc =  TopOpeBRepTool_GettracePURGE();
219   if (trc) std::cout<<"\n* PurgeClosingEdges:\n\n";
220 #endif
221   TopOpeBRepTool_CORRISO CORRISO(Fin);  
222   Standard_Real tolF = BRep_Tool::Tolerance(Fin);
223   Standard_Real uperiod; Standard_Boolean uclosed = CORRISO.Refclosed(1,uperiod);
224   Standard_Real vperiod; Standard_Boolean vclosed = CORRISO.Refclosed(2,vperiod);
225   if (!uclosed && !vclosed) return Standard_False;
226   Standard_Boolean inU = uclosed ? Standard_True : Standard_False;  
227   Standard_Real xmin = inU ? (CORRISO.GASref().FirstUParameter()) :
228                              (CORRISO.GASref().FirstVParameter());
229   Standard_Real xper = inU ? uperiod : vperiod;
230   Standard_Real tolx = inU ? (CORRISO.Tol(1,tolF)) : (CORRISO.Tol(2,tolF));
231
232   TopExp_Explorer exw(FF, TopAbs_WIRE);
233   for (; exw.More(); exw.Next()){
234     const TopoDS_Shape& W = exw.Current();
235
236     CORRISO.Init(W);
237     Standard_Boolean ok = CORRISO.UVClosed();
238     if (ok) continue;
239
240     TopTools_ListOfShape cEds; 
241     TopTools_ListIteratorOfListOfShape ite(CORRISO.Eds());
242     for (; ite.More(); ite.Next()){
243       const TopoDS_Edge& E = TopoDS::Edge(ite.Value());
244       Standard_Boolean closing = BRep_Tool::IsClosed(E,Fin); 
245       if (!closing) {// xpu231198 : pcurve modified, the information is lost
246         TopOpeBRepTool_C2DF C2DF; Standard_Boolean isb = CORRISO.UVRep(E,C2DF);
247         if (!isb) return Standard_False;//NYIRAISE
248         Standard_Boolean onclo = TopOpeBRepTool_TOOL::IsonCLO(C2DF,inU,xmin,xper,tolx);
249         if (onclo) closing=Standard_True;
250       }
251       if (closing) cEds.Append(E);
252     }          
253     Standard_Integer ncE = cEds.Extent();
254     Standard_Boolean nopurge = (ncE <= 1);
255     if (nopurge) return Standard_True;
256     
257     // Checking <W>
258     TopTools_ListOfShape fyEds; Standard_Boolean topurge = CORRISO.PurgeFyClosingE(cEds,fyEds);
259     if (topurge) {
260       TopTools_ListIteratorOfListOfShape it(fyEds);
261       for (; it.More(); it.Next()) MshNOK.Add(it.Value()); 
262       MshNOK.Add(W); 
263       MshNOK.Add(FF);
264     }
265     
266 #ifdef OCCT_DEBUG
267     if (trc && topurge) std::cout<<"found FAULTY edge = ed"<<std::endl;
268 #endif
269   } // exw
270   return Standard_True;
271 }
272
273 //=======================================================================
274 //function : PurgeClosingEdges
275 //purpose  : 
276 //=======================================================================
277
278 Standard_Boolean TopOpeBRepTool::PurgeClosingEdges(const TopoDS_Face& Fin, const TopTools_ListOfShape& LOF, 
279                                       const TopTools_DataMapOfShapeInteger& MWisOld,
280                                       TopTools_IndexedMapOfOrientedShape& MshNOK)
281 {  
282   Standard_Boolean uvclosed = FUN_tool_closedS(Fin);
283   if (!uvclosed) return Standard_True;
284   
285   TopTools_ListIteratorOfListOfShape it(LOF);
286   for (; it.More(); it.Next()){
287     const TopoDS_Face& FF = TopoDS::Face(it.Value());
288     Standard_Boolean ok = TopOpeBRepTool::PurgeClosingEdges(Fin,FF,MWisOld,MshNOK);
289     if (!ok) return Standard_False;    
290   }
291   return Standard_True;
292 }
293
294 /*static Standard_Boolean FUN_correctClosingE(TopoDS_Edge& newfE, TopoDS_Face& Fsp)
295 {    
296   Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = FUNTOOLC2D_CurveOnSurface(newfE,Fsp,f,l,tol);
297   gp_Dir2d d2d; gp_Pnt2d O2d; Standard_Boolean isuiso,isviso; 
298   Standard_Boolean uviso = FUN_tool_IsUViso(PC,isuiso,isviso,d2d,O2d);
299   if (!uviso) return Standard_False;
300
301   Standard_Real period = 2*M_PI;
302   Standard_Real piso = isuiso? O2d.X(): O2d.Y();
303   Standard_Real tol2d = 1.e-6;
304   Standard_Boolean is0   = Abs(piso) < tol2d;
305   Standard_Boolean is2PI = Abs(period-piso) < tol2d;
306   // --------------------------------------------------
307   //  prequesitory :  Closed Surfaces have period 2PI
308   if (!is0 && !is2PI) return Standard_False;
309   // -------------------------------------------------- 
310   Standard_Real factor = is0? period: -period;
311   gp_Vec2d transl(1.,0.); if (isviso) transl = gp_Vec2d(0.,1.);
312   transl.Multiply(factor);
313   
314   Standard_Integer ok = FUN_tool_translate(transl,Fsp,newfE);
315   return Standard_True;   
316 }
317
318 static Standard_Boolean FUN_correctDegeneratedE
319 (const TopTools_IndexedDataMapOfShapeListOfShape& mve,TopoDS_Edge& Ein,TopoDS_Face& Fsp)
320 {
321   TopoDS_Vertex v1,v2; TopExp::Vertices(Ein,v1,v2);
322   TopAbs_Orientation ov1 = v1.Orientation();
323   TopAbs_Orientation ov2 = v2.Orientation();
324   Standard_Boolean ok1 = mve.Contains(v1); if (!ok1) return Standard_False;
325   Standard_Boolean ok2 = mve.Contains(v2); if (!ok2) return Standard_False;
326
327   const TopTools_ListOfShape& le= mve.FindFromKey(v1);
328
329   TopoDS_Edge e1,e2; Standard_Boolean fe1 = Standard_False; Standard_Boolean fe2 = Standard_False;
330   TopoDS_Vertex vfe1,vfe2;
331   Standard_Boolean fEin = Standard_False;
332   for(TopTools_ListIteratorOfListOfShape itle(le);itle.More();itle.Next()) {
333     const TopoDS_Shape& ecx = TopoDS::Edge(itle.Value());
334     if (ecx.IsEqual(Ein)) {
335       fEin = Standard_True;
336     }
337     else {
338       TopExp_Explorer exv;
339       for (exv.Init(ecx,TopAbs_VERTEX);exv.More();exv.Next()) {
340 //      for (TopExp_Explorer exv(ecx,TopAbs_VERTEX);exv.More();exv.Next()) {
341         const TopoDS_Vertex& vecx = TopoDS::Vertex(exv.Current());
342         Standard_Boolean issam = vecx.IsSame(v1);
343         if (issam) { 
344           Standard_Boolean iseq1 = vecx.IsEqual(v1);
345           Standard_Boolean iseq2 = vecx.IsEqual(v2);
346           if (!iseq1) {
347             e1 = TopoDS::Edge(ecx);
348             vfe1 = TopoDS::Vertex(vecx); 
349             fe1 = Standard_True;
350           }
351           if (!iseq2) {
352             e2 = TopoDS::Edge(ecx);
353             vfe2 = TopoDS::Vertex(vecx); 
354             fe2 = Standard_True;
355           }
356         }
357         if (fe1 && fe2) break;
358       }
359       if (fe1 && fe2) break;
360     }
361     if (fEin && fe1 && fe2) break;
362   } // itle.More()
363
364   Standard_Boolean ok = (fEin && fe1 && fe2);
365   if (!ok) return Standard_False;
366   
367 #ifdef OCCT_DEBUG
368   debcorrUV(); // call Draw_Call("av2d;dy fyf;fit;ppcu fyf")
369 #endif
370
371   Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = FUNTOOLC2D_CurveOnSurface(Ein,Fsp,f,l,tol);
372   gp_Dir2d d2d; gp_Pnt2d O2d; Standard_Boolean isuiso = 0,isviso = 0; 
373   Standard_Boolean uviso = FUN_tool_IsUViso(PC,isuiso,isviso,d2d,O2d);
374   if (!uviso) return Standard_False;
375
376   Standard_Real pfEin,plEin,tolEin; Handle(Geom2d_Curve) PCEin = FUNTOOLC2D_CurveOnSurface(Ein,Fsp,pfEin,plEin,tolEin); 
377   if (PCEin.IsNull()) throw Standard_Failure(" FUN_correctDegeneratedE : no 2d curve Ein");
378   Standard_Real pf1,pl1,tol1; Handle(Geom2d_Curve) PC1 = FUNTOOLC2D_CurveOnSurface(e1,Fsp,pf1,pl1,tol1); 
379   if (PC1.IsNull()) throw Standard_Failure(" FUN_correctDegeneratedE : no 2d curve e1");
380   Standard_Real pf2,pl2,tol2; Handle(Geom2d_Curve) PC2 = FUNTOOLC2D_CurveOnSurface(e2,Fsp,pf2,pl2,tol2); 
381   if (PC2.IsNull()) throw Standard_Failure(" FUN_correctDegeneratedE : no 2d curve e2");
382   
383   Standard_Real parv1 = BRep_Tool::Parameter(v1,Ein,Fsp);
384   Standard_Real parv2 = BRep_Tool::Parameter(v2,Ein,Fsp);
385   gp_Pnt2d  pv1; PCEin->D0(parv1,pv1);
386   gp_Pnt2d  pv2; PCEin->D0(parv2,pv2);
387
388   Standard_Real par1 = BRep_Tool::Parameter(vfe1,e1,Fsp);
389   Standard_Real par2 = BRep_Tool::Parameter(vfe2,e2,Fsp);
390   gp_Pnt2d  p1; PC1->D0(par1,p1);
391   gp_Pnt2d  p2; PC2->D0(par2,p2);
392
393   Standard_Real cv1 = (isuiso) ? pv1.Y() : pv1.X();
394   Standard_Real cv2 = (isuiso) ? pv2.Y() : pv2.X();
395   Standard_Real c1 = (isuiso) ? p1.Y() : p1.X();
396   Standard_Real c2 = (isuiso) ? p2.Y() : p2.X();
397
398   Standard_Real d1 = (c1 - cv1);
399   Standard_Real d2 = (c2 - cv2);
400   Standard_Real adc = Abs(c1 - c2);
401   Standard_Real adcv = Abs(cv1 - cv2);
402
403   Standard_Real tol2d = 1.e-6;
404   Standard_Boolean mmd = (Abs(adc-adcv) < tol2d);
405   if (mmd) { // correction de CTS20973
406     gp_Vec2d transl(0.,1.); if (isviso) transl = gp_Vec2d(1.,0.);
407     transl.Multiply(d1); // ou d2
408     ok = FUN_tool_translate(transl,Fsp,Ein);
409   }
410   else {
411     // redefinition des parametres de v1,v2 de Ein tels que des parametres de 
412 #ifdef OCCT_DEBUG
413     if (TopOpeBRepTool_GettraceCORRISO()) {
414       std::cout<<"FUN_correctDegeneratedE : !mmd NYI"<<std::endl;
415     }
416 #endif
417     ok = Standard_False;
418   }
419   
420   return ok;   
421 } //FUN_correctDegeneratedE*/
422
423 /*static Standard_Boolean FUN_tool_reguUV(const TopoDS_Face& FF, TopoDS_Face& fF)
424 {  
425
426   const TopoDS_Face& F = TopoDS::Face(FF);
427   Standard_Boolean uclosed,vclosed; Standard_Real uperiod,vperiod;
428   Standard_Boolean closed = FUN_tool_closedS(F,uclosed,uperiod,vclosed,vperiod);
429   if (!closed) return Standard_False;    
430   Standard_Real tolu,tolv; FUN_tool_tolUV(TopoDS::Face(fF),tolu,tolv);
431
432   TopTools_ListOfShape leko;
433   // --------
434   TopTools_IndexedMapOfOrientedShape mape;
435   TopExp_Explorer ex(fF, TopAbs_EDGE);
436   for (; ex.More(); ex.Next()){
437     const TopoDS_Edge& ee = TopoDS::Edge(ex.Current());
438     TopAbs_Orientation oee = ee.Orientation();
439     TopAbs_Orientation oe = TopAbs::Complement(oee);
440     TopoDS_Edge e = TopoDS::Edge(ee.Oriented(oe));
441     Standard_Boolean hasoppo = mape.Contains(e); // e with complement ori was added to mape
442     if (hasoppo) {
443       // ee :
444       Standard_Real ff,ll; Handle(Geom2d_Curve) PCee = BRep_Tool::CurveOnSurface(ee,F,ff,ll);
445       Standard_Boolean uisoee,visoee; gp_Dir2d d2dee; gp_Pnt2d O2dee; 
446       Standard_Boolean uvisoee = FUN_tool_IsUViso(PCee,uisoee,visoee,d2dee,O2dee);
447       // e :
448       Standard_Real f,l; Handle(Geom2d_Curve) PCe = BRep_Tool::CurveOnSurface(e,F,f,l);
449       Standard_Boolean uisoe,visoe; gp_Dir2d d2de; gp_Pnt2d O2de; 
450       Standard_Boolean uvisoe = FUN_tool_IsUViso(PCe,uisoe,visoe,d2de,O2de);
451
452       // isfaulty :
453       Standard_Boolean isfaulty = Standard_False;
454       Standard_Real dd = O2dee.Distance(O2de);
455       if (uisoee && uisoe) isfaulty = (dd < tolu);
456       if (visoee && visoe) isfaulty = (dd < tolv);
457
458       if (isfaulty) leko.Append(ee);
459     }
460     else mape.Add(ee);
461   }
462   
463   Standard_Integer nko = leko.Extent();
464   if (nko != 1) return Standard_False;
465
466   // eko = edge with faulty pcurve :
467   const TopoDS_Shape& eko = leko.First();
468   TopAbs_Orientation oeko = eko.Orientation();
469   TopTools_ListOfShape edges; ex.Init(fF, TopAbs_EDGE);
470   for (; ex.More(); ex.Next()){
471     const TopoDS_Shape& ee = ex.Current();
472     if (!ee.IsSame(eko)) edges.Append(ee);
473   }    
474   // fe = edge with vfe = vertex(ivfe) not uv-connexed :
475   TopoDS_Shape fe; Standard_Integer ivfe=0; 
476   Standard_Boolean det = ::FUN_DetectEdgewithfaultyUV(FF,fF,edges,Standard_False,fe,ivfe);
477   if (!det) return Standard_False;
478
479   TopTools_Array1OfShape Vfe(1,2); FUN_Vertices(TopoDS::Edge(fe),Vfe); 
480   TopAbs_Orientation ofe = fe.Orientation(); 
481   const TopoDS_Vertex& vfe = TopoDS::Vertex(Vfe(ivfe));
482   Standard_Real parfe = BRep_Tool::Parameter(vfe,TopoDS::Edge(fe));
483   gp_Pnt2d uvfe; Standard_Boolean ok = FUN_tool_paronEF(TopoDS::Edge(fe),parfe,F,uvfe);
484   if (!ok) return Standard_False;
485   // ivconnex :
486   Standard_Integer ivconnex = (ivfe == 1) ? 2 : 1;
487 //  if (ofe == TopAbs_REVERSED) ivconnex = (ivconnex == 1) ? 2 : 1;
488   
489   // vertex(ivconnex) of eko FORWARD
490   TopoDS_Edge ekoFOR = TopoDS::Edge(eko.Oriented(TopAbs_FORWARD));
491   TopTools_Array1OfShape Veko(1,2); FUN_Vertices(TopoDS::Edge(ekoFOR),Veko);  
492   const TopoDS_Vertex& veko1 = TopoDS::Vertex(Veko(1));
493   const TopoDS_Vertex& veko2 = TopoDS::Vertex(Veko(2));
494   Standard_Integer iveko = 0;
495   if (veko1.IsSame(vfe)) iveko = 1;
496   if (veko2.IsSame(vfe)) iveko = 2;
497   if (iveko == 0) return Standard_False;
498
499   // ett : edge same eko with pcurve to translate
500   // isekoFOR=true : vfe should be connexed to vertex(ivconnex) of ekoFOR
501   Standard_Boolean isekoFOR = (iveko == ivconnex); 
502   TopAbs_Orientation oett = isekoFOR ? TopAbs_FORWARD : TopAbs_REVERSED; 
503   TopoDS_Edge ett = TopoDS::Edge(eko.Oriented(oett));
504   const TopoDS_Vertex& vtt = TopoDS::Vertex(Veko(iveko));
505
506   Standard_Real parett = BRep_Tool::Parameter(vtt,ett);
507   gp_Pnt2d uvtt; ok = FUN_tool_paronEF(ett,parett,F,uvtt);
508   if (!ok) return Standard_False;
509   
510   Standard_Real du = uvfe.X()-uvtt.X(); 
511   Standard_Real dv = uvfe.Y()-uvtt.Y(); 
512   Standard_Boolean tru=Standard_False, trv=Standard_False;
513   if (uclosed) tru = (Abs(Abs(du)-uperiod) < tolu);
514   if (vclosed) trv = (Abs(Abs(dv)-vperiod) < tolv);
515   if (!tru && !trv) return Standard_False;
516
517   gp_Vec2d tt;
518   if (tru) tt = gp_Vec2d(du,0.);
519   if (trv) tt = gp_Vec2d(0.,dv);
520   Standard_Real f,l; Handle(Geom2d_Curve) PC1 = BRep_Tool::CurveOnSurface(ett,F,f,l);
521   Standard_Boolean uisoett,visoett; gp_Dir2d d2dett; gp_Pnt2d o2dett; 
522   Standard_Boolean uvisoett = FUN_tool_IsUViso(PC1,uisoett,visoett,d2dett,o2dett);o2dett.Translate(tt);
523   Handle(Geom2d_Line) L2d = new Geom2d_Line(o2dett,d2dett);
524   Handle(Geom2d_TrimmedCurve) PC2 = new Geom2d_TrimmedCurve(L2d,f,l);
525
526   BRep_Builder BB;
527   Standard_Real toltt = BRep_Tool::Tolerance(ett);
528 //  BB.UpdateEdge(TopoDS::Edge(ett),PC2,PC1,fF,toltt);
529   // xpu220998 : cto cylcong A1
530   Handle(Geom2d_Curve) nullc2d;
531   BB.UpdateEdge(TopoDS::Edge(ekoFOR),nullc2d,nullc2d,fF,toltt); // clear
532   if (isekoFOR) BB.UpdateEdge(TopoDS::Edge(ekoFOR),PC2,PC1,fF,toltt);
533   else          BB.UpdateEdge(TopoDS::Edge(ekoFOR),PC1,PC2,fF,toltt);
534
535   return Standard_True;
536 }*/
537
538 static Standard_Boolean FUN_connexX(const Standard_Boolean onU, TopOpeBRepTool_CORRISO& CORRISO, 
539                        const TopTools_ListOfShape& EdstoCheck, TopTools_DataMapOfOrientedShapeInteger& fyEds)
540 // purpose : Fref is x-periodic, 
541 //           <fyEds>={(fye,recadre)}, recadre = INCREASE,DECREASE
542 //                                    fye has its 2 bounds faulty
543 {
544   fyEds.Clear();
545   Standard_Real tolF = BRep_Tool::Tolerance(CORRISO.Fref());
546   Standard_Integer Index = onU ? 1 : 2;
547   Standard_Real xperiod; Standard_Boolean xclosed = CORRISO.Refclosed(Index,xperiod);
548   if (!xclosed) return Standard_False;
549   Standard_Real xtol = CORRISO.Tol(Index,tolF);
550   
551   // fy has its 2 uvbounds non-connexed       
552   //nyixpu300998 : iterative (while ko) + map of "static" edges
553   TopoDS_Shape fy; Standard_Integer Ify=0; Standard_Boolean hasfy = CORRISO.EdgeWithFaultyUV(EdstoCheck,2,fy,Ify); 
554   if (!hasfy) return Standard_False;
555   TopOpeBRepTool_C2DF C2DF; Standard_Boolean isb = CORRISO.UVRep(TopoDS::Edge(fy),C2DF);
556   if (!isb) return Standard_False; // NYIRAISE
557
558   TopTools_Array1OfShape vfy(1,2); TopOpeBRepTool_TOOL::Vertices(TopoDS::Edge(fy),vfy);
559   for (Standard_Integer ii = 1; ii <=2; ii++) {
560     // vff = vertex[ii] of fy
561     const TopoDS_Vertex& vff = TopoDS::Vertex(vfy(ii));
562     Standard_Real parvff = TopOpeBRepTool_TOOL::ParE(ii,TopoDS::Edge(fy));gp_Pnt2d uvff = TopOpeBRepTool_TOOL::UVF(parvff,C2DF);
563     // loe list of edges connexed to faultE
564     TopTools_ListOfShape loe; isb = CORRISO.Connexity(vff,loe);
565     if (!isb) return Standard_False; // FUNRAISE
566
567     TopTools_ListIteratorOfListOfShape ite(loe); // iteration on connex edges of vff
568     for (; ite.More(); ite.Next()){
569       const TopoDS_Edge& ee = TopoDS::Edge(ite.Value());
570       TopTools_Array1OfShape vee(1,2); TopOpeBRepTool_TOOL::Vertices(ee,vee);
571       for (Standard_Integer ive = 1; ive <=2; ive++) {    
572         // ve = vertex[ive] of ee
573         const TopoDS_Vertex& ve = TopoDS::Vertex(vee(ive));       
574         Standard_Boolean samev = ve.IsSame(vff);
575         if (!samev) continue;   
576         if (ive == ii) continue;
577         TopOpeBRepTool_C2DF C2DFe; isb = CORRISO.UVRep(ee,C2DFe);
578         if (!isb) return Standard_False; // FUNRAISE
579         Standard_Real paree = TopOpeBRepTool_TOOL::ParE(ive,ee); gp_Pnt2d uve = TopOpeBRepTool_TOOL::UVF(paree,C2DFe);  
580         
581         // xxtrsl :
582         Standard_Real dxx = onU ? uve.X()-uvff.X() : uve.Y()-uvff.Y();
583         Standard_Boolean isper =( Abs(xperiod-Abs(dxx)) < xtol);
584         if (!isper) continue;
585         
586         Standard_Integer recadre = (dxx > 0) ? INCREASE : DECREASE; 
587         fyEds.Bind(fy,recadre);
588       } //ive=1..2
589     }//ite(loe)
590   }//ii=1..2    
591   return !fyEds.IsEmpty();
592 } // FUN_connexX
593  
594 //=======================================================================
595 //function : CorrectONUVISO
596 //purpose  :  
597 //=======================================================================
598
599 Standard_Boolean TopOpeBRepTool::CorrectONUVISO(const TopoDS_Face& Fin, TopoDS_Face& Fsp)
600 // <Fref> is x-periodic 
601 {
602 #ifdef OCCT_DEBUG
603   Standard_Boolean trc = TopOpeBRepTool_GettraceCORRISO();
604   if (trc) std::cout<<"\n####    CorrectONUVISO    ####\n\n";
605   debcorrUV();
606 #endif
607
608   Standard_Real tolF = BRep_Tool::Tolerance(Fin);
609
610   TopOpeBRepTool_CORRISO CORRISO(Fin);
611   Standard_Real uperiod,vperiod;
612   Standard_Boolean uclosed = CORRISO.Refclosed(1,uperiod);
613   Standard_Boolean vclosed = CORRISO.Refclosed(2,vperiod);
614   if (!uclosed && !vclosed) return Standard_False;
615   
616   CORRISO.Init(Fsp);
617   Standard_Boolean ok = CORRISO.UVClosed();
618   if (ok) return Standard_True; // Fsp is valid
619
620   // 1. We check connexity among all edges of <Fsp>
621   // if we find on edge with 2 faulty UVbounds, we try to UVconnect it.
622 //  for (Standard_Integer i=1; i<=2; i++) {
623   Standard_Integer i ;
624   for ( i=1; i<=2; i++) {
625     Standard_Boolean onU = (i==1) ? Standard_True : Standard_False; 
626     const TopTools_ListOfShape& Tocheck = CORRISO.Eds();
627     TopTools_DataMapOfOrientedShapeInteger fyEds; ok =::FUN_connexX(onU,CORRISO,Tocheck,fyEds);
628     if (!ok) continue;
629     ok = CORRISO.TrslUV(onU,fyEds);
630     if (!ok) continue;
631     ok = CORRISO.UVClosed();
632     if (!ok) continue;
633     ok = CORRISO.GetnewS(Fsp);
634     if (!ok) return Standard_False; //NYIRAISE
635     return Standard_True;
636   }
637
638   // 2. x-2drep(edges) are in [xfirst,xfirst+xperiod]
639   for (i = 1; i <=2; i++) {
640     Standard_Boolean onU = (i==1);     
641     Standard_Real xper=0.; Standard_Boolean xclosed = CORRISO.Refclosed(i,xper);
642     if (!xclosed) continue;
643     Standard_Real tolx = CORRISO.Tol(i,tolF);
644     tolx *= 1.e2; // BUC60380
645     TopTools_DataMapOfOrientedShapeInteger FyEds; Standard_Boolean hasfy = CORRISO.EdgesOUTofBoundsUV(CORRISO.Eds(),onU,tolx,FyEds);
646     if (!hasfy) continue;
647     ok = CORRISO.TrslUV(onU,FyEds);
648     if (!ok) return Standard_False;
649     ok = CORRISO.UVClosed();
650     if (!ok) continue;
651     ok = CORRISO.GetnewS(Fsp);
652     if (!ok) return Standard_False; //NYIRAISE
653     return Standard_True;
654   }
655   return Standard_False;
656
657   /*// xpu310898 : eC closing ff, ff sdm F(reference face), proj(eC,F) gives ee with
658   //             !closing(ee,Fsp) -> 2drep(Fsp) is not closed.
659   //             purpose : translate pceCFOR or pceCREV
660   //   cto902B7 (ff=f7,eC=e9,F=f14)
661   ok = ::FUN_tool_reguUV(Fin,Fsp);*/
662
663   /*// JYL 980909 : reecriture complete
664   // 1/ traitement de TOUTES les aretes
665   //    isou et isov fautives (et non la premiere trouvee);
666   // 2/ traitement des aretes degenerees fautives : CTS20973
667
668   TopTools_ListOfShape lisoe,ldege;
669   TopExp_Explorer exe(Fsp, TopAbs_EDGE);
670   for (; exe.More(); exe.Next()){
671     const TopoDS_Edge& E = TopoDS::Edge(exe.Current());
672     Standard_Boolean degen = BRep_Tool::Degenerated(E);
673     if ( degen ) {
674       ldege.Append(E);
675     }
676     else {
677       Standard_Real f,l; Handle(Geom2d_Curve) PC = BRep_Tool::CurveOnSurface(E,Fin,f,l);
678       Standard_Boolean uiso,viso; gp_Dir2d d2d; gp_Pnt2d O2d; 
679       Standard_Boolean uviso = FUN_tool_IsUViso(PC,uiso,viso,d2d,O2d);
680       Standard_Boolean onclosing = (uiso && uclosed) || (viso && vclosed);
681       if      ( onclosing) {
682         lisoe.Append(E);
683       }
684     }
685   }
686   
687   Standard_Integer nisoe = lisoe.Extent();
688   Standard_Integer ndege = ldege.Extent();
689   if (nisoe ==0 && ndege == 0) return Standard_False;
690
691   Standard_Integer tmpisoe;
692   Standard_Integer tmpdege;
693
694   TopTools_ListOfShape lfyisoe; Standard_Boolean tocorrectisoe = Standard_False;
695   tocorrectisoe = FUN_DetectEdgeswithfaultyUV(Fsp,Fsp,lisoe,Standard_True,lfyisoe,tmpisoe);
696
697   TopTools_ListOfShape lfydege; Standard_Boolean tocorrectdege = Standard_False;
698   tocorrectdege = FUN_DetectEdgeswithfaultyUV(Fsp,Fsp,ldege,Standard_True,lfydege,tmpdege);
699
700   tocorrect = (tocorrectisoe || tocorrectdege);
701   if (!tocorrect) {
702     return Standard_True;
703   }
704   
705 #ifdef OCCT_DEBUG
706   if (trc) {
707     std::cout<<"CorrectONUVISO ";
708     std::cout<<"iso faulty "<<tocorrectisoe<<" deg faulty "<<tocorrectdege<<std::endl;
709   }
710   debcorrUV();
711 #endif
712   
713   if (tocorrectisoe) {
714     for (TopTools_ListIteratorOfListOfShape itiso(lfyisoe);itiso.More();itiso.Next()) {
715       TopoDS_Edge& fyisoe = TopoDS::Edge(itiso.Value());
716       
717       // !! if the faulty edge ON closing appears twice in <Eds>, NOTHING is done!
718       // -> see processing ::PurgeClosingEdges later called in WESMakeFaces    
719       Standard_Integer nfoundisoe = 0;
720       for (exe.Init(Fsp, TopAbs_EDGE); exe.More(); exe.Next()) {
721         if (exe.Current().IsSame(fyisoe)) {
722           nfoundisoe++; 
723         }
724       }
725       if (nfoundisoe > 1) {
726         continue;
727       }
728       
729 #ifdef DRAW
730       if (trc) { 
731         std::cout<<"TopOpeBRepTool correctONUVISO : faulty iso edge"<<std::endl;
732         FUN_tool_draw("fyf",Fsp);FUN_tool_draw("fyisoe",fyisoe);
733       }
734 #endif
735       
736       Standard_Boolean ok = ::FUN_correctClosingE(fyisoe,Fsp);
737       if (!ok) {
738         continue;
739       }
740     }
741     
742     Standard_Integer tmpisoe;
743     TopTools_ListOfShape lffyisoe; tocorrectisoe = FUN_DetectEdgeswithfaultyUV(Fsp,Fsp,lfyisoe,Standard_False,lffyisoe,tmpisoe);
744   } // end lffyisoe process
745   
746   if (tocorrectdege) {
747     TopTools_IndexedDataMapOfShapeListOfShape mve;
748     TopExp::MapShapesAndAncestors(Fsp,TopAbs_VERTEX,TopAbs_EDGE,mve);
749     
750     for (TopTools_ListIteratorOfListOfShape itdeg(lfydege);itdeg.More();itdeg.Next()) {
751       TopoDS_Edge& fydege = TopoDS::Edge(itdeg.Value());
752       
753 #ifdef DRAW
754       if (trc) { 
755         std::cout<<"TopOpeBRepTool correctONUVISO : faulty deg edge"<<std::endl;
756         FUN_tool_draw("fyf",Fsp);FUN_tool_draw("fydege",fydege);
757       }
758 #endif
759       
760       Standard_Boolean ok = ::FUN_correctDegeneratedE(mve,fydege,Fsp);
761       if (!ok) {
762         continue;
763       }
764     } // itdeg
765     
766     TopTools_ListOfShape lffydege; tocorrectdege = FUN_DetectEdgeswithfaultyUV(Fsp,Fsp,lfydege,Standard_False,lffydege,tmpdege);
767   } // end lfydege process
768
769   TopTools_ListOfShape eFsp; FUN_tool_shapes(Fsp,TopAbs_EDGE,eFsp);
770   TopTools_ListOfShape lffydege; tocorrect = FUN_DetectEdgeswithfaultyUV(Fsp,Fsp,eFsp,Standard_False,lffydege,tmpdege);
771   Standard_Boolean done = !tocorrect;
772   return done;*/
773
774 } // correctONUVISO
775
776 //=======================================================================
777 //function : MakeFaces
778 //purpose  : 
779 //=======================================================================
780
781 Standard_Boolean TopOpeBRepTool::MakeFaces(const TopoDS_Face& Fin, const TopTools_ListOfShape& LOF, 
782                               const TopTools_IndexedMapOfOrientedShape& MshNOK,
783                               TopTools_ListOfShape& LOFF)
784 {
785 //  TopOpeBRepDS_BuildTool BT;
786   BRep_Builder BB;
787   LOFF.Clear();
788   TopTools_ListIteratorOfListOfShape it(LOF);
789   for (; it.More(); it.Next()){
790     const TopoDS_Face& FF = TopoDS::Face(it.Value());
791     Standard_Boolean valid = !MshNOK.Contains(FF);
792     if (valid) {LOFF.Append(FF); continue;}
793     
794     TopoDS_Shape aLocalShape = Fin.EmptyCopied();
795     TopoDS_Face newFace = TopoDS::Face(aLocalShape);// BT.CopyFace(Fin,newFace);
796 //    TopoDS_Face newFace = TopoDS::Face(Fin.EmptyCopied());// BT.CopyFace(Fin,newFace);
797     TopExp_Explorer exw(FF, TopAbs_WIRE);
798     
799     for (; exw.More(); exw.Next()){
800       const TopoDS_Wire& W = TopoDS::Wire(exw.Current());
801       valid = !MshNOK.Contains(W);
802       //      if (valid) {BT.AddFaceWire(newFace,W); continue;}
803       if (valid) {BB.Add(newFace,W); continue;}
804
805       TopoDS_Wire newWire; //BT.MakeWire(newWire);
806       BB.MakeWire(newWire);
807       TopExp_Explorer exe(W, TopAbs_EDGE);
808       Standard_Integer ne = 0;
809       for (; exe.More(); exe.Next()){
810         const TopoDS_Edge& E = TopoDS::Edge(exe.Current());
811         valid = !MshNOK.Contains(E);
812         if (!valid) continue;
813         //      BT.AddWireEdge(newWire,E);
814         BB.Add(newWire,E);
815         ne++;
816       } // exe
817       if (ne == 0) continue;
818       Standard_Boolean closed = FUN_tool_ClosedW(newWire);
819       //      BT.Closed(newWire,closed); 
820       //      BT.AddFaceWire(newFace,newWire);
821       newWire.Closed(closed);
822       BB.Add(newFace,newWire);
823     } // exw
824     LOFF.Append(newFace);
825   }
826   return Standard_True;
827 }
828
829 /*static Handle(Geom2d_TrimmedCurve) FUN_translate(const gp_Vec2d& tvector, const TopoDS_Face& fF, TopoDS_Edge& fyE)
830 {
831   Standard_Real f,l,tol; Handle(Geom2d_Curve) PC = FUNTOOLC2D_CurveOnSurface(fyE,fF,f,l,tol);
832   Standard_Boolean isou,isov; gp_Pnt2d o2d; gp_Dir2d d2d;
833   Standard_Boolean isouv = FUN_tool_IsUViso(PC,isou,isov,d2d,o2d); o2d.Translate(tvector);
834   Handle(Geom2d_Line) L2d = new Geom2d_Line(o2d,d2d);
835   Handle(Geom2d_TrimmedCurve) C2d = new Geom2d_TrimmedCurve(L2d,f,l);
836   return C2d;
837 }
838 Standard_EXPORT void FUN_tool_ttranslate(const gp_Vec2d& tvector, const TopoDS_Face& fF, TopoDS_Edge& fyE)
839 {  
840   Handle(Geom2d_TrimmedCurve) C2d = ::FUN_translate(tvector,fF,fyE);
841   Standard_Real tole = BRep_Tool::Tolerance(fyE);
842   BRep_Builder BB;
843 //  Handle(Geom2d_Curve) toclear; BB.UpdateEdge(fyE,toclear,fF,tole);
844   BB.UpdateEdge(fyE,C2d,fF,tole);
845 }
846
847 static Standard_Boolean FUN_tool_translate(const gp_Vec2d& tvector, TopoDS_Face& fF, TopoDS_Edge& fyE)
848      // prequesitory : <fF> is on periodic surface, translates edge 
849      //  <fyE>'s uorviso to have its uorvpar bounded in [0.,2PI].
850 {
851   Handle(Geom2d_TrimmedCurve) C2d = ::FUN_translate(tvector,fF,fyE);
852   Standard_Real tole = BRep_Tool::Tolerance(fyE);
853   
854   //xpu040598 : CTS20280 f37 modified when its split is modified!
855   TopoDS_Face newf; Standard_Boolean ok = FUN_tool_pcurveonF(fF,fyE,C2d,newf);
856   if (ok) fF = newf;
857   return ok;
858   //xpu040598
859 }
860 */