b311480e |
1 | // Created on: 1994-10-07 |
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 | |
17 | #ifdef DRAW |
18 | #include <TestTopOpeDraw_TTOT.hxx> |
19 | #include <TopOpeBRepTool_DRAW.hxx> |
20 | #endif |
21 | |
7fd59977 |
22 | |
42cf5bc1 |
23 | #include <Bnd_Box.hxx> |
7fd59977 |
24 | #include <BRep_Tool.hxx> |
25 | #include <BRepAdaptor_HSurface.hxx> |
26 | #include <BRepAdaptor_Surface.hxx> |
42cf5bc1 |
27 | #include <Geom2dAdaptor_Curve.hxx> |
7fd59977 |
28 | #include <Geom_Curve.hxx> |
29 | #include <Geom_Surface.hxx> |
7fd59977 |
30 | #include <GeomTools_Curve2dSet.hxx> |
42cf5bc1 |
31 | #include <GeomTools_CurveSet.hxx> |
7fd59977 |
32 | #include <GeomTools_SurfaceSet.hxx> |
42cf5bc1 |
33 | #include <gp_Circ2d.hxx> |
34 | #include <gp_Pnt.hxx> |
35 | #include <gp_Pnt2d.hxx> |
36 | #include <IntRes2d_IntersectionPoint.hxx> |
37 | #include <IntRes2d_IntersectionSegment.hxx> |
42cf5bc1 |
38 | #include <Precision.hxx> |
39 | #include <Standard_Failure.hxx> |
40 | #include <TCollection_AsciiString.hxx> |
41 | #include <TopExp.hxx> |
42 | #include <TopExp_Explorer.hxx> |
43 | #include <TopLoc_Location.hxx> |
44 | #include <TopoDS.hxx> |
45 | #include <TopoDS_Shape.hxx> |
46 | #include <TopoDS_Vertex.hxx> |
47 | #include <TopOpeBRep_define.hxx> |
48 | #include <TopOpeBRep_EdgesIntersector.hxx> |
49 | #include <TopOpeBRep_Point2d.hxx> |
50 | #include <TopOpeBRepDS_Transition.hxx> |
7fd59977 |
51 | #include <TopOpeBRepTool_2d.hxx> |
42cf5bc1 |
52 | #include <TopOpeBRepTool_CurveTool.hxx> |
7fd59977 |
53 | #include <TopOpeBRepTool_EXPORT.hxx> |
42cf5bc1 |
54 | #include <TopOpeBRepTool_ShapeTool.hxx> |
7fd59977 |
55 | #include <TopOpeBRepTool_tol.hxx> |
42cf5bc1 |
56 | #include <TopOpeBRepTool_TOOL.hxx> |
7fd59977 |
57 | |
0797d9d3 |
58 | #ifdef OCCT_DEBUG |
1d0a9d4d |
59 | extern Standard_Boolean TopOpeBRepTool_GettraceNYI(); |
60 | extern Standard_Boolean TopOpeBRepTool_GettraceKRO(); |
1d0a9d4d |
61 | extern Standard_Boolean TopOpeBRep_GettracePROEDG(); |
62 | extern Standard_Boolean TopOpeBRep_GetcontextTOL0(); |
63 | extern Standard_Boolean TopOpeBRep_GetcontextNOFEI(); |
64 | extern Standard_Boolean TopOpeBRep_GettraceFITOL(); |
65 | extern Standard_Boolean TopOpeBRep_GettraceEEFF(); |
66 | extern void debeeff(); |
7fd59977 |
67 | #include <TopOpeBRepTool_KRO.hxx> |
68 | Standard_EXPORT TOPKRO KRO_DSFILLER_INTEE("intersection edge/edge"); |
69 | #endif |
70 | |
71 | // la surface de reference peut etre celle de la 1ere ou la 2eme face |
72 | // de l'appel de SetFaces. Ces deux faces sont "SameDomain". |
73 | // Leurs normales geometriques sont SurfacesSameOriented() |
74 | // Leurs normales topologiques sont FacesSameOriented() |
75 | // cas type 1 : |
76 | // face1 FORWARD, normale geometrique Ng1 en +Z |
77 | // face2 REVERSED, normale geometrique Ng2 en -Z |
78 | // ==> SurfaceSameOriented = 0, FacesSameOriented = 1 |
79 | |
80 | //======================================================================= |
81 | //function : TopOpeBRep_EdgesIntersector |
82 | //purpose : |
83 | //======================================================================= |
84 | TopOpeBRep_EdgesIntersector::TopOpeBRep_EdgesIntersector() |
85 | { |
86 | mySurface1 = new BRepAdaptor_HSurface(); |
87 | mySurface2 = new BRepAdaptor_HSurface(); |
88 | mySurfacesSameOriented = Standard_False; |
89 | myFacesSameOriented = Standard_False; |
90 | myTol1 = 0.; // Precision::PConfusion(); |
91 | myTol2 = 0.; // Precision::PIntersection(); |
92 | myDimension = 2; |
93 | myTolForced = Standard_False; |
94 | myf1surf1F_sameoriented = Standard_True; |
95 | myf2surf1F_sameoriented = Standard_True; |
96 | |
97 | myNbSegments = 0; |
98 | myHasSegment = Standard_False; |
99 | SetSameDomain(Standard_False); |
100 | |
101 | myNbPoints = 0; |
102 | myTrueNbPoints = 0; |
103 | myPointIndex = 0; |
104 | myip2d = mynp2d = 0; |
105 | myselectkeep = Standard_True; |
106 | } |
107 | |
e6f550da |
108 | TopOpeBRep_EdgesIntersector::~TopOpeBRep_EdgesIntersector() |
7fd59977 |
109 | {} |
110 | |
111 | //======================================================================= |
112 | //function : SetFaces |
113 | //purpose : |
114 | //======================================================================= |
115 | void TopOpeBRep_EdgesIntersector::SetFaces(const TopoDS_Shape& F1,const TopoDS_Shape& F2) |
116 | { |
117 | Bnd_Box B1,B2; |
118 | SetFaces(F1,F2,B1,B2); |
119 | } |
120 | |
121 | //======================================================================= |
122 | //function : SetFaces |
123 | //purpose : |
124 | //======================================================================= |
125 | void TopOpeBRep_EdgesIntersector::SetFaces(const TopoDS_Shape& F1,const TopoDS_Shape& F2,const Bnd_Box& B1,const Bnd_Box& B2) |
126 | { |
7fd59977 |
127 | Standard_Boolean computerestriction = Standard_False; |
128 | |
129 | Standard_Boolean so11 = Standard_True; |
130 | Standard_Boolean so21 = Standard_True; |
131 | myf1surf1F_sameoriented = so11; |
132 | myf2surf1F_sameoriented = so21; |
133 | mySurfacesSameOriented = Standard_True; |
134 | myFacesSameOriented = Standard_True; |
135 | |
136 | myFace1 = TopoDS::Face(F1); |
137 | BRepAdaptor_Surface& S1 = mySurface1->ChangeSurface(); S1.Initialize(myFace1,computerestriction); |
138 | mySurfaceType1 = S1.GetType(); |
139 | |
140 | myFace2 = TopoDS::Face(F2); |
141 | BRepAdaptor_Surface& S2 = mySurface2->ChangeSurface(); S2.Initialize(myFace2,computerestriction); |
142 | mySurfaceType2 = S2.GetType(); |
143 | |
144 | TopoDS_Face face1forward = myFace1; |
145 | face1forward.Orientation(TopAbs_FORWARD); |
146 | |
147 | so11 = TopOpeBRepTool_ShapeTool::FacesSameOriented(face1forward,myFace1); |
148 | myf1surf1F_sameoriented = so11; |
149 | |
150 | so21 = TopOpeBRepTool_ShapeTool::FacesSameOriented(face1forward,myFace2); |
151 | myf2surf1F_sameoriented = so21; |
152 | |
153 | mySurfacesSameOriented = TopOpeBRepTool_ShapeTool::SurfacesSameOriented(S1,S2); |
154 | myFacesSameOriented = TopOpeBRepTool_ShapeTool::FacesSameOriented(myFace1,myFace2); |
155 | |
156 | if ( !myTolForced ) { |
157 | FTOL_FaceTolerances2d(B1,B2,myFace1,myFace2,S1,S2,myTol1,myTol2); |
158 | myTol1 = (myTol1 > 1.e-4)? 1.e-4: myTol1; |
159 | myTol2 = (myTol2 > 1.e-4)? 1.e-4: myTol2; |
160 | } |
161 | |
0797d9d3 |
162 | #ifdef OCCT_DEBUG |
7fd59977 |
163 | Standard_Integer DEBi = 0; |
164 | if ( DEBi ) { |
165 | cout<<"TopOpeBRep_EdgesIntersector::SetFaces : "; |
166 | cout<<"f1 "; TopAbs::Print(myFace1.Orientation(),cout); |
167 | cout<< " / f1F : "; |
168 | if (so11) cout<<"sameoriented"; else cout<<"difforiented"; cout<<endl; |
169 | cout <<" "; |
170 | cout<<"f2 "; TopAbs::Print(myFace2.Orientation(),cout); |
171 | cout<< " / f1F : "; |
172 | if (so21) cout<<"sameoriented"; else cout<<"difforiented"; cout<<endl; |
173 | } |
174 | #endif |
175 | } |
176 | |
177 | //======================================================================= |
178 | //function : ForceTolerances |
179 | //purpose : |
180 | //======================================================================= |
181 | void TopOpeBRep_EdgesIntersector::ForceTolerances(const Standard_Real Tol1,const Standard_Real Tol2) |
182 | { |
183 | myTol1 = Tol1; |
184 | myTol2 = Tol2; |
185 | myTolForced = Standard_True; |
186 | } |
187 | |
188 | #include <IntRes2d_Transition.hxx> |
189 | static Standard_Boolean TransitionEqualAndExtremity( const IntRes2d_Transition& T1 |
190 | ,const IntRes2d_Transition& T2) { |
191 | if( T1.PositionOnCurve() == IntRes2d_Head |
192 | || T1.PositionOnCurve() == IntRes2d_End) { |
193 | if(T1.PositionOnCurve() == T2.PositionOnCurve()) { |
194 | if(T1.TransitionType() == T2.TransitionType()) { |
195 | if(T1.TransitionType() == IntRes2d_Touch) { |
196 | if(T1.IsTangent()==T2.IsTangent()) { |
197 | if(T1.Situation() == T2.Situation()) { |
198 | if(T1.IsOpposite() == T2.IsOpposite()) { |
199 | return(Standard_True); |
200 | } |
201 | } |
202 | } |
203 | } |
204 | else { |
205 | return(Standard_True); |
206 | } |
207 | } |
208 | } |
209 | } |
210 | return(Standard_False); |
211 | } |
212 | |
213 | // Modified by Sergey KHROMOV - Fri Jan 11 14:49:48 2002 Begin |
214 | static Standard_Boolean IsTangentSegment(const IntRes2d_IntersectionPoint &P1, |
215 | const IntRes2d_IntersectionPoint &P2, |
216 | const Geom2dAdaptor_Curve &aC1, |
217 | const Geom2dAdaptor_Curve &aC2, |
218 | const Standard_Real aTolConf) { |
219 | const gp_Pnt2d &aP2d1 = P1.Value(); |
220 | const gp_Pnt2d &aP2d2 = P2.Value(); |
221 | const IntRes2d_Transition &aTrans1 = P1.TransitionOfFirst(); |
222 | const IntRes2d_Transition &aTrans2 = P2.TransitionOfFirst(); |
223 | |
224 | if (aTrans1.TransitionType() == IntRes2d_Touch || |
225 | aTrans2.TransitionType() == IntRes2d_Touch) { |
226 | Standard_Real aSqrDistPP = aP2d1.SquareDistance(aP2d2); |
227 | |
228 | if (aSqrDistPP <= aTolConf) { |
229 | Standard_Real aParDist1 = Abs(P1.ParamOnFirst() - P2.ParamOnFirst()); |
230 | Standard_Real aParDist2 = Abs(P1.ParamOnSecond() - P2.ParamOnSecond()); |
231 | Standard_Real aResol1 = aC1.Resolution(aTolConf); |
232 | Standard_Real aResol2 = aC2.Resolution(aTolConf); |
233 | |
234 | if (aParDist1*aParDist1 <= aResol1 && |
235 | aParDist2*aParDist2 <= aResol2) |
236 | return Standard_True; |
237 | } |
238 | } |
239 | |
240 | return Standard_False; |
241 | } |
242 | // Modified by Sergey KHROMOV - Fri Jan 11 14:49:49 2002 End |
243 | |
244 | |
245 | //------------------------------------------------------------------------ |
246 | Standard_Boolean EdgesIntersector_checkT1D(const TopoDS_Edge& E1,const TopoDS_Edge& E2,const TopoDS_Vertex& vG, |
247 | TopOpeBRepDS_Transition& newT) |
248 | //------------------------------------------------------------------------ |
249 | // E1 sdm E2, interfers with E2 at vertex vG |
250 | // vG is vertex of E2, but not vertex of E1 |
251 | // purpose : get newT / attached to E1, I1d=(newT(E2),G,E2) |
252 | { |
253 | #define FIRST (1) |
254 | #define LAST (2) |
255 | #define CLOSING (3) |
256 | |
257 | newT.Set(TopAbs_UNKNOWN,TopAbs_UNKNOWN); |
258 | Standard_Integer ovine = FUN_tool_orientVinE(vG,E2); |
259 | if (ovine == 0) { |
260 | return Standard_False; |
261 | } |
262 | else if (ovine == CLOSING) { |
263 | newT.Set(TopAbs_INTERNAL); |
264 | return Standard_True; |
265 | } |
266 | |
267 | Standard_Boolean first = (ovine == FIRST); |
268 | Standard_Boolean last = (ovine == LAST); |
269 | |
270 | TopOpeBRepDS_Config C = TopOpeBRepDS_SAMEORIENTED; |
271 | Standard_Boolean sso = TopOpeBRepTool_ShapeTool::ShapesSameOriented(E1,E2); |
272 | if (!sso) C = TopOpeBRepDS_DIFFORIENTED; |
273 | |
274 | Standard_Boolean SO = (C == TopOpeBRepDS_SAMEORIENTED); |
275 | Standard_Boolean DO = (C == TopOpeBRepDS_DIFFORIENTED); |
276 | TopAbs_Orientation o1 = E1.Orientation(); |
277 | if (o1 == TopAbs_REVERSED) {SO = !SO; DO = !DO;} // relative to E1 FORWARD |
278 | |
279 | Standard_Boolean reversed = (SO && first) || (DO && last); |
280 | Standard_Boolean forward = (SO && last) || (DO && first); |
281 | if (reversed) newT.Set(TopAbs_REVERSED); |
282 | if (forward) newT.Set(TopAbs_FORWARD); |
283 | return (reversed || forward); |
284 | } // EdgesIntersector_checkT1D |
285 | |
286 | |
287 | //modified by NIZNHY-PKV Fri Nov 5 12:27:07 1999 from |
288 | #include <BRepAdaptor_Surface.hxx> |
289 | //modified by NIZNHY-PKV Fri Nov 5 12:27:10 1999 to |
290 | //======================================================================= |
291 | //function : Perform |
292 | //purpose : |
293 | //======================================================================= |
294 | void TopOpeBRep_EdgesIntersector::Perform(const TopoDS_Shape& E1,const TopoDS_Shape& E2,const Standard_Boolean ReduceSegment) |
295 | { |
296 | mysp2d.Clear(); |
297 | myip2d = 1; mynp2d = 0; |
6e6cd5d9 |
298 | |
7fd59977 |
299 | myEdge1 = TopoDS::Edge(E1); |
300 | myEdge2 = TopoDS::Edge(E2); |
301 | |
302 | Standard_Real first,last,tole,tolpc; |
303 | gp_Pnt2d pfirst,plast; |
304 | Handle(Geom2d_Curve) PC1; |
305 | //modified by NIZNHY-PKV Thu Nov 4 16:08:05 1999 f |
306 | |
307 | BRepAdaptor_Surface aSurface1(myFace1), aSurface2(myFace2); |
308 | GeomAbs_SurfaceType aSurfaceType1=aSurface1.GetType(), |
309 | aSurfaceType2=aSurface2.GetType(); |
310 | |
311 | if (aSurfaceType1==GeomAbs_Sphere && aSurfaceType2==GeomAbs_Sphere) { |
312 | PC1 = FC2D_MakeCurveOnSurface (myEdge1,myFace1,first,last,tolpc, Standard_True); |
313 | } |
314 | else { |
315 | PC1 = FC2D_CurveOnSurface(myEdge1,myFace1,first,last,tolpc); |
316 | } |
317 | //modified by NIZNHY-PKV Thu Nov 4 15:44:13 1999 to |
318 | |
319 | if (PC1.IsNull()) |
320 | Standard_Failure::Raise("EdgesIntersector::Perform : no 2d curve"); |
321 | |
322 | myCurve1.Load(PC1); |
323 | BRep_Tool::UVPoints(myEdge1,myFace1,pfirst,plast); |
324 | tole = BRep_Tool::Tolerance(myEdge1); |
325 | myDomain1.SetValues(pfirst,first,tole,plast,last,tole); |
326 | |
0797d9d3 |
327 | #ifdef OCCT_DEBUG |
7fd59977 |
328 | Standard_Boolean trc = Standard_False; |
329 | if (trc) { |
330 | cout<<"ed1 on fa1 : {pfirst=("<<pfirst.X()<<" "<<pfirst.Y()<<"), first="<<first<<"\n"; |
331 | cout<<" plast =("<<plast.X()<<" "<<plast.Y()<<"),last="<<last<<"}"<<endl;} |
332 | #endif |
333 | |
334 | Standard_Boolean memesfaces = myFace1.IsSame(myFace2); |
335 | Standard_Boolean memesupport = Standard_False; |
336 | TopLoc_Location L1,L2; |
337 | const Handle(Geom_Surface) S1 = BRep_Tool::Surface(myFace1,L1); |
338 | const Handle(Geom_Surface) S2 = BRep_Tool::Surface(myFace2,L2); |
339 | if (S1 == S2 && L1 == L2) memesupport=Standard_True; |
340 | |
341 | if ( mySurfaceType1 == GeomAbs_Plane || memesfaces || memesupport) { |
342 | Handle(Geom2d_Curve) PC2 = FC2D_CurveOnSurface(myEdge2,myFace1,first,last,tolpc); |
343 | myCurve2.Load(PC2); |
344 | BRep_Tool::UVPoints(myEdge2,myFace1,pfirst,plast); |
345 | tole = BRep_Tool::Tolerance(myEdge2); |
346 | myDomain2.SetValues(pfirst,first,tole,plast,last,tole); |
347 | |
0797d9d3 |
348 | #ifdef OCCT_DEBUG |
7fd59977 |
349 | if (trc) { |
350 | cout<<"ed2 on fa1 : {pfirst=("<<pfirst.X()<<" "<<pfirst.Y()<<"), first="<<first<<"\n"; |
351 | cout<<" plast =("<<plast.X()<<" "<<plast.Y()<<"),last="<<last<<"}"<<endl;} |
352 | #endif |
353 | |
354 | } |
355 | |
356 | else { |
357 | |
358 | Handle(Geom2d_Curve) PC2on1; Handle(Geom_Curve) NC; |
359 | Standard_Boolean dgE2 = BRep_Tool::Degenerated(myEdge2); |
360 | if (dgE2) { //xpu210998 : cto900Q3 |
361 | TopExp_Explorer exv(myEdge2, TopAbs_VERTEX); |
362 | const TopoDS_Vertex& v2 = TopoDS::Vertex(exv.Current()); |
363 | gp_Pnt pt2 = BRep_Tool::Pnt(v2); |
364 | gp_Pnt2d uv2; Standard_Real d; Standard_Boolean ok = FUN_tool_projPonF(pt2,myFace1,uv2,d); |
365 | if (!ok) |
366 | return;//nyiRaise |
367 | |
51740958 |
368 | Handle(Geom_Surface) aSurf1 = BRep_Tool::Surface(myFace1); |
369 | Standard_Boolean apex = FUN_tool_onapex(uv2, aSurf1); |
7fd59977 |
370 | if (apex) { |
371 | TopoDS_Vertex vf,vl; TopExp::Vertices(myEdge1,vf,vl); |
372 | gp_Pnt ptf = BRep_Tool::Pnt(vf); Standard_Real df = pt2.Distance(ptf); |
302f96fb |
373 | |
7fd59977 |
374 | Standard_Real tolf = BRep_Tool::Tolerance(vf); |
302f96fb |
375 | |
7fd59977 |
376 | Standard_Boolean onf = (df < tolf); |
7fd59977 |
377 | TopoDS_Vertex v1 = onf ? vf : vl; |
378 | TopTools_IndexedDataMapOfShapeListOfShape mapVE; TopExp::MapShapesAndAncestors(myFace1,TopAbs_VERTEX,TopAbs_EDGE,mapVE); |
379 | const TopTools_ListOfShape& Edsanc = mapVE.FindFromKey(v1); |
380 | TopTools_ListIteratorOfListOfShape it(Edsanc); |
381 | for (; it.More(); it.Next()){ |
382 | const TopoDS_Edge& ee = TopoDS::Edge(it.Value()); |
383 | Standard_Boolean dgee = BRep_Tool::Degenerated(ee); |
384 | if (!dgee) continue; |
385 | // Standard_Real f,l; |
386 | PC2on1 = BRep_Tool::CurveOnSurface(ee,myFace1,first,last); |
387 | } |
388 | } |
389 | else {} // NYIxpu210998 |
390 | } //dgE2 |
391 | else { |
392 | // project curve of edge 2 on surface of face 1 |
393 | TopLoc_Location loc ; |
394 | Handle(Geom_Curve) C = BRep_Tool::Curve(myEdge2,loc,first,last); |
395 | NC = Handle(Geom_Curve)::DownCast(C->Transformed(loc.Transformation())); |
396 | Standard_Real tolreached2d; |
397 | |
398 | //modified by NIZNHY-PKV Fri Nov 5 12:29:13 1999 from |
399 | if (aSurfaceType1==GeomAbs_Sphere && aSurfaceType2==GeomAbs_Sphere) { |
400 | PC2on1 = FC2D_MakeCurveOnSurface (myEdge2, myFace1, first, last, tolpc, Standard_True); |
401 | } |
402 | else { |
403 | PC2on1 = TopOpeBRepTool_CurveTool::MakePCurveOnFace(myFace1,NC,tolreached2d); |
404 | } |
405 | //modified by NIZNHY-PKV Thu Nov 4 14:52:25 1999 t |
406 | |
407 | } |
408 | |
409 | if (!PC2on1.IsNull()) { |
410 | myCurve2.Load(PC2on1); |
411 | tole = BRep_Tool::Tolerance(myEdge2); |
412 | PC2on1->D0(first,pfirst); |
413 | PC2on1->D0(last,plast); |
414 | myDomain2.SetValues(pfirst,first,tole,plast,last,tole); |
0797d9d3 |
415 | #ifdef OCCT_DEBUG |
7fd59977 |
416 | if ( TopOpeBRep_GettracePROEDG() ) { |
417 | cout<<"------------ projection de curve"<<endl; |
418 | cout<<"--- Curve : "<<endl; |
419 | GeomTools_CurveSet::PrintCurve(NC,cout); |
420 | cout<<"--- nouvelle PCurve : "<<endl; |
421 | GeomTools_Curve2dSet::PrintCurve2d(PC2on1,cout); |
51740958 |
422 | Handle(Geom_Surface) aS1 = BRep_Tool::Surface(myFace1); |
7fd59977 |
423 | cout<<"--- sur surface : "<<endl; |
51740958 |
424 | GeomTools_SurfaceSet::PrintSurface(aS1,cout); |
7fd59977 |
425 | cout<<endl; |
426 | } |
427 | #endif |
428 | } |
429 | else return; |
430 | } |
431 | |
432 | // compute the intersection |
0797d9d3 |
433 | #ifdef OCCT_DEBUG |
7fd59977 |
434 | if (TopOpeBRepTool_GettraceKRO()) KRO_DSFILLER_INTEE.Start(); |
435 | #endif |
436 | |
437 | Standard_Real tol1 = myTol1, tol2 = myTol2; |
438 | // Wrong !!! |
439 | /* if ( !myTolForced ) { |
440 | if ( t1 != t2 ) { |
0797d9d3 |
441 | //#ifdef OCCT_DEBUG // JYL 28/09/98 : temporaire |
7fd59977 |
442 | //if ( TopOpeBRep_GetcontextTOL0() ) { // JYL 28/09/98 : temporaire |
443 | tol1 = 0.; // JYL 28/09/98 : temporaire |
444 | tol2 = 0.; // JYL 28/09/98 : temporaire |
445 | //} // JYL 28/09/98 : temporaire |
446 | //#endif // JYL 28/09/98 : temporaire |
447 | } |
448 | } |
449 | */ |
450 | |
0797d9d3 |
451 | #ifdef OCCT_DEBUG |
7fd59977 |
452 | if (TopOpeBRep_GettraceFITOL()) { |
453 | cout<<"EdgesIntersector : Perform"; |
454 | #ifdef DRAW |
455 | GeomAbs_CurveType t1 = myCurve1.GetType(); |
456 | GeomAbs_CurveType t2 = myCurve2.GetType(); |
457 | TCollection_AsciiString s1;TestTopOpeDraw_TTOT::CurveToString(t1,s1);cout<<" "<<s1; |
458 | TCollection_AsciiString s2;TestTopOpeDraw_TTOT::CurveToString(t2,s2);cout<<" "<<s2; |
459 | #endif |
460 | cout<<endl; |
461 | cout<<" tol1 = "<<tol1<<endl; |
462 | cout<<" tol2 = "<<tol2<<endl; |
463 | } |
464 | #endif |
465 | |
466 | myIntersector.Perform(myCurve1,myDomain1,myCurve2,myDomain2,tol1,tol2); |
467 | |
468 | Standard_Integer nbp = myIntersector.NbPoints(); |
469 | Standard_Integer nbs = myIntersector.NbSegments(); |
470 | |
471 | mylpnt.Clear(); mylseg.Clear(); |
472 | // for (Standard_Integer p=1; p<=nbp; p++) mylpnt.Append(myIntersector.Point(p)); |
473 | Standard_Integer p ; |
474 | for ( p=1; p<=nbp; p++) mylpnt.Append(myIntersector.Point(p)); |
475 | for (Standard_Integer s=1; s<=nbs; s++) mylseg.Append(myIntersector.Segment(s)); |
476 | |
477 | Standard_Boolean filter = Standard_True; |
0797d9d3 |
478 | #ifdef OCCT_DEBUG |
7fd59977 |
479 | Standard_Boolean nofilter = TopOpeBRep_GetcontextNOFEI(); if (nofilter) filter = Standard_False; |
480 | #endif |
481 | |
482 | //-- Filter : |
483 | if (filter) { |
484 | Standard_Boolean fin; |
485 | do { |
486 | fin=Standard_True; |
487 | for(p=1;p<nbp && fin ;p++) { |
488 | const IntRes2d_IntersectionPoint& P1=mylpnt.Value(p); |
489 | const IntRes2d_IntersectionPoint& P2=mylpnt.Value(p+1); |
490 | if( TransitionEqualAndExtremity(P1.TransitionOfFirst(),P2.TransitionOfFirst()) |
491 | || TransitionEqualAndExtremity(P1.TransitionOfSecond(),P2.TransitionOfSecond()) ) { |
0797d9d3 |
492 | #ifdef OCCT_DEBUG |
7fd59977 |
493 | Standard_Boolean TRC = Standard_True; |
494 | if (TRC) cout<<"\n Egalite de transitions \n"<<endl; |
495 | #endif |
496 | fin = Standard_False; |
497 | mylpnt.Remove(p); |
498 | nbp--; |
499 | } |
500 | // Modified by Sergey KHROMOV - Fri Jan 11 10:31:38 2002 Begin |
501 | else if (IsTangentSegment(P1, P2, myCurve1, myCurve2, Max(tol1, tol2))) { |
502 | const IntRes2d_Transition &aTrans = P2.TransitionOfFirst(); |
503 | |
504 | fin = Standard_False; |
505 | if (aTrans.TransitionType() == IntRes2d_Touch) |
506 | mylpnt.Remove(p); |
507 | else |
508 | mylpnt.Remove(p + 1); |
509 | nbp--; |
510 | } |
511 | // Modified by Sergey KHROMOV - Fri Jan 11 10:31:39 2002 End |
512 | } |
513 | } |
514 | while(fin==Standard_False); |
515 | } |
516 | //-- End filter |
517 | |
518 | myNbSegments = mylseg.Length(); |
519 | myHasSegment = (myNbSegments != 0); |
520 | ComputeSameDomain(); |
521 | |
522 | myNbPoints = mylpnt.Length(); |
523 | myTrueNbPoints = myNbPoints + 2 * myNbSegments; |
524 | myPointIndex = 0; |
525 | |
0797d9d3 |
526 | #ifdef OCCT_DEBUG |
7fd59977 |
527 | if (TopOpeBRep_GettraceEEFF()) debeeff(); |
528 | #endif |
529 | |
530 | MakePoints2d(); |
531 | if (ReduceSegment) ReduceSegments(); |
532 | |
533 | // xpu010998 : cto900J1, e5 sdm e13, IntPatch (Touch,Inside) -> |
534 | // faulty INTERNAL transition at G=v9 : |
535 | // xpu281098 : cto019D2, e3 sdm e9, faulty EXTERNAL transition |
536 | Standard_Boolean esd = SameDomain(); |
537 | for (InitPoint();MorePoint();NextPoint()) { |
538 | TopOpeBRep_Point2d& P2D = mysp2d(myip2d); |
539 | Standard_Boolean isvertex1 = P2D.IsVertex(1); |
540 | Standard_Boolean isvertex2 = P2D.IsVertex(2); |
541 | Standard_Boolean isvertex = isvertex1 || isvertex2; |
542 | |
543 | if (isvertex && esd) { |
544 | TopOpeBRepDS_Transition& T1 = P2D.ChangeTransition(1); |
545 | TopOpeBRepDS_Transition& T2 = P2D.ChangeTransition(2); |
546 | |
7fd59977 |
547 | Standard_Boolean isvertex12 = isvertex1 && isvertex2; |
548 | Standard_Boolean isvertex22 = isvertex2 && !isvertex12; |
549 | Standard_Boolean isvertex11 = isvertex1 && !isvertex12; |
550 | |
551 | Standard_Boolean T1INT = (T1.Orientation(TopAbs_IN) == TopAbs_INTERNAL); |
302f96fb |
552 | |
7fd59977 |
553 | if (T1INT && isvertex2 && !isvertex1) { |
554 | const TopoDS_Vertex& V2 = P2D.Vertex(2); |
555 | TopOpeBRepDS_Transition newT; Standard_Boolean computed = ::EdgesIntersector_checkT1D(myEdge1,myEdge2,V2,newT); |
96a95605 |
556 | if (computed) T1.Set(newT.Orientation(TopAbs_IN)); |
7fd59977 |
557 | } |
558 | |
559 | Standard_Boolean T2INT = (T2.Orientation(TopAbs_IN) == TopAbs_INTERNAL); |
560 | Standard_Boolean T2EXT = (T2.Orientation(TopAbs_IN) == TopAbs_EXTERNAL); |
561 | Standard_Boolean INTEXT2 = T2INT || T2EXT; |
562 | if (INTEXT2 && isvertex1 && !isvertex2) { |
563 | const TopoDS_Vertex& V1 = P2D.Vertex(1); |
564 | TopOpeBRepDS_Transition newT; Standard_Boolean computed = ::EdgesIntersector_checkT1D(myEdge2,myEdge1,V1,newT); |
96a95605 |
565 | if (computed) T2.Set(newT.Orientation(TopAbs_IN)); |
7fd59977 |
566 | } |
567 | |
568 | // xpu121098 : cto900I7 (e12on,vG14) |
569 | TopoDS_Vertex vcl2; Standard_Boolean clE2 = TopOpeBRepTool_TOOL::ClosedE(myEdge2,vcl2); |
570 | Standard_Boolean nT1 = ( !T1INT && clE2 && isvertex22 && vcl2.IsSame(P2D.Vertex(2)) ); |
571 | if (nT1) T1.Set(TopAbs_INTERNAL); |
572 | TopoDS_Vertex vcl1; Standard_Boolean clE1 = TopOpeBRepTool_TOOL::ClosedE(myEdge1,vcl1); |
573 | Standard_Boolean nT2 = ( !T2INT && clE1 && isvertex11 && vcl1.IsSame(P2D.Vertex(1)) ); |
574 | if (nT2) T2.Set(TopAbs_INTERNAL); |
575 | |
7fd59977 |
576 | } // (isvertex && esd) |
577 | } // MorePoint |
578 | |
579 | |
0797d9d3 |
580 | #ifdef OCCT_DEBUG |
7fd59977 |
581 | if (TopOpeBRepTool_GettraceKRO()) KRO_DSFILLER_INTEE.Stop(); |
582 | #endif |
583 | } // Perform |
584 | |
585 | //======================================================================= |
586 | //function : Dimension |
587 | //purpose : |
588 | //======================================================================= |
589 | void TopOpeBRep_EdgesIntersector::Dimension(const Standard_Integer Dim) |
590 | { |
591 | if (Dim == 1 || Dim == 2) { |
592 | myDimension = Dim; |
593 | } |
594 | } |
595 | |
596 | //======================================================================= |
597 | //function : Dimension |
598 | //purpose : |
599 | //======================================================================= |
600 | Standard_Integer TopOpeBRep_EdgesIntersector::Dimension() const |
601 | { |
602 | return myDimension; |
603 | } |
604 | |
605 | //======================================================================= |
606 | //function : ComputeSameDomain |
607 | //purpose : |
608 | //======================================================================= |
609 | Standard_Boolean TopOpeBRep_EdgesIntersector::ComputeSameDomain() |
610 | { |
611 | const Geom2dAdaptor_Curve& C1 = Curve(1); |
612 | const Geom2dAdaptor_Curve& C2 = Curve(2); |
613 | GeomAbs_CurveType t1 = C1.GetType(); |
614 | GeomAbs_CurveType t2 = C2.GetType(); |
615 | |
616 | if (!myHasSegment) |
617 | return SetSameDomain(Standard_False); |
618 | |
619 | Standard_Boolean tt = (t1 == t2); |
620 | if (!tt) |
621 | return SetSameDomain(Standard_False); |
622 | |
623 | if (t1 == GeomAbs_Line) |
624 | return SetSameDomain(Standard_True); |
625 | |
626 | if (t1 != GeomAbs_Circle) { |
0797d9d3 |
627 | #ifdef OCCT_DEBUG |
7fd59977 |
628 | if (TopOpeBRepTool_GettraceNYI()) |
629 | cout<<"TopOpeBRep_EdgesIntersector : EdgesSameDomain on NYI curve type"<<endl; |
630 | #endif |
631 | return SetSameDomain(Standard_False); |
632 | } |
633 | |
634 | gp_Circ2d c1 = C1.Circle(); |
635 | gp_Circ2d c2 = C2.Circle(); |
636 | Standard_Real r1 = c1.Radius(); |
637 | Standard_Real r2 = c2.Radius(); |
638 | // Standard_Boolean rr = (r1 == r2); |
639 | Standard_Boolean rr = (Abs(r1-r2) < Precision::Confusion()); //xpu281098 (cto019D2) tolerance a revoir |
640 | if (!rr) return SetSameDomain(Standard_False); |
641 | |
7fd59977 |
642 | const gp_Pnt2d& p1 = c1.Location(); |
643 | const gp_Pnt2d& p2 = c2.Location(); |
644 | |
645 | const BRepAdaptor_Surface& BAS1 = Surface(1); |
646 | Standard_Real u1,v1; p1.Coord(u1,v1); gp_Pnt P1 = BAS1.Value(u1,v1); |
647 | Standard_Real u2,v2; p2.Coord(u2,v2); gp_Pnt P2 = BAS1.Value(u2,v2);// recall myCurve2=C2d(myEdge2,myFace1); |
648 | Standard_Real dpp = P1.Distance(P2); |
649 | Standard_Real tol1 = BRep_Tool::Tolerance(TopoDS::Edge(Edge(1))); |
650 | Standard_Real tol2 = BRep_Tool::Tolerance(TopoDS::Edge(Edge(2))); |
651 | Standard_Real tol = tol1 + tol2; |
652 | Standard_Boolean esd = (dpp <= tol); |
653 | if (esd) return SetSameDomain(Standard_True); |
654 | |
655 | return SetSameDomain(Standard_False); |
656 | } // ComputeSameDomain |
657 | |
658 | //======================================================================= |
659 | //function : SetSameDomain |
660 | //purpose : |
661 | //======================================================================= |
662 | Standard_Boolean TopOpeBRep_EdgesIntersector::SetSameDomain(const Standard_Boolean B) |
663 | { |
664 | mySameDomain = B; |
665 | return B; |
666 | } |
667 | |
668 | //======================================================================= |
669 | //function : MakePoints2d |
670 | //purpose : |
671 | //======================================================================= |
672 | void TopOpeBRep_EdgesIntersector::MakePoints2d() |
673 | { |
674 | mysp2d.Clear(); |
675 | TopAbs_Orientation E1ori = myEdge1.Orientation(); |
676 | TopAbs_Orientation E2ori = myEdge2.Orientation(); |
677 | for (InitPoint1();MorePoint1();NextPoint1()) { |
678 | const IntRes2d_IntersectionPoint& IP = Point1(); |
679 | TopOpeBRep_Point2d p2d; |
680 | p2d.SetPint(IP); |
681 | p2d.SetTransition(1,Transition1(1,E2ori)); |
682 | p2d.SetTransition(2,Transition1(2,E1ori)); |
683 | p2d.SetParameter(1,Parameter1(1)); |
684 | p2d.SetParameter(2,Parameter1(2)); |
685 | Standard_Boolean isv1 = IsVertex1(1); p2d.SetIsVertex(1,isv1); |
686 | if (isv1) p2d.SetVertex(1,TopoDS::Vertex(Vertex1(1))); |
687 | Standard_Boolean isv2 = IsVertex1(2); p2d.SetIsVertex(2,isv2); |
688 | if (isv2) p2d.SetVertex(2,TopoDS::Vertex(Vertex1(2))); |
689 | p2d.SetIsPointOfSegment(IsPointOfSegment1()); |
690 | p2d.SetSegmentAncestors(0,0); |
691 | p2d.SetStatus(Status1()); |
692 | p2d.SetValue(Value1()); |
693 | p2d.SetValue2d(IP.Value()); |
694 | p2d.SetTolerance(ToleranceMax()); |
695 | p2d.SetEdgesConfig(EdgesConfig1()); |
696 | p2d.SetIndex(Index1()); |
697 | mysp2d.Append(p2d); |
698 | } |
699 | myip2d = 1; mynp2d = mysp2d.Length(); |
700 | } |
701 | |
702 | //======================================================================= |
703 | //function : ReduceSegment |
704 | //purpose : |
705 | //======================================================================= |
706 | Standard_Boolean TopOpeBRep_EdgesIntersector::ReduceSegment(TopOpeBRep_Point2d& psa, |
707 | TopOpeBRep_Point2d& psb, |
708 | TopOpeBRep_Point2d& Pn) const |
709 | { |
710 | Standard_Boolean reduced = Standard_False; |
711 | Standard_Integer ixpsa = psa.Index(); |
712 | Standard_Integer ixpsb = psb.Index(); |
713 | |
714 | Standard_Boolean pospsa = psa.IsPointOfSegment(); |
715 | TopOpeBRep_P2Dstatus stspsa = psa.Status(); |
7fd59977 |
716 | Standard_Real tpsa1 = psa.Parameter(1); |
717 | Standard_Real tpsa2 = psa.Parameter(2); |
718 | const TopOpeBRepDS_Transition& Tpsa1 = psa.Transition(1); |
719 | const TopOpeBRepDS_Transition& Tpsa2 = psa.Transition(2); |
720 | |
721 | Standard_Boolean pospsb = psb.IsPointOfSegment(); |
722 | TopOpeBRep_P2Dstatus stspsb = psb.Status(); |
7fd59977 |
723 | Standard_Real tpsb1 = psb.Parameter(1); |
724 | Standard_Real tpsb2 = psb.Parameter(2); |
725 | const TopOpeBRepDS_Transition& Tpsb1 = psb.Transition(1); |
726 | const TopOpeBRepDS_Transition& Tpsb2 = psb.Transition(2); |
727 | |
728 | Standard_Boolean conda = (pospsa && (stspsa == TopOpeBRep_P2DSGF)); |
729 | Standard_Boolean condb = (pospsb && (stspsb == TopOpeBRep_P2DSGL)); |
730 | Standard_Boolean cond = (conda && condb); |
731 | |
732 | if (cond) { |
733 | reduced = Standard_True; |
734 | |
735 | Standard_Real tm1 = (tpsa1 + tpsb1)/2.; Pn.SetParameter(1,tm1); |
736 | Standard_Real tm2 = (tpsa2 + tpsb2)/2.; Pn.SetParameter(2,tm2); |
737 | |
738 | TopOpeBRepDS_Transition Tn1; |
739 | Tn1.Before(Tpsa1.Before(),Tpsa1.ShapeBefore()); |
740 | Tn1.After (Tpsb1.After(),Tpsb1.ShapeAfter()); |
741 | Pn.SetTransition(1,Tn1); |
742 | TopOpeBRepDS_Transition Tn2; |
743 | Tn2.Before(Tpsa2.Before(),Tpsa2.ShapeBefore()); |
744 | Tn2.After (Tpsb2.After(),Tpsb2.ShapeAfter()); |
745 | Pn.SetTransition(2,Tn2); |
746 | |
747 | const gp_Pnt& P3Dpsa = psa.Value(); |
748 | const gp_Pnt& P3Dpsb = psb.Value(); |
749 | gp_Pnt P3Dn((P3Dpsa.X()+P3Dpsb.X())/2, |
750 | (P3Dpsa.Y()+P3Dpsb.Y())/2, |
751 | (P3Dpsa.Z()+P3Dpsb.Z())/2); |
752 | Pn.SetValue(P3Dn); |
753 | const gp_Pnt2d& P2Dpsa = psa.Value2d(); |
754 | const gp_Pnt2d& P2Dpsb = psb.Value2d(); |
755 | gp_Pnt2d P2Dn((P2Dpsa.X()+P2Dpsb.X())/2, |
756 | (P2Dpsa.Y()+P2Dpsb.Y())/2); |
757 | Pn.SetValue2d(P2Dn); |
758 | |
759 | Standard_Real tolpsa = psa.Tolerance(); |
760 | Standard_Real tolpsb = psb.Tolerance(); |
761 | Standard_Real toln = (tolpsa + tolpsb)*1.5; |
762 | Pn.SetTolerance(toln); |
763 | |
764 | Pn.SetIsPointOfSegment(Standard_False); |
765 | Pn.SetSegmentAncestors(ixpsa,ixpsb); |
766 | psa.SetKeep(Standard_False); |
767 | psb.SetKeep(Standard_False); |
768 | |
769 | TopOpeBRepDS_Config cpsa = psa.EdgesConfig(); |
6e6cd5d9 |
770 | |
7fd59977 |
771 | Pn.SetEdgesConfig(cpsa); |
772 | |
773 | Standard_Boolean isvpsa1 = psa.IsVertex(1);if (isvpsa1) Pn.SetVertex(1,psa.Vertex(1)); |
774 | Standard_Boolean isvpsa2 = psa.IsVertex(2);if (isvpsa2) Pn.SetVertex(2,psa.Vertex(2)); |
775 | Standard_Boolean isvpsb1 = psb.IsVertex(1);if (isvpsb1) Pn.SetVertex(1,psb.Vertex(1)); |
776 | Standard_Boolean isvpsb2 = psb.IsVertex(2);if (isvpsb2) Pn.SetVertex(2,psb.Vertex(2)); |
777 | } |
778 | |
779 | return reduced; |
780 | } // ReduceSegment |
781 | |
782 | //======================================================================= |
783 | //function : ReduceSegments |
784 | //purpose : |
785 | //======================================================================= |
786 | void TopOpeBRep_EdgesIntersector::ReduceSegments() |
787 | { |
788 | Standard_Boolean condredu = (myHasSegment && !mySameDomain); |
789 | if (!condredu) return; |
790 | |
7fd59977 |
791 | Standard_Integer ip = 1;Standard_Integer np = mynp2d; |
792 | while (ip < np) { |
793 | TopOpeBRep_Point2d& psa = mysp2d(ip); |
794 | TopOpeBRep_Point2d& psb = mysp2d(ip+1); |
795 | TopOpeBRep_Point2d pn; |
796 | Standard_Boolean reduced = ReduceSegment(psa,psb,pn); |
797 | if (reduced) { |
798 | pn.SetIndex(++mynp2d); |
799 | mysp2d.Append(pn); |
800 | } |
801 | ip++; |
802 | } |
803 | |
804 | mylseg.Clear(); |
805 | myNbSegments = mylseg.Length(); |
806 | myHasSegment = (myNbSegments != 0); |
807 | myTrueNbPoints = myNbPoints + 2 * myNbSegments; |
808 | |
809 | } // ReduceSegments |
810 | |
811 | |
812 | //======================================================================= |
813 | //function : IsEmpty |
814 | //purpose : |
815 | //======================================================================= |
816 | Standard_Boolean TopOpeBRep_EdgesIntersector::IsEmpty () |
817 | { |
818 | return (mynp2d == 0); |
819 | } |
820 | |
821 | //======================================================================= |
822 | //function : HasSegment |
823 | //purpose : |
824 | //======================================================================= |
825 | Standard_Boolean TopOpeBRep_EdgesIntersector::HasSegment () const |
826 | { |
827 | return myHasSegment; |
828 | } |
829 | |
830 | //======================================================================= |
831 | //function : SameDomain |
832 | //purpose : |
833 | //======================================================================= |
834 | Standard_Boolean TopOpeBRep_EdgesIntersector::SameDomain() const |
835 | { |
836 | return mySameDomain; |
837 | } |
838 | |
839 | //======================================================================= |
840 | //function : Edge |
841 | //purpose : |
842 | //======================================================================= |
843 | const TopoDS_Shape& TopOpeBRep_EdgesIntersector::Edge(const Standard_Integer Index) const |
844 | { |
845 | if ( Index == 1 ) return myEdge1; |
846 | else if ( Index == 2 ) return myEdge2; |
847 | else Standard_Failure::Raise("TopOpeBRep_EdgesIntersector::Edge"); |
848 | |
849 | return myEdge1; |
850 | } |
851 | |
852 | //======================================================================= |
853 | //function : Curve |
854 | //purpose : |
855 | //======================================================================= |
856 | const Geom2dAdaptor_Curve& TopOpeBRep_EdgesIntersector::Curve(const Standard_Integer Index) const |
857 | { |
858 | if ( Index == 1 ) return myCurve1; |
859 | else if ( Index == 2 ) return myCurve2; |
860 | else Standard_Failure::Raise("TopOpeBRep_EdgesIntersector::Curve"); |
861 | |
862 | return myCurve1; |
863 | } |
864 | |
865 | //======================================================================= |
866 | //function : Face |
867 | //purpose : |
868 | //======================================================================= |
869 | const TopoDS_Shape& TopOpeBRep_EdgesIntersector::Face(const Standard_Integer Index) const |
870 | { |
871 | if ( Index == 1 ) return myFace1; |
872 | else if ( Index == 2 ) return myFace2; |
873 | else Standard_Failure::Raise("TopOpeBRep_EdgesIntersector::Face"); |
874 | |
875 | return myFace1; |
876 | } |
877 | |
878 | //======================================================================= |
879 | //function : Surface |
880 | //purpose : |
881 | //======================================================================= |
882 | const BRepAdaptor_Surface& TopOpeBRep_EdgesIntersector::Surface(const Standard_Integer Index) const |
883 | { |
884 | if ( Index == 1 ) return mySurface1->ChangeSurface(); |
885 | else if ( Index == 2 ) return mySurface2->ChangeSurface(); |
886 | else Standard_Failure::Raise("TopOpeBRep_EdgesIntersector::Surface"); |
887 | |
888 | return mySurface1->ChangeSurface(); |
889 | } |
890 | |
891 | //======================================================================= |
892 | //function : SurfacesSameOriented |
893 | //purpose : |
894 | //======================================================================= |
895 | Standard_Boolean TopOpeBRep_EdgesIntersector::SurfacesSameOriented () const |
896 | { |
897 | return mySurfacesSameOriented; |
898 | } |
899 | |
900 | //======================================================================= |
901 | //function : FacesSameOriented |
902 | //purpose : |
903 | //======================================================================= |
904 | Standard_Boolean TopOpeBRep_EdgesIntersector::FacesSameOriented () const |
905 | { |
906 | return myFacesSameOriented; |
907 | } |
908 | |
909 | //======================================================================= |
910 | //function : InitPoint |
911 | //purpose : |
912 | //======================================================================= |
913 | void TopOpeBRep_EdgesIntersector::InitPoint(const Standard_Boolean selectkeep) |
914 | { |
915 | myselectkeep = selectkeep; |
916 | myip2d = 1; mynp2d = mysp2d.Length(); |
917 | Find(); |
918 | } |
919 | |
920 | //======================================================================= |
921 | //function : MorePoint |
922 | //purpose : |
923 | //======================================================================= |
924 | Standard_Boolean TopOpeBRep_EdgesIntersector::MorePoint() const |
925 | { |
926 | Standard_Boolean b = (myip2d <= mynp2d); |
927 | return b; |
928 | } |
929 | |
930 | //======================================================================= |
931 | //function : NextPoint |
932 | //purpose : |
933 | //======================================================================= |
934 | void TopOpeBRep_EdgesIntersector::NextPoint() |
935 | { |
936 | myip2d++; |
937 | Find(); |
938 | } |
939 | |
940 | //======================================================================= |
941 | //function : Find |
942 | //purpose : |
943 | //======================================================================= |
944 | void TopOpeBRep_EdgesIntersector::Find() |
945 | { |
946 | while (myip2d <= mynp2d) { |
947 | if (myselectkeep) { |
948 | Standard_Boolean kf = mysp2d(myip2d).Keep(); |
949 | if (kf) break; |
950 | else myip2d++; |
951 | } |
952 | else { |
953 | break; |
954 | } |
955 | } |
956 | } |
957 | |
958 | //======================================================================= |
959 | //function : Points |
960 | //purpose : |
961 | //======================================================================= |
962 | const TopOpeBRep_SequenceOfPoint2d& TopOpeBRep_EdgesIntersector::Points() const |
963 | { |
964 | return mysp2d; |
965 | } |
966 | |
967 | //======================================================================= |
968 | //function : Point |
969 | //purpose : |
970 | //======================================================================= |
971 | const TopOpeBRep_Point2d& TopOpeBRep_EdgesIntersector::Point() const |
972 | { |
973 | return mysp2d(myip2d); |
974 | } |
975 | |
976 | //======================================================================= |
977 | //function : Point |
978 | //purpose : |
979 | //======================================================================= |
980 | const TopOpeBRep_Point2d& TopOpeBRep_EdgesIntersector::Point(const Standard_Integer I) const |
981 | { |
982 | if (I<1 || I>mysp2d.Length()) Standard_Failure::Raise("TopOpeBRep_EdgesIntersector::Point(I)"); |
983 | return mysp2d(I); |
984 | } |
985 | |
986 | //======================================================================= |
987 | //function : ToleranceMax |
988 | //purpose : |
989 | //======================================================================= |
990 | Standard_Real TopOpeBRep_EdgesIntersector::ToleranceMax() const |
991 | { |
992 | Standard_Real tol = Max(myTol1,myTol2); |
993 | return tol; |
994 | } |
995 | |
996 | //======================================================================= |
997 | //function : Tolerances |
998 | //purpose : |
999 | //======================================================================= |
1000 | void TopOpeBRep_EdgesIntersector::Tolerances(Standard_Real& tol1, Standard_Real& tol2) const |
1001 | { |
1002 | tol1 = myTol1; |
1003 | tol2 = myTol2; |
1004 | } |
1005 | |
1006 | //======================================================================= |
1007 | //function : NbPoints |
1008 | //purpose : (debug) |
1009 | //======================================================================= |
1010 | Standard_Integer TopOpeBRep_EdgesIntersector::NbPoints() const |
1011 | { |
1012 | return myNbPoints; |
1013 | } |
1014 | |
1015 | //======================================================================= |
1016 | //function : NbSegments |
1017 | //purpose : (debug) |
1018 | //======================================================================= |
1019 | Standard_Integer TopOpeBRep_EdgesIntersector::NbSegments() const |
1020 | { |
1021 | return myNbSegments; |
1022 | } |
1023 | |
1024 | //======================================================================= |
1025 | //function : Dump |
1026 | //purpose : |
1027 | //======================================================================= |
0797d9d3 |
1028 | #ifndef OCCT_DEBUG |
7fd59977 |
1029 | void TopOpeBRep_EdgesIntersector::Dump(const TCollection_AsciiString& ,const Standard_Integer ,const Standard_Integer ) |
1030 | { |
1031 | #else |
1032 | void TopOpeBRep_EdgesIntersector::Dump(const TCollection_AsciiString& str,const Standard_Integer E1index,const Standard_Integer E2index) |
1033 | { |
1034 | InitPoint();if (!MorePoint()) return; |
1035 | cout<<endl<<"---- "<<str<<" ---- E/E : "<<NbPoints()<<" p , "; |
1036 | cout<<NbSegments()<<" s : "<<myTrueNbPoints<<" true points"<<endl; |
1037 | cout<<"E1 = "<<E1index<<" ";TopAbs::Print(Edge(1).Orientation(),cout)<<", "; |
1038 | cout<<"E2 = "<<E2index<<" ";TopAbs::Print(Edge(2).Orientation(),cout)<<" "; |
1039 | cout<<"hs="<<HasSegment()<<" hsd="<<SameDomain()<<endl; |
1040 | |
1041 | for (InitPoint(); MorePoint(); NextPoint()) { |
1042 | const TopOpeBRep_Point2d P2d = Point(); |
1043 | P2d.Dump(E1index,E2index); |
1044 | if (P2d.Status() == TopOpeBRep_P2DNEW) { |
1045 | Standard_Integer ip1,ip2; P2d.SegmentAncestors(ip1,ip2); |
1046 | Standard_Real d1 = Point(ip1).Value().Distance(Point(ip2).Value()); |
1047 | Standard_Real d2 = d1 + Point(ip1).Tolerance()/2. + Point(ip2).Tolerance()/2.; |
1048 | cout<<"ancestor segment : d P"<<ip1<<",P"<<ip2<<" = "<<d1<<endl; |
1049 | cout<<" t1/2 + d + t2/2 P"<<ip1<<",P"<<ip2<<" = "<<d2<<endl; |
1050 | } |
1051 | } |
1052 | cout<<endl; |
1053 | #endif |
1054 | } |
1055 | |
1056 | |