Integration of OCCT 6.5.0 from SVN
[occt.git] / src / TopOpeBRepDS / TopOpeBRepDS_ProcessEdgeInterferences.cxx
1 // File:        TopOpeBRepDS_ProcessEdgeInterferences.cxx
2 // Created:     Thu Mar 21 11:40:31 1996
3 // Author:      Modelistation
4 //              <model@mentox>
5
6 #include <TopOpeBRepDS_EXPORT.hxx>
7 #include <TopOpeBRepDS_EdgeInterferenceTool.hxx>
8 #include <TopOpeBRepDS_EdgeVertexInterference.hxx>
9 #include <TopOpeBRepDS_CurvePointInterference.hxx>
10 #include <TopOpeBRepDS_TKI.hxx>
11 #include <TopoDS.hxx>
12 #include <TopoDS_Shell.hxx>
13 #include <TopoDS_Solid.hxx>
14 #include <TopExp_Explorer.hxx>
15 #include <TopExp.hxx>
16 #include <TopOpeBRepDS_ProcessInterferencesTool.hxx>
17 #include <BRep_Tool.hxx>
18 #include <Precision.hxx>
19 #include <Geom_Curve.hxx>
20 #include <BRep_Builder.hxx>
21 #include <TopOpeBRepDS_define.hxx>
22 #include <TopOpeBRepTool_EXPORT.hxx>
23 #include <TopOpeBRepDS_connex.hxx>
24 #include <TopOpeBRepTool_SC.hxx>
25
26 #ifdef DEB
27 Standard_IMPORT Standard_Boolean TopOpeBRepDS_GettracePEI();
28 Standard_IMPORT Standard_Boolean TopOpeBRepDS_GettracePI();
29 Standard_IMPORT Standard_Boolean TopOpeBRepDS_GettraceSPSX(const Standard_Integer);
30 Standard_IMPORT Standard_Boolean TopOpeBRepDS_GettraceEDPR();
31 static Standard_Boolean TRCE(const Standard_Integer SIX) {
32   Standard_Boolean b1 = TopOpeBRepDS_GettracePEI();
33   Standard_Boolean b2 = TopOpeBRepDS_GettracePI();
34   Standard_Boolean b3 = TopOpeBRepDS_GettraceSPSX(SIX);
35   return (b1 || b2 || b3);
36 }
37 Standard_EXPORT void debredunke(const Standard_Integer i){cout<<"++ debredunke e"<<i<<endl;};
38 Standard_EXPORT void debpurse  (const Standard_Integer i){cout<<"++ debpurse e"<<i<<endl;};
39 #endif
40
41 #define MDShcpi Handle(TopOpeBRepDS_CurvePointInterference)
42 #define MAKECPI(IJKLM) (Handle(TopOpeBRepDS_CurvePointInterference)::DownCast(IJKLM))
43
44 //------------------------------------------------------
45 Standard_EXPORT Standard_Boolean FUN_vertexofedge
46 //------------------------------------------------------
47 // FUN_vertexofedge :  True si le vertex V est un vertex de E
48 (const TopoDS_Shape& V, const TopoDS_Shape& E)
49 {
50   Standard_Boolean isv = Standard_False;
51   TopExp_Explorer ex;
52   for (ex.Init(E,TopAbs_VERTEX); ex.More(); ex.Next())
53 //  for (TopExp_Explorer ex(E,TopAbs_VERTEX); ex.More(); ex.Next())
54     if (ex.Current().IsSame(V) ) {
55       isv = Standard_True;
56       break;
57     }
58   return isv;
59 }
60
61 //------------------------------------------------------
62 static Standard_Boolean FUN_keepEinterference
63 //------------------------------------------------------
64 (const TopOpeBRepDS_DataStructure& DS,const Handle(TopOpeBRepDS_Interference)& I,const TopoDS_Shape& E)
65 {
66   TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I,GT1,G1,ST1,S1);
67   
68   Standard_Boolean res = Standard_True;
69   if ( I->IsKind(STANDARD_TYPE(TopOpeBRepDS_EdgeVertexInterference)) ) {
70     // EVI I rejetee si son arete-support est E accedant I
71     Standard_Boolean k1 = ! ::FUN_interfhassupport(DS,I,E);
72     res = k1;
73     
74     // EVI rejetee si transition ON EDGE before ou after
75     const TopOpeBRepDS_Transition& T = I->Transition();
76     TopAbs_ShapeEnum shab = T.ShapeBefore(),shaa = T.ShapeAfter();
77     TopAbs_State stab = T.Before(),staa = T.After();
78     Standard_Boolean k2 = ! (((shab == TopAbs_EDGE) && (stab == TopAbs_ON)) ||
79                 ((shaa == TopAbs_EDGE) && (staa == TopAbs_ON))); 
80     res = res && k2;
81     
82     const TopoDS_Shape& VG = DS.Shape(I->Geometry());
83
84     /*   xpu : 20-01-98
85     // EVI I  rejetee si son vertex-geometrie est un vertex de l'arete 
86     // qui accede I.
87     Standard_Boolean k3 = ! ::FUN_vertexofedge(VG,E);
88     res = res && k3;
89     */
90
91     // EVI rejetee si OUT FACE before et after
92     // et si le vertex-geometrie de l'interference collisionne avec
93     // un des vertex de l'arete (E) accedant l'interference (I)
94 #ifdef DEB
95   //  Standard_Boolean k4I = (((shab == TopAbs_FACE) && (stab == TopAbs_OUT)) &&
96 //              ((shaa == TopAbs_FACE) && (staa == TopAbs_OUT))); 
97 #endif
98     Standard_Boolean k4C = Standard_False;
99     {
100       TopoDS_Vertex Vf,Vr; TopExp::Vertices(TopoDS::Edge(E),Vf,Vr);
101       TopTools_ListIteratorOfListOfShape it(DS.ShapeSameDomain(VG));
102       for (; it.More(); it.Next()) {
103         const TopoDS_Shape& Vsd = it.Value();
104         if      ( Vsd.IsSame(Vf) ) { k4C = Standard_True; break; }
105         else if ( Vsd.IsSame(Vr) ) { k4C = Standard_True; break; }
106       }
107     }
108 #ifdef DEB
109 //    Standard_Boolean k4 = ! ( k4I && k4C ); 
110 #endif
111     //    res = res && k4;
112   }
113
114   else if ( I->IsKind(STANDARD_TYPE(TopOpeBRepDS_CurvePointInterference)) ) {
115     Handle(TopOpeBRepDS_CurvePointInterference) aCPI =
116       Handle(TopOpeBRepDS_CurvePointInterference)::DownCast(I);
117
118     // MSV Oct 4, 2001: reject interference having the parameter coinciding with
119     //                  one of sides of the edge range
120
121     Standard_Real eps = Precision::PConfusion();
122     Standard_Real par = aCPI->Parameter();
123     Standard_Real f,l;
124     BRep_Tool::Range(TopoDS::Edge(E), f,l);
125     if (Abs(par-f) < eps || Abs(par-l) < eps)
126       res = Standard_False;
127   }
128
129   return res;
130 }
131
132 //------------------------------------------------------
133 Standard_EXPORT Standard_Integer FUN_unkeepEinterferences
134 //------------------------------------------------------
135 (TopOpeBRepDS_ListOfInterference& LI,const TopOpeBRepDS_DataStructure& BDS,const Standard_Integer SIX)
136 {
137 #ifdef DEB
138   Standard_Boolean TRC=TRCE(SIX);
139 #endif
140   
141   const TopoDS_Shape& E = BDS.Shape(SIX);
142   Standard_Boolean isEd;
143   isEd = BRep_Tool::Degenerated(TopoDS::Edge(E));
144   
145 #ifdef DEB
146   if (TRC) {cout<<"FUN_unkeepEinterferences on "<<SIX<<" nI = "<<LI.Extent()<<endl;}
147 #endif
148   
149   if (isEd) {
150     return LI.Extent();
151   }
152   
153   TopOpeBRepDS_ListIteratorOfListOfInterference it1(LI);
154   while (it1.More() ) {
155     Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
156     Standard_Boolean k1 = ::FUN_keepEinterference(BDS,I1,E);
157     if ( !k1 ) {
158       
159 #ifdef DEB
160       if(TRC) {cout<<endl<<"rejet d'interference "<<SIX<<endl;I1->Dump(cout);cout<<endl;}
161 #endif
162       
163       LI.Remove(it1);
164       continue;
165     }
166     else {
167       it1.Next();
168     }
169   }
170   Standard_Integer n = LI.Extent();
171   
172 #ifdef DEB
173   if (TRC) cout<<"FUN_unkeepEinterferences on "<<SIX<<" returns nI = "<<n<<endl;
174 #endif
175   
176   return n;
177 } // FUN_unkeepEinterferences
178
179 /*
180 //------------------------------------------------------
181 Standard_EXPORT void FUN_changeFOUT
182 //------------------------------------------------------
183 (TopOpeBRepDS_ListOfInterference& LF,const TopOpeBRepDS_ListOfInterference& LE,const TopOpeBRepDS_DataStructure& BDS,const Standard_Integer SIX)
184 {
185 #ifdef DEB
186   Standard_Boolean TRC=TRCE(SIX);
187   if (TRC) cout<<"FUN_changeFOUT on "<<SIX<<" nI = "<<LE.Extent()<<endl;
188 #endif
189
190   const TopoDS_Shape& E = BDS.Shape(SIX);
191   
192   // reduction du cas OUT(FACE),OUT(FACE) par un vertex si on 
193   // trouve une transition EDGE par ce meme vertex.
194   // pour toute interference Fi de LF = OUT(FACE),OUT(FACE) par vertex V
195   // chercher une interference Ei de LE : 
196   // 1/ Ei = IN(EDGE),OUT(EDGE) par vertex V <==> ON(FACE),OUT(EDGE) par vertex V
197   // 2/ Ei = OUT(EDGE),IN(EDGE) par vertex V <==> OUT(EDGE),ON(EDGE) par vertex V
198   // si trouve 1/ : Fi devient IN(FACE),OUT(FACE)
199   // si trouve 2/ : Fe devient OUT(FACE),IN(FACE)
200   
201   TopOpeBRepDS_ListIteratorOfListOfInterference it1(LF);
202   while (it1.More()) {
203     Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
204     TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
205     
206     if ( GT1 == TopOpeBRepDS_VERTEX ) {
207       TopOpeBRepDS_Transition& T1 = I1->ChangeTransition();
208       TopAbs_ShapeEnum shab1 = T1.ShapeBefore(), shaa1 = T1.ShapeAfter();
209       TopAbs_State     stab1 = T1.Before(), staa1 = T1.After();
210       const Standard_Boolean foub = (shab1 == TopAbs_FACE) && (stab1 == TopAbs_OUT);
211       const Standard_Boolean foua = (shaa1 == TopAbs_FACE) && (staa1 == TopAbs_OUT);
212       const Standard_Boolean foufou = foub && foua;
213       if (!foufou) {
214         it1.Next();
215         continue;
216       }
217       
218       TopOpeBRepDS_ListIteratorOfListOfInterference it2(LE);
219       while (it2.More()) {
220         const Handle(TopOpeBRepDS_Interference)& I2 = it2.Value();
221         TopOpeBRepDS_Kind GT2,ST2; Standard_Integer G2,S2; FDS_data(I2,GT2,G2,ST2,S2);
222         
223         Standard_Boolean memver = ((GT2 == GT1) && (G2 == G1));
224         if ( ! memver ) {
225           it2.Next();
226           continue;
227         }
228         
229         const TopOpeBRepDS_Transition& T2 = I2->Transition();
230         TopAbs_ShapeEnum shab2 = T2.ShapeBefore(), shaa2 = T2.ShapeAfter();
231         TopAbs_State     stab2 = T2.Before(), staa2 = T2.After();
232         const Standard_Boolean eoub = (shab2 == TopAbs_EDGE) && (stab2 == TopAbs_OUT);
233         const Standard_Boolean einb = (shab2 == TopAbs_EDGE) && (stab2 == TopAbs_IN);
234         const Standard_Boolean eoua = (shaa2 == TopAbs_EDGE) && (staa2 == TopAbs_OUT);
235         const Standard_Boolean eina = (shaa2 == TopAbs_EDGE) && (staa2 == TopAbs_IN);
236         const Standard_Boolean eouein = (eoub && eina);
237         const Standard_Boolean eineou = (einb && eoua);
238         Standard_Boolean changeFi = (eouein || eineou);
239         if ( ! changeFi ) {
240           it2.Next();
241           continue;
242         }
243         
244         // on modifie T1 de I1 et on arrete la pour I1
245         if      (eouein) T1.After(TopAbs_IN,TopAbs_FACE);
246         else if (eineou) T1.Before(TopAbs_IN,TopAbs_FACE);
247         break;
248         
249         it2.Next();
250       }
251       
252     }
253     it1.Next();
254   }
255 #ifdef DEB
256   if (TRC) cout<<"  FUN_changeFOUT on "<<SIX<<"returns nI = "<<LE.Extent()<<endl;
257 #endif
258   
259 }*/
260
261 //------------------------------------------------------
262 Standard_EXPORT void FUN_unkeepEsymetrictransitions
263 //------------------------------------------------------
264 // unkeepEsymetric  : pour pallier au fonctionnement limite du TopTrans_CurveTransition
265 // qui ne peut pas gerer correctement deux fois la meme arete (FORWARD,REVERSED) 
266 // incidentes en un vertex. (cas d'un shell fait de deux faces partageant une arete.)
267 (TopOpeBRepDS_ListOfInterference& LI,const TopOpeBRepDS_DataStructure& BDS,const Standard_Integer SIX)               
268 {
269 #ifdef DEB
270   Standard_Boolean TRC=TRCE(SIX);
271 #endif
272   
273   const TopoDS_Shape& E = BDS.Shape(SIX);
274   
275   Standard_Boolean isEd;
276   isEd = BRep_Tool::Degenerated(TopoDS::Edge(E));
277   
278 #ifdef DEB
279   if (TRC) {
280     cout<<"FUN_unkeepEsymetrictransitions on "<<SIX<<" nI = "<<LI.Extent()<<endl;
281     ::FDS_dumpLI(LI,"debut : ");
282   }
283 #endif
284   
285   if (isEd) return;
286   
287   TopOpeBRepDS_ListIteratorOfListOfInterference it1;
288   
289   // process interferences of LI with VERTEX geometry
290   
291   it1.Initialize(LI);
292   while (it1.More() ) {
293     Standard_Boolean it1toremove = Standard_False;
294     Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
295     TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
296     TopAbs_ShapeEnum tsb1,tsa1; Standard_Integer isb1,isa1; ::FDS_Tdata(I1,tsb1,isb1,tsa1,isa1);
297     const TopOpeBRepDS_Transition T1 = I1->Transition();
298     
299     TopOpeBRepDS_ListIteratorOfListOfInterference it2(it1);
300     it2.Next();
301     while ( it2.More() ) {
302       const Handle(TopOpeBRepDS_Interference)& I2 = it2.Value();
303       TopOpeBRepDS_Kind GT2,ST2; Standard_Integer G2,S2; FDS_data(I2,GT2,G2,ST2,S2);
304       TopAbs_ShapeEnum tsb2,tsa2; Standard_Integer isb2,isa2; ::FDS_Tdata(I2,tsb2,isb2,tsa2,isa2);
305       const TopOpeBRepDS_Transition T2 = I2->Transition(); // + 03-03-97        
306       Standard_Boolean idGS = (GT2 == GT1 && G2 == G1 && ST2 == ST1 && S2 == S1);
307       Standard_Boolean idiba = (isb1 == isb2 && isa1 == isa2);
308       Standard_Boolean cond = idGS;
309       cond = cond && idiba; // ++971219
310
311       if (cond) {
312         Standard_Boolean idshape = ::FUN_transitionSHAPEEQUAL(T1,T2);
313         Standard_Boolean idstate = ::FUN_transitionSTATEEQUAL(T1,T2);
314         Standard_Boolean newV = Standard_True;
315         Standard_Boolean oppostate;
316         
317         if (newV) {
318           // sym is not precise enough (croix3_3-> OUT/IN; ON/OUT)
319 #define M_OUTIN(st1,st2) ((st1 == TopAbs_OUT)&&(st2 == TopAbs_IN))
320           TopAbs_State t1b = T1.Before(), t2b = T2.Before();
321           TopAbs_State t1a = T1.After(), t2a = T2.After();
322           oppostate = M_OUTIN(t1b,t2b) || M_OUTIN(t2b,t1b);
323           oppostate = oppostate && (M_OUTIN(t1a,t2a) || M_OUTIN(t2a,t1a));
324         }         
325         
326         Standard_Boolean sym;
327         if (newV) sym = idshape && oppostate;
328         else sym = idshape && !idstate;
329         
330         if ( sym ) { // les 2 interferences ne different que leurs etats (symetriques)
331 #ifdef DEB
332 //        cout<<"TopOpeBRepDS FUN_unkeepEsymetrictransitions on edge "<<SIX<<endl;
333           if(TRC){
334             cout<<"edge "<<SIX<<" : symetrique ";I1->Dump(cout);cout<<endl;
335             cout<<"                    ";I2->Dump(cout);cout<<endl;
336           }
337 #endif
338           LI.Remove(it2);
339           it1toremove = Standard_True;
340         }
341         else it2.Next();
342       }
343       else it2.Next();
344     }
345     if (it1toremove) {
346       LI.Remove(it1);
347     }
348     else {
349       it1.Next();
350     }
351   } // it1.More()
352   
353 #ifdef DEB
354   if(TRC) { 
355     ::FDS_dumpLI(LI,"apres elim. des sym. : ");
356     cout<<"FUN_unkeepEsymetrictransitions on "<<SIX<<" returns nI = "<<LI.Extent()<<endl;
357   }
358 #endif  
359 }
360
361 #ifdef DEB
362 void deborderFF(const Standard_Integer) {};
363 void deborderFF1(const Standard_Integer) {};
364 void deborderFF2(const Standard_Integer) {};
365 #endif
366
367 //------------------------------------------------------
368 Standard_EXPORT void FUN_orderFFsamedomain
369 //------------------------------------------------------
370 // partition de LI en deux sous listes : 
371 // L1/ = interfs dont la transition est definie / face samedomain
372 // L2/ = les autres interfs
373 // L = L1 + L2;
374   (TopOpeBRepDS_ListOfInterference& LI,
375    const Handle(TopOpeBRepDS_HDataStructure)& HDS,
376 #ifdef DEB
377    const Standard_Integer SIX)    
378 #else
379    const Standard_Integer )    
380 #endif
381 {
382 #ifdef DEB
383   Standard_Boolean TRC=TRCE(SIX); 
384   if (TRC) deborderFF(SIX);
385   Standard_Boolean modif = Standard_False;
386 #endif
387   
388   TopOpeBRepDS_DataStructure& BDS = HDS->ChangeDS();
389   TopOpeBRepDS_ListOfInterference LIffsd,LIother;
390 //  BDS.Shape(SIX);
391   TopOpeBRepDS_ListIteratorOfListOfInterference it1;
392   
393   it1.Initialize(LI);
394   while (it1.More() ) {
395     Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
396     TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
397     TopAbs_ShapeEnum tsb1,tsa1; Standard_Integer isb1,isa1; FDS_Tdata(I1,tsb1,isb1,tsa1,isa1);
398 //    I1->Transition();
399     
400 #ifdef DEB
401     if (TRC) deborderFF1(SIX);
402 #endif
403     
404     Standard_Boolean ffsd = Standard_False;
405     if (tsb1 == TopAbs_FACE && tsa1 == TopAbs_FACE) {
406       // T1 states are defined on FACEs
407       const TopoDS_Shape& fb = BDS.Shape(isb1);
408       const TopoDS_Shape& fa = BDS.Shape(isa1);
409       Standard_Boolean ffsd1 = HDS->HasSameDomain(fb);
410       Standard_Boolean ffsd2 = HDS->HasSameDomain(fa);
411       ffsd = ffsd1 && ffsd2;
412     }
413     
414     if (ffsd) LIffsd.Append(I1);
415     else      LIother.Append(I1);
416     
417     LI.Remove(it1);
418   } // it1.More()
419   
420   LI.Clear();
421   LI.Append(LIffsd);
422   LI.Append(LIother);
423
424 #ifdef DEB
425   if(TRC && modif){ FDS_dumpLI(LI,"apres groupage fsd : "); }
426 #endif  
427 } // FUN_orderFFsamedomain
428
429
430 #ifdef DEB
431 void deborderSTATETRANS(const Standard_Integer) {};
432 #endif
433
434 //------------------------------------------------------
435 Standard_EXPORT void FUN_orderSTATETRANSonG
436 //------------------------------------------------------
437 // LI : liste d'interf en une meme Geometrie (K,G) 
438 // partition de LI en deux sous listes : 
439 // L1/ = interfs dont la transition a des etats egaux
440 // L2/ = les autres interfs
441 // L = L1 + L2;
442 (TopOpeBRepDS_ListOfInterference& LI,const Handle(TopOpeBRepDS_HDataStructure)& /*HDS*/,
443 #ifdef DEB
444  const Standard_Integer SIX)    
445 #else
446  const Standard_Integer)
447 #endif
448 {
449 #ifdef DEB
450   Standard_Boolean TRC=TRCE(SIX); 
451   if (TRC) deborderSTATETRANS(SIX);
452   Standard_Boolean modif = Standard_False;
453 #endif
454   
455 //  TopOpeBRepDS_DataStructure& BDS = HDS->ChangeDS();
456   TopOpeBRepDS_ListOfInterference L1,L2;
457   TopOpeBRepDS_ListIteratorOfListOfInterference it1;
458   
459   it1.Initialize(LI);
460   while (it1.More() ) {
461     Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
462     TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; TopAbs_ShapeEnum tsb1,tsa1; Standard_Integer isb1,isa1; 
463     FDS_Idata(I1,tsb1,isb1,tsa1,isa1,GT1,G1,ST1,S1);
464     const TopOpeBRepDS_Transition& T1 = I1->Transition();
465     TopAbs_State stab1 = T1.Before();
466     TopAbs_State staa1 = T1.After();
467
468     Standard_Boolean steq = (tsb1 == tsa1 && isb1 == isa1 && stab1 == staa1);
469     if (steq) L1.Append(I1);
470     else      L2.Append(I1);
471
472     it1.Next();
473   } // it1.More()
474   
475   LI.Clear();
476   LI.Append(L1);
477   LI.Append(L2);
478 #ifdef DEB
479   if(TRC && modif){ FDS_dumpLI(LI,"apres groupage STATETRANS : "); }
480 #endif  
481 } // FUN_orderSTATETRANSonG
482
483 //------------------------------------------------------
484 Standard_EXPORT void FUN_orderSTATETRANS
485 //------------------------------------------------------
486 // partition de LI en deux sous listes : 
487 // L1/ = interfs dont la transition a des etats egaux
488 // L2/ = les autres interfs
489 // L = L1 + L2;
490 (TopOpeBRepDS_ListOfInterference& LI,const Handle(TopOpeBRepDS_HDataStructure)& HDS,const Standard_Integer SIX)    
491 {
492 #ifdef DEB
493   Standard_Boolean TRC=TRCE(SIX); 
494   if (TRC) deborderSTATETRANS(SIX);
495 #endif
496
497   TopOpeBRepDS_TKI tki;
498   tki.FillOnGeometry(LI);
499   tki.Init();
500   for (; tki.More(); tki.Next()) {
501     TopOpeBRepDS_Kind K; Standard_Integer G; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G);
502     ::FUN_orderSTATETRANSonG(loi,HDS,SIX);
503   }
504
505   LI.Clear();
506   tki.Init();
507   for (; tki.More(); tki.Next()) {
508     TopOpeBRepDS_Kind K; Standard_Integer G; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G);
509     LI.Append(loi);
510   }
511 } // FUN_orderSTATETRANS
512
513 //------------------------------------------------------
514 Standard_EXPORT void FUN_resolveEUNKNOWN
515 //------------------------------------------------------
516 (TopOpeBRepDS_ListOfInterference& LI,TopOpeBRepDS_DataStructure& BDS,const Standard_Integer SIX)
517 {
518 #ifdef DEB
519   Standard_Boolean TRC=TRCE(SIX); if (TRC) debredunke(SIX);
520   Standard_Boolean modif = Standard_False;
521 #endif
522
523   const TopoDS_Shape& E = BDS.Shape(SIX);
524   TopOpeBRepDS_ListIteratorOfListOfInterference it1;
525   
526   const TopoDS_Edge& EE = TopoDS::Edge(E);
527   Standard_Real fE,lE; BRep_Tool::Range(EE,fE,lE);
528   
529   // process interferences of LI with UNKNOWN transition
530   
531   for (it1.Initialize(LI); it1.More(); it1.Next() ) {
532     Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
533     const TopOpeBRepDS_Transition& T1 = I1->Transition();
534     Standard_Boolean isunk = T1.IsUnknown();
535     if (!isunk) continue;
536
537 #ifdef DEB
538     modif = Standard_True;
539     if(TRC){debredunke(SIX);TCollection_AsciiString s="E";s=s+SIX+" T UNKNOWN ";I1->Dump(cout,s,"\n");}
540 #endif
541     
542     TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; TopAbs_ShapeEnum tsb1,tsa1; Standard_Integer isb1,isa1; 
543     FDS_Idata(I1,tsb1,isb1,tsa1,isa1,GT1,G1,ST1,S1);
544     Standard_Boolean idt = (tsb1==TopAbs_FACE && tsa1==TopAbs_FACE 
545                && GT1==TopOpeBRepDS_POINT && ST1==TopOpeBRepDS_FACE);
546     Standard_Boolean idi = (isb1==S1 && isa1==S1);
547     Standard_Boolean etgf = idt && idi; // edge tangent a une face en 1 point
548     if (!etgf) continue;
549
550 #ifdef DEB
551     if(TRC){debredunke(SIX);TCollection_AsciiString s="E";s=s+SIX+" etgf ";I1->Dump(cout,s,"\n");}
552 #endif
553
554     Handle(TopOpeBRepDS_CurvePointInterference) cpi = MAKECPI(I1);
555     if (cpi.IsNull()) continue;
556
557     Standard_Real bid; Handle(Geom_Curve) CE = BRep_Tool::Curve(EE,bid,bid);
558     if (CE.IsNull()) continue; // NYI : get points from 2d curve
559
560     Standard_Real parcpi = cpi->Parameter();
561     Standard_Real ttb = 0.8; Standard_Real parb = (1-ttb)*fE + ttb*parcpi;
562     Standard_Real tta = 0.2; Standard_Real para = (1-tta)*parcpi + tta*lE;
563     gp_Pnt Pb;CE->D0(parb,Pb);
564     gp_Pnt Pa;CE->D0(para,Pa);
565
566     BRep_Builder BB;
567     const TopoDS_Face& FS = TopoDS::Face(BDS.Shape(S1));
568     TopoDS_Shell sh; BB.MakeShell(sh);
569     TopoDS_Solid so; BB.MakeSolid(so);
570     BB.Add(sh,FS);BB.Add(so,sh);
571     TopOpeBRepTool_ShapeClassifier& PSC = FSC_GetPSC(so);
572     PSC.StateP3DReference(Pb);
573     TopAbs_State stateb = PSC.State();
574     PSC.StateP3DReference(Pa);
575     TopAbs_State statea = PSC.State();
576     if (stateb==TopAbs_UNKNOWN || statea==TopAbs_UNKNOWN) continue;
577
578     TopOpeBRepDS_Transition& newT1 = I1->ChangeTransition();
579     newT1.Set(stateb,statea,tsb1,tsa1);
580
581 #ifdef DEB
582     if(TRC){debredunke(SIX);TCollection_AsciiString s="E";s=s+SIX+" T corrected ";I1->Dump(cout,s,"\n");}
583 #endif
584
585   }
586
587 #ifdef DEB
588   if(TRC && modif){ FDS_dumpLI(LI,"apres correction UNKNOWN : "); }
589 #endif  
590
591   FUN_unkeepUNKNOWN(LI,BDS,SIX);
592   
593 #ifdef DEB
594   if(TRC && modif){ FDS_dumpLI(LI,"sans suppression UNKNOWN residuels : "); }
595 #endif  
596 }
597
598 // ----------------------------------------------------------------------
599 Standard_EXPORT void FUN_purgeDSonSE(const Handle(TopOpeBRepDS_HDataStructure)& HDS,const Standard_Integer EIX,TopOpeBRepDS_ListOfInterference& LI)
600 // ----------------------------------------------------------------------
601 {
602 #ifdef DEB    
603   Standard_Boolean trc = TopOpeBRepDS_GettraceSPSX(EIX);
604   if (trc) {cout<<endl<<"FUN_purgeDSonSE on "<<EIX<<" nI = "<<LI.Extent()<<endl;}
605 #endif
606   
607   // recall  : (I1,I2) / I1=(T(F),G,S=edge), I2=(T(F),G,S=F) describes a 3d interference  
608   //   
609   // purpose : attached to EIX (section egde SE), I=(T(Fsdm),G,S) /
610   //           Fsdm shares same domain with Fanc ancestor face of SE
611   //            => SE has split ON near G =>
612   //           I'=(T(Fsdm),G,S=Fsdm) gives bad information (3d information whereas
613   //           we should only have 2d information)
614   // - PRO12660 for spON(e48) - 
615   
616   TopOpeBRepDS_DataStructure& BDS = HDS->ChangeDS();
617   const TopoDS_Edge& SE = TopoDS::Edge(BDS.Shape(EIX));
618   Standard_Integer rkSE = BDS.AncestorRank(SE);
619   Standard_Boolean isse = BDS.IsSectionEdge(SE);
620   if (!isse) return;
621   
622 #ifdef DEB
623   if (trc) debpurse(EIX);
624 #endif
625
626   TopTools_MapOfShape fsdmFancSE;
627   // ---------------
628   const TopTools_ListOfShape& lFancSE = FDSCNX_EdgeConnexitySameShape(SE,HDS);
629   for (TopTools_ListIteratorOfListOfShape itf(lFancSE); itf.More(); itf.Next()){
630     const TopTools_ListOfShape& fsdm = BDS.ShapeSameDomain(itf.Value());
631     for (TopTools_ListIteratorOfListOfShape itsdm(fsdm); itsdm.More(); itsdm.Next()){
632       const TopoDS_Shape& sdmf = itsdm.Value();
633       Standard_Integer sdmrk = BDS.AncestorRank(sdmf);
634       if (sdmrk == rkSE) continue;
635       fsdmFancSE.Add(sdmf);
636     }
637   }  
638   if (fsdmFancSE.IsEmpty()) return;
639
640   TopOpeBRepDS_ListOfInterference newLI;
641   // ---------
642   TopOpeBRepDS_TKI tki;
643   tki.FillOnGeometry(LI);       
644   for (tki.Init(); tki.More(); tki.Next()) {  
645   
646     TopOpeBRepDS_Kind Kcur; Standard_Integer Gcur; TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(Kcur,Gcur);  
647 #ifdef DEB
648 //    Standard_Boolean hasfsdmFanc = Standard_False; 
649 #endif 
650     TopOpeBRepDS_ListIteratorOfListOfInterference it(loi);
651 //    for (; it.More(); it.Next()){
652 //      const Handle(TopOpeBRepDS_Interference)& I = it.Value();
653 //      TopAbs_ShapeEnum tsb,tsa; Standard_Integer isb,isa; FDS_Tdata(I,tsb,isb,tsa,isa);
654 //      if (tsb != TopAbs_FACE) continue;
655 //      const TopoDS_Shape& f = BDS.Shape(isb); Standard_Integer ifa = BDS.Shape(f); // DEB
656 //      Standard_Boolean isbound = fsdmFancSE.Contains(f);
657 //      if (isbound) {hasfsdmFanc = Standard_True; break;}
658 //    }
659 //    if (!hasfsdmFanc) 
660 //      {newLI.Append(loi); continue;}    
661 //    TopOpeBRepDS_ListOfInterference LIface; Standard_Integer nfound = FUN_selectSIinterference(loi,TopOpeBRepDS_FACE,LIface);
662
663     // - cto 900 D1 - : we need interference I''=(T(face),G,face), face !sdmFancSE
664     //                  to compute spOUT(e9)
665
666     TopOpeBRepDS_ListOfInterference LIface; 
667     for (; it.More(); it.Next()){
668       const Handle(TopOpeBRepDS_Interference)& I = it.Value();
669       TopOpeBRepDS_Kind GT,ST; Standard_Integer G,S; FDS_data(I,GT,G,ST,S);
670       TopAbs_ShapeEnum tsb,tsa; Standard_Integer isb,isa; FDS_Tdata(I,tsb,isb,tsa,isa);
671
672       if (tsb != TopAbs_FACE)       {newLI.Append(I); continue;}
673       if (ST  != TopOpeBRepDS_FACE) {newLI.Append(I); continue;}
674
675       const TopoDS_Shape& f = BDS.Shape(isb);
676       Standard_Boolean isbound = fsdmFancSE.Contains(f);
677       if (isbound) LIface.Append(I);
678       else         newLI.Append(I);
679     }
680
681 #ifdef DEB
682     if (trc)
683       for (TopOpeBRepDS_ListIteratorOfListOfInterference itt(LIface); itt.More(); itt.Next())
684         {cout<<"rejet d'interference "<<EIX<<" ";itt.Value()->Dump(cout);cout<<endl;}
685 #endif
686 //    newLI.Append(loi);
687   } // tki
688
689   LI.Clear();
690   LI.Append(newLI);
691
692 #ifdef DEB
693   if (trc) cout<<"FUN_purgeDSonSE on "<<EIX<<" returns nI = "<<LI.Extent()<<endl;
694 #endif
695 }