0022792: Globally defined symbol PI conflicts with VTK definition (Intel compiler)
[occt.git] / src / IntImpParGen / IntImpParGen_Intersector.gxx
CommitLineData
7fd59977 1// File : IntImpParGen_Intersector.gxx
2// Created : Mon Mar 2 14:00:00 1992
3// Author : Laurent BUCHARD
4// <lbr@phobox>
5// Copyright: Matra Datavision 1992
6
7
8#include <Standard_ConstructionError.hxx>
9#include <IntRes2d_Domain.hxx>
10#include <IntRes2d_IntersectionPoint.hxx>
11#include <IntRes2d_IntersectionSegment.hxx>
12#include <IntRes2d_SequenceOfIntersectionPoint.hxx>
13#include <IntRes2d_SequenceOfIntersectionSegment.hxx>
14#include <IntRes2d_Transition.hxx>
15#include <IntRes2d_Position.hxx>
16
17#include <IntImpParGen.hxx>
18
19#include <math_FunctionSample.hxx>
20#include <math_FunctionAllRoots.hxx>
21
22#include <TColStd_Array1OfReal.hxx>
23#include <gp.hxx>
24#include <gp_Vec2d.hxx>
25
26//======================================================================
27#define EPSDIST Tol
28#define EPSNUL TolConf
29#define EPSX ParTool::EpsX(TheParCurve)
30#define NB_ECHANTILLONS
31
c6541a0c 32static Standard_Real PIpPI = M_PI + M_PI;
7fd59977 33
34
35
36//======================================================================
37void IntImpParGen_Intersector::And_Domaine_Objet1_Intersections(const ImpTool& TheImpTool,
38 const ParCurve& TheParCurve,
39 const IntRes2d_Domain& TheImpCurveDomain,
40 const IntRes2d_Domain& TheParCurveDomain,
41 Standard_Integer& NbResultats,
42 TColStd_Array1OfReal& Inter2_And_Domain2,
43 TColStd_Array1OfReal& Inter1,
44 TColStd_Array1OfReal& Resultat1,
45 TColStd_Array1OfReal& Resultat2,
46 const Standard_Real EpsNul) const {
47
48
49 Standard_Integer Nb_Bornes_Intersection=NbResultats;
50 NbResultats=0;
51
52 for(Standard_Integer i=1; i<=Nb_Bornes_Intersection; i+=2) {
53 Standard_Boolean reverse=Standard_False;
54
55 Standard_Real param1=Inter1.Value(i);
56 Standard_Real param2=Inter1.Value(i+1);
57
58 Standard_Integer indice_1=i;
59 Standard_Integer indice_2=i+1;
60
61 if(param1>param2) {
62 Standard_Real t=param1; param1=param2; param2=t;
63 indice_1=i+1;
64 indice_2=i;
65 reverse=Standard_True;
66 }
67
68 gp_Pnt2d Pt1=TheImpTool.Value(param1);
69 gp_Pnt2d Pt2=TheImpTool.Value(param2);
70 gp_Pnt2d Pt;
71
72 Standard_Boolean IsOnTheImpCurveDomain1=Standard_True;
73 Standard_Boolean IsOnABoundary1=Standard_False;
74
75 Standard_Boolean IsOnTheImpCurveDomain2=Standard_True;
76 Standard_Boolean IsOnABoundary2=Standard_False;
77 //--------------------------------------------------------------------
78 if(TheImpCurveDomain.HasFirstPoint()) {
79 if(param1<TheImpCurveDomain.FirstParameter()) {
80 if(Pt1.Distance(TheImpCurveDomain.FirstPoint())
81 > TheImpCurveDomain.FirstTolerance()) {
82 IsOnTheImpCurveDomain1=Standard_False;
83 }
84 else { IsOnABoundary1=Standard_True; }
85 }
86 }
87 if(IsOnTheImpCurveDomain1 && TheImpCurveDomain.HasLastPoint()) {
88 if(param1>TheImpCurveDomain.LastParameter()) {
89 if(Pt1.Distance(TheImpCurveDomain.LastPoint())
90 > TheImpCurveDomain.FirstTolerance()) {
91 IsOnTheImpCurveDomain1=Standard_False;
92 }
93 else { IsOnABoundary1=Standard_True; }
94 }
95 }
96 //--------------------------------------------------------------------
97 if(TheImpCurveDomain.HasFirstPoint()) {
98 if(param2<TheImpCurveDomain.FirstParameter()) {
99 if(Pt2.Distance(TheImpCurveDomain.FirstPoint())
100 > TheImpCurveDomain.FirstTolerance()) {
101 IsOnTheImpCurveDomain2=Standard_False;
102 }
103 else { IsOnABoundary2=Standard_True; }
104 }
105 }
106 if(IsOnTheImpCurveDomain2 && TheImpCurveDomain.HasLastPoint()) {
107 if(param2>TheImpCurveDomain.LastParameter()) {
108 if(Pt2.Distance(TheImpCurveDomain.LastPoint())
109 > TheImpCurveDomain.FirstTolerance()) {
110 IsOnTheImpCurveDomain2=Standard_False;
111 }
112 else { IsOnABoundary2=Standard_True; }
113 }
114 }
115
116 if(IsOnTheImpCurveDomain1) {
117 //------------------------------------------------------------------
118 //--- la borne 1 est sur le domaine --
119 NbResultats++;
120 Resultat1.SetValue(NbResultats,Inter1.Value(indice_1));
121 Resultat2.SetValue(NbResultats,Inter2_And_Domain2.Value(indice_1));
122 //--- la borne2 est aussi sur le domaine ---
123 if(IsOnTheImpCurveDomain2) {
124 NbResultats++;
125 Resultat1.SetValue(NbResultats,Inter1.Value(indice_2));
126 Resultat2.SetValue(NbResultats,Inter2_And_Domain2.Value(indice_2));
127 }
128 else {
129 //--- Borne1 sur domaine et Borne 2 Hors Domaine ---
130 Standard_Real t;
131 NbResultats++;
132 t=TheImpCurveDomain.LastParameter();
133 Resultat1.SetValue(NbResultats,t);
134// Standard_Real popResult = FindV(t,Pt,TheImpTool,TheParCurve,
135// TheParCurveDomain,
136// Inter2_And_Domain2.Value(indice_1),
137// Inter2_And_Domain2.Value(indice_2),
138// EpsNul);
139//
140// Resultat2.SetValue(NbResultats,popResult);
141 Resultat2.SetValue(NbResultats,
142 IntImpParGen_Intersector::FindV(t,Pt,TheImpTool,TheParCurve,
143 TheParCurveDomain,
144 Inter2_And_Domain2.Value(indice_1),
145 Inter2_And_Domain2.Value(indice_2),
146 EpsNul));
147 }
148 }
149 else { //======= la borne1 n est pas sur le domaine ========
150 if(IsOnTheImpCurveDomain2) {
151 Standard_Real t;
152 NbResultats++;
153 t=TheImpCurveDomain.FirstParameter();
154
155 Resultat1.SetValue(NbResultats,t);
156 Resultat2.SetValue(NbResultats,
157 IntImpParGen_Intersector::FindV(t,Pt,TheImpTool,TheParCurve,
158 TheParCurveDomain,
159 Inter2_And_Domain2.Value(indice_1),
160 Inter2_And_Domain2.Value(indice_2),
161 EpsNul));
162
163 NbResultats++;
164 Resultat1.SetValue(NbResultats,Inter1.Value(indice_2));
165 Resultat2.SetValue(NbResultats,Inter2_And_Domain2.Value(indice_2));
166 }
167 else { //====== la borne2 et la borne1 sont hors domaine =====
168 if(param1<TheImpCurveDomain.FirstParameter()
169 && param2>TheImpCurveDomain.LastParameter()) {
170 Standard_Real t;
171 NbResultats++;
172 t=TheImpCurveDomain.FirstParameter();
173 Resultat1.SetValue(NbResultats,t);
174 Resultat2.SetValue(NbResultats,
175 IntImpParGen_Intersector::FindV(t,Pt,TheImpTool,TheParCurve,
176 TheParCurveDomain,
177 Inter2_And_Domain2.Value(indice_1),
178 Inter2_And_Domain2.Value(indice_2),
179 EpsNul));
180
181
182
183 NbResultats++;
184 t=TheImpCurveDomain.LastParameter();
185 Resultat1.SetValue(NbResultats,t);
186 Resultat2.SetValue(NbResultats,
187 IntImpParGen_Intersector::FindV(t,Pt,TheImpTool,TheParCurve,
188 TheParCurveDomain,
189 Inter2_And_Domain2.Value(indice_1),
190 Inter2_And_Domain2.Value(indice_2),
191 EpsNul));
192
193 }
194 }
195 }
196 }
197}
198//======================================================================
199//-- C o n s t r u c t e u r s e t P e r f o r m
200IntImpParGen_Intersector::IntImpParGen_Intersector() {
201 done=Standard_False;
202}
203//----------------------------------------------------------------------
204//--
205IntImpParGen_Intersector::IntImpParGen_Intersector(const ImpTool& TheImpTool,
206 const IntRes2d_Domain& TheImpCurveDomain,
207 const ParCurve& TheParCurve,
208 const IntRes2d_Domain& TheParCurveDomain,
209 const Standard_Real TolConf,
210 const Standard_Real Tol) {
211 Perform(TheImpTool,TheImpCurveDomain,TheParCurve,TheParCurveDomain,TolConf,Tol);
212}
213//----------------------------------------------------------------------
214//--
215void IntImpParGen_Intersector::Perform(const ImpTool& TheImpTool,
216 const IntRes2d_Domain& TheImpCurveDomain,
217 const ParCurve& TheParCurve,
218 const IntRes2d_Domain& TheParCurveDomain,
219 const Standard_Real TolConf,
220 const Standard_Real Tol) {
221
222
223 Standard_Integer i,nb_segments_solution, nb_points_solution;
224 Standard_Real param1,param2,EpsX, EpsNul, EpsDist;
225
226 IntRes2d_Transition Trans1,Trans2;
227 gp_Pnt2d pt1,pt2;
228 gp_Vec2d Tan1,Tan2,Norm1,Norm2;
229 IntRes2d_Position Pos1,Pos2;
230
231
232 //----------------------------------------------
233 //-- On teste apres appel aux maths si les bornes
234 //-- des domaines sont des solutions
235 //--
236 Standard_Boolean HeadOnImp =Standard_False;
237 Standard_Boolean HeadOnPar =Standard_False;
238 Standard_Boolean EndOnImp =Standard_False;
239 Standard_Boolean EndOnPar =Standard_False;
240
241 this->ResetFields();
242
243 IntImpParGen_MyImpParTool TheImpParTool(TheImpTool,TheParCurve);
244
245 if (! (TheParCurveDomain.HasFirstPoint() &&
246 TheParCurveDomain.HasLastPoint())) {
247 Standard_ConstructionError::Raise("Domaine sur courbe incorrect");
248 }
249
250 Standard_Integer nb_echantillons = ParTool::NbSamples(TheParCurve,
251 TheParCurveDomain.FirstParameter(),
252 TheParCurveDomain.LastParameter());
253
254 EpsX = EPSX;
255 if(EpsX>1.0e-10) EpsX = 1.0e-10;
256 EpsNul=(TolConf<=1.0e-10)? 1.0e-10: TolConf;
257 EpsDist=(Tol<=1.0e-10)? 1.0e-10: Tol;
258
259 Standard_Real Tolerance_Angulaire=EpsDist;
260
261
262
263 if((TheParCurveDomain.LastParameter() - TheParCurveDomain.FirstParameter()) < 100.0*EpsX) {
264 EpsX = (TheParCurveDomain.LastParameter() - TheParCurveDomain.FirstParameter())*0.01;
265 }
266
267 math_FunctionSample Sample2(TheParCurveDomain.FirstParameter(),
268 TheParCurveDomain.LastParameter(),
269 nb_echantillons);
270
271 math_FunctionAllRoots Sol(TheImpParTool,
272 Sample2,
273 EpsX,
274 EpsDist,
275 EpsNul);
276
277 if(!Sol.IsDone()) {done = Standard_False; return; }
278
279 nb_segments_solution=Sol.NbIntervals();
280 nb_points_solution=Sol.NbPoints();
281
282 //--------------------------------------------------------------------
283 //-- T r a i t e m e n t d e s P o i n t s S o l u t i o n s
284 for(i=1; i<=nb_points_solution; i++) {
285 gp_Pnt2d Pt;
286 param2=Sol.GetPoint(i);
287 param1=FindU(param2,Pt,TheParCurve,TheImpTool);
288
289 if(TheImpCurveDomain.IsClosed()) {
290 param1 = IntImpParGen::NormalizeOnDomain( param1
291 ,TheImpCurveDomain);
292 }
293
294 Standard_Boolean IsOnTheImpCurveDomain=Standard_True;
295 if(TheImpCurveDomain.HasFirstPoint()) {
296 if(param1<TheImpCurveDomain.FirstParameter()) {
297 if(Pt.Distance(TheImpCurveDomain.FirstPoint())
298 > TheImpCurveDomain.FirstTolerance()) {
299 IsOnTheImpCurveDomain=Standard_False;
300 }
301 }
302 }
303 if(IsOnTheImpCurveDomain && TheImpCurveDomain.HasLastPoint()) {
304 if(param1>TheImpCurveDomain.LastParameter()) {
305 if(Pt.Distance(TheImpCurveDomain.LastPoint())
306 > TheImpCurveDomain.FirstTolerance()) {
307 IsOnTheImpCurveDomain=Standard_False;
308 }
309 }
310 }
311
312 if(IsOnTheImpCurveDomain) {
313 TheImpTool.D2(param1,pt1,Tan1,Norm1);
314 ParTool::D2(TheParCurve,param2,pt2,Tan2,Norm2);
315
316 IntImpParGen::DeterminePosition(Pos1,TheImpCurveDomain,pt1,param1);
317 IntImpParGen::DeterminePosition(Pos2,TheParCurveDomain,pt2,param2);
318
319 if(Pos1==IntRes2d_End) EndOnImp = Standard_True;
320 else if(Pos1==IntRes2d_Head) HeadOnImp = Standard_True;
321 if(Pos2==IntRes2d_End) EndOnPar = Standard_True;
322 else if(Pos2==IntRes2d_Head) HeadOnPar = Standard_True;
323
324 IntImpParGen::DetermineTransition(Pos1,Tan1,Norm1,Trans1,
325 Pos2,Tan2,Norm2,Trans2,
326 Tolerance_Angulaire);
327
328 IntRes2d_IntersectionPoint IP(pt1,param1,param2
329 ,Trans1,Trans2
330 ,ReversedParameters());
331 Insert(IP);
332 }
333 }
334 //-- F i n d u T r a i t e m e n t d e s P t s S o l.
335
336
337 //--------------------------------------------------------------------
338 //-- T r a i t e m e n t D e s S e g m e n t s ---
339 //--------------------------------------------------------------------
340 //-- On a N segments solution sur le domaine de V soit au pire :
341 //-- --> N segments solution sur le domaine de U
342 //-- -->2N segments si la courbe en U est fermee
343 //--
344
345 TColStd_Array1OfReal Inter2_and_Domaine2(1,2+8*nb_segments_solution);
346 TColStd_Array1OfReal Inter1(1,2+8*nb_segments_solution);
347
348 Standard_Integer nb_segments_crees=0;
349
350 for (Standard_Integer j2=1,j=1;j<=nb_segments_solution;j++,j2+=2) {
351 Standard_Real param2_inf,param2_sup;
352 Standard_Real param1_inf,param1_sup;
353 gp_Pnt2d Ptemp;
354
355 Sol.GetInterval(j,param2_inf,param2_sup);
356 param1_inf=FindU(param2_inf,Ptemp,TheParCurve,TheImpTool);
357 param1_sup=FindU(param2_sup,Ptemp,TheParCurve,TheImpTool);
358
359 //----------------------------------------------------------------------
360 //-- C o u r b e I m p l i c i t e F e r m e e
361
362 if(TheImpCurveDomain.IsClosed()) {
363
364 gp_Pnt2d Ptemp;
365 gp_Vec2d T1,T2,N1,N2;
366 Standard_Real param1_origine,param1_fin;
367
368 TheImpCurveDomain.EquivalentParameters(param1_origine,param1_fin);
369 Standard_Real Periode=param1_fin-param1_origine;
370
371 while(param1_inf<param1_origine) { param1_inf+=Periode; }
372 while(param1_sup<param1_origine) { param1_sup+=Periode; }
373
374 ParTool::D2(TheParCurve,param2_inf,Ptemp,T2,N2);
375 TheImpTool.D2(param1_inf,Ptemp,T1,N1);
376 if(T1.Magnitude()<=gp::Resolution()) T1=N1;
377 if(T2.Magnitude()<=gp::Resolution()) T2=N2;
378
379 if(T1.Dot(T2) >=0.0) {
380 //--- param1_inf designe un point entrant (et T1 est vers la matiere)
381 if(param1_inf>=param1_sup) { param1_sup+=Periode; }
382 }
383 else { //--- param1_inf : point sortant (et T1 est Hors matiere)
384 if(param1_inf<=param1_sup) { param1_inf+=Periode; }
385 }
386 //--- On cree un nouveau segment decale de Periode
387 //-- Exemple de Pb : Domaine PI/4 PI/2 et intervalle 0,PI
388 //-- Domaine 1.5PI 2.5PI et intervalle 0,PI
389 //-- -2pi 0 2pi
390 //-- ------|--------------------|-----------------|-----------
391 //-- [----------------------------] Domaine
392 //-- [~~~~~~~~~~~~~~~~~] Inters.
393 //--
394 //-- On cree un nouvel intervalle
395 //-- interv decale
396 //-- [a~~~~~~~~~~~~b] [a~~~~~~~~~~~~~~~b] et [a~~~]
397 //--
398 //
399
400 if(TheImpCurveDomain.LastParameter()
401 > ((param1_inf>param1_sup)? (param1_sup+Periode):
402 (param1_inf+Periode))) {
403 Inter2_and_Domaine2.SetValue(j2,param2_inf);
404 Inter1.SetValue(j2,param1_inf+Periode);
405
406 Inter2_and_Domaine2.SetValue(j2+1,param2_sup);
407 Inter1.SetValue(j2+1,param1_sup+Periode);
408 j2+=2;
409 nb_segments_crees++;
410 }
411
412 if(TheImpCurveDomain.FirstParameter()
413 <((param1_inf<param1_sup)? (param1_sup-Periode): (param1_inf-Periode))) {
414 Inter2_and_Domaine2.SetValue(j2,param2_inf);
415 Inter1.SetValue(j2,param1_inf-Periode);
416
417 Inter2_and_Domaine2.SetValue(j2+1,param2_sup);
418 Inter1.SetValue(j2+1,param1_sup-Periode);
419 j2+=2;
420 nb_segments_crees++;
421 }
422 }
423 //-- F i n C o u r b e I m p l i c i t e F e r m e e
424 //----------------------------------------------------------------------
425
426
427 Inter2_and_Domaine2.SetValue(j2,param2_inf);
428 Inter1.SetValue(j2,param1_inf);
429
430 Inter2_and_Domaine2.SetValue(j2+1,param2_sup);
431 Inter1.SetValue(j2+1,param1_sup);
432 }
433
434 //------------------------------------------------------------------
435 //-- INTER2_DOMAINE2 : Intersection AND CurveDomain : Function of PARAM2
436 //-- INTER1 : Intersection AND CurveDomain : Function of PARAM1
437 //------------------------------------------------------------------
438 //--
439 TColStd_Array1OfReal Resultat1(1,2+(1+nb_segments_solution)*2);
440 TColStd_Array1OfReal Resultat2(1,2+(1+nb_segments_solution)*2);
441 nb_segments_solution+=nb_segments_crees;
442 Standard_Integer NbResultats=nb_segments_solution*2;
443
444 And_Domaine_Objet1_Intersections(TheImpTool,
445 TheParCurve,
446 TheImpCurveDomain,
447 TheParCurveDomain,
448 NbResultats,
449 Inter2_and_Domaine2,Inter1,
450 Resultat1,Resultat2,EpsNul);
451
452 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
453 //Calcule_Toutes_Transitions(NbResultats,
454 // Resultat1,Resultat2,
455 // TheImpTool,
456 // TheImpCurveDomain,
457 // TheParCurve,
458 // TheParCurveDomain);
459 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
460 //~~~ Fonction Calcule_Toutes_Transitions Repportee ici pour cause ~~~~~
461 //~~~~~ D acces aux methodes Protected APPEND
462 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
463 {
464 IntRes2d_Position Pos1,Pos2;
465 IntRes2d_Transition Trans1,Trans2;
466 gp_Vec2d Tan1,Tan2,Norm1,Norm2;
467 gp_Pnt2d Pt1_on1,Pt2_on1,Pt1_on2,Pt2_on2;
468 Standard_Real Param1_on1,Param2_on1,Param1_on2,Param2_on2;
469
470 Standard_Real Dist_Mini_ImpCurve=EPSNUL;
471 Standard_Real Tolerance_Angulaire=Dist_Mini_ImpCurve;
472
473
474 for(Standard_Integer i=1; i<=NbResultats ; i+=2) {
475 Standard_Integer ip1=i+1;
476 Standard_Boolean OnlyOnePoint=Standard_False;
477
478 Param1_on1=Resultat1.Value(i);
479 Param1_on2=Resultat2.Value(i);
480 Param2_on1=Resultat1.Value(ip1);
481 Param2_on2=Resultat2.Value(ip1);
482
483 Pt1_on1=TheImpTool.Value(Param1_on1);
484 Pt2_on1=TheImpTool.Value(Param2_on1);
485 Pt1_on2=ParTool::Value(TheParCurve,Param1_on2);
486 Pt2_on2=ParTool::Value(TheParCurve,Param2_on2);
487
488 if(!TheImpCurveDomain.IsClosed()) {
489 if( Pt1_on1.Distance(Pt2_on1) <= Dist_Mini_ImpCurve ) {
490 if( Pt1_on2.Distance(Pt2_on2) <= Dist_Mini_ImpCurve ) {
491 OnlyOnePoint=Standard_True;
492 }
493 }
494 }
495
496 Param1_on1=IntImpParGen::NormalizeOnDomain(Param1_on1,TheImpCurveDomain);
497 Param1_on2=IntImpParGen::NormalizeOnDomain(Param1_on2,TheParCurveDomain);
498
499 TheImpTool.D2(Param1_on1,Pt1_on1,Tan1,Norm1);
500 ParTool::D2(TheParCurve,Param1_on2,Pt1_on2,Tan2,Norm2);
501
502 IntImpParGen::DeterminePosition(Pos1,TheImpCurveDomain,Pt1_on1,Param1_on1);
503 IntImpParGen::DeterminePosition(Pos2,TheParCurveDomain,Pt1_on2,Param1_on2);
504
505 if(Pos1==IntRes2d_End) EndOnImp = Standard_True;
506 else if(Pos1==IntRes2d_Head) HeadOnImp = Standard_True;
507 if(Pos2==IntRes2d_End) EndOnPar = Standard_True;
508 else if(Pos2==IntRes2d_Head) HeadOnPar = Standard_True;
509
510
511 IntImpParGen::DetermineTransition(Pos1,Tan1,Norm1,Trans1,
512 Pos2,Tan2,Norm2,Trans2,
513 Tolerance_Angulaire);
514
515 //============== Detection du cas : L intersection est en bout
516 //============== sur les 2 domaines
517
518 if(Pos1!=IntRes2d_Middle && Pos2!=IntRes2d_Middle) {
519 Standard_Real m=0.5*(Pt1_on1.X() + Pt1_on2.X());
520 Pt1_on1.SetX(m);
521 m=0.5*(Pt1_on1.Y() + Pt1_on2.Y());
522 Pt1_on1.SetY(m);
523 }
524
525 IntRes2d_IntersectionPoint new_p1(Pt1_on1
526 ,Param1_on1,Param1_on2
527 ,Trans1,Trans2
528 ,ReversedParameters());
529 if(!OnlyOnePoint) {
530 IntRes2d_IntersectionPoint new_p2;
531
532 Param2_on1=IntImpParGen::NormalizeOnDomain(Param2_on1,TheImpCurveDomain);
533 Param2_on2=IntImpParGen::NormalizeOnDomain(Param2_on2,TheParCurveDomain);
534
535 TheImpTool.D2(Param2_on1,Pt2_on1,Tan1,Norm1);
536 ParTool::D2(TheParCurve,Param2_on2,Pt2_on2,Tan2,Norm2);
537
538 IntImpParGen::DeterminePosition(Pos1,TheImpCurveDomain,Pt2_on1,Param2_on1);
539 IntImpParGen::DeterminePosition(Pos2,TheParCurveDomain,Pt2_on2,Param2_on2);
540
541 if(Pos1==IntRes2d_End) EndOnImp = Standard_True;
542 else if(Pos1==IntRes2d_Head) HeadOnImp = Standard_True;
543 if(Pos2==IntRes2d_End) EndOnPar = Standard_True;
544 else if(Pos2==IntRes2d_Head) HeadOnPar = Standard_True;
545
546 IntImpParGen::DetermineTransition(Pos1,Tan1,Norm1,Trans1,
547 Pos2,Tan2,Norm2,Trans2,
548 Tolerance_Angulaire);
549
550
551 //============== Detection du cas : L intersection est en bout
552 //============== sur les 2 domaines
553
554 if(Pos1!=IntRes2d_Middle && Pos2!=IntRes2d_Middle) {
555 Standard_Real m=0.5*(Pt2_on1.X() + Pt2_on2.X() );
556 Pt2_on1.SetX(m);
557 m=0.5*(Pt2_on1.Y() + Pt2_on2.Y());
558 Pt2_on1.SetY(m);
559 }
560
561 new_p2.SetValues(Pt2_on1,Param2_on1,Param2_on2
562 ,Trans1,Trans2
563 ,ReversedParameters());
564
565 Standard_Boolean segopposite=((Tan1.Dot(Tan2) < 0.0)?
566 Standard_True : Standard_False);
567
568 IntRes2d_IntersectionSegment new_seg(new_p1,new_p2
569 ,segopposite
570 ,ReversedParameters());
571 Append(new_seg);
572 }
573 else {
574 Insert(new_p1);
575 }
576 }
577 } //~~~~~~~~~~~~ Fin du corps de la fonction Calc...Transitions~~~~~~~~~~
578
579 //-------------------------------------------
580 //-- On teste les points en bouts solutions
581 //--
582 if(!HeadOnImp && TheImpCurveDomain.HasFirstPoint()) {
583 if(!HeadOnPar) {
584 if(TheImpCurveDomain.FirstPoint().Distance(TheParCurveDomain.FirstPoint())
585 <= Max(TheImpCurveDomain.FirstTolerance(),TheParCurveDomain.FirstTolerance())) {
586 param1 = TheImpCurveDomain.FirstParameter();
587 param2 = TheParCurveDomain.FirstParameter();
588 TheImpTool.D2(param1,pt1,Tan1,Norm1);
589 ParTool::D2(TheParCurve,param2,pt2,Tan2,Norm2);
590 IntImpParGen::DetermineTransition(IntRes2d_Head,Tan1,Norm1,Trans1,
591 IntRes2d_Head,Tan2,Norm2,Trans2,
592 Tolerance_Angulaire);
593 IntRes2d_IntersectionPoint IP(TheImpCurveDomain.FirstPoint(),
594 param1,param2,
595 Trans1,Trans2,
596 ReversedParameters());
597 Insert(IP);
598 }
599 }
600 if(!EndOnPar) {
601 if(TheImpCurveDomain.FirstPoint().Distance(TheParCurveDomain.LastPoint())
602 <= Max(TheImpCurveDomain.FirstTolerance(),TheParCurveDomain.LastTolerance())) {
603 param1 = TheImpCurveDomain.FirstParameter();
604 param2 = TheParCurveDomain.LastParameter();
605 TheImpTool.D2(param1,pt1,Tan1,Norm1);
606 ParTool::D2(TheParCurve,param2,pt2,Tan2,Norm2);
607 IntImpParGen::DetermineTransition(IntRes2d_Head,Tan1,Norm1,Trans1,
608 IntRes2d_End ,Tan2,Norm2,Trans2,
609 Tolerance_Angulaire);
610 IntRes2d_IntersectionPoint IP(TheImpCurveDomain.FirstPoint(),
611 param1,param2,
612 Trans1,Trans2,
613 ReversedParameters());
614 Insert(IP);
615 }
616 }
617 }
618
619 if(!EndOnImp && TheImpCurveDomain.HasLastPoint()) {
620 if(!HeadOnPar) {
621 if(TheImpCurveDomain.LastPoint().Distance(TheParCurveDomain.FirstPoint())
622 <= Max(TheImpCurveDomain.LastTolerance(),TheParCurveDomain.FirstTolerance())) {
623 param1 = TheImpCurveDomain.LastParameter();
624 param2 = TheParCurveDomain.FirstParameter();
625 TheImpTool.D2(param1,pt1,Tan1,Norm1);
626 ParTool::D2(TheParCurve,param2,pt2,Tan2,Norm2);
627 IntImpParGen::DetermineTransition(IntRes2d_End,Tan1,Norm1,Trans1,
628 IntRes2d_Head,Tan2,Norm2,Trans2,
629 Tolerance_Angulaire);
630 IntRes2d_IntersectionPoint IP(TheImpCurveDomain.LastPoint(),
631 param1,param2,
632 Trans1,Trans2,
633 ReversedParameters());
634 Insert(IP);
635 }
636 }
637 if(!EndOnPar) {
638 if(TheImpCurveDomain.LastPoint().Distance(TheParCurveDomain.LastPoint())
639 <= Max(TheImpCurveDomain.LastTolerance(),TheParCurveDomain.LastTolerance())) {
640 param1 = TheImpCurveDomain.LastParameter();
641 param2 = TheParCurveDomain.LastParameter();
642 TheImpTool.D2(param1,pt1,Tan1,Norm1);
643 ParTool::D2(TheParCurve,param2,pt2,Tan2,Norm2);
644 IntImpParGen::DetermineTransition(IntRes2d_End,Tan1,Norm1,Trans1,
645 IntRes2d_End,Tan2,Norm2,Trans2,
646 Tolerance_Angulaire);
647 IntRes2d_IntersectionPoint IP(TheImpCurveDomain.LastPoint(),
648 param1,param2,
649 Trans1,Trans2,
650 ReversedParameters());
651 Insert(IP);
652 }
653 }
654 }
655 done=Standard_True;
656}
657
658
659
660
661
662
663Standard_Real IntImpParGen_Intersector::FindU(const Standard_Real parameter
664 ,gp_Pnt2d& point
665 ,const ParCurve& TheParCurve
666 ,const ImpTool& TheImpTool) const
667{
668 point=ParTool::Value(TheParCurve,parameter);
669 return(TheImpTool.FindParameter(point));
670}
671
672Standard_Real IntImpParGen_Intersector::FindV(const Standard_Real parameter
673 ,gp_Pnt2d& point
674 ,const ImpTool& TheImpTool
675 ,const ParCurve& TheParCurve
676 ,const IntRes2d_Domain& TheParCurveDomain
677 ,const Standard_Real V0
678 ,const Standard_Real V1
679 ,const Standard_Real Tolerance) const
680{
681 point=TheImpTool.Value(parameter);
682 if(TheParCurveDomain.IsClosed()) {
683 Standard_Real V = ProjectOnPCurveTool::FindParameter(TheParCurve,
684 point,
685 Tolerance);
686 return(IntImpParGen::NormalizeOnDomain(V,TheParCurveDomain));
687 }
688 else {
689 Standard_Real VV0 = V0;
690 Standard_Real VV1 = V1;
691 if(V1<V0) { VV0 = V1; VV1 = V0; }
692 //-- ??????????????????????????????????????????????????????????????????????
693 //-- Modif le 15 Septembre 1992 : On Teste le parametre retourne
694 //--??????????????????????????????????????????????????????????????????????
695 Standard_Real X = ProjectOnPCurveTool::FindParameter(TheParCurve,
696 point,
697 VV0,VV1,Tolerance);
698 if(X>VV1) X=VV1; else if(X<VV0) X=VV0;
699 return(X);
700 }
701}