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