b311480e |
1 | // Created on: 1992-10-13 |
2 | // Created by: Laurent BUCHARD |
3 | // Copyright (c) 1992-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 | // |
973c2be1 |
8 | // This library is free software; you can redistribute it and / or modify it |
9 | // under the terms of the GNU Lesser General Public version 2.1 as published |
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 | // Modified by skv - Tue Mar 1 14:22:09 2005 OCC8169 |
18 | |
19 | |
20 | #ifndef DEB |
21 | #define No_Standard_RangeError |
22 | #define No_Standard_OutOfRange |
23 | #endif |
24 | |
25 | |
26 | #include <Standard_ConstructionError.hxx> |
27 | |
28 | #include <IntRes2d_Domain.hxx> |
29 | #include <IntRes2d_Position.hxx> |
30 | #include <IntRes2d_Transition.hxx> |
31 | #include <IntRes2d_IntersectionPoint.hxx> |
32 | #include <IntRes2d_IntersectionSegment.hxx> |
33 | |
34 | |
35 | #include <IntImpParGen.hxx> |
36 | |
37 | #include <Intf_SectionPoint.hxx> |
38 | #include <Intf_SectionLine.hxx> |
39 | #include <Intf_TangentZone.hxx> |
9530af27 |
40 | #include <Intf_InterferencePolygon2d.hxx> |
7fd59977 |
41 | |
42 | #include <gp_Vec2d.hxx> |
43 | |
44 | #include <math_Vector.hxx> |
45 | #include <math_FunctionSetRoot.hxx> |
46 | #include <math_NewtonFunctionSetRoot.hxx> |
305cc3f8 |
47 | #include <NCollection_Handle.hxx> |
7fd59977 |
48 | |
49 | //====================================================================== |
50 | |
51 | // Modified by skv - Tue Mar 1 14:22:09 2005 OCC8169 Begin |
52 | // #define NBITER_MAX_POLYGON 3 |
53 | #define NBITER_MAX_POLYGON 10 |
54 | // Modified by skv - Tue Mar 1 14:22:09 2005 OCC8169 End |
55 | #define TOL_CONF_MINI 0.0000000001 |
56 | #define TOL_MINI 0.0000000001 |
57 | |
58 | //---------------------------------------------------------------------- |
59 | |
7fd59977 |
60 | |
61 | |
62 | |
63 | |
64 | Standard_Boolean HeadOrEndPoint( const IntRes2d_Domain& D1 |
65 | ,const TheCurve& C1 |
66 | ,const Standard_Real u |
67 | ,const IntRes2d_Domain& D2 |
68 | ,const TheCurve& C2 |
69 | ,const Standard_Real v |
70 | ,const Standard_Real TolConf |
71 | ,IntRes2d_IntersectionPoint& IntPt |
72 | ,Standard_Boolean& HeadOn1 |
73 | ,Standard_Boolean& HeadOn2 |
74 | ,Standard_Boolean& EndOn1 |
75 | ,Standard_Boolean& EndOn2 |
76 | ,Standard_Integer PosSegment); |
77 | |
78 | |
79 | //====================================================================== |
80 | IntCurve_IntPolyPolyGen::IntCurve_IntPolyPolyGen(void) { |
81 | done = Standard_False; |
82 | } |
83 | //====================================================================== |
84 | void IntCurve_IntPolyPolyGen::Perform( const TheCurve& C1 |
85 | ,const IntRes2d_Domain& D1 |
86 | ,const TheCurve& C2 |
87 | ,const IntRes2d_Domain& D2 |
88 | ,const Standard_Real TheTolConf |
89 | ,const Standard_Real TheTol) |
90 | { |
7fd59977 |
91 | this->ResetFields(); |
92 | DomainOnCurve1=D1; |
93 | DomainOnCurve2=D2; |
94 | Standard_Real DU = D1.LastParameter()-D1.FirstParameter(); |
95 | Standard_Real DV = D2.LastParameter()-D2.FirstParameter(); |
96 | Standard_Real Tl=(TheTol < TOL_MINI)? TOL_MINI : TheTol; |
97 | Standard_Real TlConf=(TheTolConf < TOL_CONF_MINI)? TOL_CONF_MINI : TheTolConf; |
98 | Perform(C1,D1,C2,D2,TlConf,Tl,0,DU,DV); |
99 | //---------------------------------------------------------------------- |
100 | //-- Traitement des points en bouts |
101 | //---------------------------------------------------------------------- |
102 | Standard_Boolean HeadOn1 = Standard_False; |
103 | Standard_Boolean HeadOn2 = Standard_False; |
104 | Standard_Boolean EndOn1 = Standard_False; |
105 | Standard_Boolean EndOn2 = Standard_False; |
106 | Standard_Integer i; |
107 | Standard_Integer n=this->NbPoints(); |
108 | |
109 | |
110 | //-------------------------------------------------------------------- |
111 | //-- On ne rejette les points Head Head ... End End |
112 | //-- si ils figurent deja dans un bout de segment |
113 | //-- ( On ne peut pas tester les egalites sur les parametres) |
114 | //-- ( ces points n etant pas trouves a EpsX pres ) |
115 | //-- PosSegment = 1 si Head Head |
116 | //-- 2 si Head End |
117 | //-- 4 si End Head |
118 | //-- 8 si End End |
119 | //-------------------------------------------------------------------- |
120 | Standard_Integer PosSegment = 0; |
121 | |
7fd59977 |
122 | for(i=1;i<=n;i++) { |
123 | IntRes2d_Position Pos1 = this->Point(i).TransitionOfFirst().PositionOnCurve(); |
124 | if(Pos1 == IntRes2d_Head) HeadOn1 = Standard_True; |
125 | else if(Pos1 == IntRes2d_End) EndOn1 = Standard_True; |
126 | |
127 | IntRes2d_Position Pos2 = this->Point(i).TransitionOfSecond().PositionOnCurve(); |
128 | if(Pos2 == IntRes2d_Head) HeadOn2 = Standard_True; |
129 | else if(Pos2 == IntRes2d_End) EndOn2 = Standard_True; |
130 | |
131 | if(Pos1 == IntRes2d_Head) { |
132 | if(Pos2 == IntRes2d_Head) PosSegment|=1; |
133 | else if(Pos2 == IntRes2d_End) PosSegment|=2; |
134 | } |
135 | else if(Pos1 == IntRes2d_End) { |
136 | if(Pos2 == IntRes2d_Head) PosSegment|=4; |
137 | else if(Pos2 == IntRes2d_End) PosSegment|=8; |
138 | } |
139 | } |
140 | |
141 | n=this->NbSegments(); |
142 | for(i=1;i<=n;i++) { |
143 | IntRes2d_Position Pos1 = this->Segment(i).FirstPoint().TransitionOfFirst().PositionOnCurve(); |
144 | if(Pos1 == IntRes2d_Head) HeadOn1 = Standard_True; |
145 | else if(Pos1 == IntRes2d_End) EndOn1 = Standard_True; |
146 | |
147 | IntRes2d_Position Pos2 = this->Segment(i).FirstPoint().TransitionOfSecond().PositionOnCurve(); |
148 | if(Pos2 == IntRes2d_Head) HeadOn2 = Standard_True; |
149 | else if(Pos2 == IntRes2d_End) EndOn2 = Standard_True; |
150 | |
151 | if(Pos1 == IntRes2d_Head) { |
152 | if(Pos2 == IntRes2d_Head) PosSegment|=1; |
153 | else if(Pos2 == IntRes2d_End) PosSegment|=2; |
154 | } |
155 | else if(Pos1 == IntRes2d_End) { |
156 | if(Pos2 == IntRes2d_Head) PosSegment|=4; |
157 | else if(Pos2 == IntRes2d_End) PosSegment|=8; |
158 | } |
159 | |
160 | Pos1 = this->Segment(i).LastPoint().TransitionOfFirst().PositionOnCurve(); |
161 | if(Pos1 == IntRes2d_Head) HeadOn1 = Standard_True; |
162 | else if(Pos1 == IntRes2d_End) EndOn1 = Standard_True; |
163 | |
164 | Pos2 = this->Segment(i).LastPoint().TransitionOfSecond().PositionOnCurve(); |
165 | if(Pos2 == IntRes2d_Head) HeadOn2 = Standard_True; |
166 | else if(Pos2 == IntRes2d_End) EndOn2 = Standard_True; |
167 | |
168 | if(Pos1 == IntRes2d_Head) { |
169 | if(Pos2 == IntRes2d_Head) PosSegment|=1; |
170 | else if(Pos2 == IntRes2d_End) PosSegment|=2; |
171 | } |
172 | else if(Pos1 == IntRes2d_End) { |
173 | if(Pos2 == IntRes2d_Head) PosSegment|=4; |
174 | else if(Pos2 == IntRes2d_End) PosSegment|=8; |
175 | } |
176 | } |
177 | |
7fd59977 |
178 | Standard_Real U0 = D1.FirstParameter(); |
179 | Standard_Real U1 = D1.LastParameter(); |
180 | Standard_Real V0 = D2.FirstParameter(); |
181 | Standard_Real V1 = D2.LastParameter(); |
7fd59977 |
182 | IntRes2d_IntersectionPoint IntPt; |
183 | |
184 | if(D1.FirstTolerance() || D2.FirstTolerance()) { |
185 | if(HeadOrEndPoint(D1,C1,U0,D2,C2,V0,TheTolConf,IntPt,HeadOn1,HeadOn2,EndOn1,EndOn2,PosSegment)) |
186 | this->Insert(IntPt); |
187 | } |
188 | if(D1.FirstTolerance() || D2.LastTolerance()) { |
189 | if(HeadOrEndPoint(D1,C1,U0,D2,C2,V1,TheTolConf,IntPt,HeadOn1,HeadOn2,EndOn1,EndOn2,PosSegment)) |
190 | this->Insert(IntPt); |
191 | } |
192 | if(D1.LastTolerance() || D2.FirstTolerance()) { |
193 | if(HeadOrEndPoint(D1,C1,U1,D2,C2,V0,TheTolConf,IntPt,HeadOn1,HeadOn2,EndOn1,EndOn2,PosSegment)) |
194 | this->Insert(IntPt); |
195 | } |
196 | if(D1.LastTolerance() || D2.LastTolerance()) { |
197 | if(HeadOrEndPoint(D1,C1,U1,D2,C2,V1,TheTolConf,IntPt,HeadOn1,HeadOn2,EndOn1,EndOn2,PosSegment)) |
198 | this->Insert(IntPt); |
199 | } |
7fd59977 |
200 | } |
201 | |
202 | |
7fd59977 |
203 | //====================================================================== |
204 | //== A u t o I n t e r s e c t i o n |
205 | //====================================================================== |
206 | void IntCurve_IntPolyPolyGen::Perform( const TheCurve& C1 |
207 | ,const IntRes2d_Domain& D1 |
208 | ,const Standard_Real TheTolConf |
209 | ,const Standard_Real TheTol) |
210 | { |
211 | |
7fd59977 |
212 | this->ResetFields(); |
213 | DomainOnCurve1=D1; |
214 | DomainOnCurve2=D1; |
215 | Standard_Real DU = D1.LastParameter()-D1.FirstParameter(); |
216 | Standard_Real Tl=(TheTol < TOL_MINI)? TOL_MINI : TheTol; |
217 | Standard_Real TlConf=(TheTolConf < TOL_CONF_MINI)? TOL_CONF_MINI : TheTolConf; |
218 | Perform(C1,D1,TlConf,Tl,0,DU,DU); |
7fd59977 |
219 | Standard_Integer i; |
220 | Standard_Integer n=this->NbPoints(); |
221 | |
7fd59977 |
222 | //-------------------------------------------------------------------- |
223 | //-- On ne rejette les points Head Head ... End End |
224 | //-- si ils figurent deja dans un bout de segment |
225 | //-- ( On ne peut pas tester les egalites sur les parametres) |
226 | //-- ( ces points n etant pas trouves a EpsX pres ) |
227 | //-- PosSegment = 1 si Head Head |
228 | //-- 2 si Head End |
229 | //-- 4 si End Head |
230 | //-- 8 si End End |
231 | //-------------------------------------------------------------------- |
232 | Standard_Integer PosSegment = 0; |
233 | |
7fd59977 |
234 | for(i=1;i<=n;i++) { |
235 | IntRes2d_Position Pos1 = this->Point(i).TransitionOfFirst().PositionOnCurve(); |
7fd59977 |
236 | IntRes2d_Position Pos2 = this->Point(i).TransitionOfSecond().PositionOnCurve(); |
7fd59977 |
237 | |
238 | if(Pos1 == IntRes2d_Head) { |
239 | if(Pos2 == IntRes2d_Head) PosSegment|=1; |
240 | else if(Pos2 == IntRes2d_End) PosSegment|=2; |
241 | } |
242 | else if(Pos1 == IntRes2d_End) { |
243 | if(Pos2 == IntRes2d_Head) PosSegment|=4; |
244 | else if(Pos2 == IntRes2d_End) PosSegment|=8; |
245 | } |
246 | } |
247 | |
248 | n=this->NbSegments(); |
249 | for(i=1;i<=n;i++) { |
250 | IntRes2d_Position Pos1 = this->Segment(i).FirstPoint().TransitionOfFirst().PositionOnCurve(); |
7fd59977 |
251 | IntRes2d_Position Pos2 = this->Segment(i).FirstPoint().TransitionOfSecond().PositionOnCurve(); |
7fd59977 |
252 | |
253 | if(Pos1 == IntRes2d_Head) { |
254 | if(Pos2 == IntRes2d_Head) PosSegment|=1; |
255 | else if(Pos2 == IntRes2d_End) PosSegment|=2; |
256 | } |
257 | else if(Pos1 == IntRes2d_End) { |
258 | if(Pos2 == IntRes2d_Head) PosSegment|=4; |
259 | else if(Pos2 == IntRes2d_End) PosSegment|=8; |
260 | } |
261 | |
262 | Pos1 = this->Segment(i).LastPoint().TransitionOfFirst().PositionOnCurve(); |
7fd59977 |
263 | Pos2 = this->Segment(i).LastPoint().TransitionOfSecond().PositionOnCurve(); |
7fd59977 |
264 | |
265 | if(Pos1 == IntRes2d_Head) { |
266 | if(Pos2 == IntRes2d_Head) PosSegment|=1; |
267 | else if(Pos2 == IntRes2d_End) PosSegment|=2; |
268 | } |
269 | else if(Pos1 == IntRes2d_End) { |
270 | if(Pos2 == IntRes2d_Head) PosSegment|=4; |
271 | else if(Pos2 == IntRes2d_End) PosSegment|=8; |
272 | } |
273 | } |
274 | } |
275 | //====================================================================== |
276 | |
7fd59977 |
277 | void IntCurve_IntPolyPolyGen::Perform( const TheCurve& C1 |
278 | ,const IntRes2d_Domain& D1 |
279 | ,const Standard_Real TolConf |
280 | ,const Standard_Real Tol |
281 | ,const Standard_Integer NbIter |
35e08fe8 |
282 | ,const Standard_Real /*DeltaU*/ |
7fd59977 |
283 | ,const Standard_Real) { |
284 | |
285 | gp_Vec2d Tan1,Tan2,Norm1,Norm2; |
286 | gp_Pnt2d P1,P2; |
287 | Standard_Integer nbsamples; |
288 | done = Standard_False; |
7fd59977 |
289 | |
290 | nbsamples = TheCurveTool::NbSamples(C1,D1.FirstParameter(),D1.LastParameter()); |
291 | |
292 | if(NbIter>3 || (NbIter>2 && nbsamples>100)) return; |
293 | |
294 | nbsamples*=2; //--- On prend systematiquement 2 fois plus de points que |
295 | //-- sur une courbe normale. |
296 | //-- Les courbes auto-intersectantes donne souvent des |
297 | //-- polygones assez loin de la courbe a parametre ct. |
298 | |
5d351552 |
299 | if(NbIter>0) { |
1665a85a |
300 | nbsamples=(3*(nbsamples*NbIter))/2; |
7fd59977 |
301 | } |
302 | IntCurve_ThePolygon2d Poly1(C1,nbsamples,D1,Tol); |
303 | if(!Poly1.AutoIntersectionIsPossible()) { |
304 | done = Standard_True; |
305 | return; |
306 | } |
307 | //-- Poly1.Dump(); |
308 | //---------------------------------------------------------------------- |
309 | //-- Si la deflection est inferieure a la Tolerance de Confusion |
310 | //-- Alors la deflection du polygone est fixee a TolConf |
311 | //-- (Detection des Zones de Tangence) |
312 | //---------------------------------------------------------------------- |
313 | if(Poly1.DeflectionOverEstimation() < TolConf) { |
314 | Poly1.SetDeflectionOverEstimation(TolConf); |
315 | } |
316 | |
9530af27 |
317 | Intf_InterferencePolygon2d InterPP(Poly1); |
7fd59977 |
318 | IntCurve_ExactIntersectionPoint EIP(C1,C1,TolConf); |
319 | Standard_Real U,V; |
320 | |
321 | //---------------------------------------------------------------------- |
322 | //-- Traitement des SectionPoint |
323 | //---------------------------------------------------------------------- |
324 | Standard_Integer Nbsp = InterPP.NbSectionPoints(); |
325 | if(Nbsp>=1) { |
326 | |
327 | //-- --------------------------------------------------------------------- |
328 | //-- tri tri tri tri tri tri tri tri tri tri tri tri tri tri |
329 | //-- |
330 | Standard_Integer* TriIndex = new Standard_Integer [Nbsp+1]; |
331 | Standard_Integer* PtrSegIndex1 = new Standard_Integer [Nbsp+1]; |
332 | Standard_Integer* PtrSegIndex2 = new Standard_Integer [Nbsp+1]; |
333 | Standard_Boolean Triok; |
334 | Standard_Integer SegIndex1,SegIndex2,SegIndex_1,SegIndex_2; |
335 | // Standard_Real ParamOn1,ParamOn2,ParamOn_1,ParamOn_2; |
336 | Standard_Real ParamOn1,ParamOn2; |
337 | Intf_PIType Type; |
338 | Standard_Integer i ; |
339 | for( i=1;i<=Nbsp;i++) { |
340 | TriIndex[i]=i; |
341 | const Intf_SectionPoint& SPnt1 = InterPP.PntValue(i); |
342 | SPnt1.InfoFirst(Type,PtrSegIndex1[i],ParamOn1); |
343 | SPnt1.InfoSecond(Type,PtrSegIndex2[i],ParamOn2); |
344 | } |
345 | |
346 | |
347 | do { |
348 | Triok=Standard_True; |
349 | |
350 | for(Standard_Integer tr=1;tr<Nbsp;tr++) { |
1665a85a |
351 | SegIndex1=PtrSegIndex1[TriIndex[tr]]; |
352 | SegIndex_1=PtrSegIndex1[TriIndex[tr+1]]; |
353 | |
354 | SegIndex2=PtrSegIndex2[TriIndex[tr]]; |
355 | SegIndex_2=PtrSegIndex2[TriIndex[tr+1]]; |
356 | |
357 | if(SegIndex1 > SegIndex_1) { |
358 | Standard_Integer q=TriIndex[tr]; |
359 | TriIndex[tr]=TriIndex[tr+1]; |
360 | TriIndex[tr+1]=q; |
361 | Triok=Standard_False; |
362 | } |
363 | else if(SegIndex1 == SegIndex_1) { |
364 | if(SegIndex2 > SegIndex_2) { |
365 | Standard_Integer q=TriIndex[tr]; |
366 | TriIndex[tr]=TriIndex[tr+1]; |
367 | TriIndex[tr+1]=q; |
368 | Triok=Standard_False; |
369 | } |
370 | } |
7fd59977 |
371 | } |
372 | } |
373 | while(Triok==Standard_False); |
374 | |
375 | //-- supression des doublons Si Si ! |
376 | for(i=1; i<Nbsp;i++) { |
377 | if( (PtrSegIndex1[TriIndex[i]] == PtrSegIndex1[TriIndex[i+1]]) |
1665a85a |
378 | && (PtrSegIndex2[TriIndex[i]] == PtrSegIndex2[TriIndex[i+1]])) { |
379 | TriIndex[i]=-i; |
7fd59977 |
380 | } |
381 | } |
382 | |
383 | Standard_Integer Nelarg=(Poly1.NbSegments()/20); |
384 | if(Nelarg<2) Nelarg=2; |
385 | |
386 | for(Standard_Integer sp=1; sp <= Nbsp; sp++) { |
387 | if(TriIndex[sp]>0) { |
1665a85a |
388 | const Intf_SectionPoint& SPnt = InterPP.PntValue(TriIndex[sp]); |
389 | |
390 | SPnt.InfoFirst(Type,SegIndex1,ParamOn1); |
391 | SPnt.InfoSecond(Type,SegIndex2,ParamOn2); |
392 | |
393 | if(Abs(SegIndex1-SegIndex2)>1) { |
7fd59977 |
394 | |
1665a85a |
395 | EIP.Perform(Poly1,Poly1,SegIndex1,SegIndex2,ParamOn1,ParamOn2); |
396 | if(EIP.NbRoots()==0) { |
397 | //-- On supprime tous les segments voisins |
398 | for(Standard_Integer k=sp+1;k<=Nbsp;k++) { |
399 | Standard_Integer kk=TriIndex[k]; |
400 | // --- avoid negative indicies as well as in outer done |
401 | if( kk > 0 ) { |
402 | if( Abs(SegIndex1-PtrSegIndex1[kk])< Nelarg |
403 | && Abs(SegIndex2-PtrSegIndex2[kk])< Nelarg) { |
404 | TriIndex[k]=-k; |
405 | } |
406 | } |
407 | } |
408 | } |
409 | else if(EIP.NbRoots()>=1) { |
410 | //-------------------------------------------------------------------- |
411 | //-- On verifie que le point trouve est bien une racine |
412 | //-------------------------------------------------------------------- |
413 | EIP.Roots(U,V); |
414 | |
415 | TheCurveTool::D1(C1,U,P1,Tan1); |
416 | TheCurveTool::D1(C1,V,P2,Tan2); |
417 | Standard_Real Dist = P1.Distance(P2); |
418 | Standard_Real EpsX1 = 10.0*TheCurveTool::EpsX(C1); |
419 | |
420 | if(Abs(U-V)<=EpsX1) { |
421 | //----------------------------------------- |
422 | //-- Solution non valide |
423 | //-- Les maths ont du converger vers une |
424 | //-- solution triviale ( point U = V ) |
425 | //----------------------------------------- |
426 | Dist = TolConf+1.0; |
427 | } |
428 | |
429 | //----------------------------------------------------------------- |
430 | //-- On verifie que le point (u,v) n existe pas deja |
431 | //-- |
432 | done = Standard_True; |
433 | Standard_Integer nbp=NbPoints(); |
434 | |
435 | for(Standard_Integer p=1; p<=nbp; p++) { |
436 | const IntRes2d_IntersectionPoint& P=Point(p); |
437 | if(Abs(U-P.ParamOnFirst()) <= EpsX1) { |
438 | if(Abs(V-P.ParamOnSecond()) <= EpsX1) { |
439 | Dist = TolConf+1.0; p+=nbp; |
440 | } |
441 | } |
442 | } |
443 | |
444 | if(Dist <= TolConf) { //-- Ou le point est deja present |
445 | IntRes2d_Position Pos1 = IntRes2d_Middle; |
446 | IntRes2d_Position Pos2 = IntRes2d_Middle; |
447 | IntRes2d_Transition Trans1,Trans2; |
448 | //----------------------------------------------------------------- |
449 | //-- Calcul des Positions des Points sur la courbe |
450 | //-- |
451 | if(P1.Distance(DomainOnCurve1.FirstPoint())<=DomainOnCurve1.FirstTolerance()) |
452 | Pos1 = IntRes2d_Head; |
453 | else if(P1.Distance(DomainOnCurve1.LastPoint())<=DomainOnCurve1.LastTolerance()) |
454 | Pos1 = IntRes2d_End; |
455 | |
456 | if(P2.Distance(DomainOnCurve2.FirstPoint())<=DomainOnCurve2.FirstTolerance()) |
457 | Pos2 = IntRes2d_Head; |
458 | else if(P2.Distance(DomainOnCurve2.LastPoint())<=DomainOnCurve2.LastTolerance()) |
459 | Pos2 = IntRes2d_End; |
460 | //----------------------------------------------------------------- |
461 | if(IntImpParGen::DetermineTransition( Pos1,Tan1,Trans1 |
462 | ,Pos2,Tan2,Trans2 |
463 | ,TolConf) == Standard_False) |
464 | { |
465 | TheCurveTool::D2(C1,U,P1,Tan1,Norm1); |
466 | TheCurveTool::D2(C1,V,P2,Tan2,Norm2); |
467 | IntImpParGen::DetermineTransition( Pos1,Tan1,Norm1,Trans1 |
468 | ,Pos2,Tan2,Norm2,Trans2 |
469 | ,TolConf); |
470 | } |
471 | IntRes2d_IntersectionPoint IP(P1,U,V,Trans1,Trans2,Standard_False); |
472 | Insert(IP); |
473 | } |
474 | } |
7fd59977 |
475 | } |
7fd59977 |
476 | } |
477 | } |
478 | delete [] TriIndex; |
479 | delete [] PtrSegIndex1; |
480 | delete [] PtrSegIndex2; |
481 | } |
1c418d0e |
482 | done = Standard_True; |
7fd59977 |
483 | } |
484 | |
485 | |
486 | Standard_Boolean HeadOrEndPoint( const IntRes2d_Domain& D1 |
487 | ,const TheCurve& C1 |
488 | ,const Standard_Real tu |
489 | ,const IntRes2d_Domain& D2 |
490 | ,const TheCurve& C2 |
491 | ,const Standard_Real tv |
492 | ,const Standard_Real TolConf |
493 | ,IntRes2d_IntersectionPoint& IntPt |
494 | ,Standard_Boolean& HeadOn1 |
495 | ,Standard_Boolean& HeadOn2 |
496 | ,Standard_Boolean& EndOn1 |
497 | ,Standard_Boolean& EndOn2 |
498 | ,Standard_Integer PosSegment) { |
499 | |
500 | gp_Pnt2d P1,P2,SP1,SP2; |
501 | gp_Vec2d T1,T2,N1,N2; |
502 | Standard_Real u=tu; |
503 | Standard_Real v=tv; |
504 | Standard_Real svu = u; |
505 | Standard_Real svv = v; |
506 | |
507 | TheCurveTool::D1(C1,u,P1,T1); |
508 | TheCurveTool::D1(C2,v,P2,T2); |
509 | |
510 | IntRes2d_Position Pos1 = IntRes2d_Middle; |
511 | IntRes2d_Position Pos2 = IntRes2d_Middle; |
512 | IntRes2d_Transition Trans1,Trans2; |
513 | |
514 | //---------------------------------------------------------------------- |
515 | //-- Head On 1 : Head1 <-> P2 |
516 | if(P2.Distance(D1.FirstPoint())<=D1.FirstTolerance()) { |
517 | Pos1 = IntRes2d_Head; |
518 | HeadOn1 = Standard_True; |
519 | SP1 = D1.FirstPoint(); |
520 | u = D1.FirstParameter(); |
521 | } |
522 | //---------------------------------------------------------------------- |
523 | //-- End On 1 : End1 <-> P2 |
524 | else if(P2.Distance(D1.LastPoint())<=D1.LastTolerance()) { |
525 | Pos1 = IntRes2d_End; |
526 | EndOn1 = Standard_True; |
527 | SP1 = D1.LastPoint(); |
528 | u = D1.LastParameter(); |
529 | } |
530 | |
7fd59977 |
531 | //---------------------------------------------------------------------- |
532 | //-- Head On 2 : Head2 <-> P1 |
533 | else if(P1.Distance(D2.FirstPoint())<=D2.FirstTolerance()) { |
534 | Pos2 = IntRes2d_Head; |
535 | HeadOn2 = Standard_True; |
536 | SP2 = D2.FirstPoint(); |
537 | v = D2.FirstParameter(); |
538 | } |
539 | //---------------------------------------------------------------------- |
540 | //-- End On 2 : End2 <-> P1 |
541 | else if(P1.Distance(D2.LastPoint())<=D2.LastTolerance()) { |
542 | Pos2 = IntRes2d_End; |
543 | EndOn2 = Standard_True; |
544 | SP2 = D2.LastPoint(); |
545 | v = D2.LastParameter(); |
546 | } |
547 | |
548 | Standard_Real EpsX1 = TheCurveTool::EpsX(C1); |
549 | Standard_Real EpsX2 = TheCurveTool::EpsX(C2); |
550 | |
7fd59977 |
551 | if((Pos1 != IntRes2d_Middle)||(Pos2 != IntRes2d_Middle)) { |
552 | if(Pos1 == IntRes2d_Middle) { |
553 | if(Abs(u-D1.FirstParameter()) <= EpsX1) { |
1665a85a |
554 | Pos1 = IntRes2d_Head; |
555 | P1 = D1.FirstPoint(); |
556 | HeadOn1 = Standard_True; |
7fd59977 |
557 | } |
558 | else if(Abs(u-D1.LastParameter()) <= EpsX1) { |
1665a85a |
559 | Pos1 = IntRes2d_End; |
560 | P1 = D1.LastPoint(); |
561 | EndOn1 = Standard_True; |
7fd59977 |
562 | } |
563 | } |
564 | else if(u!=tu) { |
565 | P1 = SP1; |
566 | } |
567 | |
568 | |
569 | if(Pos2 == IntRes2d_Middle) { |
570 | if(Abs(v-D2.FirstParameter()) <= EpsX2) { |
1665a85a |
571 | Pos2 = IntRes2d_Head; |
572 | HeadOn2 = Standard_True; |
573 | P2 = D2.FirstPoint(); |
574 | if(Pos1 != IntRes2d_Middle) { |
575 | P1.SetCoord(0.5*(P1.X()+P2.X()),0.5*(P1.Y()+P2.Y())); |
576 | } |
577 | else { |
578 | P2 = P1; |
579 | } |
7fd59977 |
580 | } |
581 | else if(Abs(v-D2.LastParameter()) <= EpsX2) { |
1665a85a |
582 | Pos2 = IntRes2d_End; |
583 | EndOn2 = Standard_True; |
584 | P2 = D2.LastPoint(); |
585 | if(Pos1 != IntRes2d_Middle) { |
586 | P1.SetCoord(0.5*(P1.X()+P2.X()),0.5*(P1.Y()+P2.Y())); |
587 | } |
588 | else { |
589 | P2 = P1; |
590 | } |
7fd59977 |
591 | } |
592 | } |
593 | |
7fd59977 |
594 | //-------------------------------------------------------------------- |
595 | //-- On Teste si un point de bout de segment a deja ces trnasitions |
596 | //-- Si Oui, on ne cree pas de nouveau point |
597 | //-- |
598 | //-- PosSegment = 1 si Head Head |
599 | //-- 2 si Head End |
600 | //-- 4 si End Head |
601 | //-- 8 si End End |
602 | //-------------------------------------------------------------------- |
603 | if(Pos1 == IntRes2d_Head) { |
604 | if((Pos2 == IntRes2d_Head)&&(PosSegment & 1)) return(Standard_False); |
605 | if((Pos2 == IntRes2d_End )&&(PosSegment & 2)) return(Standard_False); |
606 | } |
607 | else if(Pos1 == IntRes2d_End) { |
608 | if((Pos2 == IntRes2d_Head)&&(PosSegment & 4)) return(Standard_False); |
609 | if((Pos2 == IntRes2d_End )&&(PosSegment & 8)) return(Standard_False); |
610 | } |
611 | |
612 | |
613 | if(IntImpParGen::DetermineTransition( Pos1,T1,Trans1,Pos2,T2,Trans2,TolConf) |
614 | == Standard_False) { |
615 | TheCurveTool::D2(C1,svu,P1,T1,N1); |
616 | TheCurveTool::D2(C2,svv,P2,T2,N2); |
617 | IntImpParGen::DetermineTransition(Pos1,T1,N1,Trans1, |
618 | Pos2,T2,N2,Trans2,TolConf); |
619 | } |
620 | IntPt.SetValues(P1,u,v,Trans1,Trans2,Standard_False); |
621 | return(Standard_True); |
622 | } |
623 | else |
624 | return(Standard_False); |
625 | } |
626 | |
627 | |
7fd59977 |
628 | //====================================================================== |
629 | void IntCurve_IntPolyPolyGen::Perform( const TheCurve& C1 |
630 | ,const IntRes2d_Domain& D1 |
631 | ,const TheCurve& C2 |
632 | ,const IntRes2d_Domain& D2 |
633 | ,const Standard_Real TolConf |
634 | ,const Standard_Real Tol |
635 | ,const Standard_Integer NbIter |
636 | ,const Standard_Real DeltaU |
637 | ,const Standard_Real DeltaV) { |
638 | |
7fd59977 |
639 | Standard_Integer nbsamplesOnC1,nbsamplesOnC2; |
640 | done = Standard_False; |
641 | |
642 | if(NbIter>NBITER_MAX_POLYGON) return; |
643 | |
644 | nbsamplesOnC1 = TheCurveTool::NbSamples(C1,D1.FirstParameter(),D1.LastParameter()); |
645 | |
7fd59977 |
646 | if (NbIter == 0) // first time |
1665a85a |
647 | { |
648 | if (nbsamplesOnC1 < 20) |
649 | nbsamplesOnC1 = 20; |
650 | } |
7fd59977 |
651 | else // NbIter > 0 |
1665a85a |
652 | { |
653 | nbsamplesOnC1=(5*(nbsamplesOnC1*NbIter))/4; |
654 | } |
7fd59977 |
655 | ///////////////////////////////////////////// |
656 | |
657 | nbsamplesOnC2 = TheCurveTool::NbSamples(C2,D2.FirstParameter(),D2.LastParameter()); |
658 | |
7fd59977 |
659 | if (NbIter == 0) // first time |
1665a85a |
660 | { |
661 | if (nbsamplesOnC2 < 20) |
662 | nbsamplesOnC2 = 20; |
663 | } |
7fd59977 |
664 | else // NbIter > 0 |
1665a85a |
665 | { |
666 | nbsamplesOnC2=(5*(nbsamplesOnC2*NbIter))/4; |
667 | } |
7fd59977 |
668 | ///////////////////////////////////////////// |
669 | |
305cc3f8 |
670 | |
671 | NCollection_Handle<IntCurve_ThePolygon2d> aPoly1 ,aPoly2; |
7fd59977 |
672 | if(nbsamplesOnC2 > nbsamplesOnC1) { |
305cc3f8 |
673 | aPoly1 = new IntCurve_ThePolygon2d(C1,nbsamplesOnC1,D1,Tol); |
674 | if(aPoly1->DeflectionOverEstimation() < TolConf) { |
675 | aPoly2 = new IntCurve_ThePolygon2d(C2,nbsamplesOnC2,D2,Tol); |
7fd59977 |
676 | } |
677 | else { |
305cc3f8 |
678 | aPoly2 = new IntCurve_ThePolygon2d(C2,nbsamplesOnC2,D2,Tol,aPoly1->Bounding()); |
679 | aPoly1->SetDeflectionOverEstimation( aPoly2->DeflectionOverEstimation() |
680 | + aPoly1->DeflectionOverEstimation()); |
681 | aPoly1->ComputeWithBox(C1,aPoly2->Bounding()); |
7fd59977 |
682 | } |
683 | } |
684 | else { |
305cc3f8 |
685 | aPoly2 = new IntCurve_ThePolygon2d(C2,nbsamplesOnC2,D2,Tol); |
686 | if(aPoly2->DeflectionOverEstimation() < TolConf) { |
687 | aPoly1 = new IntCurve_ThePolygon2d(C1,nbsamplesOnC1,D1,Tol); |
7fd59977 |
688 | } |
689 | else { |
305cc3f8 |
690 | aPoly1 = new IntCurve_ThePolygon2d(C1,nbsamplesOnC1,D1,Tol,aPoly2->Bounding()); |
691 | aPoly2->SetDeflectionOverEstimation( aPoly2->DeflectionOverEstimation() |
692 | + aPoly1->DeflectionOverEstimation()); |
693 | aPoly2->ComputeWithBox(C2,aPoly1->Bounding()); |
7fd59977 |
694 | } |
695 | } |
696 | //---------------------------------------------------------------------- |
697 | //-- Si la deflection est inferieure a la Tolerance de Confusion |
698 | //-- Alors la deflection du polygone est fixee a TolConf |
699 | //-- (Detection des Zones de Tangence) |
700 | //---------------------------------------------------------------------- |
701 | |
305cc3f8 |
702 | if(aPoly1->DeflectionOverEstimation() < TolConf) { |
703 | aPoly1->SetDeflectionOverEstimation(TolConf); |
7fd59977 |
704 | } |
305cc3f8 |
705 | if(aPoly2->DeflectionOverEstimation() < TolConf) { |
706 | aPoly2->SetDeflectionOverEstimation(TolConf); |
707 | } |
708 | //for case when a few polygon points were replaced by line |
709 | //if exact solution was not found |
710 | //then search of precise solution will be repeat |
711 | //for polygon conatins all initial points |
712 | //secondary search will be performed only for case when initial points |
713 | //were dropped |
714 | Standard_Boolean isFullRepresentation = ( aPoly1->NbSegments() == nbsamplesOnC1 && |
715 | aPoly2->NbSegments() == nbsamplesOnC2 ); |
716 | |
717 | if( !findIntersect( C1, D1, C2, D2, TolConf, Tol, NbIter, |
718 | DeltaU, DeltaV, *aPoly1, *aPoly2, isFullRepresentation ) && !isFullRepresentation ) |
719 | { |
1665a85a |
720 | if(aPoly1->NbSegments() < nbsamplesOnC1) |
721 | { |
722 | aPoly1 = new IntCurve_ThePolygon2d(C1,nbsamplesOnC1,D1,Tol); |
723 | } |
724 | if(aPoly2->NbSegments() < nbsamplesOnC2) |
725 | { |
726 | aPoly2 = new IntCurve_ThePolygon2d(C2,nbsamplesOnC2,D2,Tol); |
727 | } |
728 | |
729 | findIntersect( C1, D1, C2, D2, TolConf, Tol, NbIter, |
730 | DeltaU, DeltaV, *aPoly1, *aPoly2, |
731 | Standard_True); |
732 | |
7fd59977 |
733 | } |
305cc3f8 |
734 | |
735 | done = Standard_True; |
736 | } |
737 | |
738 | //====================================================================== |
1665a85a |
739 | // Purpose : findIntersect |
305cc3f8 |
740 | //====================================================================== |
741 | |
742 | Standard_Boolean IntCurve_IntPolyPolyGen::findIntersect( |
743 | const TheCurve& C1, |
1665a85a |
744 | const IntRes2d_Domain& D1, |
745 | const TheCurve& C2, |
746 | const IntRes2d_Domain& D2, |
747 | const Standard_Real TolConf, |
748 | const Standard_Real Tol, |
749 | const Standard_Integer NbIter, |
750 | const Standard_Real DeltaU, |
751 | const Standard_Real DeltaV, |
752 | const IntCurve_ThePolygon2d& thePoly1, |
753 | const IntCurve_ThePolygon2d& thePoly2, |
754 | Standard_Boolean isFullPolygon ) |
305cc3f8 |
755 | { |
756 | |
757 | gp_Vec2d Tan1,Tan2,Norm1,Norm2; |
758 | gp_Pnt2d P1,P2; |
759 | Intf_InterferencePolygon2d InterPP(thePoly1,thePoly2); |
7fd59977 |
760 | IntCurve_ExactIntersectionPoint EIP(C1,C2,TolConf); |
1665a85a |
761 | Standard_Real U = 0., V = 0.; |
762 | Standard_Boolean AnErrorOccurred = Standard_False; |
763 | done = Standard_True; // To prevent exception in nbp=NbPoints(); |
7fd59977 |
764 | //---------------------------------------------------------------------- |
765 | //-- Traitement des SectionPoint |
766 | //---------------------------------------------------------------------- |
767 | Standard_Integer Nbsp = InterPP.NbSectionPoints(); |
305cc3f8 |
768 | for(Standard_Integer sp=1; sp <= Nbsp; sp++) { |
1665a85a |
769 | const Intf_SectionPoint& SPnt = InterPP.PntValue(sp); |
305cc3f8 |
770 | Standard_Integer SegIndex1,SegIndex2; |
771 | Standard_Real ParamOn1,ParamOn2; |
772 | Intf_PIType Type; |
773 | |
774 | SPnt.InfoFirst(Type,SegIndex1,ParamOn1); |
775 | SPnt.InfoSecond(Type,SegIndex2,ParamOn2); |
776 | EIP.Perform(thePoly1,thePoly2,SegIndex1,SegIndex2,ParamOn1,ParamOn2); |
1665a85a |
777 | AnErrorOccurred = EIP.AnErrorOccurred(); |
778 | |
305cc3f8 |
779 | if( !EIP.NbRoots() && !isFullPolygon) |
780 | return Standard_False; |
1665a85a |
781 | |
782 | if(AnErrorOccurred) |
783 | { |
784 | continue; |
785 | } |
786 | |
787 | //-------------------------------------------------------------------- |
788 | //-- On verifie que le point trouve est bien une racine |
789 | //-------------------------------------------------------------------- |
790 | EIP.Roots(U,V); |
791 | TheCurveTool::D1(C1,U,P1,Tan1); |
792 | TheCurveTool::D1(C2,V,P2,Tan2); |
793 | Standard_Real Dist = P1.Distance(P2); |
794 | //----------------------------------------------------------------- |
795 | //-- On verifie que le point (u,v) n existe pas deja |
796 | //-- |
797 | Standard_Integer nbp=NbPoints(); |
798 | Standard_Real EpsX1 = 10.0*TheCurveTool::EpsX(C1); |
799 | Standard_Real EpsX2 = 10.0*TheCurveTool::EpsX(C2); |
800 | for(Standard_Integer p=1; p<=nbp; p++) { |
801 | const IntRes2d_IntersectionPoint& P=Point(p); |
802 | if(Abs(U-P.ParamOnFirst()) <= EpsX1) { |
803 | if(Abs(V-P.ParamOnSecond()) <= EpsX2) { |
804 | Dist = TolConf+1.0; p+=nbp; |
805 | } |
806 | } |
807 | } |
808 | |
809 | if(Dist <= TolConf) { //-- Ou le point est deja present |
810 | IntRes2d_Position Pos1 = IntRes2d_Middle; |
811 | IntRes2d_Position Pos2 = IntRes2d_Middle; |
812 | IntRes2d_Transition Trans1,Trans2; |
813 | //----------------------------------------------------------------- |
814 | //-- Calcul des Positions des Points sur la courbe |
815 | //-- |
816 | if(P1.Distance(DomainOnCurve1.FirstPoint())<=DomainOnCurve1.FirstTolerance()) |
817 | Pos1 = IntRes2d_Head; |
818 | else if(P1.Distance(DomainOnCurve1.LastPoint())<=DomainOnCurve1.LastTolerance()) |
819 | Pos1 = IntRes2d_End; |
820 | |
821 | if(P2.Distance(DomainOnCurve2.FirstPoint())<=DomainOnCurve2.FirstTolerance()) |
822 | Pos2 = IntRes2d_Head; |
823 | else if(P2.Distance(DomainOnCurve2.LastPoint())<=DomainOnCurve2.LastTolerance()) |
824 | Pos2 = IntRes2d_End; |
825 | //----------------------------------------------------------------- |
826 | //-- Calcul des Transitions (Voir IntImpParGen.cxx) |
827 | //-- |
828 | if(IntImpParGen::DetermineTransition (Pos1, Tan1, Trans1, Pos2, Tan2, Trans2, TolConf) == Standard_False) { |
829 | TheCurveTool::D2(C1,U,P1,Tan1,Norm1); |
830 | TheCurveTool::D2(C2,V,P2,Tan2,Norm2); |
831 | IntImpParGen::DetermineTransition (Pos1, Tan1, Norm1, Trans1, Pos2, Tan2, Norm2, Trans2, TolConf); |
832 | } |
833 | IntRes2d_IntersectionPoint IP(P1,U,V,Trans1,Trans2,Standard_False); |
834 | Insert(IP); |
835 | } |
7fd59977 |
836 | } |
837 | |
7fd59977 |
838 | //---------------------------------------------------------------------- |
839 | //-- Traitement des TangentZone |
840 | //---------------------------------------------------------------------- |
841 | Standard_Integer Nbtz = InterPP.NbTangentZones(); |
842 | for(Standard_Integer tz=1; tz <= Nbtz; tz++) { |
843 | Standard_Integer NbPnts = InterPP.ZoneValue(tz).NumberOfPoints(); |
844 | //==================================================================== |
845 | //== Recherche du premier et du dernier point dans la zone de tg. |
846 | //==================================================================== |
847 | Standard_Real ParamSupOnCurve2,ParamInfOnCurve2; |
848 | Standard_Real ParamSupOnCurve1,ParamInfOnCurve1; |
849 | // Standard_Integer SegIndex,SegIndex1onP1,SegIndex1onP2,SegIndex2onP1,SegIndex2onP2; |
850 | Standard_Integer SegIndex1onP1,SegIndex1onP2; |
851 | Intf_PIType Type; |
852 | Standard_Real ParamOnLine; |
853 | Standard_Real PolyUInf,PolyUSup,PolyVInf,PolyVSup; |
854 | ParamSupOnCurve2=ParamSupOnCurve1=PolyUSup=PolyVSup=-RealLast(); |
855 | ParamInfOnCurve2=ParamInfOnCurve1=PolyUInf=PolyVInf= RealLast(); |
856 | for(Standard_Integer qq=1;qq<=NbPnts;qq++) { |
857 | const Intf_SectionPoint& SPnt1 = InterPP.ZoneValue(tz).GetPoint(qq); |
858 | //==================================================================== |
859 | //== On discretise sur les zones de tangence |
860 | //== Test d arret : |
861 | //== Compteur |
862 | //== Deflection < Tolerance |
863 | //== OU Echantillon < EpsX (normalement la premiere condition est |
864 | //== plus severe) |
865 | //==================================================================== |
866 | // Standard_Real _PolyUInf,_PolyUSup,_PolyVInf,_PolyVSup; |
867 | Standard_Real _PolyUInf,_PolyVInf; |
868 | |
869 | SPnt1.InfoFirst(Type,SegIndex1onP1,ParamOnLine); |
404d419d |
870 | if(SegIndex1onP1 > thePoly1.NbSegments()) { SegIndex1onP1--; ParamOnLine = 1.0; } |
7fd59977 |
871 | if(SegIndex1onP1 <= 0) { SegIndex1onP1=1; ParamOnLine = 0.0; } |
305cc3f8 |
872 | _PolyUInf = thePoly1.ApproxParamOnCurve(SegIndex1onP1,ParamOnLine); |
7fd59977 |
873 | |
874 | SPnt1.InfoSecond(Type,SegIndex1onP2,ParamOnLine); |
404d419d |
875 | if(SegIndex1onP2 > thePoly2.NbSegments()) { SegIndex1onP2--; ParamOnLine = 1.0; } |
7fd59977 |
876 | if(SegIndex1onP2 <= 0) { SegIndex1onP2=1; ParamOnLine = 0.0; } |
305cc3f8 |
877 | _PolyVInf = thePoly2.ApproxParamOnCurve(SegIndex1onP2,ParamOnLine); |
7fd59977 |
878 | |
879 | //---------------------------------------------------------------------- |
880 | |
881 | if(ParamInfOnCurve1 > _PolyUInf) ParamInfOnCurve1=_PolyUInf; |
882 | if(ParamInfOnCurve2 > _PolyVInf) ParamInfOnCurve2=_PolyVInf; |
883 | |
884 | if(ParamSupOnCurve1 < _PolyUInf) ParamSupOnCurve1=_PolyUInf; |
885 | if(ParamSupOnCurve2 < _PolyVInf) ParamSupOnCurve2=_PolyVInf; |
7fd59977 |
886 | } |
887 | |
888 | PolyUInf= ParamInfOnCurve1; |
889 | PolyUSup= ParamSupOnCurve1; |
890 | PolyVInf= ParamInfOnCurve2; |
891 | PolyVSup= ParamSupOnCurve2; |
892 | |
893 | TheCurveTool::D0(C1,PolyUInf,P1); |
894 | TheCurveTool::D0(C2,PolyVInf,P2); |
895 | Standard_Real distmemesens = P1.SquareDistance(P2); |
896 | TheCurveTool::D0(C2,PolyVSup,P2); |
897 | Standard_Real distdiffsens = P1.SquareDistance(P2); |
898 | if(distmemesens > distdiffsens) { |
899 | Standard_Real qwerty=PolyVInf; PolyVInf=PolyVSup; PolyVSup=qwerty; |
900 | } |
901 | |
305cc3f8 |
902 | if( ( (thePoly1.DeflectionOverEstimation() > TolConf) |
903 | ||(thePoly2.DeflectionOverEstimation() > TolConf)) |
1665a85a |
904 | &&(NbIter<NBITER_MAX_POLYGON)) { |
7fd59977 |
905 | |
906 | IntRes2d_Domain RecursD1( TheCurveTool::Value(C1,ParamInfOnCurve1) |
907 | ,ParamInfOnCurve1,TolConf |
908 | ,TheCurveTool::Value(C1,ParamSupOnCurve1) |
909 | ,ParamSupOnCurve1,TolConf); |
910 | IntRes2d_Domain RecursD2( TheCurveTool::Value(C2,ParamInfOnCurve2) |
911 | ,ParamInfOnCurve2,TolConf |
912 | ,TheCurveTool::Value(C2,ParamSupOnCurve2) |
913 | ,ParamSupOnCurve2,TolConf); |
305cc3f8 |
914 | //-- On ne delete pas thePoly1(2) , |
7fd59977 |
915 | //-- ils sont detruits enfin de fct. |
916 | //-- !! Pas de return intempestif !! |
917 | Perform(C1,RecursD1,C2,RecursD2,Tol,TolConf,NbIter+1,DeltaU,DeltaV); |
918 | } |
919 | else { |
920 | //----------------------------------------------------------------- |
921 | //-- Calcul des Positions des Points sur la courbe et des |
922 | //-- Transitions sur chaque borne du segment |
923 | |
924 | IntRes2d_Position Pos1 = IntRes2d_Middle; |
925 | IntRes2d_Position Pos2 = IntRes2d_Middle; |
926 | IntRes2d_Transition Trans1,Trans2; |
927 | |
928 | TheCurveTool::D1(C1,PolyUInf,P1,Tan1); |
929 | TheCurveTool::D1(C2,PolyVInf,P2,Tan2); |
930 | |
931 | if(P1.Distance(DomainOnCurve1.FirstPoint())<=DomainOnCurve1.FirstTolerance()) { |
1665a85a |
932 | Pos1 = IntRes2d_Head; |
7fd59977 |
933 | } |
934 | else if(P1.Distance(DomainOnCurve1.LastPoint())<=DomainOnCurve1.LastTolerance()) { |
1665a85a |
935 | Pos1 = IntRes2d_End; |
7fd59977 |
936 | } |
937 | if(P2.Distance(DomainOnCurve2.FirstPoint())<=DomainOnCurve2.FirstTolerance()) { |
1665a85a |
938 | Pos2 = IntRes2d_Head; |
7fd59977 |
939 | } |
940 | else if(P2.Distance(DomainOnCurve2.LastPoint())<=DomainOnCurve2.LastTolerance()) { |
1665a85a |
941 | Pos2 = IntRes2d_End; |
7fd59977 |
942 | } |
943 | |
944 | if(Pos1==IntRes2d_Middle && Pos2!=IntRes2d_Middle) { |
1665a85a |
945 | PolyUInf=TheProjPCur::FindParameter( C1,P2,D1.FirstParameter(),D1.LastParameter(),TheCurveTool::EpsX(C1)); |
7fd59977 |
946 | } |
947 | else if(Pos1!=IntRes2d_Middle && Pos2==IntRes2d_Middle) { |
1665a85a |
948 | PolyVInf=TheProjPCur::FindParameter( C2,P1,D2.FirstParameter(),D2.LastParameter(),TheCurveTool::EpsX(C2)); |
7fd59977 |
949 | } |
950 | else if(Abs(ParamInfOnCurve1-ParamSupOnCurve1) > Abs(ParamInfOnCurve2-ParamSupOnCurve2)) { |
1665a85a |
951 | PolyVInf=TheProjPCur::FindParameter( C2,P1,D2.FirstParameter(),D2.LastParameter(),TheCurveTool::EpsX(C2)); |
7fd59977 |
952 | } |
953 | else { |
1665a85a |
954 | PolyUInf=TheProjPCur::FindParameter( C1,P2,D1.FirstParameter(),D1.LastParameter(),TheCurveTool::EpsX(C1)); |
7fd59977 |
955 | } |
956 | |
957 | |
958 | |
959 | if(IntImpParGen::DetermineTransition( Pos1,Tan1,Trans1,Pos2,Tan2,Trans2,TolConf) |
1665a85a |
960 | == Standard_False) |
961 | { |
962 | TheCurveTool::D2(C1,PolyUInf,P1,Tan1,Norm1); |
963 | TheCurveTool::D2(C2,PolyVInf,P2,Tan2,Norm2); |
964 | IntImpParGen::DetermineTransition(Pos1,Tan1,Norm1,Trans1, |
965 | Pos2,Tan2,Norm2,Trans2,TolConf); |
7fd59977 |
966 | } |
967 | IntRes2d_IntersectionPoint PtSeg1(P1,PolyUInf,PolyVInf |
968 | ,Trans1,Trans2,Standard_False); |
969 | //---------------------------------------------------------------------- |
970 | |
971 | if((Abs(PolyUInf-PolyUSup) <= TheCurveTool::EpsX(C1)) |
1665a85a |
972 | || (Abs(PolyVInf-PolyVSup) <= TheCurveTool::EpsX(C2))) |
973 | { |
974 | Insert(PtSeg1); |
7fd59977 |
975 | } |
1665a85a |
976 | else |
977 | { |
978 | TheCurveTool::D1(C1,PolyUSup,P1,Tan1); |
979 | TheCurveTool::D1(C2,PolyVSup,P2,Tan2); |
980 | Pos1 = IntRes2d_Middle; Pos2 = IntRes2d_Middle; |
7fd59977 |
981 | |
1665a85a |
982 | if(P1.Distance(DomainOnCurve1.FirstPoint())<=DomainOnCurve1.FirstTolerance()) { |
983 | Pos1 = IntRes2d_Head; |
984 | } |
985 | else if(P1.Distance(DomainOnCurve1.LastPoint())<=DomainOnCurve1.LastTolerance()) { |
986 | Pos1 = IntRes2d_End; |
987 | } |
988 | if(P2.Distance(DomainOnCurve2.FirstPoint())<=DomainOnCurve2.FirstTolerance()) { |
989 | Pos2 = IntRes2d_Head; |
990 | } |
991 | else if(P2.Distance(DomainOnCurve2.LastPoint())<=DomainOnCurve2.LastTolerance()) { |
992 | Pos2 = IntRes2d_End; |
993 | } |
994 | |
995 | |
996 | if(Pos1==IntRes2d_Middle && Pos2!=IntRes2d_Middle) { |
997 | PolyUSup=TheProjPCur::FindParameter( C1,P2,D1.FirstParameter(),D1.LastParameter(),TheCurveTool::EpsX(C1)); |
998 | } |
999 | else if(Pos1!=IntRes2d_Middle && Pos2==IntRes2d_Middle) { |
1000 | PolyVSup=TheProjPCur::FindParameter( C2,P1,D2.FirstParameter(),D2.LastParameter(),TheCurveTool::EpsX(C2)); |
1001 | } |
1002 | else if(Abs(ParamInfOnCurve1-ParamSupOnCurve1) > Abs(ParamInfOnCurve2-ParamSupOnCurve2)) { |
1003 | PolyVSup=TheProjPCur::FindParameter( C2,P1,D2.FirstParameter(),D2.LastParameter(),TheCurveTool::EpsX(C2)); |
1004 | } |
1005 | else { |
1006 | PolyUSup=TheProjPCur::FindParameter( C1,P2,D1.FirstParameter(),D1.LastParameter(),TheCurveTool::EpsX(C1)); |
1007 | } |
7fd59977 |
1008 | |
1665a85a |
1009 | if(IntImpParGen::DetermineTransition( Pos1,Tan1,Trans1,Pos2,Tan2,Trans2,TolConf) |
1010 | ==Standard_False) { |
1011 | TheCurveTool::D2(C1,PolyUSup,P1,Tan1,Norm1); |
1012 | TheCurveTool::D2(C2,PolyVSup,P2,Tan2,Norm2); |
1013 | IntImpParGen::DetermineTransition(Pos1,Tan1,Norm1,Trans1, |
1014 | Pos2,Tan2,Norm2,Trans2,TolConf); |
1015 | } |
1016 | IntRes2d_IntersectionPoint PtSeg2(P1,PolyUSup,PolyVSup |
1017 | ,Trans1,Trans2,Standard_False); |
7fd59977 |
1018 | |
1665a85a |
1019 | Standard_Boolean Oppos = (Tan1.Dot(Tan2) > 0.0)? Standard_False : Standard_True; |
1020 | if(ParamInfOnCurve1 > ParamSupOnCurve1) { |
1021 | IntRes2d_IntersectionSegment Seg(PtSeg2,PtSeg1,Oppos,Standard_False); |
1022 | Append(Seg); |
1023 | } |
1024 | else { |
1025 | IntRes2d_IntersectionSegment Seg(PtSeg1,PtSeg2,Oppos,Standard_False); |
1026 | Append(Seg); |
1027 | } |
7fd59977 |
1028 | } |
1029 | } |
1030 | } |
305cc3f8 |
1031 | return Standard_True; |
7fd59977 |
1032 | } |
1033 | |