projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0029915: Porting to VC 2017 : Regressions in Modeling Algorithms on VC 2017
[occt.git] / src / TopOpeBRepDS / TopOpeBRepDS_EIR.cxx
CommitLineData
b311480e 1// Copyright (c) 1998-1999 Matra Datavision
973c2be1 2// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 3//
973c2be1 4// This file is part of Open CASCADE Technology software library.
b311480e 5//
d5f74e42 6// This library is free software; you can redistribute it and/or modify it under
7// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 8// by the Free Software Foundation, with special exception defined in the file
9// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10// distribution for complete text of the license and disclaimer of any warranty.
b311480e 11//
973c2be1 12// Alternatively, this file may be used under the terms of Open CASCADE
13// commercial license or contractual agreement.
7fd59977 14
42cf5bc1 15
7fd59977 16#include <BRep_Tool.hxx>
17#include <TopExp.hxx>
42cf5bc1 18#include <TopoDS.hxx>
19#include <TopOpeBRepDS_connex.hxx>
7fd59977 20#include <TopOpeBRepDS_CurvePointInterference.hxx>
42cf5bc1 21#include <TopOpeBRepDS_define.hxx>
7fd59977 22#include <TopOpeBRepDS_Dumper.hxx>
23#include <TopOpeBRepDS_Edge3dInterferenceTool.hxx>
24#include <TopOpeBRepDS_EdgeInterferenceTool.hxx>
25#include <TopOpeBRepDS_EdgeVertexInterference.hxx>
42cf5bc1 26#include <TopOpeBRepDS_EIR.hxx>
27#include <TopOpeBRepDS_EXPORT.hxx>
28#include <TopOpeBRepDS_HDataStructure.hxx>
7fd59977 29#include <TopOpeBRepDS_Interference.hxx>
7fd59977 30#include <TopOpeBRepDS_ProcessInterferencesTool.hxx>
7fd59977 31#include <TopOpeBRepDS_repvg.hxx>
42cf5bc1 32#include <TopOpeBRepDS_TKI.hxx>
33#include <TopOpeBRepTool_EXPORT.hxx>
7fd59977 34#include <TopOpeBRepTool_TOOL.hxx>
42cf5bc1 35
7fd59977 36#define M_FORWARD(O) (O == TopAbs_FORWARD)
37#define M_REVERSED(O) (O == TopAbs_REVERSED)
38#define M_INTERNAL(O) (O == TopAbs_INTERNAL)
39#define M_EXTERNAL(O) (O == TopAbs_EXTERNAL)
40
41// modified by NIZHNY-MKK Mon Apr 2 15:34:28 2001.BEGIN
42static Standard_Boolean CheckInterferenceIsValid(const Handle(TopOpeBRepDS_Interference)& I,
43 const TopoDS_Edge& theEdge,
44 const TopoDS_Edge& theSupportEdge,
45 const TopoDS_Vertex& theVertex);
46// modified by NIZHNY-MKK Mon Apr 2 15:34:32 2001.END
47
48//------------------------------------------------------
49static void FDS_reduceONFACEinterferences(TopOpeBRepDS_ListOfInterference& LI,
50 const TopOpeBRepDS_DataStructure& /*BDS*/,
536a3cb8 51 const Standard_Integer)
7fd59977 52//------------------------------------------------------
53{
7fd59977 54
55 TopOpeBRepDS_ListIteratorOfListOfInterference it1; // set hasONFACE = True if LI contains interfs with (ON,FACE) transition(s).
56 Standard_Boolean hasONFACE = Standard_False;
57 for (it1.Initialize(LI); it1.More(); it1.Next() ) {
58 Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
59 TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
60 if ( GT1 == TopOpeBRepDS_POINT ) {
61 hasONFACE = FUN_hasStateShape(I1->Transition(),TopAbs_ON,TopAbs_FACE);
62 if ( hasONFACE ) break;
63 }
64 }
65
7fd59977 66 if ( hasONFACE ) {
67 // LI has (ON,FACE) : remove all other interf (POINT,(not(ON,FACE)))
68 it1.Initialize(LI);
69 while( it1.More() ) {
70 Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
71 TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
72 if ( GT1 == TopOpeBRepDS_POINT ) {
73 hasONFACE = FUN_hasStateShape(I1->Transition(),TopAbs_ON,TopAbs_FACE);
74 if ( ! hasONFACE ) {
75 LI.Remove(it1);
76 }
77 else it1.Next();
78 }
79 else it1.Next();
80 }
81 }
7fd59977 82}
83
84//------------------------------------------------------
85static void FUN_ReducerEdge3d(const Standard_Integer SIX, TopOpeBRepDS_DataStructure& BDS,
86 TopOpeBRepDS_ListOfInterference& LI,TopOpeBRepDS_ListOfInterference& reducedLI)
87//------------------------------------------------------
88// <LI> = { I3d = (TonFACE, G=POINT/VERTEX, S=EDGE) }
89// {I3d} --reducing processing-> I3d' = (TonFACE, G=POINT/VERTEX, S=FACE)
90// <LI> -> <reducedLI> + <LI>
91{
92 reducedLI.Clear();
536a3cb8 93
7fd59977 94 Standard_Integer n3d = LI.Extent();
95 if (n3d <= 1) return;
96 const TopoDS_Edge& E = TopoDS::Edge(BDS.Shape(SIX));
97 Standard_Integer rankE = BDS.AncestorRank(E);
98 TopoDS_Shape OOv; Standard_Integer Gsta = 0;
99
100 TopOpeBRepDS_ListIteratorOfListOfInterference it1;
101 it1.Initialize(LI);
102
103 // <-- jyl 231198 : cts21797
104 Standard_Integer nLI = LI.Extent();
105 if (nLI >= 1) {
106 while (it1.More()) {
107 const Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
108 TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
109 TopAbs_ShapeEnum SB1,SA1; Standard_Integer IB1,IA1; FDS_Tdata(I1,SB1,IB1,SA1,IA1);
110 Standard_Boolean torem = Standard_False;
111 if (ST1 == TopOpeBRepDS_EDGE) {
112 const TopoDS_Edge& EE = TopoDS::Edge(BDS.Shape(S1));
113 const TopoDS_Face& FF = TopoDS::Face(BDS.Shape(IB1));
114 TopAbs_Orientation o; Standard_Boolean ok = FUN_tool_orientEinFFORWARD(EE,FF,o);
115 if (ok && (o == TopAbs_EXTERNAL)) torem = Standard_True;
116 }
117 if (torem) LI.Remove(it1);
118 else it1.Next();
119 }
120 nLI = LI.Extent();
121 if (nLI <= 1) return;
122 }
123 // --> jyl 231198 : cts21797
124
125 it1.Initialize(LI);
126 while (it1.More()){
127
128 Standard_Boolean isComplex = Standard_False;
129 TopOpeBRepDS_Edge3dInterferenceTool EFITool;
130 const Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
131 TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
132 TopAbs_ShapeEnum SB1,SA1; Standard_Integer IB1,IA1; FDS_Tdata(I1,SB1,IB1,SA1,IA1);
133
134 // modified by NIZHNY-MKK Mon Apr 2 15:35:58 2001.BEGIN
135 TopoDS_Vertex aVertex;
136
137 if((GT1 == TopOpeBRepDS_VERTEX) && G1!=0) {
138 aVertex = TopoDS::Vertex(BDS.Shape(G1));
139 }
140
141 if(!CheckInterferenceIsValid(I1, E, TopoDS::Edge(BDS.Shape(S1)), aVertex)) {
142 LI.Remove(it1);
143 continue;
144 }
145 // modified by NIZHNY-MKK Mon Apr 2 15:36:02 2001.END
146
147 TopOpeBRepDS_ListIteratorOfListOfInterference it2(it1);
148 if (it2.More()) it2.Next();
149 else return;
150
151 while ( it2.More()){
152 const Handle(TopOpeBRepDS_Interference)& I2 = it2.Value();
153 TopOpeBRepDS_Kind GT2,ST2; Standard_Integer G2,S2; FDS_data(I2,GT2,G2,ST2,S2);
154 TopAbs_ShapeEnum SB2,SA2; Standard_Integer IB2,IA2; FDS_Tdata(I2,SB2,IB2,SA2,IA2);
155
156 // modified by NIZHNY-MKK Mon Apr 2 15:36:42 2001.BEGIN
157 aVertex.Nullify();
158
159 if((GT2 == TopOpeBRepDS_VERTEX) && G2!=0) {
160 aVertex = TopoDS::Vertex(BDS.Shape(G2));
161 }
162
163 if(!CheckInterferenceIsValid(I2, E, TopoDS::Edge(BDS.Shape(S2)), aVertex)) {
164 LI.Remove(it2);
165 continue;
166 }
167 // modified by NIZHNY-MKK Mon Apr 2 15:36:45 2001.END
168
169 Standard_Boolean sameG = (GT2 == GT1) && (G2 == G1);
170 if (!sameG) break;
171
172 // <Gsta>, <OOv>
173 if (GT1 == TopOpeBRepDS_VERTEX) {
174 TopoDS_Vertex vG1 = TopoDS::Vertex(BDS.Shape(G1));
175 Standard_Integer rankvG1 = BDS.AncestorRank(vG1);
176 Standard_Integer sdG1; Standard_Boolean G1hsd = FUN_ds_getVsdm(BDS,G1,sdG1);
177 if (rankvG1 != rankE) { // vG1 not on E
178 OOv = vG1;
179 Gsta = G1hsd? 3: 2;
180 }
181 else { // vG on E
182 if (G1hsd) OOv = BDS.Shape(sdG1);
183 Gsta = G1hsd? 3: 1;
184 }
185 }
186
187 const TopoDS_Face& F1 = TopoDS::Face(BDS.Shape(IB1));
188 const TopoDS_Face& F2 = TopoDS::Face(BDS.Shape(IB2)); // F2 != F1
189
190 Standard_Boolean sameS = (ST2 == ST1) && (S2 == S1);
191 if (!sameS) {
192 TopoDS_Shape Eshared; Standard_Boolean foundsh = FUN_tool_Eshared(OOv,F1,F2,Eshared);
193 if (!foundsh) return;
194
195 // modified by NIZHNY-MKK Mon Apr 2 15:37:12 2001.BEGIN
196 if(!BDS.HasShape(Eshared)) {
197 return;
198 }
199 // modified by NIZHNY-MKK Mon Apr 2 15:37:15 2001.END
200
201 S1 = S2 = BDS.Shape(Eshared);
202 }
203
204 const TopoDS_Edge& E1 = TopoDS::Edge(BDS.Shape(S1));
205 const TopoDS_Edge& E2 = TopoDS::Edge(BDS.Shape(S2)); // E2 == E1
206
207 Standard_Boolean sdm = FUN_ds_sdm(BDS,E,E1);
208 if (sdm) {
536a3cb8 209
7fd59977 210 it2.Next(); continue;
211 }
212
213 Standard_Boolean init = !isComplex;
214 Standard_Boolean isvertex = (GT1 == TopOpeBRepDS_VERTEX);
215 init = init || isvertex; // !!!KK a revoir!!!!
216
217 if (init) {
218
219 // xpu : 04-03-98 : !!!KK a revoir!!!!
220 if (isComplex) {
221 Handle(TopOpeBRepDS_Interference) IBID = new TopOpeBRepDS_Interference();
222 EFITool.Transition(IBID);
223 I1->ChangeTransition().Set(IBID->Transition().Orientation(TopAbs_IN));
224 }
225 // !!!KK a revoir!!!!
226
227 if (!isComplex) EFITool.InitPointVertex(Gsta,OOv);
228 isComplex = Standard_True;
229 EFITool.Init(E,E1,F1,I1);
230 EFITool.Add(E,E1,F1,I1);
7fd59977 231 } // !isComplex
232
7fd59977 233 EFITool.Add(E,E2,F2,I2);
234 LI.Remove(it2);
235
7fd59977 236 } // it2
237
238 if (isComplex) {
239 Handle(TopOpeBRepDS_Interference) newI;
240 Handle(TopOpeBRepDS_Interference) IIBID = new TopOpeBRepDS_Interference();
241 EFITool.Transition(IIBID);
242 TopOpeBRepDS_Transition T = IIBID->Transition(); T.Index(IB1);
243
244 Standard_Boolean isevi = I1->IsKind(STANDARD_TYPE(TopOpeBRepDS_EdgeVertexInterference));
245 Standard_Boolean iscpi = I1->IsKind(STANDARD_TYPE(TopOpeBRepDS_CurvePointInterference));
246 if (isevi) {
c5f3a425 247 Handle(TopOpeBRepDS_EdgeVertexInterference) EVI (Handle(TopOpeBRepDS_EdgeVertexInterference)::DownCast(I1));
7fd59977 248 newI = new TopOpeBRepDS_EdgeVertexInterference(T,TopOpeBRepDS_FACE,IB1,G1,EVI->GBound(),
249 TopOpeBRepDS_UNSHGEOMETRY,EVI->Parameter());
250 }
251 if (iscpi) {
c5f3a425 252 Handle(TopOpeBRepDS_CurvePointInterference) CPI (Handle(TopOpeBRepDS_CurvePointInterference)::DownCast(I1));
7fd59977 253 newI = new TopOpeBRepDS_CurvePointInterference(T,TopOpeBRepDS_FACE,IB1,TopOpeBRepDS_POINT,G1,CPI->Parameter());
254 }
255
7fd59977 256 if (!newI.IsNull()) {
257 reducedLI.Append(newI);
258 LI.Remove(it1);
259 }
260 }
261 else
262 it1.Next();
263 } // it1
7fd59977 264}
265
266//------------------------------------------------------
267static void FUN_ReducerEdge(const Standard_Integer SIX,const TopOpeBRepDS_DataStructure& BDS,
268 TopOpeBRepDS_ListOfInterference& LI,TopOpeBRepDS_ListOfInterference& reducedLI)
269//------------------------------------------------------
270{
7fd59977 271 FDS_repvg(BDS,SIX,TopOpeBRepDS_VERTEX,LI,reducedLI);
272 FDS_reduceONFACEinterferences(LI,BDS,SIX);
273 FDS_repvg(BDS,SIX,TopOpeBRepDS_POINT,LI,reducedLI);
7fd59977 274}
275
276//------------------------------------------------------
277static void FUN_ReducerSDEdge(const Standard_Integer SIX,const TopOpeBRepDS_DataStructure& BDS,
278 TopOpeBRepDS_ListOfInterference& LI,TopOpeBRepDS_ListOfInterference& reducedLI)
279//------------------------------------------------------
280{
281 reducedLI.Clear();
282 Standard_Integer nI = LI.Extent();
536a3cb8 283
7fd59977 284 if (nI <= 1) return;
285
286 TopOpeBRepDS_ListOfInterference newLI;
287 const TopoDS_Shape& EIX = BDS.Shape(SIX);
288 TopOpeBRepDS_TKI tki; tki.FillOnGeometry(LI);
289 for (tki.Init(); tki.More(); tki.Next()) {
290 TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
291 TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G); TopOpeBRepDS_ListOfInterference Rloi;
292
293 TopOpeBRepDS_ListIteratorOfListOfInterference it1(loi);
294 while (it1.More()) {
295 const Handle(TopOpeBRepDS_Interference)& I1 = it1.Value(); const TopOpeBRepDS_Transition& T1 = I1->Transition();
296 TopAbs_Orientation O1 = T1.Orientation(TopAbs_IN); Standard_Integer IB1 = T1.Index();
297 Standard_Boolean cond1 = FUN_ds_sdm(BDS,EIX,BDS.Shape(IB1));
298 if (!cond1) {newLI.Append(I1); it1.Next(); continue;}
299
300 Standard_Boolean complex1d = Standard_False;
301 TopOpeBRepDS_ListIteratorOfListOfInterference it2(it1);
302 if (it2.More()) it2.Next();
303 else break;
304
305 TopOpeBRepDS_Transition T(TopAbs_IN,TopAbs_IN,TopAbs_EDGE,TopAbs_EDGE);
306 while (it2.More()){
307 const Handle(TopOpeBRepDS_Interference)& I2 = it2.Value(); const TopOpeBRepDS_Transition& T2 = I2->Transition();
308 TopAbs_Orientation O2 = T2.Orientation(TopAbs_IN); Standard_Integer IB2 = T2.Index();
309 Standard_Boolean cond2 = FUN_ds_sdm(BDS,EIX,BDS.Shape(IB2));
310 if (!cond2) {newLI.Append(I2); it2.Next(); continue;}
311
312 complex1d = (M_FORWARD(O1) && M_REVERSED(O2));
313 complex1d = complex1d || (M_FORWARD(O2) && M_REVERSED(O1));
314 if (!complex1d) {newLI.Append(I2); it2.Next(); continue;}
315
316 if (complex1d) {
317 Standard_Integer IB = (M_REVERSED(O1)) ? IB1 : IB2; T.IndexBefore(IB);
318 Standard_Integer IA = (M_REVERSED(O1)) ? IB2 : IB1; T.IndexAfter(IA);
319 }
320 loi.Remove(it2);
321 break; // no more than 2 interferences on sdmTRASHA at same G
322 } // it2
323
324 if (complex1d) {
c5f3a425 325 Handle(TopOpeBRepDS_EdgeVertexInterference) EVI (Handle(TopOpeBRepDS_EdgeVertexInterference)::DownCast(I1));
7fd59977 326 TopOpeBRepDS_Config cEIX=BDS.SameDomainOri(SIX), c1=BDS.SameDomainOri(IB1);
327 TopOpeBRepDS_Config Conf = (cEIX == c1) ? TopOpeBRepDS_SAMEORIENTED : TopOpeBRepDS_DIFFORIENTED;
328 Handle(TopOpeBRepDS_Interference) newI = new TopOpeBRepDS_EdgeVertexInterference(T,TopOpeBRepDS_EDGE,IB1,G,EVI->GBound(),Conf,EVI->Parameter());
329 reducedLI.Append(newI);
330 it1.Next();
331 }
332 else {
333 newLI.Append(I1);
334 loi.Remove(it1);
335 }
336 } // it1
337 } // tki
338
339 LI.Clear(); LI.Append(newLI);
7fd59977 340}
341
342//------------------------------------------------------
343static void FUN_reclSE2(const Standard_Integer SIX,const TopOpeBRepDS_DataStructure& BDS,
344 TopOpeBRepDS_ListOfInterference& LI,TopOpeBRepDS_ListOfInterference& reducedLI)
345//------------------------------------------------------
346// reducing LI = {I = (T(edge),G0,edge)}
347// edge <SIX> is same domain with edge <SE>
348// {I1 = (OU/IN(SE),VG,SE)
349// I2 = (IN/OU(SE),VG,SE))} -> Ir = (IN/IN(SE),VG,SE)
350{
351 reducedLI.Clear();
7fd59977 352
353 const TopoDS_Edge& E = TopoDS::Edge(BDS.Shape(SIX));
354
7fd59977 355 TopOpeBRepDS_ListIteratorOfListOfInterference it1(LI);
356 while (it1.More()) {
357 const Handle(TopOpeBRepDS_Interference)& I1 = it1.Value();
358 TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; FDS_data(I1,GT1,G1,ST1,S1);
359
360 const TopOpeBRepDS_Transition& T1 = I1->Transition(); TopAbs_Orientation O1 = T1.Orientation(TopAbs_IN);
361 if (M_INTERNAL(O1) || M_EXTERNAL(O1)) {it1.Next(); continue;}
362 TopAbs_Orientation cO1 = TopAbs::Complement(O1);
363
364 const TopoDS_Vertex& v1 = TopoDS::Vertex(BDS.Shape(G1));
365 const TopoDS_Edge& E1 = TopoDS::Edge(BDS.Shape(S1));
366 TopoDS_Vertex vclo1; Standard_Boolean iscE1 = TopOpeBRepTool_TOOL::ClosedE(E1,vclo1);
367 if (!iscE1) {it1.Next(); continue;}
368 if (!vclo1.IsSame(v1)) {it1.Next(); continue;}
369
370 Standard_Boolean sdm = FUN_ds_sdm(BDS,E,E1);
371 if (!sdm) {it1.Next(); continue;}
372
373 Standard_Boolean hascO = Standard_False;
374 TopOpeBRepDS_ListIteratorOfListOfInterference it2(it1);
375 if (it2.More()) it2.Next();
376 else {it1.Next(); continue;}
377 while ( it2.More()){
378 const Handle(TopOpeBRepDS_Interference)& I2 = it2.Value();
379 const TopOpeBRepDS_Transition& T2 = I2->Transition(); TopAbs_Orientation O2 = T2.Orientation(TopAbs_IN);
380 TopOpeBRepDS_Kind GT2,ST2; Standard_Integer G2,S2; FDS_data(I2,GT2,G2,ST2,S2);
381
382 if (S1 != S2) {it2.Next(); continue;}
383 if (O2 != cO1) {it2.Next(); continue;}
384
385 LI.Remove(it2);
7fd59977 386 hascO = Standard_True; break;
387 } //it2
388
389 if (hascO) {
390 I1->ChangeTransition().Set(TopAbs_INTERNAL);
391 reducedLI.Append(I1); LI.Remove(it1);
7fd59977 392 }
393 else it1.Next();
394 } //it1
7fd59977 395} // FUN_reclSE2
396
397//------------------------------------------------------
398Standard_EXPORT void FUN_reclSE(const Standard_Integer EIX,const TopOpeBRepDS_DataStructure& BDS,
399 TopOpeBRepDS_ListOfInterference& LOI,TopOpeBRepDS_ListOfInterference& RLOI)
400//------------------------------------------------------
401{
402 TopOpeBRepDS_TKI tki; tki.FillOnGeometry(LOI);
7fd59977 403
404 LOI.Clear();
405 for (tki.Init(); tki.More(); tki.Next()) {
406 TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
407 if (K != TopOpeBRepDS_VERTEX) continue;
536a3cb8 408
7fd59977 409 TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G); TopOpeBRepDS_ListOfInterference Rloi;
410 Standard_Integer nloi = loi.Extent();
411 if (nloi == 0) continue;
412 else if (nloi == 1) LOI.Append(loi);
413 else {
414 FUN_reclSE2(EIX,BDS,loi,Rloi);
415 LOI.Append(loi); RLOI.Append(Rloi);
416 }
417 }
7fd59977 418} // FUN_reclSE
419
420//------------------------------------------------------
421static void FUN_unkeepEVIonGb1(const TopOpeBRepDS_DataStructure& BDS,const Standard_Integer EIX,TopOpeBRepDS_ListOfInterference& LI)
422//------------------------------------------------------
423// LI = {I attached to <E> = (T,G,S)}, unkeep I = EVI with G = vertex of <E>
424{
425
7fd59977 426 const TopoDS_Edge& E = TopoDS::Edge(BDS.Shape(EIX));
427
428 TopOpeBRepDS_ListIteratorOfListOfInterference it(LI);
429 while (it.More()) {
430 const Handle(TopOpeBRepDS_Interference)& I = it.Value();
431 Standard_Boolean evi = I->IsKind(STANDARD_TYPE(TopOpeBRepDS_EdgeVertexInterference));
432 if (!evi) {it.Next(); continue;}
433 TopOpeBRepDS_Kind GT,ST; Standard_Integer G,S; FDS_data(I,GT,G,ST,S);
434 if (GT != TopOpeBRepDS_VERTEX){it.Next(); continue;}
435
436 const TopoDS_Vertex& V = TopoDS::Vertex(BDS.Shape(G));
437 Standard_Integer o = FUN_tool_orientVinE(V,E);
438 if (o == 0){it.Next(); continue;}
7fd59977 439
536a3cb8 440 LI.Remove(it);
7fd59977 441 }
442}
536a3cb8 443static void FUN_keepl3dF(const Standard_Integer, const Handle(TopOpeBRepDS_HDataStructure)&
7fd59977 444 ,const TopOpeBRepDS_ListOfInterference& l3dF
445 ,const TopOpeBRepDS_ListOfInterference& LR3dFE,
446 TopOpeBRepDS_ListOfInterference& l3dFkeep)
447//purpose : soit I de l3dF, on cherche IR interf dans LR3dFE de meme geometrie
448// si on n'en trouve pas, l3dFkeep += I
449{
7fd59977 450 TopOpeBRepDS_TKI tki;
451 tki.FillOnGeometry(l3dF);
452
453 TopOpeBRepDS_TKI tkiR;
454 tkiR.FillOnGeometry(LR3dFE);
455
456 for (tki.Init(); tki.More(); tki.Next()) {
457 TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
458 TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G);
459 tkiR.Init();
460 Standard_Boolean isbound = tkiR.IsBound(K,G);
461 if (!isbound) {l3dFkeep.Append(loi);}
462
7fd59977 463 }
464} // FUN_keepl3dF
465
466static void FUN_reducepure2dI0(TopOpeBRepDS_ListOfInterference& LI, TopOpeBRepDS_ListOfInterference& RLI)
467// xpu210798 : CTS21216 (e7,G=P3,S=E9,FTRASHA=f8,f10)
468// LI attached to section edge
469// 2dI1=(REVERSED(ftrasha1),G,ES), 2dI2=(FORWARD(ftrasha2),G,ES)
470// for the compute of splitON(EIX), reduce 2dI1+2dI2 -> 2dR=(IN(ftrasha1,ftrasha2)
471// LI-> RLI + LI
472{
473 const Handle(TopOpeBRepDS_Interference)& I1 = LI.First();
474 TopAbs_Orientation O1 = I1->Transition().Orientation(TopAbs_IN);
475 TopOpeBRepDS_Kind GT1,ST1; Standard_Integer G1,S1; TopAbs_ShapeEnum tsb1,tsa1; Standard_Integer isb1,isa1;
476 FDS_Idata(I1,tsb1,isb1,tsa1,isa1,GT1,G1,ST1,S1);
477
478 const Handle(TopOpeBRepDS_Interference)& I2 = LI.Last();
479 TopAbs_Orientation O2 = I2->Transition().Orientation(TopAbs_IN);
480 TopOpeBRepDS_Kind GT2,ST2; Standard_Integer G2,S2; TopAbs_ShapeEnum tsb2,tsa2; Standard_Integer isb2,isa2;
481 FDS_Idata(I2,tsb2,isb2,tsa2,isa2,GT2,G2,ST2,S2);
482
483 if (isb1 == isb2) return; //xpu170898 FOR+REV ->INT/EXT (cto009B1(es6,p1,f9))
484
485 // recall : G1==G2 && ST1==ST2==EDGE
486 Standard_Boolean ok = (G1==G2);
487 ok = ok && (tsb1 == TopAbs_FACE) && (tsb1==tsb2) && (isb1==isa1) && (isb2==isa2);
488 if (!ok) return;
489
490 Standard_Boolean int12 = M_REVERSED(O1) && M_FORWARD(O2);
491 Standard_Boolean int21 = M_REVERSED(O2) && M_FORWARD(O1);
492 ok = int12 || int21;
493 if (!ok) return;
494
495 TopOpeBRepDS_Transition newT(TopAbs_INTERNAL);
496 Standard_Integer bef = int12? isb1 : isb2;
497 Standard_Integer aft = int21? isb1 : isb2;
498 newT.IndexBefore(bef); newT.IndexAfter(aft);
499 I1->ChangeTransition() = newT;
500 RLI.Append(I1);
501 LI.Clear();
502} // FUN_reducepure2dI0
503
504static void FUN_reducepure2dI(TopOpeBRepDS_ListOfInterference& LI, TopOpeBRepDS_ListOfInterference& RLI)
505{
506 TopOpeBRepDS_TKI tki; tki.FillOnGeometry(LI);
507 TopOpeBRepDS_ListOfInterference newLI;
508 for (tki.Init(); tki.More(); tki.Next()) {
509 TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
510 TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G); TopOpeBRepDS_ListOfInterference Rloi;
511 Standard_Integer nloi = loi.Extent();
512 Standard_Boolean ok = (nloi == 2) && (K == TopOpeBRepDS_POINT);
513 if (ok) ::FUN_reducepure2dI0(loi,Rloi);
514 RLI.Append(Rloi);
515 newLI.Append(loi);
516 }
517 LI.Clear(); LI.Append(newLI);
518} // FUN_reducepure2dI
519
520//=======================================================================
521//function : TopOpeBRepDS_EIR
522//purpose :
523//=======================================================================
524TopOpeBRepDS_EIR::TopOpeBRepDS_EIR
525(const Handle(TopOpeBRepDS_HDataStructure)& HDS) : myHDS(HDS)
526{}
527
528//=======================================================================
529//function : ProcessEdgeInterferences
530//purpose :
531//=======================================================================
532void TopOpeBRepDS_EIR::ProcessEdgeInterferences()
533{
534 TopOpeBRepDS_DataStructure& BDS = myHDS->ChangeDS();
535 Standard_Integer i,nshape = BDS.NbShapes();
536 for (i = 1; i <= nshape; i++) {
537 const TopoDS_Shape& S = BDS.Shape(i);
538 if(S.IsNull()) continue;
539 if ( S.ShapeType() == TopAbs_EDGE ) {
540 ProcessEdgeInterferences(i);
541 }
542 }
543}
544static void FUN_ProcessEdgeInterferences(const Standard_Integer EIX
545 , const TopOpeBRepDS_Kind
7fd59977 546 ,const Standard_Integer
7fd59977 547 , const Handle(TopOpeBRepDS_HDataStructure)& HDS,
548 TopOpeBRepDS_ListOfInterference& LI)
549{
550 TopOpeBRepDS_DataStructure& BDS = HDS->ChangeDS();
551 const TopoDS_Shape& E = BDS.Shape(EIX);
7fd59977 552
7fd59977 553 // LI -> (lF + lFE) + lE + [LI]
554 // lF = {interference on edge <EIX> : (T(face),G=POINT/VERTEX,S)
555 // lFE = {interference on edge <EIX> : (T(face),G=POINT/VERTEX,S=EDGE)
556 // lE = {interference on edge <EIX> : (T(edge),G=POINT/VERTEX,S)
96a95605
DB		 557 TopOpeBRepDS_ListOfInterference lF; FUN_selectTRASHAinterference(LI,TopAbs_FACE,lF);
558 TopOpeBRepDS_ListOfInterference lFE; FUN_selectSKinterference(lF,TopOpeBRepDS_EDGE,lFE);
559 TopOpeBRepDS_ListOfInterference lE; FUN_selectTRASHAinterference(LI,TopAbs_EDGE,lE);
7fd59977 560
7fd59977 561 // xpu210798 : CTS21216 (e7,G=P3,S=E9,FTRASHA=f8,f10)
562 // EIX is section edge
563 // 2dI1=(REVERSED(ftrasha1),G,ES), 2dI2=(FORWARD(ftrasha2),G,ES)
564 // for the compute of splitON(EIX), reduce 2dI1+2dI2 -> 2dR=(IN(ftrasha1,ftrasha2)
565 Standard_Boolean isse = BDS.IsSectionEdge(TopoDS::Edge(E));
566 if (isse) {
567 TopOpeBRepDS_ListOfInterference lI2dFE,lRI2dFE;
568 // lF -> lF
569 // lFE -> lI2dFE + [lFE] / lI2dFE={FEI=(T(FTRASHA),G,SE) : no FFI=(T(FTRASHA),G,FTRASHA)}
570 FUN_selectpure2dI(lF,lFE,lI2dFE);
7fd59977 571 ::FUN_reducepure2dI(lI2dFE,lRI2dFE); // lI2dFE -> lRI2dFE + lI2dFE
7fd59977 572 lFE.Append(lI2dFE); lFE.Append(lRI2dFE);
573 }
574
575 // I -> 3dI +2dI + 1dI:
576 // -------------------
577 // lFE -> l3dFE [+l3dFEresi] +l2dFE [+lFE (+lFEresi)]
578 // : l3dFE={I3d } to reduce; for I3dFE=(T(F),G,SE) there is I3dF=(T(F),G,F)
579 // l2dFE={I2d} to reduce
580 // lFEresi to remove
581 // lF -> l3dF [+lF] : l3dF to remove
582
583 // lE -> l1dE +l1dEsd [+lE}
584 // : l1dE={I1d=(T(ETRA),G,ETRA)/same ETRA} to reduce
585 // l2dEsd={I1dsd=(T(ETRA),G,ETRA)/ E sdm ETRA}
586
587 TopOpeBRepDS_ListOfInterference lFEresi,l3dFE,l3dF,l3dFEresi,l2dFE;
588 FUN_select3dinterference(EIX,BDS,lF,l3dF,
589 lFE,lFEresi,l3dFE,l3dFEresi,
590 l2dFE);
591 TopOpeBRepDS_ListOfInterference l1dE; FUN_select2dI(EIX,BDS,TopAbs_EDGE,lE,l1dE);
592 TopOpeBRepDS_ListOfInterference l1dEsd; FUN_select1dI(EIX,BDS,lE,l1dEsd);
593
7fd59977 594 // reducer3d :
595 // ----------
596 // l3dFE -> lR3dFE [+l3dFE (non reduced 3dI)]
597 TopOpeBRepDS_ListOfInterference lR3dFE; FUN_ReducerEdge3d(EIX,BDS,l3dFE,lR3dFE);
7fd59977 598
599// FUN_unkeepEVIonGb1(BDS,EIX,l1dE); // filter :
600// FUN_unkeepEVIonGb1(BDS,EIX,l2dFE); // filter :
601
602 // no reduction on G : we keep l3dF(G)
603 TopOpeBRepDS_ListOfInterference l3dFkeep; FUN_keepl3dF(EIX,HDS,l3dF,lR3dFE,l3dFkeep);
604 lF.Append(l3dFkeep);
605
606 // reducer2d :
607 // ----------
608 // l2dFE -> LR2dFE + l2dFE (non reduced 2dI)
609 TopOpeBRepDS_ListOfInterference LR2dFE; FUN_ReducerEdge(EIX,BDS,l2dFE,LR2dFE);
610
611 // reducer1d :
612 // ----------
613 // xpu210498 : reduce interferences I1(T1(esd1),VG,esd1), I2(T2(esd2),VG,esd2)
614 // if EIX sdm {esd1,esd2}
615 // - t2_2 e32 has I1(in/ou(e32),v30,e20) && I2(ou/in(e20),v30,e20) -
616 TopOpeBRepDS_ListOfInterference lR1dEsd; FUN_ReducerSDEdge(EIX,BDS,l1dEsd,lR1dEsd);
617
618 // xpu190298 : edge <EIX> same domain with closed support edge <SE>
619 // at same G = vertex <VG> = closing vertex of <SE>
620 // (I1 = (OU/IN(SE),VG,SE) && I2 = (IN/OU(SE),VG,SE)) -> Ir = (IN/IN(SE),VG,SE)
621 TopOpeBRepDS_ListOfInterference lR1dclosedSE; FUN_reclSE(EIX,BDS,l1dE,lR1dclosedSE);
622
623 // l1dE -> LR1dE + l1dE (non reduced 2dI)
624 TopOpeBRepDS_ListOfInterference LR1dE; FUN_ReducerEdge(EIX,BDS,l1dE,LR1dE);
625
626 // attached to edge <EIX>,
627 // at same G : I =(T, G,S) gives less information than
628 // Ir =(Tr,G,Sr) -reduced interference- with valid Tr
629 // -> unkeep I.
630 // using reduced I : lR3dFE, LR2dFE, LR1dE
631 TopOpeBRepDS_ListOfInterference LRI;
632 LRI.Append(lR1dEsd); LRI.Append(LR1dE); LRI.Append(lR1dclosedSE);
633 LRI.Append(LR2dFE);
634 LRI.Append(lR3dFE);
635
636 lF.Append(lFE); lF.Append(l3dFE); lF.Append(l2dFE);// lF += LFE + l3dFE + l2dFE
637 lE.Append(l1dE); // lE += l1dE
638 lE.Append(l1dEsd); // lE += l1dEsd xpu210498
639// TopOpeBRepDS_ListOfInterference LItmp; LItmp.Append(lF); LItmp.Append(lE);
640
641 // xpu : 23-01-98 : attached to edge <EIX>,
642 // at same G : I =(T, G, S) gives less information than
643 // Ir =(Tr,G,Sr) -reduced interference-
644 // -> I is added after Ir to help the edge builder.
645 LI.Clear();
646 LI.Append(LRI);LI.Append(lE);LI.Append(lF);
647// FUN_reorder(EIX,HDS,LRI, LItmp, LI);
648
649 // xpu260698 : cto902A5, spOU(e6)
650 // cto801G1, spON(se26)
651 if (isse) {
652 FUN_unkeepEVIonGb1(BDS,EIX,LI); // filter :
653 }
654//FUN_unkeepEVIonGb1(BDS,EIX,LI); // filter :
7fd59977 655} // ProcessEdgeInterferences
656
657//=======================================================================
658//function : ProcessEdgeInterferences
659//purpose :
660//=======================================================================
661void TopOpeBRepDS_EIR::ProcessEdgeInterferences(const Standard_Integer EIX)
662{
663 TopOpeBRepDS_DataStructure& BDS = myHDS->ChangeDS();
664
7fd59977 665 // E is the edge, LI is list of interferences to compact
666 const TopoDS_Edge& E = TopoDS::Edge(BDS.Shape(EIX));
667 Standard_Boolean isdg = BRep_Tool::Degenerated(E);
668 if (isdg) return;
669
670 TopOpeBRepDS_ListOfInterference& LI = BDS.ChangeShapeInterferences(EIX);
671 TopOpeBRepDS_TKI newtki; newtki.FillOnGeometry(LI);
672 TopOpeBRepDS_TKI tki; tki.FillOnGeometry(LI);
673 for (tki.Init(); tki.More(); tki.Next()) {
674 TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
675 const TopOpeBRepDS_ListOfInterference& loi = tki.Value(K,G);
676 if (K==TopOpeBRepDS_POINT) continue;
677 const TopoDS_Shape& vG = BDS.Shape(G);
678 TopoDS_Shape oovG; Standard_Boolean sdm = FUN_ds_getoov(vG,BDS,oovG);
679 if (!sdm) continue;
680 Standard_Integer OOG=BDS.Shape(oovG);
681 if (OOG == 0) continue;//NYIRaise
682
683 Standard_Boolean isb = newtki.IsBound(K,OOG);
684
685 // xpu201098 : cto904F6, e10,v6
686 Standard_Boolean isbound = Handle(TopOpeBRepDS_EdgeVertexInterference)::DownCast(loi.First())->GBound();
687 if (isbound) { // replacing vG with oovG
688 TopOpeBRepDS_ListIteratorOfListOfInterference it(loi); TopOpeBRepDS_ListOfInterference newloi;
689 for (; it.More(); it.Next()){
690 const Handle(TopOpeBRepDS_Interference)& I = it.Value();
691 TopOpeBRepDS_Kind GT,ST;
692 Standard_Integer G1,S;
693 FDS_data(I,GT,G1,ST,S);
694 Standard_Real par = FDS_Parameter(I);
695 Handle(TopOpeBRepDS_Interference) newI = MakeEPVInterference(I->Transition(),S,OOG,par,K,ST,Standard_False);
696 newloi.Append(newI);
7fd59977 697 }
698 newtki.ChangeInterferences(K,G).Clear();
699 if (!isb) newtki.Add(K,OOG);
700 newtki.ChangeInterferences(K,OOG).Append(newloi);
701 continue;
702 }
703
704 if (!isb) continue;
705 TopOpeBRepDS_ListOfInterference& li = newtki.ChangeInterferences(K,OOG);
706 newtki.ChangeInterferences(K,G).Append(li);
707 } // tki
708
709 TopOpeBRepDS_ListOfInterference LInew;
710 for (newtki.Init(); newtki.More(); newtki.Next()) {
711 TopOpeBRepDS_Kind K; Standard_Integer G; newtki.Value(K,G);
712 TopOpeBRepDS_ListOfInterference& loi = newtki.ChangeValue(K,G);
713 ::FUN_ProcessEdgeInterferences(EIX,K,G,myHDS,loi);
714 LInew.Append(loi);
715 }
716 LI.Clear();
717 LI.Append(LInew);
718
719 Standard_Boolean performPNC = Standard_False; // JYL 28/09/98 : temporaire
536a3cb8 720
7fd59977 721 if (!performPNC) return;
722
723 // suppression des I/G(I) n'est accede par aucune courbe
724 // portee par une des faces cnx a EIX.
725 Standard_Boolean isfafa = BDS.Isfafa();
726 if (!isfafa) {
727
728 tki.Clear();
729 tki.FillOnGeometry(LI);
730 LI.Clear();
731
732 for (tki.Init(); tki.More(); tki.Next()) {
733 TopOpeBRepDS_Kind K; Standard_Integer G; tki.Value(K,G);
734 TopOpeBRepDS_ListOfInterference& loi = tki.ChangeValue(K,G);
7fd59977 735 if (K != TopOpeBRepDS_POINT) {
736 LI.Append(loi);
737 continue;
738 }
739
740 const TopTools_ListOfShape& lfx = FDSCNX_EdgeConnexitySameShape(E,myHDS);
7fd59977 741
742 // nlfx < 2 => 0 ou 1 face accede E => pas d'autre fcx pouvant generer une courbe 3d
743 TopTools_ListIteratorOfListOfShape itlfx(lfx);
744 Standard_Boolean curvefound = Standard_False;
745 for (; itlfx.More();itlfx.Next()) {
746 const TopoDS_Face& fx = TopoDS::Face(itlfx.Value());
747// BDS.Shape(fx);
748 const TopOpeBRepDS_ListOfInterference& lifx = BDS.ShapeInterferences(fx); TopOpeBRepDS_ListIteratorOfListOfInterference itlifx(lifx);
749 if (!itlifx.More()) continue;
750
751 Handle(TopOpeBRepDS_Interference) I1;TopOpeBRepDS_Kind GT1;Standard_Integer G1;TopOpeBRepDS_Kind ST1;Standard_Integer S1;
752 for (; itlifx.More(); itlifx.Next()) {
753 FDS_data(itlifx,I1,GT1,G1,ST1,S1);
754 Standard_Boolean isfci = (GT1 == TopOpeBRepDS_CURVE);
755 if (!isfci) continue;
756
757 TopOpeBRepDS_ListOfInterference& lic = BDS.ChangeCurveInterferences(G1);
758 TopOpeBRepDS_ListIteratorOfListOfInterference itlic(lic);
759 if (!itlic.More()) continue;
760
761 Handle(TopOpeBRepDS_Interference) I2;TopOpeBRepDS_Kind GT2;Standard_Integer G2;TopOpeBRepDS_Kind ST2;Standard_Integer S2;
762 for (; itlic.More(); itlic.Next()) {
763 FDS_data(itlic,I2,GT2,G2,ST2,S2);
764 Standard_Boolean isp = (GT2 == TopOpeBRepDS_POINT);
765 if (!isp) continue;
766 if ( G2 != G ) continue;
767 curvefound = Standard_True;
768 break;
769 } // itlic.More()
770
771 if (curvefound) break;
772 } // itlifx.More()
773
774 if (curvefound) break;
775 } // itlfx.More()
776
7fd59977 777 if (curvefound) {
778 LI.Append(loi);
779 }
7fd59977 780 } // tki.More()
781 } // (!isfafa)
782
783} // ProcessEdgeInterferences
784
785// modified by NIZHNY-MKK Mon Apr 2 15:34:56 2001.BEGIN
786static Standard_Boolean CheckInterferenceIsValid(const Handle(TopOpeBRepDS_Interference)& I,
787 const TopoDS_Edge& theEdge,
788 const TopoDS_Edge& theSupportEdge,
789 const TopoDS_Vertex& theVertex) {
790 Standard_Real pref = 0. ;
791 Standard_Boolean ok = Standard_False;
792 BRepAdaptor_Curve BC(theEdge);
793
794 Handle(TopOpeBRepDS_CurvePointInterference) CPI;
795 CPI = Handle(TopOpeBRepDS_CurvePointInterference)::DownCast(I);
796
797 if(!CPI.IsNull()) {
798 pref = CPI->Parameter();
799 ok = Standard_True;
800 }
801
802 if(!ok) {
803 Handle(TopOpeBRepDS_EdgeVertexInterference) EVI = Handle(TopOpeBRepDS_EdgeVertexInterference)::DownCast(I);
804 if(!EVI.IsNull()) {
805 pref = EVI->Parameter();
806 ok = Standard_True;
807 }
808 }
809
810 if(!ok)
811 return ok;
812
813 gp_Pnt P3d1 = BC.Value(pref);
814 Standard_Real dist, paronSupportE;
815 ok = FUN_tool_projPonE(P3d1,theSupportEdge,paronSupportE,dist);
816
817 if(!ok)
818 return ok;
819 BRepAdaptor_Curve BCtmp(theSupportEdge);
820 gp_Pnt P3d2 = BCtmp.Value(paronSupportE);
821 Standard_Real Tolerance = (BRep_Tool::Tolerance(theEdge) > BRep_Tool::Tolerance(theSupportEdge)) ? BRep_Tool::Tolerance(theEdge) : BRep_Tool::Tolerance(theSupportEdge);
822 if(!theVertex.IsNull()) {
823 Tolerance = (BRep_Tool::Tolerance(theVertex) > Tolerance) ? BRep_Tool::Tolerance(theVertex) : Tolerance;
824 }
825 if(P3d1.Distance(P3d2) > Tolerance) {
826 ok = Standard_False;
827 }
828
829 return ok;
830}
Open CASCADE Technology repository