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