0024510: Remove unused local variables
[occt.git] / src / TopOpeBRepDS / TopOpeBRepDS_EIR.cxx
1 // Copyright (c) 1998-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and / or modify it
7 // under the terms of the GNU Lesser General Public version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 #include <TopOpeBRepDS_EIR.ixx>
16 #include <BRep_Tool.hxx>
17 #include <TopExp.hxx>
18 #include <TopOpeBRepDS_CurvePointInterference.hxx>
19 #include <TopOpeBRepDS_Dumper.hxx>
20 #include <TopOpeBRepDS_Edge3dInterferenceTool.hxx>
21 #include <TopOpeBRepDS_EdgeInterferenceTool.hxx>
22 #include <TopOpeBRepDS_EdgeVertexInterference.hxx>
23 #include <TopOpeBRepDS_Interference.hxx>
24 #include <TopOpeBRepDS_TKI.hxx>
25 #include <TopoDS.hxx>
26 #include <TopOpeBRepDS_ProcessInterferencesTool.hxx>
27 #include <TopOpeBRepTool_EXPORT.hxx>
28 #include <TopOpeBRepDS_EXPORT.hxx>
29 #include <TopOpeBRepDS_define.hxx>
30 #include <TopOpeBRepDS_repvg.hxx>
31 #include <TopOpeBRepDS_connex.hxx>
32 #include <TopOpeBRepTool_TOOL.hxx>
33 #ifdef DEB
34 #include <TopOpeBRepDS_reDEB.hxx>
35 Standard_EXPORT void debredpnc(const Standard_Integer ie){cout<<"+++ debredpnc e"<<ie<<endl;}
36 extern Standard_Boolean TopOpeBRepDS_GetcontextNOPNC();
37 #endif
38
39 #define M_FORWARD(O)  (O == TopAbs_FORWARD)
40 #define M_REVERSED(O) (O == TopAbs_REVERSED)
41 #define M_INTERNAL(O) (O == TopAbs_INTERNAL)
42 #define M_EXTERNAL(O) (O == TopAbs_EXTERNAL)
43
44 // modified by NIZHNY-MKK  Mon Apr  2 15:34:28 2001.BEGIN
45 static Standard_Boolean CheckInterferenceIsValid(const Handle(TopOpeBRepDS_Interference)& I, 
46                                                  const TopoDS_Edge&                       theEdge, 
47                                                  const TopoDS_Edge&                       theSupportEdge, 
48                                                  const TopoDS_Vertex&                     theVertex);
49 // modified by NIZHNY-MKK  Mon Apr  2 15:34:32 2001.END
50
51 //------------------------------------------------------
52 static void FDS_reduceONFACEinterferences(TopOpeBRepDS_ListOfInterference& LI,
53                                           const TopOpeBRepDS_DataStructure& /*BDS*/,
54                                           const Standard_Integer
55 #ifdef DEB
56                                                                   EIX
57 #endif
58                                           )
59 //------------------------------------------------------
60 {
61 #ifdef DEB
62   Standard_Boolean TRC=DSREDUEDGETRCE(EIX);
63   TRC = Standard_False; //MOINSTRACE
64   if (TRC) cout<<endl<<"reduceONFACEinterferences on "<<EIX<<" <- "<<LI.Extent()<<endl;
65 #endif
66
67   TopOpeBRepDS_ListIteratorOfListOfInterference it1;  // set hasONFACE = True if LI contains interfs with (ON,FACE) transition(s).
68   Standard_Boolean hasONFACE = Standard_False;
69   for (it1.Initialize(LI); it1.More(); it1.Next() ) {
70     Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
71     TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
72     if ( GT1 == TopOpeBRepDS_POINT ) {
73       hasONFACE = FUN_hasStateShape(I1->Transition(),TopAbs_ON,TopAbs_FACE);
74       if ( hasONFACE ) break;
75     }
76   }
77
78 #ifdef DEB
79   if(TRC){if( hasONFACE)cout<<"egde "<<EIX<<" has (ON,FACE)"<<endl;}
80   if(TRC){if(!hasONFACE)cout<<"egde "<<EIX<<" has no (ON,FACE)"<<endl;}
81 #endif
82
83   if ( hasONFACE ) {
84     // LI has (ON,FACE) : remove all other interf (POINT,(not(ON,FACE)))
85     it1.Initialize(LI);
86     while( it1.More() ) {
87       Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
88       TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
89       if ( GT1 == TopOpeBRepDS_POINT ) {
90         hasONFACE = FUN_hasStateShape(I1->Transition(),TopAbs_ON,TopAbs_FACE);
91         if ( ! hasONFACE ) {
92           LI.Remove(it1);
93         }
94         else it1.Next();
95       }
96       else it1.Next();
97     }
98   }
99
100 #ifdef DEB
101   if (TRC) cout<<"reduceONFACEinterferences E"<<EIX<<" -> "<<LI.Extent()<<endl<<endl;
102 #endif
103 }
104
105 //------------------------------------------------------
106 static void FUN_ReducerEdge3d(const Standard_Integer SIX, TopOpeBRepDS_DataStructure& BDS,
107                               TopOpeBRepDS_ListOfInterference& LI,TopOpeBRepDS_ListOfInterference& reducedLI)   
108 //------------------------------------------------------
109 // <LI> = { I3d = (TonFACE, G=POINT/VERTEX, S=EDGE) }
110 // {I3d} --reducing processing-> I3d' = (TonFACE, G=POINT/VERTEX, S=FACE) 
111 // <LI> -> <reducedLI> + <LI>
112 {
113   reducedLI.Clear();
114 #ifdef DEB
115   Standard_Boolean TRC=DSREDUEDGETRCE(SIX); 
116   TRC = Standard_False; //MOINSTRACE
117   if(TRC) {cout<<endl; debreducer3d(SIX);}
118   if (TRC) cout<<endl<<"ReducerEdge3d E"<<SIX<<" <- "<<LI.Extent()<<endl;
119 #endif
120   Standard_Integer n3d = LI.Extent(); 
121   if (n3d <= 1) return;
122   const TopoDS_Edge& E = TopoDS::Edge(BDS.Shape(SIX));
123   Standard_Integer rankE  = BDS.AncestorRank(E);
124   TopoDS_Shape OOv; Standard_Integer Gsta = 0;
125   
126   TopOpeBRepDS_ListIteratorOfListOfInterference it1;
127   it1.Initialize(LI);
128
129   // <-- jyl 231198 : cts21797
130   Standard_Integer nLI = LI.Extent();
131   if (nLI >= 1) {
132     while (it1.More()) {
133       const Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
134       TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
135       TopAbs_ShapeEnum SB1,SA1; Standard_Integer IB1,IA1; FDS_Tdata(I1,SB1,IB1,SA1,IA1);
136       Standard_Boolean torem = Standard_False;
137       if (ST1 == TopOpeBRepDS_EDGE) {
138         const TopoDS_Edge& EE = TopoDS::Edge(BDS.Shape(S1));
139         const TopoDS_Face& FF = TopoDS::Face(BDS.Shape(IB1));
140         TopAbs_Orientation o; Standard_Boolean ok = FUN_tool_orientEinFFORWARD(EE,FF,o);
141         if (ok && (o == TopAbs_EXTERNAL)) torem = Standard_True;
142       }
143       if (torem) LI.Remove(it1);
144       else it1.Next();
145     }
146     nLI = LI.Extent();
147     if (nLI <= 1) return;
148   }
149   // --> jyl 231198 : cts21797
150
151   it1.Initialize(LI); 
152   while (it1.More()){
153
154     Standard_Boolean isComplex = Standard_False;
155     TopOpeBRepDS_Edge3dInterferenceTool EFITool;
156     const Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
157     TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
158     TopAbs_ShapeEnum SB1,SA1; Standard_Integer IB1,IA1; FDS_Tdata(I1,SB1,IB1,SA1,IA1);
159
160     // modified by NIZHNY-MKK  Mon Apr  2 15:35:58 2001.BEGIN
161     TopoDS_Vertex aVertex;
162
163     if((GT1 == TopOpeBRepDS_VERTEX) && G1!=0) {
164       aVertex = TopoDS::Vertex(BDS.Shape(G1));
165     }
166
167     if(!CheckInterferenceIsValid(I1, E, TopoDS::Edge(BDS.Shape(S1)), aVertex)) {
168       LI.Remove(it1);
169       continue;
170     }
171     // modified by NIZHNY-MKK  Mon Apr  2 15:36:02 2001.END
172
173     TopOpeBRepDS_ListIteratorOfListOfInterference it2(it1);
174     if (it2.More()) it2.Next();
175     else return;
176
177     while ( it2.More()){
178       const Handle(TopOpeBRepDS_Interference)& I2 = it2.Value();
179       TopOpeBRepDS_Kind GT2,ST2; Standard_Integer G2,S2; FDS_data(I2,GT2,G2,ST2,S2);
180       TopAbs_ShapeEnum SB2,SA2; Standard_Integer IB2,IA2; FDS_Tdata(I2,SB2,IB2,SA2,IA2);
181
182       // modified by NIZHNY-MKK  Mon Apr  2 15:36:42 2001.BEGIN
183       aVertex.Nullify();
184
185       if((GT2 == TopOpeBRepDS_VERTEX) && G2!=0) {
186         aVertex = TopoDS::Vertex(BDS.Shape(G2));
187       }
188       
189       if(!CheckInterferenceIsValid(I2, E, TopoDS::Edge(BDS.Shape(S2)), aVertex)) {
190         LI.Remove(it2);
191         continue;
192       }
193       // modified by NIZHNY-MKK  Mon Apr  2 15:36:45 2001.END
194         
195       Standard_Boolean sameG = (GT2 == GT1) && (G2 == G1);
196       if (!sameG) break;
197
198       // <Gsta>, <OOv>
199       if (GT1 == TopOpeBRepDS_VERTEX) {
200         TopoDS_Vertex vG1 = TopoDS::Vertex(BDS.Shape(G1));
201         Standard_Integer rankvG1 = BDS.AncestorRank(vG1);
202         Standard_Integer sdG1; Standard_Boolean G1hsd = FUN_ds_getVsdm(BDS,G1,sdG1);    
203         if (rankvG1 != rankE) { // vG1 not on E
204           OOv = vG1;
205           Gsta = G1hsd? 3: 2;
206         }
207         else { // vG on E
208           if (G1hsd) OOv = BDS.Shape(sdG1); 
209           Gsta = G1hsd? 3: 1;
210         }
211       }      
212
213       const TopoDS_Face& F1 = TopoDS::Face(BDS.Shape(IB1));
214       const TopoDS_Face& F2 = TopoDS::Face(BDS.Shape(IB2)); // F2 != F1
215
216       Standard_Boolean sameS = (ST2 == ST1) && (S2 == S1);
217       if (!sameS) {
218         TopoDS_Shape Eshared; Standard_Boolean foundsh = FUN_tool_Eshared(OOv,F1,F2,Eshared);
219         if (!foundsh) return;
220
221         // modified by NIZHNY-MKK  Mon Apr  2 15:37:12 2001.BEGIN
222         if(!BDS.HasShape(Eshared)) {
223           return;
224         }
225         // modified by NIZHNY-MKK  Mon Apr  2 15:37:15 2001.END
226
227         S1 = S2 = BDS.Shape(Eshared);
228       }
229
230       const TopoDS_Edge& E1 = TopoDS::Edge(BDS.Shape(S1)); 
231       const TopoDS_Edge& E2 = TopoDS::Edge(BDS.Shape(S2)); // E2 == E1
232
233       Standard_Boolean sdm = FUN_ds_sdm(BDS,E,E1);
234       if (sdm) {
235 #ifdef DEB
236           if (TRC) cout<<"  NO I3d : e"<<SIX<<" same domain with e"<<S1<<endl;
237 #endif
238         it2.Next(); continue;
239       }
240
241       Standard_Boolean init = !isComplex;
242       Standard_Boolean isvertex = (GT1 == TopOpeBRepDS_VERTEX); 
243       init = init || isvertex; // !!!KK a revoir!!!!
244
245       if (init) {
246
247         // xpu : 04-03-98 : !!!KK a revoir!!!!
248         if (isComplex) {
249           Handle(TopOpeBRepDS_Interference) IBID = new TopOpeBRepDS_Interference();
250           EFITool.Transition(IBID);
251           I1->ChangeTransition().Set(IBID->Transition().Orientation(TopAbs_IN));
252         }
253         // !!!KK a revoir!!!!
254
255         if (!isComplex) EFITool.InitPointVertex(Gsta,OOv);
256         isComplex = Standard_True;
257         EFITool.Init(E,E1,F1,I1); 
258         EFITool.Add(E,E1,F1,I1);
259 #ifdef DEB
260         if(TRC){cout<<endl<<"complex T3d E"<<SIX<<endl;I1->Dump(cout,"init :","\n");} 
261 #endif  
262       } // !isComplex
263       
264 #ifdef DEB
265       if(TRC) I2->Dump(cout,"add : ","\n");
266 #endif    
267       EFITool.Add(E,E2,F2,I2);
268       LI.Remove(it2);
269       
270 #ifdef DEB
271       if(TRC){cout<<"resulting : "; Handle(TopOpeBRepDS_Interference) IBID = new TopOpeBRepDS_Interference();
272               EFITool.Transition(IBID);IBID->Transition().Dump(cout);cout<<endl;}
273 #endif  
274     } // it2
275
276     if (isComplex) {
277       Handle(TopOpeBRepDS_Interference) newI;
278       Handle(TopOpeBRepDS_Interference) IIBID = new TopOpeBRepDS_Interference();
279       EFITool.Transition(IIBID); 
280       TopOpeBRepDS_Transition T = IIBID->Transition(); T.Index(IB1);
281
282       Standard_Boolean isevi = I1->IsKind(STANDARD_TYPE(TopOpeBRepDS_EdgeVertexInterference));
283       Standard_Boolean iscpi = I1->IsKind(STANDARD_TYPE(TopOpeBRepDS_CurvePointInterference));
284       if (isevi) {
285         const Handle(TopOpeBRepDS_EdgeVertexInterference)& EVI = Handle(TopOpeBRepDS_EdgeVertexInterference)::DownCast(I1);
286         newI = new TopOpeBRepDS_EdgeVertexInterference(T,TopOpeBRepDS_FACE,IB1,G1,EVI->GBound(),
287                           TopOpeBRepDS_UNSHGEOMETRY,EVI->Parameter());    
288       }
289       if (iscpi) {
290         const Handle(TopOpeBRepDS_CurvePointInterference)& CPI = Handle(TopOpeBRepDS_CurvePointInterference)::DownCast(I1);
291         newI = new TopOpeBRepDS_CurvePointInterference(T,TopOpeBRepDS_FACE,IB1,TopOpeBRepDS_POINT,G1,CPI->Parameter());         
292       }
293
294 #ifdef DEB
295       if (TRC){cout<<"reduced T E"<<SIX<<" ";newI->Dump(cout);cout<<endl;}
296 #endif
297       if (!newI.IsNull()) {
298         reducedLI.Append(newI);
299         LI.Remove(it1);
300       }
301     }
302     else 
303       it1.Next();
304   } // it1
305
306 #ifdef DEB
307   if (TRC) {
308     cout<<"ReducerEdge3d E"<<SIX<<" -> nIreduced "<<reducedLI.Extent();
309     cout<<" + nInonreduced "<<LI.Extent()<<endl<<endl;
310   }
311 #endif
312 }
313
314 //------------------------------------------------------
315 static void FUN_ReducerEdge(const Standard_Integer SIX,const TopOpeBRepDS_DataStructure& BDS,
316                             TopOpeBRepDS_ListOfInterference& LI,TopOpeBRepDS_ListOfInterference& reducedLI)
317 //------------------------------------------------------
318 {
319 #ifdef DEB
320   Standard_Boolean TRC=DSREDUEDGETRCE(SIX);
321 //  TRC = Standard_False; //MOINSTRACE
322   if (TRC) cout<<endl<<"ReducerEdge E"<<SIX<<" <- nI "<<LI.Extent()<<endl;
323 #endif
324   
325   FDS_repvg(BDS,SIX,TopOpeBRepDS_VERTEX,LI,reducedLI);
326   FDS_reduceONFACEinterferences(LI,BDS,SIX);
327   FDS_repvg(BDS,SIX,TopOpeBRepDS_POINT,LI,reducedLI);
328   
329 #ifdef DEB
330   if (TRC) cout<<"ReducerEdge E"<<SIX<<" -> nI "<<LI.Extent()<<endl<<endl;
331 #endif
332 }
333
334 //------------------------------------------------------
335 static void FUN_ReducerSDEdge(const Standard_Integer SIX,const TopOpeBRepDS_DataStructure& BDS,
336                               TopOpeBRepDS_ListOfInterference& LI,TopOpeBRepDS_ListOfInterference& reducedLI)
337 //------------------------------------------------------
338 {
339   reducedLI.Clear();
340   Standard_Integer nI = LI.Extent();
341 #ifdef DEB
342   Standard_Boolean TRC=DSREDUEDGETRCE(SIX);
343   TRC = Standard_False; //MOINSTRACE
344   if (TRC) cout<<endl<<"ReducerSDEdge E"<<SIX<<" <- nI "<<nI<<endl;  
345 #endif
346   if (nI <= 1) return;
347
348   TopOpeBRepDS_ListOfInterference newLI;
349   const TopoDS_Shape& EIX = BDS.Shape(SIX);
350   TopOpeBRepDS_TKI tki; tki.FillOnGeometry(LI);
351   for (tki.Init(); tki.More(); tki.Next()) {
352     TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
353     TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G); TopOpeBRepDS_ListOfInterference Rloi;
354     
355     TopOpeBRepDS_ListIteratorOfListOfInterference it1(loi);
356     while (it1.More()) {
357       const Handle(TopOpeBRepDS_Interference)& I1 = it1.Value(); const TopOpeBRepDS_Transition& T1 = I1->Transition();
358       TopAbs_Orientation O1 = T1.Orientation(TopAbs_IN); Standard_Integer IB1 = T1.Index();
359       Standard_Boolean cond1 = FUN_ds_sdm(BDS,EIX,BDS.Shape(IB1));  
360       if (!cond1) {newLI.Append(I1); it1.Next(); continue;}  
361  
362       Standard_Boolean complex1d = Standard_False;
363       TopOpeBRepDS_ListIteratorOfListOfInterference it2(it1);
364       if (it2.More()) it2.Next();
365       else break;
366
367       TopOpeBRepDS_Transition T(TopAbs_IN,TopAbs_IN,TopAbs_EDGE,TopAbs_EDGE);
368       while (it2.More()){
369         const Handle(TopOpeBRepDS_Interference)& I2 = it2.Value(); const TopOpeBRepDS_Transition& T2 = I2->Transition();
370         TopAbs_Orientation O2 = T2.Orientation(TopAbs_IN); Standard_Integer IB2 = T2.Index();
371         Standard_Boolean cond2 = FUN_ds_sdm(BDS,EIX,BDS.Shape(IB2));  
372         if (!cond2) {newLI.Append(I2); it2.Next(); continue;} 
373
374         complex1d =              (M_FORWARD(O1) && M_REVERSED(O2));
375         complex1d = complex1d || (M_FORWARD(O2) && M_REVERSED(O1)); 
376         if (!complex1d) {newLI.Append(I2); it2.Next(); continue;}
377
378         if (complex1d) {
379           Standard_Integer IB = (M_REVERSED(O1)) ? IB1 : IB2; T.IndexBefore(IB); 
380           Standard_Integer IA = (M_REVERSED(O1)) ? IB2 : IB1; T.IndexAfter(IA); 
381         }
382         loi.Remove(it2);
383         break; // no more than 2 interferences on sdmTRASHA at same G
384       } // it2
385
386       if (complex1d) {
387         const Handle(TopOpeBRepDS_EdgeVertexInterference)& EVI = Handle(TopOpeBRepDS_EdgeVertexInterference)::DownCast(I1);
388         TopOpeBRepDS_Config cEIX=BDS.SameDomainOri(SIX), c1=BDS.SameDomainOri(IB1); 
389         TopOpeBRepDS_Config Conf = (cEIX == c1) ? TopOpeBRepDS_SAMEORIENTED : TopOpeBRepDS_DIFFORIENTED;
390         Handle(TopOpeBRepDS_Interference) newI = new TopOpeBRepDS_EdgeVertexInterference(T,TopOpeBRepDS_EDGE,IB1,G,EVI->GBound(),Conf,EVI->Parameter());        
391         reducedLI.Append(newI);
392         it1.Next();
393       }
394       else {
395         newLI.Append(I1);
396         loi.Remove(it1);
397       }
398     } // it1    
399   } // tki
400   
401   LI.Clear(); LI.Append(newLI);
402
403 #ifdef DEB
404   if (TRC) cout<<"ReducerSDEdge E"<<SIX<<" -> nI "<<LI.Extent()<<endl<<endl;
405 #endif
406 }
407
408 //------------------------------------------------------
409 static void FUN_reclSE2(const Standard_Integer SIX,const TopOpeBRepDS_DataStructure& BDS,
410                         TopOpeBRepDS_ListOfInterference& LI,TopOpeBRepDS_ListOfInterference& reducedLI)
411 //------------------------------------------------------
412 // reducing LI = {I = (T(edge),G0,edge)}
413 //  edge <SIX> is same domain with edge <SE>
414 //  {I1 = (OU/IN(SE),VG,SE) 
415 //  I2 = (IN/OU(SE),VG,SE))} -> Ir = (IN/IN(SE),VG,SE)
416 {
417   reducedLI.Clear();
418 #ifdef DEB
419   Standard_Integer nI = LI.Extent(); // DEB
420 #endif
421
422   const TopoDS_Edge& E = TopoDS::Edge(BDS.Shape(SIX));
423
424 #ifdef DEB
425   Standard_Boolean TRC=DSREDUEDGETRCE(SIX);
426   TRC = Standard_False; //MOINSTRACE
427   if (TRC) cout<<endl<<"reclSE2 E"<<SIX<<" <- nI "<<nI<<endl;
428 #endif   
429
430     TopOpeBRepDS_ListIteratorOfListOfInterference it1(LI);
431     while (it1.More()) {
432       const Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
433       TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
434
435       const TopOpeBRepDS_Transition& T1 = I1->Transition(); TopAbs_Orientation O1 = T1.Orientation(TopAbs_IN);
436       if (M_INTERNAL(O1) || M_EXTERNAL(O1)) {it1.Next(); continue;}
437       TopAbs_Orientation cO1 = TopAbs::Complement(O1);
438
439       const TopoDS_Vertex& v1 = TopoDS::Vertex(BDS.Shape(G1));      
440       const TopoDS_Edge& E1 = TopoDS::Edge(BDS.Shape(S1));
441       TopoDS_Vertex vclo1; Standard_Boolean iscE1 = TopOpeBRepTool_TOOL::ClosedE(E1,vclo1);
442       if (!iscE1)            {it1.Next(); continue;}
443       if (!vclo1.IsSame(v1)) {it1.Next(); continue;}
444
445       Standard_Boolean sdm = FUN_ds_sdm(BDS,E,E1);
446       if (!sdm) {it1.Next(); continue;}
447
448       Standard_Boolean hascO = Standard_False;
449       TopOpeBRepDS_ListIteratorOfListOfInterference it2(it1); 
450       if (it2.More()) it2.Next(); 
451       else {it1.Next(); continue;}
452       while ( it2.More()){ 
453         const Handle(TopOpeBRepDS_Interference)& I2 = it2.Value();
454         const TopOpeBRepDS_Transition& T2 = I2->Transition(); TopAbs_Orientation O2 = T2.Orientation(TopAbs_IN);
455         TopOpeBRepDS_Kind GT2,ST2; Standard_Integer G2,S2; FDS_data(I2,GT2,G2,ST2,S2);
456         
457         if (S1 != S2)  {it2.Next(); continue;}
458         if (O2 != cO1) {it2.Next(); continue;}
459         
460         LI.Remove(it2);
461 #ifdef DEB
462         nI = LI.Extent(); // DEB
463 #endif
464         hascO = Standard_True; break;
465       } //it2
466       
467       if (hascO) {
468         I1->ChangeTransition().Set(TopAbs_INTERNAL);
469         reducedLI.Append(I1); LI.Remove(it1);
470 #ifdef DEB
471         nI = LI.Extent(); // DEB
472 #endif
473       }
474       else it1.Next();
475     } //it1
476
477 #ifdef DEB
478   if (TRC) cout<<"reclSE2 E"<<SIX<<" -> nI "<<LI.Extent()<<endl<<endl;
479 #endif
480 } // FUN_reclSE2
481
482 //------------------------------------------------------
483 Standard_EXPORT void FUN_reclSE(const Standard_Integer EIX,const TopOpeBRepDS_DataStructure& BDS,
484                                 TopOpeBRepDS_ListOfInterference& LOI,TopOpeBRepDS_ListOfInterference& RLOI)
485 //------------------------------------------------------
486 {
487   TopOpeBRepDS_TKI tki; tki.FillOnGeometry(LOI);
488 #ifdef DEB
489   Standard_Boolean TRC=DSREDUEDGETRCE(EIX);
490   TRC = Standard_False; //MOINSTRACE
491   if (TRC) cout<<endl<<"reclSE E"<<EIX<<" <- "<<LOI.Extent()<<endl;
492   if (TRC) tki.DumpTKIIterator("","\n");
493 #endif
494
495   LOI.Clear();
496   for (tki.Init(); tki.More(); tki.Next()) {
497     TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
498     if (K != TopOpeBRepDS_VERTEX) continue; 
499     
500 #ifdef DEB
501     if (TRC) {tki.DumpTKI(K,G,"","\n");}
502 #endif
503     TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G); TopOpeBRepDS_ListOfInterference Rloi;
504     Standard_Integer nloi = loi.Extent();
505     if      (nloi == 0) continue;
506     else if (nloi == 1) LOI.Append(loi);
507     else {
508       FUN_reclSE2(EIX,BDS,loi,Rloi);  
509       LOI.Append(loi); RLOI.Append(Rloi);
510     }
511   }
512
513 #ifdef DEB
514   if (TRC) cout<<"reclSE E"<<EIX<<" -> reste "<<LOI.Extent()<<" + reduit "<<RLOI.Extent()<<endl<<endl;
515 #endif
516 } // FUN_reclSE
517
518 //------------------------------------------------------
519 static void FUN_unkeepEVIonGb1(const TopOpeBRepDS_DataStructure& BDS,const Standard_Integer EIX,TopOpeBRepDS_ListOfInterference& LI)
520 //------------------------------------------------------
521 // LI = {I attached to <E> = (T,G,S)}, unkeep I = EVI with G = vertex of <E>
522 {
523
524 #ifdef DEB
525   Standard_Boolean TRC=DSREDUEDGETRCE(EIX);
526   TRC = Standard_False; //MOINSTRACE
527   if (TRC) {cout<<endl;debreducerE(EIX);}
528 #endif
529
530   const TopoDS_Edge& E = TopoDS::Edge(BDS.Shape(EIX));
531   
532   TopOpeBRepDS_ListIteratorOfListOfInterference it(LI);
533   while (it.More()) {
534     const Handle(TopOpeBRepDS_Interference)& I = it.Value();
535     Standard_Boolean evi = I->IsKind(STANDARD_TYPE(TopOpeBRepDS_EdgeVertexInterference));
536     if (!evi) {it.Next(); continue;}
537     TopOpeBRepDS_Kind GT,ST; Standard_Integer G,S; FDS_data(I,GT,G,ST,S);
538     if (GT != TopOpeBRepDS_VERTEX){it.Next(); continue;}
539
540     const TopoDS_Vertex& V = TopoDS::Vertex(BDS.Shape(G));
541     Standard_Integer o = FUN_tool_orientVinE(V,E);
542     if (o == 0){it.Next(); continue;}
543 #ifdef DEB
544     if (TRC) {cout<<"-> rejet EVI on Gb 1 on "<<EIX<<" : ";I->Dump(cout);cout<<endl;}
545 #endif
546     LI.Remove(it);
547   }
548 }
549
550 // ---------------------------------------------------------
551 //unreferenced function, commented
552 /*#ifdef DEB
553 static void FUN_reorder(const Standard_Integer EIX, const Handle(TopOpeBRepDS_HDataStructure)& HDS,TopOpeBRepDS_ListOfInterference& LIR, TopOpeBRepDS_ListOfInterference& LI, TopOpeBRepDS_ListOfInterference& LIend)
554 // ---------------------------------------------------------
555 // at same G :in <LI>  I  =(T, G, S)
556 //            in <LRI> Ir =(Tr,G,Sr)
557 // I gives less information than reduced Ir   
558 {
559
560   Standard_Boolean TRC=DSREDUEDGETRCE(EIX);
561   TRC = Standard_False; //MOINSTRACE
562   if (TRC) cout<<endl<<"FUN_reorder :"<<endl;
563   TopOpeBRepDS_Dumper DSD(HDS); 
564
565   LIend.Clear();
566
567   TopOpeBRepDS_TKI tki;
568   tki.FillOnGeometry(LI);
569
570   TopOpeBRepDS_TKI tkiR;
571   tkiR.FillOnGeometry(LIR); 
572   
573   for (tkiR.Init(); tkiR.More(); tkiR.Next()) {
574     TopOpeBRepDS_Kind K; Standard_Integer G; tkiR.Value(K,G);
575
576     tki.Init();
577     Standard_Boolean isbound = tki.IsBound(K,G);
578     if (!isbound) continue;
579
580     TopOpeBRepDS_ListOfInterference& loiR = tkiR.ChangeValue(K,G);
581     TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G);
582 #ifdef DEB
583     if (TRC) {TCollection_AsciiString bb("lIreduced");bb += TCollection_AsciiString(G);DSD.DumpLOI(loiR,cout,bb);
584               TCollection_AsciiString aa("lI");aa+=TCollection_AsciiString(G);DSD.DumpLOI(loi,cout,aa);}
585 #endif
586     loiR.Append(loi);
587   }
588   
589 #ifdef DEB
590     if (TRC) cout<<"-> ordered :"<<endl;
591 #endif
592   for (tkiR.Init(); tkiR.More(); tkiR.Next()) {
593     TopOpeBRepDS_Kind K; Standard_Integer G; TopOpeBRepDS_ListOfInterference& loi = tkiR.ChangeValue(K,G);
594 #ifdef DEB
595     if (TRC) {TCollection_AsciiString aa("lI");aa+=TCollection_AsciiString(G);DSD.DumpLOI(loi,cout,aa);}
596 #endif
597     LIend.Append(loi);
598   }
599
600 #ifdef DEB
601     if (TRC) cout<<"-> residual :"<<endl;
602 #endif
603   for (tki.Init(); tki.More(); tki.Next()) {
604     TopOpeBRepDS_Kind K; Standard_Integer G; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G);
605 #ifdef DEB
606     if (TRC) {TCollection_AsciiString aa("lI");aa+=TCollection_AsciiString(G);DSD.DumpLOI(loi,cout,aa);}
607 #endif
608     LIend.Append(loi);
609   }
610 }
611 #endif
612 */
613
614 static void FUN_keepl3dF(const Standard_Integer
615 #ifdef DEB
616                                                 SIX
617 #endif
618                          ,const Handle(TopOpeBRepDS_HDataStructure)&
619 #ifdef DEB
620                                                 HDS
621 #endif
622                          ,const TopOpeBRepDS_ListOfInterference& l3dF
623                          ,const TopOpeBRepDS_ListOfInterference& LR3dFE,
624                          TopOpeBRepDS_ListOfInterference& l3dFkeep)
625 //purpose : soit I de l3dF, on cherche IR interf dans LR3dFE de meme geometrie
626 //          si on n'en trouve pas, l3dFkeep += I
627 {
628 #ifdef DEB
629   Standard_Boolean TRC=DSREDUEDGETRCE(SIX);
630   TRC = Standard_False; //MOINSTRACE
631   if (TRC) cout<<endl<<"keepl3dF E"<<SIX<<endl;
632   TopOpeBRepDS_Dumper DSD(HDS); 
633 #endif
634
635   TopOpeBRepDS_TKI tki;
636   tki.FillOnGeometry(l3dF);
637
638   TopOpeBRepDS_TKI tkiR;
639   tkiR.FillOnGeometry(LR3dFE); 
640   
641   for (tki.Init(); tki.More(); tki.Next()) {
642     TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
643     TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G);
644     tkiR.Init();
645     Standard_Boolean isbound = tkiR.IsBound(K,G);
646     if (!isbound) {l3dFkeep.Append(loi);}
647
648 #ifdef DEB
649     if (TRC) {TCollection_AsciiString bb("l3dFkeep");bb += TCollection_AsciiString(G);DSD.DumpLOI(loi,cout,bb);cout<<endl;}
650 #endif
651   }  
652 } // FUN_keepl3dF
653
654 static void FUN_reducepure2dI0(TopOpeBRepDS_ListOfInterference& LI, TopOpeBRepDS_ListOfInterference& RLI)
655 // xpu210798 : CTS21216 (e7,G=P3,S=E9,FTRASHA=f8,f10)
656 //  LI attached to section edge
657 //  2dI1=(REVERSED(ftrasha1),G,ES), 2dI2=(FORWARD(ftrasha2),G,ES)
658 //  for the compute of splitON(EIX), reduce 2dI1+2dI2 -> 2dR=(IN(ftrasha1,ftrasha2)
659 // LI-> RLI + LI
660 {
661   const Handle(TopOpeBRepDS_Interference)& I1 = LI.First();
662   TopAbs_Orientation O1 = I1->Transition().Orientation(TopAbs_IN);
663   TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; TopAbs_ShapeEnum tsb1,tsa1; Standard_Integer isb1,isa1; 
664   FDS_Idata(I1,tsb1,isb1,tsa1,isa1,GT1,G1,ST1,S1);
665   
666   const Handle(TopOpeBRepDS_Interference)& I2 = LI.Last();
667   TopAbs_Orientation O2 = I2->Transition().Orientation(TopAbs_IN);
668   TopOpeBRepDS_Kind GT2,ST2; Standard_Integer G2,S2; TopAbs_ShapeEnum tsb2,tsa2; Standard_Integer isb2,isa2; 
669   FDS_Idata(I2,tsb2,isb2,tsa2,isa2,GT2,G2,ST2,S2);
670   
671   if (isb1 == isb2) return; //xpu170898 FOR+REV ->INT/EXT (cto009B1(es6,p1,f9))
672
673   // recall : G1==G2 && ST1==ST2==EDGE
674   Standard_Boolean ok = (G1==G2);
675   ok = ok && (tsb1 == TopAbs_FACE) && (tsb1==tsb2) && (isb1==isa1) && (isb2==isa2);
676   if (!ok) return;
677
678   Standard_Boolean int12 = M_REVERSED(O1) && M_FORWARD(O2);
679   Standard_Boolean int21 = M_REVERSED(O2) && M_FORWARD(O1);
680   ok = int12 || int21;
681   if (!ok) return;
682
683   TopOpeBRepDS_Transition newT(TopAbs_INTERNAL);
684   Standard_Integer bef = int12? isb1 : isb2;
685   Standard_Integer aft = int21? isb1 : isb2; 
686   newT.IndexBefore(bef); newT.IndexAfter(aft);
687   I1->ChangeTransition() = newT;
688   RLI.Append(I1);
689   LI.Clear();
690 } // FUN_reducepure2dI0
691
692 static void FUN_reducepure2dI(TopOpeBRepDS_ListOfInterference& LI, TopOpeBRepDS_ListOfInterference& RLI)
693 {  
694   TopOpeBRepDS_TKI tki; tki.FillOnGeometry(LI);
695   TopOpeBRepDS_ListOfInterference newLI;
696   for (tki.Init(); tki.More(); tki.Next()) {
697     TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
698     TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G); TopOpeBRepDS_ListOfInterference Rloi;
699     Standard_Integer nloi = loi.Extent();
700     Standard_Boolean ok = (nloi == 2) && (K == TopOpeBRepDS_POINT);
701     if (ok) ::FUN_reducepure2dI0(loi,Rloi);
702     RLI.Append(Rloi);
703     newLI.Append(loi);
704   }
705   LI.Clear(); LI.Append(newLI);
706 } // FUN_reducepure2dI
707
708 //=======================================================================
709 //function : TopOpeBRepDS_EIR
710 //purpose  : 
711 //=======================================================================
712 TopOpeBRepDS_EIR::TopOpeBRepDS_EIR
713 (const Handle(TopOpeBRepDS_HDataStructure)& HDS) : myHDS(HDS)
714 {}
715
716 //=======================================================================
717 //function : ProcessEdgeInterferences
718 //purpose  : 
719 //=======================================================================
720 void TopOpeBRepDS_EIR::ProcessEdgeInterferences()
721 {
722   TopOpeBRepDS_DataStructure& BDS = myHDS->ChangeDS();
723   Standard_Integer i,nshape = BDS.NbShapes();
724   for (i = 1; i <= nshape; i++) {
725     const TopoDS_Shape& S = BDS.Shape(i);
726     if(S.IsNull()) continue;
727     if ( S.ShapeType() == TopAbs_EDGE ) {
728       ProcessEdgeInterferences(i);
729     }
730   }
731 }
732 static void FUN_ProcessEdgeInterferences(const Standard_Integer EIX
733                                          , const TopOpeBRepDS_Kind
734 #ifdef DEB
735                                                                  K
736 #endif
737                                          ,const Standard_Integer
738 #ifdef DEB
739                                                                  G
740 #endif
741                                          , const Handle(TopOpeBRepDS_HDataStructure)& HDS, 
742                                          TopOpeBRepDS_ListOfInterference& LI)
743 {
744   TopOpeBRepDS_DataStructure& BDS = HDS->ChangeDS();
745   const TopoDS_Shape& E = BDS.Shape(EIX);
746 #ifdef DEB
747   Standard_Boolean TRC=DSREDUEDGETRCE(EIX);
748   if (TRC) {
749     cout<<endl;debreducerE(EIX);cout<<"EIR E"<<EIX;
750     if(K==TopOpeBRepDS_POINT)cout<<",point";
751     else                     cout<<",vertex";
752     cout<<G<<endl;
753   }
754 #endif
755
756   // LI -> (lF + lFE) + lE + [LI]
757   // lF  = {interference on edge <EIX> :  (T(face),G=POINT/VERTEX,S)
758   // lFE = {interference on edge <EIX> :  (T(face),G=POINT/VERTEX,S=EDGE)
759   // lE  = {interference on edge <EIX> :  (T(edge),G=POINT/VERTEX,S)
760   TopOpeBRepDS_ListOfInterference lF; FUN_selectTRASHAinterference(LI,TopAbs_FACE,lF);
761   TopOpeBRepDS_ListOfInterference lFE; FUN_selectSKinterference(lF,TopOpeBRepDS_EDGE,lFE);
762   TopOpeBRepDS_ListOfInterference lE; FUN_selectTRASHAinterference(LI,TopAbs_EDGE,lE);
763
764 #ifdef DEB 
765   TopOpeBRepDS_Dumper DSD(HDS);       
766   Standard_Boolean trcl = TRC;
767 //  trcl = Standard_False; // MOINSTRACE
768 #endif
769
770   // xpu210798 : CTS21216 (e7,G=P3,S=E9,FTRASHA=f8,f10)
771   //   EIX is section edge
772   //   2dI1=(REVERSED(ftrasha1),G,ES), 2dI2=(FORWARD(ftrasha2),G,ES)
773   //   for the compute of splitON(EIX), reduce 2dI1+2dI2 -> 2dR=(IN(ftrasha1,ftrasha2)
774   Standard_Boolean isse = BDS.IsSectionEdge(TopoDS::Edge(E));
775   if (isse) {
776     TopOpeBRepDS_ListOfInterference lI2dFE,lRI2dFE;
777     // lF  -> lF
778     // lFE -> lI2dFE + [lFE] / lI2dFE={FEI=(T(FTRASHA),G,SE) : no FFI=(T(FTRASHA),G,FTRASHA)}
779     FUN_selectpure2dI(lF,lFE,lI2dFE);
780 #ifdef DEB
781     if (trcl) {
782       cout<<endl<<"lI2dFE -> lRI2dFE + lI2dFE"<<endl;
783       TCollection_AsciiString aa("lI2dFE  :"); DSD.DumpLOI(lI2dFE,cout,aa);
784     }
785 #endif    
786     ::FUN_reducepure2dI(lI2dFE,lRI2dFE); // lI2dFE -> lRI2dFE + lI2dFE
787 #ifdef DEB
788     if (trcl) { TCollection_AsciiString bb("lRI2dFE  :"); DSD.DumpLOI(lRI2dFE,cout,bb);}
789 #endif
790     lFE.Append(lI2dFE); lFE.Append(lRI2dFE);
791   }
792
793   // I -> 3dI +2dI + 1dI:
794   // -------------------
795   // lFE -> l3dFE [+l3dFEresi] +l2dFE [+lFE (+lFEresi)]
796   //    : l3dFE={I3d } to reduce; for I3dFE=(T(F),G,SE) there is I3dF=(T(F),G,F)
797   //      l2dFE={I2d} to reduce
798   //      lFEresi to remove 
799   // lF  -> l3dF [+lF] : l3dF to remove
800
801   // lE  -> l1dE +l1dEsd [+lE}
802   //    : l1dE={I1d=(T(ETRA),G,ETRA)/same ETRA} to reduce
803   //      l2dEsd={I1dsd=(T(ETRA),G,ETRA)/ E sdm ETRA}
804
805   TopOpeBRepDS_ListOfInterference lFEresi,l3dFE,l3dF,l3dFEresi,l2dFE;
806   FUN_select3dinterference(EIX,BDS,lF,l3dF,
807                            lFE,lFEresi,l3dFE,l3dFEresi,
808                            l2dFE);
809   TopOpeBRepDS_ListOfInterference l1dE; FUN_select2dI(EIX,BDS,TopAbs_EDGE,lE,l1dE);
810   TopOpeBRepDS_ListOfInterference l1dEsd; FUN_select1dI(EIX,BDS,lE,l1dEsd);
811
812 #ifdef DEB
813   if (trcl) {
814     cout<<"lFE("<<EIX<<") -> l3dFE (S=EDGE) [+l3dFEresi] + l2dFE  + [lFE +lFEresi]"<<endl;
815     TCollection_AsciiString oo("lFE :");DSD.DumpLOI(lFE,cout,oo);
816     TCollection_AsciiString pp("lFEresi :");DSD.DumpLOI(lFEresi,cout,pp);
817     TCollection_AsciiString bb("l3dFE :");DSD.DumpLOI(l3dFE,cout,bb);
818     TCollection_AsciiString bb1("l3dFEresi :");DSD.DumpLOI(l3dFEresi,cout,bb1);
819     TCollection_AsciiString ll("l2dFE :");DSD.DumpLOI(l2dFE,cout,ll);
820     cout<<"lF("<<EIX<<")  -> l3dF  (S=FACE)          [+lF]"<<endl;
821     TCollection_AsciiString cc("lF :");   DSD.DumpLOI(lF,cout,cc);
822     TCollection_AsciiString aa("l3dF :"); DSD.DumpLOI(l3dF,cout,aa);
823     cout<<"lE("<<EIX<<")  -> l1dE + lE"<<endl;
824     TCollection_AsciiString ee("lE :");   DSD.DumpLOI(lE,cout,ee);
825     TCollection_AsciiString ff("l1dE :"); DSD.DumpLOI(l1dE,cout,ff);
826     TCollection_AsciiString gg("l1dEsd :"); DSD.DumpLOI(l1dEsd,cout,gg);}
827 #endif
828
829   // reducer3d :
830   // ----------
831   // l3dFE -> lR3dFE [+l3dFE (non reduced 3dI)]
832   TopOpeBRepDS_ListOfInterference lR3dFE; FUN_ReducerEdge3d(EIX,BDS,l3dFE,lR3dFE);
833 #ifdef DEB
834   if (trcl) { cout<<"l3dFE("<<EIX<<") -> lR3dFE + l3dFE"<<endl;
835               TCollection_AsciiString aa("lR3dFE :");DSD.DumpLOI(lR3dFE,cout,aa);
836               TCollection_AsciiString bb("l3dFE :"); DSD.DumpLOI(l3dFE,cout,bb);}
837 #endif
838
839 //  FUN_unkeepEVIonGb1(BDS,EIX,l1dE);  // filter : 
840 //  FUN_unkeepEVIonGb1(BDS,EIX,l2dFE); // filter : 
841
842   // no reduction on G : we keep l3dF(G)
843   TopOpeBRepDS_ListOfInterference l3dFkeep; FUN_keepl3dF(EIX,HDS,l3dF,lR3dFE,l3dFkeep);
844   lF.Append(l3dFkeep);
845
846   // reducer2d :
847   // ----------
848   // l2dFE -> LR2dFE + l2dFE (non reduced 2dI)
849   TopOpeBRepDS_ListOfInterference LR2dFE; FUN_ReducerEdge(EIX,BDS,l2dFE,LR2dFE);
850
851   // reducer1d :
852   // ----------
853   // xpu210498 : reduce interferences I1(T1(esd1),VG,esd1), I2(T2(esd2),VG,esd2)
854   // if EIX sdm {esd1,esd2}
855   // - t2_2 e32 has I1(in/ou(e32),v30,e20) && I2(ou/in(e20),v30,e20) -
856   TopOpeBRepDS_ListOfInterference lR1dEsd; FUN_ReducerSDEdge(EIX,BDS,l1dEsd,lR1dEsd);
857
858   // xpu190298 : edge <EIX> same domain with closed support edge <SE>
859   // at same G = vertex <VG>  = closing vertex of <SE>
860   //  (I1 = (OU/IN(SE),VG,SE) && I2 = (IN/OU(SE),VG,SE)) -> Ir = (IN/IN(SE),VG,SE)
861   TopOpeBRepDS_ListOfInterference lR1dclosedSE; FUN_reclSE(EIX,BDS,l1dE,lR1dclosedSE);  
862
863   // l1dE  -> LR1dE + l1dE (non reduced 2dI)
864   TopOpeBRepDS_ListOfInterference LR1dE;  FUN_ReducerEdge(EIX,BDS,l1dE,LR1dE);
865
866   //  attached to edge <EIX>,
867   //  at same G : I  =(T,  G,S)   gives less information than
868   //              Ir =(Tr,G,Sr) -reduced interference- with valid Tr 
869   //  -> unkeep I.
870   // using reduced I : lR3dFE, LR2dFE, LR1dE
871   TopOpeBRepDS_ListOfInterference LRI; 
872   LRI.Append(lR1dEsd); LRI.Append(LR1dE); LRI.Append(lR1dclosedSE);
873   LRI.Append(LR2dFE);
874   LRI.Append(lR3dFE);
875
876   lF.Append(lFE); lF.Append(l3dFE); lF.Append(l2dFE);// lF += LFE + l3dFE + l2dFE
877   lE.Append(l1dE);                                   // lE += l1dE
878   lE.Append(l1dEsd);                                 // lE += l1dEsd xpu210498
879 //  TopOpeBRepDS_ListOfInterference LItmp; LItmp.Append(lF); LItmp.Append(lE);
880
881   // xpu : 23-01-98 : attached to edge <EIX>,
882   //  at same G : I  =(T, G, S) gives less information than
883   //              Ir =(Tr,G,Sr) -reduced interference- 
884   //  -> I is added after Ir to help the edge builder.
885   LI.Clear(); 
886   LI.Append(LRI);LI.Append(lE);LI.Append(lF);
887 //  FUN_reorder(EIX,HDS,LRI, LItmp, LI); 
888   
889   // xpu260698 : cto902A5, spOU(e6)
890   //             cto801G1, spON(se26) 
891   if (isse) {
892     FUN_unkeepEVIonGb1(BDS,EIX,LI);  // filter : 
893   }
894 //FUN_unkeepEVIonGb1(BDS,EIX,LI);  // filter : 
895   
896 #ifdef DEB
897   if (TRC){TCollection_AsciiString aa("reduced->");DSD.DumpLOI(LI,cout,aa);}
898 #endif
899 } // ProcessEdgeInterferences
900
901 //=======================================================================
902 //function : ProcessEdgeInterferences
903 //purpose  : 
904 //=======================================================================
905 void TopOpeBRepDS_EIR::ProcessEdgeInterferences(const Standard_Integer EIX)
906 {
907   TopOpeBRepDS_DataStructure& BDS = myHDS->ChangeDS();
908
909 #ifdef DEB
910   TopOpeBRepDS_Dumper DSD(myHDS);       
911   Standard_Boolean TRC=DSREDUEDGETRCE(EIX);
912   if (TRC) {cout<<endl;debreducerE(EIX);}
913 #endif
914
915   // E is the edge, LI is list of interferences to compact
916   const TopoDS_Edge& E = TopoDS::Edge(BDS.Shape(EIX));
917   Standard_Boolean isdg = BRep_Tool::Degenerated(E);
918   if (isdg) return;
919
920   TopOpeBRepDS_ListOfInterference& LI = BDS.ChangeShapeInterferences(EIX);
921   TopOpeBRepDS_TKI newtki; newtki.FillOnGeometry(LI);
922   TopOpeBRepDS_TKI tki; tki.FillOnGeometry(LI);
923   for (tki.Init(); tki.More(); tki.Next()) {
924     TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
925     const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
926     if (K==TopOpeBRepDS_POINT) continue;
927     const TopoDS_Shape& vG = BDS.Shape(G);
928     TopoDS_Shape oovG; Standard_Boolean sdm = FUN_ds_getoov(vG,BDS,oovG);
929     if (!sdm) continue;
930     Standard_Integer OOG=BDS.Shape(oovG);
931     if (OOG == 0) continue;//NYIRaise
932
933     Standard_Boolean isb = newtki.IsBound(K,OOG);
934
935     // xpu201098 : cto904F6, e10,v6
936     Standard_Boolean isbound = Handle(TopOpeBRepDS_EdgeVertexInterference)::DownCast(loi.First())->GBound();
937     if (isbound) { // replacing vG with oovG
938       TopOpeBRepDS_ListIteratorOfListOfInterference it(loi); TopOpeBRepDS_ListOfInterference newloi;
939       for (; it.More(); it.Next()){
940         const Handle(TopOpeBRepDS_Interference)& I = it.Value();
941         TopOpeBRepDS_Kind GT,ST;
942         Standard_Integer G1,S;
943         FDS_data(I,GT,G1,ST,S);
944         Standard_Real par = FDS_Parameter(I);
945         Handle(TopOpeBRepDS_Interference) newI = MakeEPVInterference(I->Transition(),S,OOG,par,K,ST,Standard_False);
946         newloi.Append(newI);
947 #ifdef DEB
948         if (TRC) {cout<<"on e"<<EIX;I->Dump(cout);cout<<"gives ";newI->Dump(cout);cout<<endl;}
949 #endif
950       }
951       newtki.ChangeInterferences(K,G).Clear();
952       if (!isb) newtki.Add(K,OOG);
953       newtki.ChangeInterferences(K,OOG).Append(newloi);
954       continue;
955     }
956
957     if (!isb) continue;
958     TopOpeBRepDS_ListOfInterference& li = newtki.ChangeInterferences(K,OOG);
959     newtki.ChangeInterferences(K,G).Append(li);
960   } // tki
961
962   TopOpeBRepDS_ListOfInterference LInew;
963   for (newtki.Init(); newtki.More(); newtki.Next()) {
964     TopOpeBRepDS_Kind K; Standard_Integer G; newtki.Value(K,G);
965     TopOpeBRepDS_ListOfInterference& loi = newtki.ChangeValue(K,G);
966     ::FUN_ProcessEdgeInterferences(EIX,K,G,myHDS,loi);
967     LInew.Append(loi);
968   }
969   LI.Clear();
970   LI.Append(LInew);
971
972   Standard_Boolean performPNC = Standard_False; // JYL 28/09/98 : temporaire
973 #ifdef DEB
974   if (TopOpeBRepDS_GetcontextNOPNC()) performPNC = Standard_False;
975   if (TRC) debredpnc(EIX);
976 #endif
977   if (!performPNC) return;
978
979   // suppression des I/G(I) n'est accede par aucune courbe
980   // portee par une des faces cnx a EIX.
981   Standard_Boolean isfafa = BDS.Isfafa();
982   if (!isfafa) {
983
984     tki.Clear();
985     tki.FillOnGeometry(LI);
986     LI.Clear();
987
988     for (tki.Init(); tki.More(); tki.Next()) {
989       TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
990       TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G);
991       if (K != TopOpeBRepDS_POINT) {
992         LI.Append(loi);
993         continue;
994       }
995
996       const TopTools_ListOfShape& lfx = FDSCNX_EdgeConnexitySameShape(E,myHDS);
997 #ifdef DEB
998 //      Standard_Integer nlfx = lfx.Extent();
999 #endif
1000
1001       // nlfx < 2 => 0 ou 1 face accede E => pas d'autre fcx pouvant generer une courbe 3d
1002       TopTools_ListIteratorOfListOfShape itlfx(lfx);
1003       Standard_Boolean curvefound = Standard_False;
1004       for (; itlfx.More();itlfx.Next()) {
1005         const TopoDS_Face& fx = TopoDS::Face(itlfx.Value());
1006 //                  BDS.Shape(fx);
1007         const TopOpeBRepDS_ListOfInterference& lifx = BDS.ShapeInterferences(fx); TopOpeBRepDS_ListIteratorOfListOfInterference itlifx(lifx);
1008         if (!itlifx.More()) continue;
1009         
1010         Handle(TopOpeBRepDS_Interference) I1;TopOpeBRepDS_Kind GT1;Standard_Integer G1;TopOpeBRepDS_Kind ST1;Standard_Integer S1;
1011         for (; itlifx.More(); itlifx.Next()) {
1012           FDS_data(itlifx,I1,GT1,G1,ST1,S1);
1013           Standard_Boolean isfci = (GT1 == TopOpeBRepDS_CURVE);
1014           if (!isfci) continue;
1015           
1016           TopOpeBRepDS_ListOfInterference& lic = BDS.ChangeCurveInterferences(G1);
1017           TopOpeBRepDS_ListIteratorOfListOfInterference itlic(lic);
1018           if (!itlic.More()) continue;
1019           
1020           Handle(TopOpeBRepDS_Interference) I2;TopOpeBRepDS_Kind GT2;Standard_Integer G2;TopOpeBRepDS_Kind ST2;Standard_Integer S2;
1021           for (; itlic.More(); itlic.Next()) {
1022             FDS_data(itlic,I2,GT2,G2,ST2,S2);
1023             Standard_Boolean isp = (GT2 == TopOpeBRepDS_POINT);
1024             if (!isp) continue;
1025             if ( G2 != G ) continue;
1026             curvefound = Standard_True;
1027             break;
1028           } // itlic.More()
1029
1030           if (curvefound) break;
1031         } // itlifx.More()
1032
1033         if (curvefound) break;
1034       } // itlfx.More()
1035       
1036 #ifdef DEB
1037 //      Standard_Integer nLI = LI.Extent();
1038 #endif
1039       if (curvefound) {
1040         LI.Append(loi);
1041       } 
1042       else {
1043 #ifdef DEB
1044 //      if (TRC) {
1045 //        debredpnc(EIX);
1046           TCollection_AsciiString ss = "\n--- TopOpeBRepDS_EIR::ProcessEdgeInterferences : suppress pnc of E"; ss = ss + EIX;
1047           DSD.DumpLOI(loi,cout,ss);
1048 //      }
1049 #endif  
1050       }
1051       
1052     } // tki.More()
1053   } // (!isfafa)
1054   
1055 } // ProcessEdgeInterferences
1056
1057 // modified by NIZHNY-MKK  Mon Apr  2 15:34:56 2001.BEGIN
1058 static Standard_Boolean CheckInterferenceIsValid(const Handle(TopOpeBRepDS_Interference)& I, 
1059                                                  const TopoDS_Edge&                       theEdge, 
1060                                                  const TopoDS_Edge&                       theSupportEdge, 
1061                                                  const TopoDS_Vertex&                     theVertex) {
1062   Standard_Real pref = 0. ;
1063   Standard_Boolean ok = Standard_False;
1064   BRepAdaptor_Curve BC(theEdge);
1065
1066   Handle(TopOpeBRepDS_CurvePointInterference) CPI;
1067   CPI = Handle(TopOpeBRepDS_CurvePointInterference)::DownCast(I);
1068
1069   if(!CPI.IsNull()) {
1070     pref = CPI->Parameter();
1071     ok = Standard_True;
1072   }
1073
1074   if(!ok) {
1075     Handle(TopOpeBRepDS_EdgeVertexInterference) EVI = Handle(TopOpeBRepDS_EdgeVertexInterference)::DownCast(I);
1076     if(!EVI.IsNull()) {
1077       pref = EVI->Parameter();
1078       ok = Standard_True;
1079     }
1080   }
1081
1082   if(!ok)
1083     return ok;
1084
1085   gp_Pnt P3d1 = BC.Value(pref);
1086   Standard_Real dist, paronSupportE;      
1087   ok = FUN_tool_projPonE(P3d1,theSupportEdge,paronSupportE,dist);
1088
1089   if(!ok)
1090     return ok;
1091   BRepAdaptor_Curve BCtmp(theSupportEdge);
1092   gp_Pnt P3d2 = BCtmp.Value(paronSupportE);
1093   Standard_Real Tolerance = (BRep_Tool::Tolerance(theEdge) > BRep_Tool::Tolerance(theSupportEdge)) ? BRep_Tool::Tolerance(theEdge) : BRep_Tool::Tolerance(theSupportEdge);
1094   if(!theVertex.IsNull()) {
1095     Tolerance = (BRep_Tool::Tolerance(theVertex) > Tolerance) ? BRep_Tool::Tolerance(theVertex) : Tolerance;
1096   }
1097   if(P3d1.Distance(P3d2) > Tolerance) {
1098     ok = Standard_False;
1099   }
1100   
1101   return ok;
1102 }