0022922: Clean up warnings on uninitialized / unused variables
[occt.git] / src / TopOpeBRep / TopOpeBRep_FacesFiller_1.cxx
1 // File:      TopOpeBRep_FacesFiller_1.cxx
2 // Created:   Thu Feb 17 11:02:12 1994
3 // Author:    Jean Yves LEBEY
4 // Copyright: OPEN CASCADE 1994
5
6 #include <TopOpeBRep_FacesFiller.ixx>
7
8 #include <BRep_Tool.hxx>
9 #include <TopoDS.hxx>
10 #include <TopExp.hxx>
11 #include <Standard_CString.hxx>
12 #include <BRepTools.hxx>
13 #include <Precision.hxx>
14 #include <TColStd_ListOfInteger.hxx>
15 #include <TColStd_ListIteratorOfListOfInteger.hxx>
16
17 #include <TopOpeBRep_FFDumper.hxx>
18 #include <TopOpeBRepTool_TOOL.hxx>
19 #include <TopOpeBRepTool_defineG.hxx>
20 #include <TopOpeBRepTool_EXPORT.hxx>
21 #include <TopOpeBRepTool_makeTransition.hxx>
22
23 #include <TopOpeBRepDS_Dumper.hxx>
24 #include <TopOpeBRepDS_InterferenceTool.hxx>
25 #include <TopOpeBRepDS_Curve.hxx>
26 #include <TopOpeBRepDS_ProcessInterferencesTool.hxx>
27
28 #include <TopOpeBRep.hxx>
29 #include <TopOpeBRep_FFTransitionTool.hxx>
30 #include <TopOpeBRep_GeomTool.hxx>
31 #include <TopOpeBRep_PointGeomTool.hxx>
32 #include <TopOpeBRep_FFDumper.hxx>
33
34 #include <TopOpeBRep_define.hxx>
35
36 #include <Bnd_Box.hxx>
37 #include <BndLib_Add3dCurve.hxx>
38
39 #ifdef DRAW
40 #include <TopOpeBRep_DRAW.hxx>
41 #endif
42
43 #ifdef DEB
44 Standard_EXPORT void debrest(const Standard_Integer i)   {cout<<"+ debrest "<<i<<endl;}
45 Standard_EXPORT void debrline()   {cout<<"+ debrline"<<endl;}
46
47 Standard_EXPORT Standard_Boolean TopOpeBRepDS_GettraceCX(const Standard_Integer i);
48 Standard_EXPORT Standard_Boolean TopOpeBRepDS_GettraceSPSX(const Standard_Integer i);
49 Standard_EXPORT Standard_Boolean TopOpeBRepDS_GettraceSTRANGE(); 
50 Standard_EXPORT Standard_Boolean TopOpeBRepDS_GettraceISTO(); 
51 Standard_EXPORT Standard_Boolean TopOpeBRepDS_GettraceDSP(); 
52 Standard_EXPORT Standard_Boolean TopOpeBRepDS_GettraceDSF(); 
53 Standard_EXPORT Standard_Boolean TopOpeBRepDS_GettraceDSFK(); 
54 Standard_EXPORT Standard_Boolean TopOpeBRepDS_GettraceDSNC(); 
55 Standard_EXPORT Standard_Boolean TopOpeBRepDS_GettraceDSLT();
56 Standard_EXPORT Standard_Boolean TopOpeBRep_GettraceNVP(Standard_Integer a,Standard_Integer b,Standard_Integer c,Standard_Integer d,Standard_Integer e);
57 Standard_IMPORT Standard_Boolean GLOBAL_bvpr;Standard_EXPORT void debvprmess(Standard_Integer f1,Standard_Integer f2,Standard_Integer il,Standard_Integer vp,Standard_Integer si);
58 Standard_EXPORT Standard_Boolean TopOpeBRep_GetcontextNOPUNK();
59
60 static void SSAVFF(const TopoDS_Shape& F1, const TopoDS_Shape& F2)
61 {
62   TCollection_AsciiString aname_1("ffbug_1"), aname_2("ffbug_2");
63   Standard_CString name_1=aname_1.ToCString(),name_2=aname_2.ToCString();
64   cout<<"FacesFiller : "<<name_1<<","<<name_2<<endl;
65   BRepTools::Write(F1,name_1); BRepTools::Write(F2,name_2);
66 }
67
68 static void FUN_traceRLine(const TopOpeBRep_LineInter& L)
69 {
70 #ifdef DRAW
71   TCollection_AsciiString ee("Edofline"); ee.Cat(L.Index()); char* eee = ee.ToCString();
72   DBRep::Set(eee,L.Arc());
73 #endif
74 }
75
76 static void FUN_traceGLine(const TopOpeBRep_LineInter& L)
77 {
78 #ifdef DRAW
79   TCollection_AsciiString ll("Glineof"); ll.Cat(L.Index()); char* lll = ll.ToCString();
80   Handle(Geom_Curve) c = L.Curve();
81   Standard_Integer iINON1,iINONn,nINON; L.VPBounds(iINON1,iINONn,nINON);
82   Standard_Real par1 = L.VPoint(iINON1).ParameterOnLine();
83   Standard_Real parn = L.VPoint(iINONn).ParameterOnLine();
84   Standard_Boolean isperiodic = L.IsPeriodic();
85   Handle(Geom_TrimmedCurve) tc = new Geom_TrimmedCurve(c,par1,parn,Standard_True);  
86   DrawTrSurf::Set(lll,tc);
87 #endif
88 }
89 #endif
90
91 #define M_FORWARD(o)  (o == TopAbs_FORWARD)
92 #define M_REVERSED(o) (o == TopAbs_REVERSED)
93
94 #define FORWARD  (1)
95 #define REVERSED (2)
96 #define INTERNAL (3)
97 #define EXTERNAL (4)
98 #define CLOSING  (5)
99
100 Standard_EXPORT void FUN_GetdgData(TopOpeBRepDS_PDataStructure& pDS,const TopOpeBRep_LineInter& L,
101                                    const TopoDS_Face& F1,const TopoDS_Face& F2, TopTools_DataMapOfShapeListOfShape& datamap);
102 Standard_EXPORT void FUN_FillVof12(const TopOpeBRep_LineInter& L,TopOpeBRepDS_PDataStructure pDS);
103
104 #define M_FINDVP  (0) // only look for new vp
105 #define M_MKNEWVP (1) // only make newvp
106 #define M_GETVP   (2) // steps (0) [+(1) if (O) fails]
107 Standard_EXPORT void FUN_VPIndex(TopOpeBRep_FacesFiller& FF,
108                                  const TopOpeBRep_LineInter& L,
109                                  const TopOpeBRep_VPointInter& VP,
110                                  const Standard_Integer ShapeIndex,
111                                  const Handle(TopOpeBRepDS_HDataStructure)& HDS,
112                                  const TopOpeBRepDS_ListOfInterference& DSCIL,
113                                  TopOpeBRepDS_Kind& PVKind, Standard_Integer& PVIndex, // out
114                                  Standard_Boolean& EPIfound, Handle(TopOpeBRepDS_Interference)& IEPI, // out 
115                                  Standard_Boolean& CPIfound, Handle(TopOpeBRepDS_Interference)& ICPI, // out
116                                  const Standard_Integer mkVP);
117 Standard_EXPORT Standard_Boolean FUN_newtransEdge(const Handle(TopOpeBRepDS_HDataStructure) HDS,
118                                      const TopOpeBRep_FacesFiller& FF,
119                                      const TopOpeBRep_LineInter& L,
120                                      const Standard_Boolean& Lonrest,
121                                      const TopOpeBRep_VPointInter& VP, 
122                                      const TopOpeBRepDS_Kind PVKind, const Standard_Integer PVIndex,
123                                      const Standard_Integer& OOShapeIndex,
124                                      const TopoDS_Edge& edge, const TopTools_ListOfShape& ERL, TopOpeBRepDS_Transition& T);
125 #define M_INTERNAL(st)  (st == TopAbs_INTERNAL) 
126
127
128 static Standard_Boolean FUN_IwithsuppiS(const TopOpeBRepDS_ListOfInterference& loI, const Standard_Integer iS, TopOpeBRepDS_ListOfInterference& loIfound)
129 {
130   TopOpeBRepDS_ListIteratorOfListOfInterference it(loI);
131   for (; it.More(); it.Next()) {const Handle(TopOpeBRepDS_Interference)& I = it.Value(); 
132                                 if (I->Support() == iS) loIfound.Append(I);}
133   Standard_Boolean ok = (loIfound.Extent() > 0);
134   return ok;
135 }
136 static Standard_Boolean FUN_IwithsuppkS(const TopOpeBRepDS_ListOfInterference& loI, const TopOpeBRepDS_Kind& kS, TopOpeBRepDS_ListOfInterference& loIfound)
137 {
138   TopOpeBRepDS_ListIteratorOfListOfInterference it(loI);
139   for (; it.More(); it.Next()) {const Handle(TopOpeBRepDS_Interference)& I = it.Value(); 
140                                 if (I->SupportType() == kS) loIfound.Append(I);}
141   Standard_Boolean ok = (loIfound.Extent() > 0);
142   return ok;
143 }
144 static Standard_Boolean FUN_IwithToniS(const TopOpeBRepDS_ListOfInterference& loI, const Standard_Integer iS, TopOpeBRepDS_ListOfInterference& loIfound)
145 {
146   TopOpeBRepDS_ListIteratorOfListOfInterference it(loI);
147   for (; it.More(); it.Next()) {const Handle(TopOpeBRepDS_Interference)& I = it.Value(); 
148                                 if (I->Transition().Index() == iS) loIfound.Append(I);}
149   Standard_Boolean ok = (loIfound.Extent() > 0);
150   return ok;
151 }
152 static Standard_Boolean FUN_supponF(const TopOpeBRepDS_PDataStructure pDS, 
153                        const TopOpeBRepDS_ListOfInterference& loI, const Standard_Integer iF,
154                        TopOpeBRepDS_ListOfInterference& lIsupponF, TColStd_ListOfInteger& losupp)
155 {
156   //<losupp> = list of support S / I in <loI> : I = (T,G,S = Edge on <F>);
157   Standard_Boolean ok = (0 < iF) && (iF <= pDS->NbShapes());
158   if (!ok) return Standard_False; 
159
160   TopTools_IndexedMapOfShape MOOE; TopExp::MapShapes(pDS->Shape(iF),TopAbs_EDGE,MOOE);
161   TopOpeBRepDS_ListIteratorOfListOfInterference it(loI);
162   for (; it.More(); it.Next()){ 
163     const Handle(TopOpeBRepDS_Interference)& I = it.Value(); Standard_Integer iS = I->Support();
164     TopOpeBRepDS_Kind skind = I->SupportType(); 
165     Standard_Boolean add = Standard_False;
166     if (skind == TopOpeBRepDS_EDGE) add = MOOE.Contains(pDS->Shape(iS));
167     if (add) {losupp.Append(iS); lIsupponF.Append(I);}
168   }
169   if (losupp.Extent() < 1) return Standard_False;
170   return Standard_True;
171 }
172 static Standard_Boolean FUN_IoflSsuppS(const TopOpeBRepDS_PDataStructure pDS, 
173                           const Standard_Integer iS,const TColStd_ListOfInteger& lShape, 
174                           TopOpeBRepDS_ListOfInterference& IsuppiS)
175 {
176   Standard_Boolean ok = Standard_False;
177   // E in <losupp> /
178   // I on E : I = (T, G, S=iS)
179
180   // looking for interferences attached to shapes of <lShape> with support <iS>
181   TColStd_ListIteratorOfListOfInteger iti(lShape);
182   for (; iti.More(); iti.Next()){
183     const TopOpeBRepDS_ListOfInterference& lI = pDS->ShapeInterferences(iti.Value());
184     ok = FUN_IwithsuppiS(lI,iS,IsuppiS);
185   }
186   return ok;
187 }
188
189 //=======================================================================
190 // 3D
191 // purpose : The compute of a transition edge/face given interferences
192 //           attached to the edge (stored in the DS).
193 //=======================================================================
194 static Standard_Boolean FUN_findTF(const TopOpeBRepDS_PDataStructure pDS,
195                       const Standard_Integer iE, const Standard_Integer iF, const Standard_Integer iOOF,
196                       TopOpeBRepDS_Transition& TF)
197 {  
198   Standard_Real factor = 0.5;
199   // ----------------------------------------------------------------------
200   // <Ifound> on <E> : Ifound = (T, S=OOF, G=POINT/VERTEX on <E>)
201   //                            (T, S=edge of OOF, G=POINT/VERTEX on <E>)
202   // ----------------------------------------------------------------------
203
204   // <lITonOOF>
205   TopOpeBRepDS_ListOfInterference lITonOOF;
206   Standard_Boolean ok = FUN_IwithToniS(pDS->ShapeInterferences(iE),iOOF,lITonOOF);
207   if (!ok) return Standard_False;  
208   TopOpeBRepDS_ListOfInterference lITOOFskFACE;
209   Standard_Boolean found = FUN_IwithsuppkS(lITonOOF,TopOpeBRepDS_FACE,lITOOFskFACE);
210   if (found) {
211     // NYI : a deeper analysis is needed, for the moment, we make the following
212     // prequesitory : transition on E of F on point of ES is valid for
213     //                all the ES (here restriction) ie :
214     //                TF : transition face(F) / face(OOF) on G = ES =
215     //                TE : transition edge(E) / face(OOF) at G = POINT/VERTEX 
216     //Ifound on <E> : Ifound = (T(on face OOF), S=FACE, G=POINT/VERTEX on <E>)
217     const Handle(TopOpeBRepDS_Interference)& Ifound = lITOOFskFACE.First();
218     TF = Ifound->Transition(); 
219   }
220
221   Standard_Boolean done = Standard_False;
222   TopOpeBRepDS_ListOfInterference lITOOFskEDGE;
223   if (!found) done = FUN_IwithsuppkS(lITonOOF,TopOpeBRepDS_EDGE,lITOOFskEDGE);
224   if (done) {
225     // Ifound on <E> : Ifound = (T(on face OOF), S=FACE, G=POINT/VERTEX on <E>) 
226     // if <Ifound> found : compute TE at G / <OOF>.
227     // TE ->TF. 
228     const Handle(TopOpeBRepDS_Interference)& Ifound = lITOOFskEDGE.First();
229     const TopoDS_Edge& OOE = TopoDS::Edge(pDS->Shape(Ifound->Support()));             
230     Standard_Real paronE; Standard_Boolean OOdone = FDS_Parameter(Ifound,paronE);
231     if (!OOdone) return Standard_False;
232
233     const TopoDS_Edge& E   = TopoDS::Edge(pDS->Shape(iE));
234 #ifdef DEB
235     const TopoDS_Face& F   =
236 #endif
237                      TopoDS::Face(pDS->Shape(iF));
238     const TopoDS_Face& OOF = TopoDS::Face(pDS->Shape(iOOF));
239
240     Standard_Real f,l; FUN_tool_bounds(E,f,l);
241     TopOpeBRepTool_makeTransition MKT; 
242
243     Standard_Boolean OOEboundOOF = FUN_tool_EboundF(OOE,OOF);    
244     Standard_Boolean iscl = TopOpeBRepTool_TOOL::IsClosingE(OOE,OOF);
245     if (OOEboundOOF && (!iscl)) {
246       Standard_Real oopar; Standard_Boolean ok1 = FUN_tool_parE(E,paronE,OOE,oopar);
247       if (!ok1) return Standard_False;
248       gp_Pnt2d uv;   ok1 = FUN_tool_paronEF(OOE,oopar,OOF,uv);
249       if (!ok1) return Standard_False;
250
251       ok = MKT.Initialize(E,f,l,paronE, OOF,uv, factor); 
252       if (ok) ok = MKT.SetRest(OOE,oopar);
253     }
254     else {
255       gp_Pnt2d uv; Standard_Boolean ok1 = FUN_tool_parF(E,paronE,OOF,uv);
256       if (!ok1) return Standard_False;
257
258       ok = MKT.Initialize(E,f,l,paronE, OOF,uv, factor);       
259     }
260     TopAbs_State stb,sta; ok = MKT.MkTonE(stb,sta);
261     if (!ok) return Standard_False;
262     TF.Before(stb); TF.After(sta);
263     return Standard_True;
264     
265   }
266   ok = found || done;
267   return ok;
268 }
269 static Standard_Boolean FUN_findTOOF(const TopOpeBRepDS_PDataStructure pDS,
270                         const Standard_Integer iE, const Standard_Integer iF, const Standard_Integer iOOF,
271                         TopOpeBRepDS_Transition& TOOF)
272 {
273   Standard_Real factor = 0.5;
274
275   // ----------------------------------------------------------------------
276   // <E> bound of <F>, 
277   // <OOE> on <OOF> / 
278   // <OOIfound> on <OOE>  : OOIfound = (T, S=iF, G=POINT/VERTEX on <E>)
279   // ----------------------------------------------------------------------
280  
281   // <lIsuppOOE> = list of interferences attached to <E> of support S = edge of <OOF>
282   // <liOOE> = list of supports of <lIsuppOOE>.
283   const TopOpeBRepDS_ListOfInterference& loIE = pDS->ShapeInterferences(iE);
284   TopOpeBRepDS_ListOfInterference lITonOOF; Standard_Boolean ok = FUN_IwithToniS(loIE,iOOF,lITonOOF);
285   TopOpeBRepDS_ListOfInterference lIsuppOOE; 
286   TColStd_ListOfInteger liOOEGonE;   
287   if (ok) {
288     ok = FUN_IwithsuppkS(lITonOOF,TopOpeBRepDS_EDGE,lIsuppOOE);
289     if (ok) {TopOpeBRepDS_ListIteratorOfListOfInterference it(lIsuppOOE);
290              for (; it.More(); it.Next()) liOOEGonE.Append(it.Value()->Support());}
291   }
292   else ok = FUN_supponF(pDS,loIE,iOOF,lIsuppOOE,liOOEGonE);
293   if (!ok) return Standard_False;
294
295 //  TopAbs_Orientation oritransOOE;
296
297   // <lOOIfound> = list of I attached to shapes of <liOOE> /
298   //               I = (T, S=F, G=POINT/VERTEX on <E>)
299   TopOpeBRepDS_ListOfInterference lIOOEsuppFGonE;
300   Standard_Boolean OOfound = FUN_IoflSsuppS(pDS,iF,liOOEGonE,lIOOEsuppFGonE);
301   if (OOfound) {        
302     // NYI : a deeper analysis is needed, for the moment, we make the following
303     // prequesitory : transition on OOE of OOF on point of ES is valid for
304     //                all the ES (here restriction) ie :
305     //                TOOF : transition face(OOF) / face(F) on (G == ES)
306     //            <=> TOOE : transition edge(OOE) / face(F) at G = POINT/VERTEX 
307     const Handle(TopOpeBRepDS_Interference)& OOIfound = lIOOEsuppFGonE.First(); 
308     TOOF = OOIfound->Transition();    
309   }
310
311   Standard_Boolean OOdone = Standard_False;
312   if (!OOfound) {
313     // Ifound on <E> : Ifound = (T, S=EDGE on <OOF>, G=POINT/VERTEX on <E>)
314     // if <Ifound> found : compute TOOE at G / <F>
315     // TOOE ->TOOF.
316     const Handle(TopOpeBRepDS_Interference)& Ifound = lIsuppOOE.First();
317     const TopoDS_Edge& OOE = TopoDS::Edge(pDS->Shape(Ifound->Support()));             
318     Standard_Real paronE; OOdone = FDS_Parameter(Ifound,paronE);
319     if (!OOdone) return Standard_False;
320
321     const TopoDS_Edge& E = TopoDS::Edge(pDS->Shape(iE));
322     const TopoDS_Face& F = TopoDS::Face(pDS->Shape(iF));
323     
324     Standard_Real oopar; Standard_Boolean ok1 = FUN_tool_parE(E,paronE,OOE,oopar);
325     if (!ok1) return Standard_False;
326     gp_Pnt2d uv;   ok1 = FUN_tool_paronEF(E,paronE,F,uv);
327     if (!ok1) return Standard_False;
328     Standard_Real f,l; FUN_tool_bounds(OOE,f,l);
329     
330     TopAbs_State stb,sta;
331     TopOpeBRepTool_makeTransition MKT; 
332     OOdone = MKT.Initialize(OOE,f,l,oopar,F,uv,factor);
333     if (OOdone) OOdone = MKT.SetRest(E,paronE);
334     if (OOdone) OOdone = MKT.MkTonE(stb,sta);
335     if (OOdone) {TOOF.Before(stb); TOOF.After(sta);}
336   }
337   ok = OOfound || OOdone;
338   return ok;
339
340
341 Standard_EXPORT Standard_Boolean GLOBAL_btcx = Standard_False;void debtcx(){};
342 Standard_EXPORT void debtcxmess(Standard_Integer f1,Standard_Integer f2,Standard_Integer il)
343 {cout<<"f1,f2,il : "<<f1<<","<<f2<<","<<il<<endl;cout.flush();debtcx();}
344
345 //=======================================================================
346 //function : ProcessLine
347 //purpose  : 
348 //=======================================================================
349 void TopOpeBRep_FacesFiller::ProcessLine()
350 {
351   Standard_Boolean reject = ( !myLineOK || myLine==NULL );
352   if (reject) return;
353   ResetDSC();
354   
355 #ifdef DEB
356   Standard_Integer ili = myLine->Index(),nli = myFacesIntersector->NbLines();
357   Standard_Boolean tcx = TopOpeBRepDS_GettraceCX(ili);
358   Standard_Boolean tDSF = TopOpeBRepDS_GettraceDSF();
359   Standard_Boolean traceDSNC = TopOpeBRepDS_GettraceDSNC();
360   if(tDSF)cout<<"trc tnvp 1   "<<myexF1<<" "<<myexF2<<" "<<ili<<endl;
361   if (tDSF||tcx) myHFFD->DumpLine(*myLine);
362   if (traceDSNC) cout<<"line "<<ili<<"/"<<nli<<endl;
363 #endif
364   
365   Standard_Boolean HasVPonR = myLine->HasVPonR();
366   if (HasVPonR) FillLineVPonR();
367   else          FillLine();
368   
369   Standard_Boolean inl = myLine->INL();
370   if (inl) return;
371   
372   myHDS->SortOnParameter(myDSCIL);
373   
374 #ifdef DEB
375   TopOpeBRepDS_Dumper Dumper(myHDS);
376   if (tDSF||traceDSNC) Dumper.DumpLOI(myDSCIL,cout,"current curve : ");
377 #endif
378   
379   AddShapesLine();
380 }
381
382 //=======================================================================
383 //function : ResetDSC
384 //purpose  : 
385 //=======================================================================
386 void TopOpeBRep_FacesFiller::ResetDSC()
387 {
388   myDSCIndex = 0;
389   myDSCIL.Clear();
390 }
391
392 //=======================================================================
393 //function : ProcessVPInotonR
394 //purpose  : Same as ProcessVPnotonR.
395 //=======================================================================
396 void TopOpeBRep_FacesFiller::ProcessVPInotonR(TopOpeBRep_VPointInterIterator& VPI)
397 {
398   const TopOpeBRep_VPointInter& VP = VPI.CurrentVP();
399   ProcessVPnotonR(VP); 
400
401
402 //=======================================================================
403 //function : ProcessVPnotonR
404 //purpose  : 
405 //=======================================================================
406 void TopOpeBRep_FacesFiller::ProcessVPnotonR(const TopOpeBRep_VPointInter& VP)
407 {
408 #ifdef DEB
409   Standard_Boolean traceDSF = TopOpeBRepDS_GettraceDSF();
410   Standard_Boolean traceDSP = TopOpeBRepDS_GettraceDSP();
411   Standard_Boolean traceISTO = TopOpeBRepDS_GettraceISTO();
412   if (traceDSF) cout<<endl;
413 #endif
414   
415   Standard_Integer ShapeIndex = 0;
416   Standard_Integer iVP = VP.Index();
417
418 #ifdef DEB
419   Standard_Integer ili=myLine->Index(),ivp=iVP,isi=ShapeIndex;
420   if(traceDSF || traceDSP){
421     cout<<"trc tnvp 1   "<<myexF1<<" "<<myexF2<<" "<<ili<<" "<<ivp<<" "<<isi;
422     cout<<"; # VPonR "<<iVP<<" on "<<ShapeIndex<<endl;
423   }
424   if (traceISTO) {
425     cout<<"f1,f2,l,vp,si : ";
426     cout<<myexF1<<","<<myexF2<<","<<ili<<","<<ivp<<","<<isi<<endl;
427   }
428   GLOBAL_bvpr = TopOpeBRep_GettraceNVP(myexF1,myexF2,ili,ivp,isi);
429   if (GLOBAL_bvpr) debvprmess(myexF1,myexF2,ili,ivp,isi);
430 #endif
431
432   Standard_Integer iINON1,iINONn,nINON;
433   myLine->VPBounds(iINON1,iINONn,nINON);  
434   TopOpeBRepDS_ListIteratorOfListOfInterference itCPIL(myDSCIL);
435
436   TopOpeBRepDS_Kind PVKind; Standard_Integer PVIndex;
437   Standard_Boolean CPIfound = GetGeometry(itCPIL,VP,PVIndex,PVKind);
438   if ( !CPIfound ) {
439     if (iVP != iINON1 && iVP != iINONn) {
440 #ifdef DEB
441       cout<<"VP "<<iVP<<" on "<<0<<" : point d'intersection anormal : rejet"<<endl;
442 #endif
443       return;
444     }
445   }
446
447   if ( ! CPIfound ) {
448     Standard_Boolean found = GetFFGeometry(VP,PVKind,PVIndex);
449     if ( ! found ) PVIndex = MakeGeometry(VP,ShapeIndex,PVKind);
450   }
451   
452   TopOpeBRepDS_Transition transLine;
453   if ( CPIfound ) {
454     const Handle(TopOpeBRepDS_Interference)& I = itCPIL.Value();
455     const TopOpeBRepDS_Transition& TI = I->Transition();
456     transLine = TI.Complement();
457   }
458   else {
459     if      (iVP == iINON1) transLine.Set(TopAbs_FORWARD);
460     else if (iVP == iINONn) transLine.Set(TopAbs_REVERSED);
461   }
462   
463   Standard_Real parline = VP.ParameterOnLine();
464   Handle(TopOpeBRepDS_Interference) CPI = TopOpeBRepDS_InterferenceTool::MakeCurveInterference
465     (transLine,TopOpeBRepDS_CURVE,0,PVKind,PVIndex,parline);
466   StoreCurveInterference(CPI);
467   
468 } // ProcessVPnotonR
469
470 //=======================================================================
471 //function : ProcessVPR
472 //purpose  : 
473 //=======================================================================
474 void TopOpeBRep_FacesFiller::ProcessVPR(TopOpeBRep_FacesFiller& FF,const TopOpeBRep_VPointInter& VP)
475 {
476   TopOpeBRepDS_Transition LineTonF1 = FaceFaceTransition(1);
477   TopOpeBRepDS_Transition LineTonF2 = FaceFaceTransition(2);
478   TopoDS_Face F1 = myF1; 
479   TopoDS_Face F2 = myF2;
480   // --- check interiority of VPoint to the restrictions    
481   Standard_Boolean tokeep = VP.Keep();
482   if ( !tokeep ) return;
483   
484   Standard_Integer ShapeIndex = VP.ShapeIndex();
485   
486   if (ShapeIndex == 0) {
487     FF.ProcessVPnotonR(VP);
488   }
489   else if (ShapeIndex == 1) {
490     FF.ProcessVPonR(VP,LineTonF1,F1,1);
491   }
492   else if (ShapeIndex == 2) {
493     FF.ProcessVPonR(VP,LineTonF2,F2,2);
494   }
495   else if (ShapeIndex == 3) {
496     
497     Standard_Boolean isV1 = VP.IsVertexOnS1();
498     Standard_Boolean isV2 = VP.IsVertexOnS2();
499     
500     Standard_Integer   shin1 = 1;
501     if (isV2 && !isV1) shin1 = 2;
502     
503     if      (shin1 == 1) {
504       FF.ProcessVPonR(VP,LineTonF1,F1,1);
505       FF.ProcessVPonR(VP,LineTonF2,F2,2);
506     }
507     else if (shin1 == 2) {
508       FF.ProcessVPonR(VP,LineTonF2,F2,2);
509       FF.ProcessVPonR(VP,LineTonF1,F1,1);
510     }
511   }
512 } // FUNvponr
513
514 static Standard_Boolean FUN_brep_ONfirstP(const TopOpeBRep_VPointInter& vpf, const TopOpeBRep_VPointInter& VP)
515 // prequesitory : gline is on edge
516 {  
517   Standard_Real parfirst = vpf.ParameterOnLine();
518   Standard_Real parcur = VP.ParameterOnLine();
519   Standard_Real d = parcur - parfirst;
520   Standard_Real tol = Precision::Confusion(); //nyixpu051098 : see lbr...
521   Standard_Boolean ONfirstP = (Abs(d) < tol);
522   return ONfirstP;
523 }
524
525 #ifdef DEB
526 static void FUN_remove(TopOpeBRepDS_ListOfInterference& lI, const Handle(TopOpeBRepDS_Interference)& I)
527 {
528   TopOpeBRepDS_ListIteratorOfListOfInterference itI(lI);
529   while (itI.More()) {
530     const Handle(TopOpeBRepDS_Interference)& Icur = itI.Value();
531     if (Icur == I) lI.Remove(itI);
532     else           itI.Next();
533   }
534 }
535 #endif
536
537 //=======================================================================
538 //function : ProcessRLine
539 //purpose  : 
540 //=======================================================================
541 void TopOpeBRep_FacesFiller::ProcessRLine()
542 {
543 #ifdef DEB
544   Standard_Boolean tDSF = TopOpeBRepDS_GettraceDSF();
545 #endif
546   
547   if (myLine->TypeLineCurve() != TopOpeBRep_RESTRICTION) {return;}
548   
549   Standard_Boolean addIFE = Standard_True;
550   if (!addIFE) return;
551
552   const TopoDS_Edge& Erest = TopoDS::Edge(myLine->Arc());
553   Standard_Boolean FIisrest = myFacesIntersector->IsRestriction(Erest);
554   if (!FIisrest) return; 
555
556   Standard_Boolean isedge1 = myLine->ArcIsEdge(1);
557   Standard_Boolean isedge2 = myLine->ArcIsEdge(2);
558   Standard_Integer EShapeIndex = (isedge1) ? 1 : (isedge2) ? 2 : 0;
559   
560   Standard_Integer iErest = myDS->AddShape(Erest,EShapeIndex);
561   Standard_Integer rank = myDS->AncestorRank(iErest);
562   Standard_Integer OOrank = (rank == 1)? 2: 1;
563   
564 #ifdef DEB
565   if (tDSF) {cout<<"+ edge restriction "<<myDS->SectionEdge(Erest);
566              cout<<" (DS "<<iErest<<")"<<endl;}
567   Standard_Boolean trce = TopOpeBRepDS_GettraceSPSX(iErest); if(trce) debrest(iErest);
568 #endif
569   
570   Standard_Integer iF1 = myDS->AddShape(myF1,1);
571   Standard_Integer iF2 = myDS->AddShape(myF2,2);
572   Handle(TopOpeBRepDS_Interference) IFE;
573   
574   TopOpeBRepDS_Transition T1 = FaceFaceTransition(1); T1.Index(iF2);
575   TopOpeBRepDS_Transition T2 = FaceFaceTransition(2); T2.Index(iF1);
576   
577   Standard_Boolean T1unk = T1.IsUnknown();
578   Standard_Boolean T2unk = T2.IsUnknown();
579   Standard_Boolean processUNK = Standard_False;
580 #ifdef DEB
581   Standard_Boolean nopunk = TopOpeBRep_GetcontextNOPUNK();
582   if (nopunk) processUNK = Standard_False;
583 #endif
584   if (processUNK && (T1unk || T2unk)) {
585 #ifdef DEB
586     Standard_Boolean trc = TopOpeBRepDS_GettraceSTRANGE(); trc = trc || tDSF;
587     if (trc) cout<<"T UNKNOWN FEI F"<<iF1<<" F"<<iF2<<" on Erest"<<iErest<<endl;
588 #endif
589     TopoDS_Shape F =   (*this).Face(rank);   Standard_Integer iF = myDS->Shape(F);
590     TopoDS_Shape OOF = (*this).Face(OOrank); Standard_Integer iOOF = myDS->Shape(OOF);
591     Standard_Boolean findTOOF = (T1unk && (OOrank == 1)) || (T2unk && (OOrank == 2));
592     Standard_Boolean findTF = (T1unk && (rank == 1)) || (T2unk && (rank == 2));
593     
594     if (findTOOF) {
595       // <Erest> on <F>, 
596       // ?<OOE> on <OOF> / 
597       // ?<OOIfound> on <OOE>  : OOIfound = (T, S=iF, G=POINT/VERTEX on <Erest>)
598       TopOpeBRepDS_Transition T; Standard_Boolean OOTok = FUN_findTOOF(myDS,iErest,iF,iOOF,T);
599       if (OOTok) {
600         if (OOrank == 1) FDS_SetT(T1,T);
601         else             FDS_SetT(T2,T);
602 #ifdef DEB
603         if (trc) {
604           cout<<"F"<<iOOF<<" + new FEI(";TopAbs::Print(T.Before(),cout);cout<<",";
605           TopAbs::Print(T.After(),cout);cout<<" (F"<<iF<<") (E"<<iErest<<"))\n";
606         }
607 #endif
608       }
609     } // !findTOOF
610     if (findTF) {
611       // ?Ifound on <Erest> : Ifound = (T on FACE=iOOF, S, G=POINT/VERTEX on <Erest>)
612       // if <Ifound> found : compute TErest at G / <OOF>
613       TopOpeBRepDS_Transition T; Standard_Boolean Tok = FUN_findTF(myDS,iErest,iF,iOOF,T);
614       if (Tok) {
615         if (rank == 1)  FDS_SetT(T1,T);
616         else            FDS_SetT(T2,T);
617 #ifdef DEB
618         if (trc) {cout<<"F"<<iF<<" + new FEI(";TopAbs::Print(T.Before(),cout);cout<<",";
619                   TopAbs::Print(T.After(),cout);cout<<" (F"<<iOOF<<") (E"<<iErest<<"))\n";}
620 #endif
621       }
622     }
623     T1unk = T1.IsUnknown();
624     T2unk = T2.IsUnknown();
625   } // processUNK && (T1unk || T2unk)
626   
627   IFE = TopOpeBRepDS_InterferenceTool::MakeFaceEdgeInterference
628     (T1,iF2,iErest,isedge1,TopOpeBRepDS_UNSHGEOMETRY);
629   myHDS->StoreInterference(IFE,iF1);
630
631   IFE = TopOpeBRepDS_InterferenceTool::MakeFaceEdgeInterference
632     (T2,iF1,iErest,isedge2,TopOpeBRepDS_UNSHGEOMETRY);
633   myHDS->StoreInterference(IFE,iF2);
634
635   //#################### Rline Processing ####################
636   // xpu061098 
637   TopOpeBRep_VPointInterIterator VPI;
638   VPI.Init((*myLine));  
639   Standard_Real tola = Precision::Angular()*1.e5;//NYIXPUTOL
640
641 #ifdef DEB
642   if (tDSF) {
643     debrline();
644     cout<<endl<<"------------ Rline processing --------------------"<<endl;
645   }
646 #endif  
647
648   const TopOpeBRep_VPointInter& vpf = VPI.CurrentVP();
649   for (; VPI.More(); VPI.Next()) {
650     const TopOpeBRep_VPointInter& VP = VPI.CurrentVP();
651 #ifdef DEB
652     if (tDSF) {cout<<endl;myHFFD->DumpVP(VP);}
653 #endif
654     Standard_Integer absindex = VP.ShapeIndex(); // 0,1,2,3
655     Standard_Real parRest;
656     Standard_Boolean okR  = VP.ParonE(Erest,parRest);
657     if (!okR) parRest = VP.ParameterOnLine();
658     Standard_Boolean on2edges = (absindex == 3) || (absindex == OOrank);
659
660     if (!on2edges) {
661       // MSV: treat the case when an edge is touched by interior of a face
662
663 // MSV: the commented code below leads to exception on 1cto 025 H3
664 //      (object and tool have same subshapes), so to enable it
665 //      the debug is needed
666
667 //        Standard_Boolean SIisvertex = VP.IsVertex(EShapeIndex);
668 //        if (SIisvertex) continue;
669 //        Standard_Integer ShapeIndex = EShapeIndex;
670 //        Standard_Integer OOShapeIndex = (ShapeIndex == 1) ? 2 : 1;
671 //        TopoDS_Face OOFace = (*this).Face(OOShapeIndex);
672 //        Standard_Integer iOOFace = myDS->Shape(OOFace);
673
674 //        // make PVIndex
675 //        TopOpeBRepDS_Kind PVKind = TopOpeBRepDS_POINT;
676 //        Standard_Integer PVIndex = 0;
677 //        Standard_Boolean EPIfound=Standard_False,CPIfound=Standard_False;
678 //        Handle(TopOpeBRepDS_Interference) IEPI,ICPI;
679 //        FUN_VPIndex((*this),(*myLine),VP,ShapeIndex,myHDS,myDSCIL,
680 //                    PVKind,PVIndex,EPIfound,IEPI,CPIfound,ICPI,
681 //                    M_GETVP);
682 //        Standard_Boolean Efound = (EPIfound || CPIfound);
683 //        Standard_Boolean Ifound = (PVIndex != 0);
684 //        Standard_Boolean condmake = (!Efound && !Ifound);
685 //        if (condmake)
686 //          PVIndex = MakeGeometry(VP,ShapeIndex,PVKind);
687
688 //        // make transition on edge
689 //        TopOpeBRepDS_Transition transEdge;
690 //        TopOpeBRepDS_Transition Trans = FaceFaceTransition(ShapeIndex);
691 //        Standard_Boolean TransUNK = Trans.IsUnknown();
692 //        if (!TransUNK) {
693 //          TopAbs_Orientation oriErest = Erest.Orientation();
694 //          transEdge = TopOpeBRep_FFTransitionTool::ProcessLineTransition(VP,ShapeIndex,oriErest);
695 //      TransUNK = FDS_hasUNK(transEdge);
696 //        }
697 //        if (TransUNK) {
698 //          Standard_Boolean ONfirstP = ::FUN_brep_ONfirstP(vpf,VP);
699 //          TopAbs_Orientation OVP = ONfirstP ? TopAbs_FORWARD : TopAbs_REVERSED;
700 //          transEdge.Set(OVP);
701 //          if (ONfirstP) transEdge.StateAfter(TopAbs_ON);
702 //          else          transEdge.StateBefore(TopAbs_ON);
703 //          TransUNK = FDS_hasUNK(transEdge);
704 //        }
705 //        if (TransUNK) continue;
706
707 //        // see if there is already such interference in DS
708 //        TopAbs_Orientation otransEdge = transEdge.Orientation(TopAbs_IN);
709 //        const TopOpeBRepDS_ListOfInterference& lIedge = myHDS->DS().ShapeInterferences(Erest);
710 //        TopOpeBRepDS_ListOfInterference copy; FDS_copy(lIedge,copy);
711 //        TopOpeBRepDS_ListOfInterference l1,l2;
712 //        Standard_Integer nfound = FUN_selectGIinterference(copy,PVIndex,l1);
713 //        if (nfound) {
714 //      if (iOOFace != 0) {
715 //        TopOpeBRepDS_ListOfInterference l3,l4;
716 //            nfound = FUN_selectITRASHAinterference(l2,iOOFace,l3);
717 //        if (nfound != 0) nfound = FUN_selectTRAORIinterference(l3,otransEdge,l4);
718 //        if (nfound) continue;
719 //      }
720 //        }
721
722 //        // make and store interference
723 //        Handle(TopOpeBRepDS_Interference) EPIf;
724 //        if (iOOFace == 0) iOOFace = myDS->AddShape(OOFace,OOShapeIndex);
725 //        TopOpeBRepDS_Transition T = transEdge; T.Index(iOOFace);
726 //        EPIf = MakeEPVInterference(T,iOOFace,PVIndex,parRest,PVKind,
727 //                                   TopOpeBRepDS_FACE,SIisvertex);
728 //        myHDS->StoreInterference(EPIf,Erest);
729
730       continue;
731     }
732
733     TopoDS_Edge OOE = TopoDS::Edge(VP.Edge(OOrank)); 
734     Standard_Integer iOO = myDS->AddShape(OOE,OOrank);
735
736     Standard_Real OOpar; 
737     VP.ParonE(OOE,OOpar);
738  
739     // xpu091198 : 1d interf done in EdgesFiller processing (cto cylcong *)     
740     Standard_Boolean sdmeds = FUN_ds_sdm((*myDS),Erest,OOE);
741     if (sdmeds) continue;
742     
743     Standard_Integer obRest = TopOpeBRepTool_TOOL::OnBoundary(parRest,Erest); //vertex can be missed
744     Standard_Integer obOO   = TopOpeBRepTool_TOOL::OnBoundary(OOpar,OOE);     //vertex can be missed
745
746     if ((obRest == EXTERNAL)||(obOO == EXTERNAL)){
747 #ifdef DEB
748       if(obRest==EXTERNAL) cout<<"***********ProcessRLine : faulty parameter on Erest"<<endl;
749       if(obOO==EXTERNAL)   cout<<"***********ProcessRLine : faulty parameter on OOE"<<endl;
750 #endif
751     }
752
753     Standard_Boolean tgeds = FUN_tool_EtgOOE(parRest,Erest, OOpar,OOE, tola);
754
755     TopOpeBRepDS_Kind PVKind = TopOpeBRepDS_POINT; Standard_Integer PVIndex = 0;  // POINT or VERTEX index
756
757     for (Standard_Integer ShapeIndex = 1; ShapeIndex<=2; ShapeIndex++) {    
758       Standard_Integer OOShapeIndex = (ShapeIndex == 1) ? 2 : 1;
759       Standard_Boolean SIErest = (ShapeIndex == rank);
760     
761       Standard_Boolean SIisvertex = VP.IsVertex(ShapeIndex);
762       Standard_Boolean OOisvertex = VP.IsVertex(OOShapeIndex);
763       TopoDS_Face OOFace = (*this).Face(OOShapeIndex);
764       Standard_Integer iOOFace = myDS->Shape(OOFace);
765
766       TopoDS_Edge edge,OOedge; Standard_Integer SIedgeIndex,OOedgeIndex;
767       Standard_Real paredge,OOparedge;
768       Standard_Integer onbound;
769       if (SIErest) 
770         {edge = Erest;  SIedgeIndex = iErest; paredge = parRest; onbound = obRest; 
771          OOedge = OOE;  OOedgeIndex = iOO;    OOparedge = OOpar;} 
772       else         
773         {OOedge = Erest;OOedgeIndex = iErest; OOparedge = parRest;   onbound = obOO;
774          edge = OOE;    SIedgeIndex = iOO;    paredge = OOpar;}
775       
776       // PVIndex :
777       // --------
778       // xpu150399 : BUC60382
779       Standard_Boolean EPIfound=Standard_False,CPIfound=Standard_False; Handle(TopOpeBRepDS_Interference) IEPI,ICPI;
780       ProcessVPondgE(VP, ShapeIndex,
781                      PVKind,PVIndex, // out
782                      EPIfound,IEPI,  // out
783                      CPIfound,ICPI); // out 
784                      
785       if (PVIndex == 0) {
786 //      Standard_Boolean EPIfound=Standard_False,CPIfound=Standard_False; Handle(TopOpeBRepDS_Interference) IEPI,ICPI;
787         FUN_VPIndex((*this),(*myLine),VP,ShapeIndex,myHDS,myDSCIL,
788                     PVKind,PVIndex,EPIfound,IEPI,CPIfound,ICPI,
789                     M_GETVP);
790         Standard_Boolean Efound = (EPIfound || CPIfound);
791         Standard_Boolean Ifound = (PVIndex != 0);
792         Standard_Boolean condmake = (!Efound && !Ifound);
793         if (condmake) {
794           if      ( SIisvertex ) PVIndex = MakeGeometry(VP,ShapeIndex,PVKind);
795           else if ( OOisvertex ) PVIndex = MakeGeometry(VP,OOShapeIndex,PVKind);
796           else                   PVIndex = MakeGeometry(VP,ShapeIndex,PVKind);  
797         }
798       }      
799   
800       // transEdge : 
801       // ----------
802       if (OOedgeIndex == 0) OOedgeIndex = myDS->AddShape(OOedge,OOShapeIndex);
803       const TopOpeBRepDS_Transition& llt1 = FaceFaceTransition(1);
804       const TopOpeBRepDS_Transition& llt2 = FaceFaceTransition(2);
805       TopOpeBRepDS_Transition Trans = (ShapeIndex == 1)? llt1 : llt2;
806       Standard_Boolean TransUNK = Trans.IsUnknown();
807       TopAbs_Orientation Transori; if (!TransUNK) Transori = Trans.Orientation(TopAbs_IN); 
808       
809       TopOpeBRepDS_Transition transEdge; Standard_Boolean Tunk = Standard_True;
810       if (!TransUNK) { //xpu281098 PRO12875(edge9,OOface11)
811         if ((absindex==ShapeIndex)||(absindex==3)) { 
812           if (SIErest) {
813             // transition on Erest at VP / OOface = transition at VP on Line restriction
814             TopAbs_Orientation oriErest = Erest.Orientation();
815             transEdge = TopOpeBRep_FFTransitionTool::ProcessLineTransition(VP,ShapeIndex,oriErest);
816             
817             if (((onbound == 1)||(onbound == 2))&&tgeds) // xpu290399 : edge is restriction, 
818               // edge15,OOedge14,OOface13               
819               {transEdge.Before(TopAbs_UNKNOWN); transEdge.After(TopAbs_UNKNOWN);}
820           }
821           else {
822             // transition on edge at VP / OOface ?= 
823             //  TopOpeBRep_FFTransitionTool::ProcessEdgeTransition(VP,ShapeIndex,Transori);  
824             // nyi
825           }
826         }
827         Tunk = FDS_hasUNK(transEdge);
828       }
829       if (Tunk) {
830         if (SIErest) {
831           // As edge=Erest is on OOFace, we only compute 2d interferences
832           Standard_Boolean ONfirstP = ::FUN_brep_ONfirstP(vpf,VP);
833           TopAbs_Orientation OVP = ONfirstP ? TopAbs_FORWARD : TopAbs_REVERSED;
834           TopAbs_Orientation oOO; Standard_Boolean ok = FUN_tool_orientEinFFORWARD(OOedge,OOFace,oOO);
835           if (!ok) continue;
836           if (M_INTERNAL(oOO)) OVP = TopAbs_INTERNAL;
837
838           // xpu240399 : cto015I2 (e15,v16)
839           //             edge and OOedge are tangent, we do not keep the orientation
840           if (!tgeds) transEdge.Set(OVP);
841         }
842         else {  
843           TopOpeBRepDS_Transition Tr;
844           Standard_Boolean ok = FUN_newtransEdge(myHDS,(*this),(*myLine),myLineIsonEdge,VP,PVKind,PVIndex,OOShapeIndex,
845                                   edge,myERL,Tr);
846           if (!ok) continue;
847           transEdge.Before(Tr.Before()); transEdge.After(Tr.After());  
848         }
849 #ifdef DEB
850         if (tDSF) {cout<<"*-> new transEdge (edge"<<SIedgeIndex<<",face"<<iOOFace<<")=";
851                    TopAbs::Print(transEdge.Before(),cout);
852                    cout<<" ";TopAbs::Print(transEdge.After(),cout);cout<<endl;}
853 #endif    
854       }//Tunk
855       Tunk = FDS_hasUNK(transEdge);
856       if (Tunk) continue;
857
858       TopAbs_Orientation otransEdge = transEdge.Orientation(TopAbs_IN);
859       const TopOpeBRepDS_ListOfInterference& lIedge = myHDS->DS().ShapeInterferences(edge);
860       TopOpeBRepDS_ListOfInterference copy; FDS_copy(lIedge,copy);
861       TopOpeBRepDS_ListOfInterference l1,l2; Standard_Integer nfound = FUN_selectGIinterference(copy,PVIndex,l1);
862       if (OOedgeIndex != 0) nfound = FUN_selectSIinterference(l1,OOedgeIndex,l2);
863       if (nfound) {
864         if (sdmeds) {
865           TopOpeBRepDS_ListOfInterference l3,l4; nfound = FUN_selectITRASHAinterference(l2,OOedgeIndex,l3);
866           if (nfound != 0) nfound = FUN_selectTRAORIinterference(l3,otransEdge,l4);
867           if (nfound) continue; // has I1d=(transEdge(OOedgeIndex),PVIndex,OOedgeIndex);
868         }
869         else if (iOOFace != 0) {
870           TopOpeBRepDS_ListOfInterference l3,l4; nfound = FUN_selectITRASHAinterference(l2,iOOFace,l3);
871           if (nfound != 0) nfound = FUN_selectTRAORIinterference(l3,otransEdge,l4);
872           if (nfound) continue; // has I2d=(transEdge(iOOFace),PVIndex,OOedgeIndex)
873         }  
874       }// nfound
875       
876       // EPI : 
877       // ----
878       Handle(TopOpeBRepDS_Interference) EPI;
879       { 
880         if (iOOFace == 0) iOOFace = myDS->AddShape(OOFace,OOShapeIndex);
881         TopOpeBRepDS_Transition T = transEdge; T.Index(iOOFace);
882         EPI = MakeEPVInterference(T,OOedgeIndex,PVIndex,paredge,PVKind,SIisvertex);
883       }
884       myHDS->StoreInterference(EPI,edge);     
885
886       // EPIf : 
887       // -----
888       if (!SIErest) {
889         Handle(TopOpeBRepDS_Interference) EPIf;
890         TopOpeBRepDS_Transition T = transEdge; T.Index(iOOFace);
891         EPIf = MakeEPVInterference(T,iOOFace,PVIndex,paredge,PVKind,
892                                    TopOpeBRepDS_FACE,SIisvertex);
893         myHDS->StoreInterference(EPIf,edge);    
894       }
895
896     } // ShapeIndex=1..2
897   } // VPI
898   //####################
899 }
900
901 static Standard_Boolean FUN_haslastvpon0(const TopOpeBRep_LineInter& L)
902 {
903   const Standard_Boolean wline = (L.TypeLineCurve() == TopOpeBRep_WALKING);
904   if (!wline) return Standard_False;
905   
906   Standard_Integer iINON1,iINONn,nINON; L.VPBounds(iINON1,iINONn,nINON);
907   
908   TopOpeBRep_VPointInterIterator VPI;
909   VPI.Init(L);  
910   for (; VPI.More(); VPI.Next()) {
911     const TopOpeBRep_VPointInter& VP = VPI.CurrentVP();
912     const Standard_Integer absindex = VP.ShapeIndex();
913     const Standard_Integer iVP = VP.Index();
914     if (iVP == iINONn && absindex == 0) return Standard_True;
915   }
916   return Standard_False;
917 }
918
919 //=======================================================================
920 //function : FillLineVPonR
921 //purpose  : 
922 //=======================================================================
923 void TopOpeBRep_FacesFiller::FillLineVPonR()
924 {
925 #ifdef DEB
926   Standard_Boolean tDSF = TopOpeBRepDS_GettraceDSF();
927   Standard_Boolean trline = Standard_False;
928 #endif
929
930   // if a VP is on degenerated edge, adds the triplet
931   // (vertex, closing edge, degenerated edge) to the
932   // map as vertex for key.
933 //  myDataforDegenEd.Clear();
934   FUN_GetdgData(myDS,(*myLine),myF1,myF2,myDataforDegenEd);
935   FUN_FillVof12((*myLine),myDS) ;
936   
937   mykeptVPnbr = 0; 
938   
939   if (myLine->TypeLineCurve() == TopOpeBRep_RESTRICTION) {
940 #ifdef DEB
941     if (trline) FUN_traceRLine(*myLine);
942 #endif    
943     ProcessRLine();
944     return;
945   }
946   
947   Standard_Integer iINON1,iINONn,nINON;
948   myLine->VPBounds(iINON1,iINONn,nINON);
949   if ( nINON == 0 ) {
950     return; 
951   }
952   
953 #ifdef DEB
954   if (trline) FUN_traceGLine(*myLine);
955 #endif
956   
957   myLineIsonEdge = LSameDomainERL(*myLine, myERL);
958   
959   // walking (case mouch1a 1 1) : line (vpfirst on 3,vplast on 0,nvpkept = 2) => kept
960   myLastVPison0 = ::FUN_haslastvpon0(*myLine);
961   
962 #ifdef DEB
963   if (tDSF) {
964     if (myLineIsonEdge) cout<<" geometric line is on edge"<<endl;
965     else cout <<" geometric line not on edge"<<endl;
966   }
967 #endif
968   
969   //----------------------------------------------------------------------
970   // IMPORTANT : 
971   // Some of Curve/Point transitions for vpoints keep on RESTRICTION lines
972   // sharing same domain with the current geometric line are computed here
973   //----------------------------------------------------------------------
974   
975 #ifdef DEB
976   Standard_Boolean trcd = Standard_False;
977 #ifdef DRAW
978   if (trcd) FUN_DrawMap(myDataforDegenEd);
979 #endif
980 #endif
981   
982   TopOpeBRep_VPointInterIterator VPI;
983   VPI.Init((*myLine));  
984   for (; VPI.More(); VPI.Next()) {
985     const TopOpeBRep_VPointInter& VP = VPI.CurrentVP();
986     ProcessVPR((*this),VP);
987   }
988   
989   if ( myLineIsonEdge && (!myDSCIL.IsEmpty()) ) {
990 #ifdef DEB
991     if (tDSF) cout<<"myLineIsonEdge && (!myDSCIL.IsEmpty())"<<endl;
992 #endif
993     myDSCIL.Clear();
994   }
995 }
996
997 //=======================================================================
998 //function : FillLine
999 //purpose  : 
1000 //=======================================================================
1001 void TopOpeBRep_FacesFiller::FillLine()
1002 {
1003 #ifdef DEB
1004   Standard_Boolean tDSF = TopOpeBRepDS_GettraceDSF();
1005 #endif
1006   
1007   Standard_Integer iINON1,iINONn,nINON;
1008   myLine->VPBounds(iINON1,iINONn,nINON);
1009   if ( nINON == 0 ) return; 
1010   
1011   Standard_Integer ShapeIndex = 0;
1012   Handle(TopOpeBRepDS_Interference) CPI;
1013   
1014   TopOpeBRep_VPointInterIterator VPI;
1015   for (VPI.Init((*myLine)); VPI.More(); VPI.Next()) {
1016     
1017     const TopOpeBRep_VPointInter& VP = VPI.CurrentVP();
1018     if ( ! VP.Keep() ) continue;
1019     
1020 #ifdef DEB
1021     if (tDSF) cout<<endl;
1022 #endif    
1023     
1024     Standard_Integer PVIndex;
1025     TopOpeBRepDS_Kind    PVKind;
1026     TopOpeBRepDS_ListIteratorOfListOfInterference itCPIL(myDSCIL);
1027     Standard_Boolean CPIfound;
1028     CPIfound = GetGeometry(itCPIL,VP,PVIndex,PVKind);
1029     if ( ! CPIfound ) {
1030       Standard_Boolean found = GetFFGeometry(VP,PVKind,PVIndex);
1031       if ( !found ) PVIndex = MakeGeometry(VP,ShapeIndex,PVKind);
1032     }
1033     
1034     TopOpeBRepDS_Transition transLine;
1035     if (! CPIfound) {
1036       Standard_Integer iVP = VPI.CurrentVPIndex();
1037       if      (iVP == iINON1) transLine.Set(TopAbs_FORWARD);
1038       else if (iVP == iINONn) transLine.Set(TopAbs_REVERSED);
1039     }
1040     else transLine = itCPIL.Value()->Transition().Complement();
1041     
1042     Standard_Real parline = VPI.CurrentVP().ParameterOnLine();
1043     CPI = TopOpeBRepDS_InterferenceTool::MakeCurveInterference
1044       (transLine,TopOpeBRepDS_CURVE,0,PVKind,PVIndex,parline);
1045     StoreCurveInterference(CPI);
1046     
1047   } //   loop on VPoints
1048   
1049 } // FillLine
1050
1051 //=======================================================================
1052 //function : AddShapesLine
1053 //purpose  : 
1054 //=======================================================================
1055 void TopOpeBRep_FacesFiller::AddShapesLine()
1056 {
1057   Standard_Boolean dscilemp = myDSCIL.IsEmpty();
1058   if (dscilemp) return;
1059   
1060   Standard_Boolean inl = myLine->INL();
1061   if (inl) return;
1062   
1063   TopOpeBRepDS_Curve& DSC = myDS->ChangeCurve(myDSCIndex);
1064   
1065   Handle(Geom_Curve) C3D;
1066   Handle(Geom2d_Curve) PC1,PC2;
1067   Handle(TopOpeBRepDS_Interference) FCI1, FCI2;
1068   
1069   Standard_Integer iF1 = myDS->AddShape(myF1,1);
1070   Standard_Integer iF2 = myDS->AddShape(myF2,2);
1071   
1072   Standard_Real pmin,pmax;
1073   myHDS->MinMaxOnParameter(myDSCIL,pmin,pmax);
1074   
1075   Standard_Real d = Abs(pmin-pmax);
1076   Standard_Boolean id = (d <= Precision::PConfusion());
1077   Standard_Boolean isper = myLine->IsPeriodic(); 
1078   id = (id && !isper);
1079  
1080   Standard_Boolean wline = (myLine->TypeLineCurve() == TopOpeBRep_WALKING);
1081   Standard_Boolean vclosed = myLine->IsVClosed();
1082   if (wline && !isper && vclosed) {
1083     //xpu240399 : USA60298 : avoid creating curve
1084     // MSV: take into account that geometry can be of type VERTEX
1085     Standard_Integer ipf = myDSCIL.First()->Geometry();
1086     TopOpeBRepDS_Kind kpf = myDSCIL.First()->GeometryType();
1087     gp_Pnt ptf;
1088     Standard_Real tol,tolf, toll;
1089     if (kpf == TopOpeBRepDS_POINT) {
1090       TopOpeBRepDS_Point pf = myDS->Point(ipf);
1091       ptf = pf.Point();
1092       tolf = pf.Tolerance();
1093     }
1094     else { // VERTEX
1095       TopoDS_Vertex vf = TopoDS::Vertex(myDS->Shape(ipf));
1096       ptf = BRep_Tool::Pnt(vf);
1097       tolf = BRep_Tool::Tolerance(vf);
1098     }
1099
1100     Standard_Integer ipl = myDSCIL.Last()->Geometry();
1101     TopOpeBRepDS_Kind kpl = myDSCIL.Last()->GeometryType();
1102     if (kpl == TopOpeBRepDS_POINT) {
1103       TopOpeBRepDS_Point pl = myDS->Point(ipl); 
1104       toll = pl.Tolerance();
1105     }
1106     else { // VERTEX
1107       TopoDS_Vertex vl = TopoDS::Vertex(myDS->Shape(ipl));
1108       toll = BRep_Tool::Tolerance(vl);
1109     }
1110
1111     tol = Max(tolf, toll);
1112     Standard_Boolean onsampt = Standard_True;
1113     for (Standard_Integer ii = 1; ii <= myLine->NbWPoint(); ii++) {
1114       TopOpeBRep_WPointInter wp = myLine->WPoint(ii);
1115       gp_Pnt pp = wp.Value();
1116       if (!pp.IsEqual(ptf,tol)) {onsampt = Standard_False;break;}
1117     }
1118     if (onsampt) id = Standard_True;
1119   }
1120  
1121 #ifdef DEB
1122   if (TopOpeBRepDS_GettraceDSF()) {
1123     cout<<endl<<"minmax "<<pmin<<","<<pmax;
1124     if (id) cout<<" --> rejet";
1125     cout<<endl;
1126   }
1127 #endif
1128   
1129   if (id) {
1130     DSC.ChangeKeep(Standard_False);
1131     return;
1132   }
1133   
1134   TopOpeBRep_GeomTool::MakeCurves(pmin,pmax,(*myLine),myF1,myF2,DSC,PC1,PC2);
1135
1136   //Patch: avoid making too small edges. Made for the bug buc60926 by jgv, 14.06.01.
1137   Standard_Real fpar, lpar;
1138   DSC.Range(fpar, lpar);
1139   GeomAdaptor_Curve theCurve( DSC.Curve(), fpar, lpar );
1140   Bnd_Box theBox;
1141   BndLib_Add3dCurve::Add( theCurve, 0., theBox );
1142   Standard_Real Xmin, Ymin, Zmin, Xmax, Ymax, Zmax, MaxSide;
1143   theBox.Get( Xmin, Ymin, Zmin, Xmax, Ymax, Zmax );
1144   MaxSide = Max( Max(Xmax-Xmin, Ymax-Ymin), Zmax-Zmin );
1145   Standard_Real MinTol = Min( BRep_Tool::Tolerance(myF1), BRep_Tool::Tolerance(myF2) );
1146   if (MaxSide < MinTol)
1147     {
1148       DSC.ChangeKeep(Standard_False);
1149       return;
1150     }
1151
1152   Standard_Real tolDSC = 1.e-8;
1153   DSC.Tolerance(tolDSC);
1154   const TopOpeBRepDS_Transition& lllt1 = FaceFaceTransition(1);
1155   const TopOpeBRepDS_Transition& lllt2 = FaceFaceTransition(2);
1156   
1157   myDS->ChangeCurveInterferences(myDSCIndex).Append(myDSCIL);
1158   {
1159     TopOpeBRepDS_Transition T1 = lllt1; T1.Index(iF2);
1160     FCI1 = TopOpeBRepDS_InterferenceTool::MakeFaceCurveInterference
1161       (T1,iF2,myDSCIndex,PC1);
1162     myHDS->StoreInterference(FCI1,myF1);
1163   }
1164   
1165   {
1166     TopOpeBRepDS_Transition T2 = lllt2; T2.Index(iF1);
1167     FCI2 = TopOpeBRepDS_InterferenceTool::MakeFaceCurveInterference
1168       (T2,iF1,myDSCIndex,PC2);
1169     myHDS->StoreInterference(FCI2,myF2);
1170   }
1171   
1172   DSC.SetShapes(myF1,myF2);
1173   DSC.SetSCI(FCI1,FCI2);
1174   
1175 }
1176
1177 //=======================================================================
1178 //function : StoreCurveInterference
1179 //purpose  : private
1180 //=======================================================================
1181 void TopOpeBRep_FacesFiller::StoreCurveInterference(const Handle(TopOpeBRepDS_Interference)& I)
1182 {
1183   if ( myDSCIndex == 0 ) {
1184     TopOpeBRepDS_Curve DSC;
1185     myDSCIndex = myDS->AddCurve(DSC);
1186     
1187 #ifdef DEB
1188     if (TopOpeBRepDS_GettraceDSF() || TopOpeBRepDS_GettraceDSNC()) 
1189       cout<<"new DSC "<<myDSCIndex<<endl;
1190     if (TopOpeBRepDS_GettraceDSLT()) myLine->DumpLineTransitions(cout);
1191 #endif
1192   }
1193   
1194   I->Support(myDSCIndex);
1195   myHDS->StoreInterference(I,myDSCIL);
1196 }
1197
1198 //=======================================================================
1199 //function : GetGeometry
1200 //purpose  : 
1201 //=======================================================================
1202 Standard_Boolean TopOpeBRep_FacesFiller::GetGeometry(TopOpeBRepDS_ListIteratorOfListOfInterference& IT,const TopOpeBRep_VPointInter& VP,Standard_Integer& G,TopOpeBRepDS_Kind& K)
1203 {
1204   TopOpeBRepDS_Point DSP = TopOpeBRep_PointGeomTool::MakePoint(VP);
1205   Standard_Boolean b = myHDS->GetGeometry(IT,DSP,G,K);
1206 #ifdef DEB
1207   Standard_Boolean trc = TopOpeBRepDS_GettraceDSF() || TopOpeBRepDS_GettraceDSP();
1208   if (b && trc) { 
1209     Standard_Boolean newinDS = Standard_False; myHFFD->DumpDSP(VP,K,G,newinDS);
1210   }
1211 #endif
1212   return b;
1213 }
1214
1215 //=======================================================================
1216 //function : MakeGeometry
1217 //purpose  : 
1218 //=======================================================================
1219 Standard_Integer TopOpeBRep_FacesFiller::MakeGeometry(const TopOpeBRep_VPointInter& VP,const Standard_Integer ShapeIndex,TopOpeBRepDS_Kind& K)
1220 {
1221   Standard_Integer G;
1222   Standard_Boolean isvertex = VP.IsVertex(ShapeIndex);
1223   if ( isvertex ) {
1224     const TopoDS_Shape& S = VP.Vertex(ShapeIndex);
1225     G = myDS->AddShape(S,ShapeIndex);
1226     K = TopOpeBRepDS_VERTEX;
1227   }
1228   else {
1229     TopOpeBRepDS_Point P = TopOpeBRep_PointGeomTool::MakePoint(VP);
1230     G = myDS->AddPoint(P);
1231     K = TopOpeBRepDS_POINT;
1232   }
1233   
1234 #ifdef DEB
1235   Standard_Boolean trc = TopOpeBRepDS_GettraceDSF() || TopOpeBRepDS_GettraceDSP();
1236   if (trc) {
1237     Standard_Boolean newinDS = Standard_True; myHFFD->DumpDSP(VP,K,G,newinDS);
1238   }  
1239 #endif
1240   
1241   return G;
1242 }
1243
1244 //=======================================================================
1245 //function : GetFFGeometry
1246 //purpose  : 
1247 //=======================================================================
1248 Standard_Boolean TopOpeBRep_FacesFiller::GetFFGeometry(const TopOpeBRepDS_Point& DSP,TopOpeBRepDS_Kind& K,Standard_Integer& G) const 
1249 {
1250   Standard_Boolean found = Standard_False;
1251   Standard_Integer i = myFFfirstDSP, n = myDS->NbPoints();
1252   for (; i <= n; i++) {
1253     const TopOpeBRepDS_Point& OODSP = myDS->Point(i);
1254     found = TopOpeBRep_PointGeomTool::IsEqual(DSP,OODSP);
1255     if (found) break; 
1256   }
1257   if ( found ) {
1258     K = TopOpeBRepDS_POINT;
1259     G = i;
1260   }
1261   return found;
1262 }
1263
1264 //=======================================================================
1265 //function : GetFFGeometry
1266 //purpose  : 
1267 //=======================================================================
1268 Standard_Boolean TopOpeBRep_FacesFiller::GetFFGeometry(const TopOpeBRep_VPointInter& VP,TopOpeBRepDS_Kind& K,Standard_Integer& G) const 
1269 {
1270   TopOpeBRepDS_Point DSP = TopOpeBRep_PointGeomTool::MakePoint(VP);
1271   Standard_Integer found = GetFFGeometry(DSP,K,G);
1272   return found;
1273 }
1274