projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0025380: Intersection curve cannot reach boundary of surface
[occt.git] / src / IntWalk / IntWalk_PWalking.cxx
CommitLineData
b311480e 1// Copyright (c) 1995-1999 Matra Datavision
973c2be1 2// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 3//
973c2be1 4// This file is part of Open CASCADE Technology software library.
b311480e 5//
d5f74e42 6// This library is free software; you can redistribute it and/or modify it under
7// the terms of the GNU Lesser General Public License version 2.1 as published
973c2be1 8// by the Free Software Foundation, with special exception defined in the file
9// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10// distribution for complete text of the license and disclaimer of any warranty.
b311480e 11//
973c2be1 12// Alternatively, this file may be used under the terms of Open CASCADE
13// commercial license or contractual agreement.
b311480e 14
47cbf134 15#include <IntWalk_PWalking.ixx>
16
17#include <IntWalk_StatusDeflection.hxx>
18
19#include <TColgp_Array1OfPnt.hxx>
20#include <TColStd_Array1OfReal.hxx>
21
22#include <IntImp_ComputeTangence.hxx>
23
24#include <Adaptor3d_HSurface.hxx>
25#include <Adaptor3d_HSurfaceTool.hxx>
7fd59977 26
27#include <Precision.hxx>
7fd59977 28
47cbf134 29#include <math_FunctionSetRoot.hxx>
00302ba4 30#include <Geom_Surface.hxx>
31
47cbf134 32#include <Standard_Failure.hxx>
33#include <gp_Pnt2d.hxx>
7fd59977 34
35//==================================================================================
36// function : IntWalk_PWalking::IntWalk_PWalking
37// purpose :
b1c5c4e6 38// estimate of max step : To avoid abrupt changes
39// during change of isos
7fd59977 40//==================================================================================
41void ComputePasInit(Standard_Real *pasuv,
00302ba4 42 Standard_Real Um1,Standard_Real UM1,
43 Standard_Real Vm1,Standard_Real VM1,
44 Standard_Real Um2,Standard_Real UM2,
45 Standard_Real Vm2,Standard_Real VM2,
46 Standard_Real _Um1,Standard_Real _UM1,
47 Standard_Real _Vm1,Standard_Real _VM1,
48 Standard_Real _Um2,Standard_Real _UM2,
49 Standard_Real _Vm2,Standard_Real _VM2,
47cbf134 50 const Handle(Adaptor3d_HSurface)& ,
51 const Handle(Adaptor3d_HSurface)& ,
00302ba4 52 const Standard_Real Increment)
7fd59977 53{
54 Standard_Real du1=Abs(UM1-Um1);
55 Standard_Real dv1=Abs(VM1-Vm1);
56 Standard_Real du2=Abs(UM2-Um2);
57 Standard_Real dv2=Abs(VM2-Vm2);
00302ba4 58
7fd59977 59 Standard_Real _du1=Abs(_UM1-_Um1);
60 Standard_Real _dv1=Abs(_VM1-_Vm1);
61 Standard_Real _du2=Abs(_UM2-_Um2);
62 Standard_Real _dv2=Abs(_VM2-_Vm2);
00302ba4 63
b1c5c4e6 64 //-- limit the reduction of uv box estimate to 0.01 natural box
65 //-- du1 : On box of Inter
66 //-- _du1 : On parametric space
7fd59977 67 if(_du1<1e50 && du1<0.01*_du1) du1=0.01*_du1;
68 if(_dv1<1e50 && dv1<0.01*_dv1) dv1=0.01*_dv1;
69 if(_du2<1e50 && du2<0.01*_du2) du2=0.01*_du2;
70 if(_dv2<1e50 && dv2<0.01*_dv2) dv2=0.01*_dv2;
00302ba4 71
7fd59977 72 pasuv[0]=Increment*du1;
73 pasuv[1]=Increment*dv1;
74 pasuv[2]=Increment*du2;
75 pasuv[3]=Increment*dv2;
76}
c2c2f2b6 77
78//=======================================================================
79//function : IsParallel
80//purpose : Checks if theLine is parallel of some boundary of given
81// surface (it is determined by theCheckSurf1 flag).
82// Parallelism assumes small oscillations (swing is less or
83// equal than theToler).
84// Small lines (if first and last parameters in the Surface
85// are almost equal) are classified as parallel (as same as
86// any point can be considered as parallel of any line).
87//=======================================================================
88static void IsParallel(const Handle(IntSurf_LineOn2S)& theLine,
47cbf134 89 const Standard_Boolean theCheckSurf1,
90 const Standard_Real theToler,
91 Standard_Boolean& theIsUparallel,
92 Standard_Boolean& theIsVparallel)
c2c2f2b6 93{
94 const Standard_Integer aNbPointsMAX = 23;
95
96 theIsUparallel = theIsVparallel = Standard_True;
97
98 Standard_Integer aNbPoints = theLine->NbPoints();
99 if(aNbPoints > aNbPointsMAX)
100 {
101 aNbPoints = aNbPointsMAX;
102 }
103 else if(aNbPoints < 3)
104 {
105 //Here we cannot estimate parallelism.
106 //Do all same as for small lines
107 return;
108 }
109
110 Standard_Real aStep = IntToReal(theLine->NbPoints()) / aNbPoints;
111 Standard_Real aNPoint = 1.0;
112
113 Standard_Real aUmin = RealLast(), aUmax = RealFirst(), aVmin = RealLast(), aVmax = RealFirst();
114 for(Standard_Integer aNum = 1; aNum <= aNbPoints; aNum++, aNPoint += aStep)
115 {
116 if(aNPoint > aNbPoints)
117 {
118 aNPoint = aNbPoints;
119 }
120
121 Standard_Real u, v;
122 if(theCheckSurf1)
123 theLine->Value(RealToInt(aNPoint)).ParametersOnS1(u, v);
124 else
125 theLine->Value(RealToInt(aNPoint)).ParametersOnS2(u, v);
126
127 if(u < aUmin)
128 aUmin = u;
129
130 if(u > aUmax)
131 aUmax = u;
132
133 if(v < aVmin)
134 aVmin = v;
135
136 if(v > aVmax)
137 aVmax = v;
138 }
139
140 theIsVparallel = ((aUmax - aUmin) < theToler);
141 theIsUparallel = ((aVmax - aVmin) < theToler);
142}
143
144//=======================================================================
145//function : Checking
146//purpose : Check, if given point is in surface's boundaries.
147// If "yes" then theFactTol = 0.0, else theFactTol is
148// equal maximal deviation.
149//=======================================================================
150static Standard_Boolean Checking( const Handle(Adaptor3d_HSurface)& theASurf1,
47cbf134 151 const Handle(Adaptor3d_HSurface)& theASurf2,
152 Standard_Real& theU1,
153 Standard_Real& theV1,
154 Standard_Real& theU2,
155 Standard_Real& theV2,
156 Standard_Real& theFactTol)
c2c2f2b6 157{
158 const Standard_Real aTol = Precision::PConfusion();
159 const Standard_Real aU1bFirst = theASurf1->FirstUParameter();
160 const Standard_Real aU1bLast = theASurf1->LastUParameter();
161 const Standard_Real aU2bFirst = theASurf2->FirstUParameter();
162 const Standard_Real aU2bLast = theASurf2->LastUParameter();
163 const Standard_Real aV1bFirst = theASurf1->FirstVParameter();
164 const Standard_Real aV1bLast = theASurf1->LastVParameter();
165 const Standard_Real aV2bFirst = theASurf2->FirstVParameter();
166 const Standard_Real aV2bLast = theASurf2->LastVParameter();
167
168 Standard_Boolean isOnOrIn = Standard_True;
169 theFactTol = 0.0;
170
171 Standard_Real aDelta = aU1bFirst - theU1;
172 if(aDelta > aTol)
173 {
174 theU1 = aU1bFirst;
175 theFactTol = Max(theFactTol, aDelta);
176 isOnOrIn = Standard_False;
177 }
47cbf134 178
c2c2f2b6 179 aDelta = theU1 - aU1bLast;
180 if(aDelta > aTol)
181 {
182 theU1 = aU1bLast;
183 theFactTol = Max(theFactTol, aDelta);
184 isOnOrIn = Standard_False;
185 }
186
187 aDelta = aV1bFirst - theV1;
188 if(aDelta > aTol)
189 {
190 theV1 = aV1bFirst;
191 theFactTol = Max(theFactTol, aDelta);
192 isOnOrIn = Standard_False;
193 }
47cbf134 194
c2c2f2b6 195 aDelta = theV1 - aV1bLast;
196 if(aDelta > aTol)
197 {
198 theV1 = aV1bLast;
199 theFactTol = Max(theFactTol, aDelta);
200 isOnOrIn = Standard_False;
201 }
202
203 aDelta = aU2bFirst - theU2;
204 if(aDelta > aTol)
205 {
206 theU2 = aU2bFirst;
207 theFactTol = Max(theFactTol, aDelta);
208 isOnOrIn = Standard_False;
209 }
47cbf134 210
c2c2f2b6 211 aDelta = theU2 - aU2bLast;
212 if(aDelta > aTol)
213 {
214 theU2 = aU2bLast;
215 theFactTol = Max(theFactTol, aDelta);
216 isOnOrIn = Standard_False;
217 }
218
219 aDelta = aV2bFirst - theV2;
220 if(aDelta > aTol)
221 {
222 theV2 = aV2bFirst;
223 theFactTol = Max(theFactTol, aDelta);
224 isOnOrIn = Standard_False;
225 }
47cbf134 226
c2c2f2b6 227 aDelta = theV2 - aV2bLast;
228 if(aDelta > aTol)
229 {
230 theV2 = aV2bLast;
231 theFactTol = Max(theFactTol, aDelta);
232 isOnOrIn = Standard_False;
233 }
234
235 return isOnOrIn;
236}
237
7fd59977 238//==================================================================================
239// function : IntWalk_PWalking::IntWalk_PWalking
240// purpose :
241//==================================================================================
47cbf134 242IntWalk_PWalking::IntWalk_PWalking(const Handle(Adaptor3d_HSurface)& Caro1,
243 const Handle(Adaptor3d_HSurface)& Caro2,
00302ba4 244 const Standard_Real TolTangency,
245 const Standard_Real Epsilon,
246 const Standard_Real Deflection,
247 const Standard_Real Increment )
248 :
249
250done(Standard_True),
251close(Standard_False),
252fleche(Deflection),
253tolconf(Epsilon),
254sensCheminement(1),
255myIntersectionOn2S(Caro1,Caro2,TolTangency),
256STATIC_BLOCAGE_SUR_PAS_TROP_GRAND(0),
257STATIC_PRECEDENT_INFLEXION(0)
7fd59977 258{
259 Standard_Real KELARG=20.;
260 //
b1c5c4e6 261 pasMax=Increment*0.2; //-- June 25 99 after problems with precision
47cbf134 262 Um1 = Adaptor3d_HSurfaceTool::FirstUParameter(Caro1);
263 Vm1 = Adaptor3d_HSurfaceTool::FirstVParameter(Caro1);
264 UM1 = Adaptor3d_HSurfaceTool::LastUParameter(Caro1);
265 VM1 = Adaptor3d_HSurfaceTool::LastVParameter(Caro1);
7fd59977 266
47cbf134 267 Um2 = Adaptor3d_HSurfaceTool::FirstUParameter(Caro2);
268 Vm2 = Adaptor3d_HSurfaceTool::FirstVParameter(Caro2);
269 UM2 = Adaptor3d_HSurfaceTool::LastUParameter(Caro2);
270 VM2 = Adaptor3d_HSurfaceTool::LastVParameter(Caro2);
7fd59977 271
47cbf134 272 ResoU1 = Adaptor3d_HSurfaceTool::UResolution(Caro1,Precision::Confusion());
273 ResoV1 = Adaptor3d_HSurfaceTool::VResolution(Caro1,Precision::Confusion());
7fd59977 274
47cbf134 275 ResoU2 = Adaptor3d_HSurfaceTool::UResolution(Caro2,Precision::Confusion());
276 ResoV2 = Adaptor3d_HSurfaceTool::VResolution(Caro2,Precision::Confusion());
7fd59977 277
278 Standard_Real NEWRESO;
279 Standard_Real MAXVAL;
280 Standard_Real MAXVAL2;
281 //
282 MAXVAL = Abs(Um1); MAXVAL2 = Abs(UM1);
283 if(MAXVAL2 > MAXVAL) MAXVAL = MAXVAL2;
284 NEWRESO = ResoU1 * MAXVAL ;
285 if(NEWRESO > ResoU1 &&NEWRESO<10) { ResoU1 = NEWRESO; }
286
287
288 MAXVAL = Abs(Um2); MAXVAL2 = Abs(UM2);
289 if(MAXVAL2 > MAXVAL) MAXVAL = MAXVAL2;
290 NEWRESO = ResoU2 * MAXVAL ;
291 if(NEWRESO > ResoU2 && NEWRESO<10) { ResoU2 = NEWRESO; }
292
293
294 MAXVAL = Abs(Vm1); MAXVAL2 = Abs(VM1);
295 if(MAXVAL2 > MAXVAL) MAXVAL = MAXVAL2;
296 NEWRESO = ResoV1 * MAXVAL ;
297 if(NEWRESO > ResoV1 && NEWRESO<10) { ResoV1 = NEWRESO; }
298
299
300 MAXVAL = Abs(Vm2); MAXVAL2 = Abs(VM2);
301 if(MAXVAL2 > MAXVAL) MAXVAL = MAXVAL2;
302 NEWRESO = ResoV2 * MAXVAL ;
303 if(NEWRESO > ResoV2 && NEWRESO<10) { ResoV2 = NEWRESO; }
304
305 pasuv[0]=pasMax*Abs(UM1-Um1);
306 pasuv[1]=pasMax*Abs(VM1-Vm1);
307 pasuv[2]=pasMax*Abs(UM2-Um2);
308 pasuv[3]=pasMax*Abs(VM2-Vm2);
309
310 if(ResoU1>0.0001*pasuv[0]) ResoU1=0.00001*pasuv[0];
311 if(ResoV1>0.0001*pasuv[1]) ResoV1=0.00001*pasuv[1];
312 if(ResoU2>0.0001*pasuv[2]) ResoU2=0.00001*pasuv[2];
313 if(ResoV2>0.0001*pasuv[3]) ResoV2=0.00001*pasuv[3];
314
315
47cbf134 316 if(Adaptor3d_HSurfaceTool::IsUPeriodic(Caro1)==Standard_False) {
e9a6ce82 317 //UM1+=KELARG*pasuv[0]; Um1-=KELARG*pasuv[0];
7fd59977 318 }
319 else {
320 Standard_Real t = UM1-Um1;
47cbf134 321 if(t<Adaptor3d_HSurfaceTool::UPeriod(Caro1)) {
322 t=0.5*(Adaptor3d_HSurfaceTool::UPeriod(Caro1)-t);
7fd59977 323 t=(t>KELARG*pasuv[0])? KELARG*pasuv[0] : t;
324 UM1+=t; Um1-=t;
325 }
326 }
00302ba4 327
47cbf134 328 if(Adaptor3d_HSurfaceTool::IsVPeriodic(Caro1)==Standard_False) {
e9a6ce82 329 //VM1+=KELARG*pasuv[1]; Vm1-=KELARG*pasuv[1];
7fd59977 330 }
331 else {
332 Standard_Real t = VM1-Vm1;
47cbf134 333 if(t<Adaptor3d_HSurfaceTool::VPeriod(Caro1)) {
334 t=0.5*(Adaptor3d_HSurfaceTool::VPeriod(Caro1)-t);
7fd59977 335 t=(t>KELARG*pasuv[1])? KELARG*pasuv[1] : t;
336 VM1+=t; Vm1-=t;
337 }
338 }
00302ba4 339
47cbf134 340 if(Adaptor3d_HSurfaceTool::IsUPeriodic(Caro2)==Standard_False) {
e9a6ce82 341 //UM2+=KELARG*pasuv[2]; Um2-=KELARG*pasuv[2];
7fd59977 342 }
343 else {
344 Standard_Real t = UM2-Um2;
47cbf134 345 if(t<Adaptor3d_HSurfaceTool::UPeriod(Caro2)) {
346 t=0.5*(Adaptor3d_HSurfaceTool::UPeriod(Caro2)-t);
7fd59977 347 t=(t>KELARG*pasuv[2])? KELARG*pasuv[2] : t;
348 UM2+=t; Um2-=t;
349 }
350 }
00302ba4 351
47cbf134 352 if(Adaptor3d_HSurfaceTool::IsVPeriodic(Caro2)==Standard_False) {
e9a6ce82 353 //VM2+=KELARG*pasuv[3]; Vm2-=KELARG*pasuv[3];
7fd59977 354 }
355 else {
356 Standard_Real t = VM2-Vm2;
47cbf134 357 if(t<Adaptor3d_HSurfaceTool::VPeriod(Caro2)) {
358 t=0.5*(Adaptor3d_HSurfaceTool::VPeriod(Caro2)-t);
7fd59977 359 t=(t>KELARG*pasuv[3])? KELARG*pasuv[3] : t;
360 VM2+=t; Vm2-=t;
361 }
362 }
363
364 //-- ComputePasInit(pasuv,Um1,UM1,Vm1,VM1,Um2,UM2,Vm2,VM2,Caro1,Caro2);
365
366 for (Standard_Integer i = 0; i<=3;i++) {
367 if(pasuv[i]>10)
368 pasuv[i] = 10;
369 pasInit[i] = pasSav[i] = pasuv[i];
370 }
371
372
373}
374//==================================================================================
375// function : IntWalk_PWalking
376// purpose :
377//==================================================================================
47cbf134 378IntWalk_PWalking::IntWalk_PWalking(const Handle(Adaptor3d_HSurface)& Caro1,
379 const Handle(Adaptor3d_HSurface)& Caro2,
00302ba4 380 const Standard_Real TolTangency,
381 const Standard_Real Epsilon,
382 const Standard_Real Deflection,
383 const Standard_Real Increment,
384 const Standard_Real U1,
385 const Standard_Real V1,
386 const Standard_Real U2,
387 const Standard_Real V2)
388 :
389
390done(Standard_True),
391close(Standard_False),
392fleche(Deflection),
393tolconf(Epsilon),
394sensCheminement(1),
395myIntersectionOn2S(Caro1,Caro2,TolTangency),
396STATIC_BLOCAGE_SUR_PAS_TROP_GRAND(0),
397STATIC_PRECEDENT_INFLEXION(0)
7fd59977 398{
399 Standard_Real KELARG=20.;
400 //
b1c5c4e6 401 pasMax=Increment*0.2; //-- June 25 99 after problems with precision
7fd59977 402 //
47cbf134 403 Um1 = Adaptor3d_HSurfaceTool::FirstUParameter(Caro1);
404 Vm1 = Adaptor3d_HSurfaceTool::FirstVParameter(Caro1);
405 UM1 = Adaptor3d_HSurfaceTool::LastUParameter(Caro1);
406 VM1 = Adaptor3d_HSurfaceTool::LastVParameter(Caro1);
7fd59977 407
47cbf134 408 Um2 = Adaptor3d_HSurfaceTool::FirstUParameter(Caro2);
409 Vm2 = Adaptor3d_HSurfaceTool::FirstVParameter(Caro2);
410 UM2 = Adaptor3d_HSurfaceTool::LastUParameter(Caro2);
411 VM2 = Adaptor3d_HSurfaceTool::LastVParameter(Caro2);
7fd59977 412
47cbf134 413 ResoU1 = Adaptor3d_HSurfaceTool::UResolution(Caro1,Precision::Confusion());
414 ResoV1 = Adaptor3d_HSurfaceTool::VResolution(Caro1,Precision::Confusion());
7fd59977 415
47cbf134 416 ResoU2 = Adaptor3d_HSurfaceTool::UResolution(Caro2,Precision::Confusion());
417 ResoV2 = Adaptor3d_HSurfaceTool::VResolution(Caro2,Precision::Confusion());
7fd59977 418 //
419 Standard_Real NEWRESO, MAXVAL, MAXVAL2;
420 //
421 MAXVAL = Abs(Um1);
422 MAXVAL2 = Abs(UM1);
423 if(MAXVAL2 > MAXVAL) {
424 MAXVAL = MAXVAL2;
425 }
426 NEWRESO = ResoU1 * MAXVAL ;
427 if(NEWRESO > ResoU1) {
428 ResoU1 = NEWRESO;
429 }
430 //
431 MAXVAL = Abs(Um2);
432 MAXVAL2 = Abs(UM2);
433 if(MAXVAL2 > MAXVAL){
434 MAXVAL = MAXVAL2;
435 }
436 NEWRESO = ResoU2 * MAXVAL ;
437 if(NEWRESO > ResoU2) {
438 ResoU2 = NEWRESO;
439 }
440 //
441 MAXVAL = Abs(Vm1);
442 MAXVAL2 = Abs(VM1);
443 if(MAXVAL2 > MAXVAL) {
444 MAXVAL = MAXVAL2;
445 }
446 NEWRESO = ResoV1 * MAXVAL ;
447 if(NEWRESO > ResoV1) {
448 ResoV1 = NEWRESO;
449 }
450 //
451 MAXVAL = Abs(Vm2);
452 MAXVAL2 = Abs(VM2);
453 if(MAXVAL2 > MAXVAL){
454 MAXVAL = MAXVAL2;
455 }
456 NEWRESO = ResoV2 * MAXVAL ;
457 if(NEWRESO > ResoV2) {
458 ResoV2 = NEWRESO;
459 }
460 //
461 pasuv[0]=pasMax*Abs(UM1-Um1);
462 pasuv[1]=pasMax*Abs(VM1-Vm1);
463 pasuv[2]=pasMax*Abs(UM2-Um2);
464 pasuv[3]=pasMax*Abs(VM2-Vm2);
465 //
47cbf134 466 if(Adaptor3d_HSurfaceTool::IsUPeriodic(Caro1)==Standard_False) {
7fd59977 467 UM1+=KELARG*pasuv[0];
468 Um1-=KELARG*pasuv[0];
469 }
470 else {
471 Standard_Real t = UM1-Um1;
47cbf134 472 if(t<Adaptor3d_HSurfaceTool::UPeriod(Caro1)) {
473 t=0.5*(Adaptor3d_HSurfaceTool::UPeriod(Caro1)-t);
7fd59977 474 t=(t>KELARG*pasuv[0])? KELARG*pasuv[0] : t;
475 UM1+=t;
476 Um1-=t;
477 }
478 }
479 //
47cbf134 480 if(Adaptor3d_HSurfaceTool::IsVPeriodic(Caro1)==Standard_False) {
7fd59977 481 VM1+=KELARG*pasuv[1];
482 Vm1-=KELARG*pasuv[1];
483 }
484 else {
485 Standard_Real t = VM1-Vm1;
47cbf134 486 if(t<Adaptor3d_HSurfaceTool::VPeriod(Caro1)) {
487 t=0.5*(Adaptor3d_HSurfaceTool::VPeriod(Caro1)-t);
7fd59977 488 t=(t>KELARG*pasuv[1])? KELARG*pasuv[1] : t;
489 VM1+=t; Vm1-=t;
490 }
491 }
492 //
47cbf134 493 if(Adaptor3d_HSurfaceTool::IsUPeriodic(Caro2)==Standard_False) {
7fd59977 494 UM2+=KELARG*pasuv[2];
495 Um2-=KELARG*pasuv[2];
496 }
497 else {
498 Standard_Real t = UM2-Um2;
47cbf134 499 if(t<Adaptor3d_HSurfaceTool::UPeriod(Caro2)) {
500 t=0.5*(Adaptor3d_HSurfaceTool::UPeriod(Caro2)-t);
7fd59977 501 t=(t>KELARG*pasuv[2])? KELARG*pasuv[2] : t;
502 UM2+=t;
503 Um2-=t;
504 }
505 }
00302ba4 506
47cbf134 507 if(Adaptor3d_HSurfaceTool::IsVPeriodic(Caro2)==Standard_False) {
7fd59977 508 VM2+=KELARG*pasuv[3];
509 Vm2-=KELARG*pasuv[3];
510 }
511 else {
512 Standard_Real t = VM2-Vm2;
47cbf134 513 if(t<Adaptor3d_HSurfaceTool::VPeriod(Caro2)) {
514 t=0.5*(Adaptor3d_HSurfaceTool::VPeriod(Caro2)-t);
7fd59977 515 t=(t>KELARG*pasuv[3])? KELARG*pasuv[3] : t;
516 VM2+=t;
517 Vm2-=t;
518 }
519 }
520 //-- ComputePasInit(pasuv,Um1,UM1,Vm1,VM1,Um2,UM2,Vm2,VM2,Caro1,Caro2);
521
522 for (Standard_Integer i = 0; i<=3;i++) {
523 pasInit[i] = pasSav[i] = pasuv[i];
524 }
525
526 if(ResoU1>0.0001*pasuv[0]) ResoU1=0.00001*pasuv[0];
527 if(ResoV1>0.0001*pasuv[1]) ResoV1=0.00001*pasuv[1];
528 if(ResoU2>0.0001*pasuv[2]) ResoU2=0.00001*pasuv[2];
529 if(ResoV2>0.0001*pasuv[3]) ResoV2=0.00001*pasuv[3];
530 //
531 TColStd_Array1OfReal Par(1,4);
532 Par(1) = U1;
533 Par(2) = V1;
534 Par(3) = U2;
535 Par(4) = V2;
536 Perform(Par);
537}
538
539//==================================================================================
540// function : PerformFirstPoint
541// purpose :
542//==================================================================================
543Standard_Boolean IntWalk_PWalking::PerformFirstPoint (const TColStd_Array1OfReal& ParDep,
00302ba4 544 IntSurf_PntOn2S& FirstPoint)
7fd59977 545{
546 sensCheminement = 1;
547 close = Standard_False;
548 //
549 Standard_Integer i;
7fd59977 550 TColStd_Array1OfReal Param(1,4);
551 //
552 for (i=1; i<=4; ++i) {
7fd59977 553 Param(i) = ParDep(i);
554 }
b1c5c4e6 555 //-- calculate the first solution point
7fd59977 556 math_FunctionSetRoot Rsnld(myIntersectionOn2S.Function());
557 //
558 myIntersectionOn2S.Perform(Param,Rsnld);
559 if (!myIntersectionOn2S.IsDone()) {
560 return Standard_False;
561 }
c63628e8 562
7fd59977 563 if (myIntersectionOn2S.IsEmpty()) {
564 return Standard_False;
565 }
c63628e8 566
7fd59977 567 FirstPoint = myIntersectionOn2S.Point();
568 return Standard_True;
569}
570//==================================================================================
571// function : Perform
572// purpose :
573//==================================================================================
574void IntWalk_PWalking::Perform(const TColStd_Array1OfReal& ParDep)
575{
576 Perform(ParDep,Um1,Vm1,Um2,Vm2,UM1,VM1,UM2,VM2);
577}
578//==================================================================================
579// function : Perform
580// purpose :
581//==================================================================================
582void IntWalk_PWalking::Perform(const TColStd_Array1OfReal& ParDep,
00302ba4 583 const Standard_Real u1min,
584 const Standard_Real v1min,
585 const Standard_Real u2min,
586 const Standard_Real v2min,
587 const Standard_Real u1max,
588 const Standard_Real v1max,
589 const Standard_Real u2max,
590 const Standard_Real v2max)
7fd59977 591{
00302ba4 592 const Standard_Real aSQDistMax = 1.0e-14;
7fd59977 593 //xf
00302ba4 594
595 Standard_Integer NbPasOKConseq=0;
596 Standard_Real pasMaxSV[4], aTmp;
7fd59977 597 TColStd_Array1OfReal Param(1,4);
598 IntImp_ConstIsoparametric ChoixIso;
599 //xt
600 //
601 done = Standard_False;
7fd59977 602 //
603 // Caro1 and Caro2
47cbf134 604 const Handle(Adaptor3d_HSurface)& Caro1 =myIntersectionOn2S.Function().AuxillarSurface1();
605 const Handle(Adaptor3d_HSurface)& Caro2 =myIntersectionOn2S.Function().AuxillarSurface2();
7fd59977 606 //
47cbf134 607 const Standard_Real UFirst1 = Adaptor3d_HSurfaceTool::FirstUParameter(Caro1);
608 const Standard_Real VFirst1 = Adaptor3d_HSurfaceTool::FirstVParameter(Caro1);
609 const Standard_Real ULast1 = Adaptor3d_HSurfaceTool::LastUParameter (Caro1);
610 const Standard_Real VLast1 = Adaptor3d_HSurfaceTool::LastVParameter (Caro1);
611
612 const Standard_Real UFirst2 = Adaptor3d_HSurfaceTool::FirstUParameter(Caro2);
613 const Standard_Real VFirst2 = Adaptor3d_HSurfaceTool::FirstVParameter(Caro2);
614 const Standard_Real ULast2 = Adaptor3d_HSurfaceTool::LastUParameter (Caro2);
615 const Standard_Real VLast2 = Adaptor3d_HSurfaceTool::LastVParameter (Caro2);
7fd59977 616 //
617 ComputePasInit(pasuv,u1min,u1max,v1min,v1max,u2min,u2max,v2min,v2max,
00302ba4 618 Um1,UM1,Vm1,VM1,Um2,UM2,Vm2,VM2,Caro1,Caro2,pasMax+pasMax);
7fd59977 619 //
00302ba4 620 if(pasuv[0]<100.0*ResoU1) {
621 pasuv[0]=100.0*ResoU1;
7fd59977 622 }
00302ba4 623 if(pasuv[1]<100.0*ResoV1) {
624 pasuv[1]=100.0*ResoV1;
7fd59977 625 }
00302ba4 626 if(pasuv[2]<100.0*ResoU2) {
627 pasuv[2]=100.0*ResoU2;
7fd59977 628 }
00302ba4 629 if(pasuv[3]<100.0*ResoV2) {
630 pasuv[3]=100.0*ResoV2;
7fd59977 631 }
632 //
00302ba4 633 for (Standard_Integer i=0; i<4; ++i)
634 {
635 if(pasuv[i]>10)
636 {
7fd59977 637 pasuv[i] = 10;
638 }
00302ba4 639
7fd59977 640 pasInit[i] = pasSav[i] = pasuv[i];
641 }
642 //
643 line = new IntSurf_LineOn2S ();
644 //
00302ba4 645 for (Standard_Integer i=1; i<=4; ++i)
646 {
647 aTmp=ParDep(i);
7fd59977 648 Param(i)=ParDep(i);
649 }
b1c5c4e6 650 //-- reproduce steps uv connected to surfaces Caro1 and Caro2
651 //-- pasuv[] and pasSav[] are modified during the marching
00302ba4 652 for(Standard_Integer i = 0; i < 4; ++i)
653 {
654 pasMaxSV[i] = pasSav[i] = pasuv[i] = pasInit[i];
7fd59977 655 }
656
b1c5c4e6 657 //-- calculate the first solution point
7fd59977 658 math_FunctionSetRoot Rsnld(myIntersectionOn2S.Function());
659 //
660 ChoixIso = myIntersectionOn2S.Perform(Param,Rsnld);
00302ba4 661 if (!myIntersectionOn2S.IsDone())
662 {
7fd59977 663 return;
664 }
00302ba4 665
7fd59977 666 //
00302ba4 667 if (myIntersectionOn2S.IsEmpty())
668 {
7fd59977 669 return;
670 }
671 //
00302ba4 672 if(myIntersectionOn2S.IsTangent())
673 {
7fd59977 674 return;
675 }
676 //
677 Standard_Boolean Arrive, DejaReparti;
00302ba4 678 const Standard_Integer RejectIndexMAX = 250000;
7fd59977 679 Standard_Integer IncKey, RejectIndex;
680 gp_Pnt pf,pl;
681 //
682 DejaReparti = Standard_False;
683 IncKey = 0;
684 RejectIndex = 0;
685 //
686 previousPoint = myIntersectionOn2S.Point();
687 previoustg = Standard_False;
688 previousd = myIntersectionOn2S.Direction();
689 previousd1 = myIntersectionOn2S.DirectionOnS1();
690 previousd2 = myIntersectionOn2S.DirectionOnS2();
691 indextg = 1;
692 tgdir = previousd;
693 firstd1 = previousd1;
694 firstd2 = previousd2;
695 tgfirst = tglast = Standard_False;
696 choixIsoSav = ChoixIso;
697 //------------------------------------------------------------
b1c5c4e6 698 //-- Test if the first point of marching corresponds
699 //-- to a point on borders.
700 //-- In this case, DejaReparti is initialized as True
7fd59977 701 //--
702 pf = previousPoint.Value();
703 Standard_Boolean bTestFirstPoint = Standard_True;
00302ba4 704
705 previousPoint.Parameters(Param(1),Param(2),Param(3),Param(4));
7fd59977 706 AddAPoint(line,previousPoint);
707 //
708 IntWalk_StatusDeflection Status = IntWalk_OK;
709 Standard_Boolean NoTestDeflection = Standard_False;
710 Standard_Real SvParam[4], f;
711 Standard_Integer LevelOfEmptyInmyIntersectionOn2S=0;
712 Standard_Integer LevelOfPointConfondu = 0;
713 Standard_Integer LevelOfIterWithoutAppend = -1;
714 //
715 Arrive = Standard_False;
00302ba4 716 while(!Arrive) //010
717 {
7fd59977 718 LevelOfIterWithoutAppend++;
00302ba4 719 if(LevelOfIterWithoutAppend>20)
720 {
7fd59977 721 Arrive = Standard_True;
722 if(DejaReparti) {
00302ba4 723 break;
7fd59977 724 }
725 RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
726 LevelOfIterWithoutAppend = 0;
727 }
728 //
729 // compute f
730 f = 0.;
731 switch (ChoixIso) {
732 case IntImp_UIsoparametricOnCaro1: f = Abs(previousd1.X()); break;
733 case IntImp_VIsoparametricOnCaro1: f = Abs(previousd1.Y()); break;
734 case IntImp_UIsoparametricOnCaro2: f = Abs(previousd2.X()); break;
735 case IntImp_VIsoparametricOnCaro2: f = Abs(previousd2.Y()); break;
736 default:break;
737 }
738 //
739 if(f<0.1) {
740 f=0.1;
741 }
742 //
743 previousPoint.Parameters(Param(1),Param(2),Param(3),Param(4));
744 //
745 //--ofv.begin
746 Standard_Real aIncKey, aEps, dP1, dP2, dP3, dP4;
747 //
748 dP1 = sensCheminement * pasuv[0] * previousd1.X() /f;
749 dP2 = sensCheminement * pasuv[1] * previousd1.Y() /f;
750 dP3 = sensCheminement * pasuv[2] * previousd2.X() /f;
751 dP4 = sensCheminement * pasuv[3] * previousd2.Y() /f;
752 //
753 aIncKey=5.*(Standard_Real)IncKey;
754 aEps=1.e-7;
00302ba4 755 if(ChoixIso == IntImp_UIsoparametricOnCaro1 && Abs(dP1) < aEps)
756 {
7fd59977 757 dP1 *= aIncKey;
758 }
00302ba4 759
760 if(ChoixIso == IntImp_VIsoparametricOnCaro1 && Abs(dP2) < aEps)
761 {
7fd59977 762 dP2 *= aIncKey;
763 }
00302ba4 764
765 if(ChoixIso == IntImp_UIsoparametricOnCaro2 && Abs(dP3) < aEps)
766 {
7fd59977 767 dP3 *= aIncKey;
768 }
00302ba4 769
770 if(ChoixIso == IntImp_VIsoparametricOnCaro2 && Abs(dP4) < aEps)
771 {
7fd59977 772 dP4 *= aIncKey;
773 }
774 //--ofv.end
775 //
776 Param(1) += dP1;
777 Param(2) += dP2;
778 Param(3) += dP3;
779 Param(4) += dP4;
780 //==========================
781 SvParam[0]=Param(1);
782 SvParam[1]=Param(2);
783 SvParam[2]=Param(3);
784 SvParam[3]=Param(4);
785 //
1eaf1cc1 786 Standard_Integer aTryNumber = 0;
787 Standard_Real isBadPoint = Standard_False;
788 IntImp_ConstIsoparametric aBestIso = ChoixIso;
789 do
790 {
791 isBadPoint = Standard_False;
792
793 ChoixIso= myIntersectionOn2S.Perform(Param, Rsnld, aBestIso);
794
795 if (myIntersectionOn2S.IsDone() && !myIntersectionOn2S.IsEmpty())
796 {
797 Standard_Real aNewPnt[4], anAbsParamDist[4];
798 myIntersectionOn2S.Point().Parameters(aNewPnt[0], aNewPnt[1], aNewPnt[2], aNewPnt[3]);
799
800 if (aNewPnt[0] < u1min || aNewPnt[0] > u1max ||
801 aNewPnt[1] < v1min || aNewPnt[1] > v1max ||
802 aNewPnt[2] < u2min || aNewPnt[2] > u2max ||
803 aNewPnt[3] < v2min || aNewPnt[3] > v2max)
804 {
805 break; // Out of borders, handle this later.
806 }
807
808 anAbsParamDist[0] = Abs(Param(1) - dP1 - aNewPnt[0]);
809 anAbsParamDist[1] = Abs(Param(2) - dP2 - aNewPnt[1]);
810 anAbsParamDist[2] = Abs(Param(3) - dP3 - aNewPnt[2]);
811 anAbsParamDist[3] = Abs(Param(4) - dP4 - aNewPnt[3]);
812 if (anAbsParamDist[0] < ResoU1 &&
813 anAbsParamDist[1] < ResoV1 &&
814 anAbsParamDist[2] < ResoU2 &&
815 anAbsParamDist[3] < ResoV2 &&
816 Status != IntWalk_PasTropGrand)
817 {
818 isBadPoint = Standard_True;
819 aBestIso = IntImp_ConstIsoparametric((aBestIso + 1) % 4);
820 }
821 }
822 } while (isBadPoint && ++aTryNumber <= 4);
7fd59977 823 //
00302ba4 824 if (!myIntersectionOn2S.IsDone())
825 {
b1c5c4e6 826 //end of line, division
7fd59977 827 Arrive = Standard_False;
828 Param(1)=SvParam[0];
829 Param(2)=SvParam[1];
830 Param(3)=SvParam[2];
831 Param(4)=SvParam[3];
832 RepartirOuDiviser(DejaReparti, ChoixIso, Arrive);
833 }
00302ba4 834 else //009
835 {
b1c5c4e6 836 //== Calculation of exact point from Param(.) is possible
00302ba4 837 if (myIntersectionOn2S.IsEmpty())
838 {
839 Standard_Real u1,v1,u2,v2;
840 previousPoint.Parameters(u1,v1,u2,v2);
841 //
842 Arrive = Standard_False;
843 if(u1<UFirst1 || u1>ULast1)
844 {
845 Arrive=Standard_True;
846 }
847
848 if(u2<UFirst2 || u2>ULast2)
849 {
850 Arrive=Standard_True;
851 }
852
853 if(v1<VFirst1 || v1>VLast1)
854 {
855 Arrive=Standard_True;
856 }
857
858 if(v2<VFirst2 || v2>VLast2)
859 {
860 Arrive=Standard_True;
861 }
862
863 RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
864 LevelOfEmptyInmyIntersectionOn2S++;
865 //
866 if(LevelOfEmptyInmyIntersectionOn2S>10)
867 {
868 pasuv[0]=pasSav[0];
869 pasuv[1]=pasSav[1];
870 pasuv[2]=pasSav[2];
871 pasuv[3]=pasSav[3];
872 }
7fd59977 873 }
00302ba4 874 else //008
875 {
876 //============================================================
877 //== A point has been found : T E S T D E F L E C T I O N
878 //============================================================
879 if(NoTestDeflection)
880 {
881 NoTestDeflection = Standard_False;
882 }
883 else
884 {
885 if(--LevelOfEmptyInmyIntersectionOn2S<=0)
886 {
887 LevelOfEmptyInmyIntersectionOn2S=0;
888 if(LevelOfIterWithoutAppend < 10)
889 {
890 Status = TestDeflection();
891 }
892 else
893 {
894 pasuv[0]*=0.5;
895 pasuv[1]*=0.5;
896 pasuv[2]*=0.5;
897 pasuv[3]*=0.5;
898 }
899 }
900 }
901
902 //============================================================
903 //== T r a i t e m e n t s u r S t a t u s ==
904 //============================================================
905 if(LevelOfPointConfondu > 5)
906 {
907 Status = IntWalk_ArretSurPoint;
908 LevelOfPointConfondu = 0;
909 }
910 //
911 if(Status==IntWalk_OK)
912 {
913 NbPasOKConseq++;
914 if(NbPasOKConseq >= 5)
915 {
916 NbPasOKConseq=0;
917 Standard_Boolean pastroppetit;
918 Standard_Real t;
919 //
920 do
921 {
922 pastroppetit=Standard_True;
923 //
924 if(pasuv[0]<pasInit[0])
925 {
926 t = (pasInit[0]-pasuv[0])*0.25;
927 if(t>0.1*pasInit[0])
928 {
929 t=0.1*pasuv[0];
930 }
931
932 pasuv[0]+=t;
933 pastroppetit=Standard_False;
934 }
935
936 if(pasuv[1]<pasInit[1])
937 {
938 t = (pasInit[1]-pasuv[1])*0.25;
939 if(t>0.1*pasInit[1]) {
940 t=0.1*pasuv[1];
941 }
942
943 pasuv[1]+=t;
944 pastroppetit=Standard_False;
945 }
946
947 if(pasuv[2]<pasInit[2])
948 {
949 t = (pasInit[2]-pasuv[2])*0.25;
950 if(t>0.1*pasInit[2])
951 {
952 t=0.1*pasuv[2];
953 }
954
955 pasuv[2]+=t;
956 pastroppetit=Standard_False;
957 }
958
959 if(pasuv[3]<pasInit[3])
960 {
961 t = (pasInit[3]-pasuv[3])*0.25;
962 if(t>0.1*pasInit[3]) {
963 t=0.1*pasuv[3];
964 }
965 pasuv[3]+=t;
966 pastroppetit=Standard_False;
967 }
968 if(pastroppetit)
969 {
970 if(pasMax<0.1)
971 {
972 pasMax*=1.1;
973 pasInit[0]*=1.1;
974 pasInit[1]*=1.1;
975 pasInit[2]*=1.1;
976 pasInit[3]*=1.1;
977 }
978 else
979 {
980 pastroppetit=Standard_False;
981 }
982 }
983 }
984 while(pastroppetit);
985 }
986 }//Status==IntWalk_OK
987 else
988 NbPasOKConseq=0;
989
990 //
991 switch(Status)//007
992 {
993 case IntWalk_ArretSurPointPrecedent:
994 {
995 Arrive = Standard_False;
996 RepartirOuDiviser(DejaReparti, ChoixIso, Arrive);
997 break;
998 }
999 case IntWalk_PasTropGrand:
1000 {
1001 Param(1)=SvParam[0];
1002 Param(2)=SvParam[1];
1003 Param(3)=SvParam[2];
1004 Param(4)=SvParam[3];
1005
1006 if(LevelOfIterWithoutAppend > 5)
1007 {
1008 if(pasSav[0]<pasInit[0])
1009 {
1010 pasInit[0]-=(pasInit[0]-pasSav[0])*0.25;
1011 LevelOfIterWithoutAppend=0;
1012 }
1013
1014 if(pasSav[1]<pasInit[1])
1015 {
1016 pasInit[1]-=(pasInit[1]-pasSav[1])*0.25;
1017 LevelOfIterWithoutAppend=0;
1018 }
1019
1020 if(pasSav[2]<pasInit[2])
1021 {
1022 pasInit[2]-=(pasInit[2]-pasSav[2])*0.25;
1023 LevelOfIterWithoutAppend=0;
1024 }
1025
1026 if(pasSav[3]<pasInit[3])
1027 {
1028 pasInit[3]-=(pasInit[3]-pasSav[3])*0.25;
1029 LevelOfIterWithoutAppend=0;
1030 }
1031 }
1032
1033 break;
1034 }
1035 case IntWalk_PointConfondu:
1036 {
1037 LevelOfPointConfondu++;
1038
1039 if(LevelOfPointConfondu>5)
1040 {
1041 Standard_Boolean pastroppetit;
1042 //
1043 do
1044 {
1045 pastroppetit=Standard_True;
1046
1047 if(pasuv[0]<pasInit[0])
1048 {
1049 pasuv[0]+=(pasInit[0]-pasuv[0])*0.25;
1050 pastroppetit=Standard_False;
1051 }
1052
1053 if(pasuv[1]<pasInit[1])
1054 {
1055 pasuv[1]+=(pasInit[1]-pasuv[1])*0.25;
1056 pastroppetit=Standard_False;
1057 }
1058
1059 if(pasuv[2]<pasInit[2])
1060 {
1061 pasuv[2]+=(pasInit[2]-pasuv[2])*0.25;
1062 pastroppetit=Standard_False;
1063 }
1064
1065 if(pasuv[3]<pasInit[3])
1066 {
1067 pasuv[3]+=(pasInit[3]-pasuv[3])*0.25;
1068 pastroppetit=Standard_False;
1069 }
1070
1071 if(pastroppetit)
1072 {
1073 if(pasMax<0.1)
1074 {
1075 pasMax*=1.1;
1076 pasInit[0]*=1.1;
1077 pasInit[1]*=1.1;
1078 pasInit[2]*=1.1;
1079 pasInit[3]*=1.1;
1080 }
1081 else
1082 {
1083 pastroppetit=Standard_False;
1084 }
1085 }
1086 }
1087 while(pastroppetit);
1088 }
1089
1090 break;
1091 }
1092 case IntWalk_OK:
1093 case IntWalk_ArretSurPoint://006
1094 {
1095 //=======================================================
1096 //== Stop Test t : Frame on Param(.) ==
1097 //=======================================================
1098 //xft arrive here
1099 Arrive = TestArret(DejaReparti,Param,ChoixIso);
1100 // JMB 30th December 1999.
1101 // Some statement below should not be put in comment because they are useful.
1102 // See grid CTO 909 A1 which infinitely loops
1103 if(Arrive==Standard_False && Status==IntWalk_ArretSurPoint)
1104 {
1105 Arrive=Standard_True;
7fd59977 1106#ifdef DEB
00302ba4 1107 cout << "Compile with option DEB : if problems with intersection : ";
1108 cout << "IntWalk_PWalking_1.gxx (lbr le 1erdec98)"<<endl;
7fd59977 1109#endif
00302ba4 1110 }
1111
1112 if(Arrive)
1113 {
1114 NbPasOKConseq = -10;
1115 }
1116
1117 if(!Arrive)//005
1118 {
1119 //=====================================================
1120 //== Param(.) is in the limits ==
1121 //== and does not end a closed line ==
1122 //=====================================================
1123 //== Check on the current point of myInters
1124 Standard_Boolean pointisvalid = Standard_False;
1125 {
1126 Standard_Real u1,v1,u2,v2;
1127 myIntersectionOn2S.Point().Parameters(u1,v1,u2,v2);
1128
1129 //
1130 if(u1 <= UM1 && u2 <= UM2 && v1 <= VM1 &&
1131 v2 <= VM2 && u1 >= Um1 && u2 >= Um2 &&
1132 v1 >= Vm1 && v2 >= Vm2)
1133 {
1134 pointisvalid=Standard_True;
1135 }
1136 }
1137
1138 //
1139 if(pointisvalid)
1140 {
1141 previousPoint = myIntersectionOn2S.Point();
1142 previoustg = myIntersectionOn2S.IsTangent();
1143
1144 if(!previoustg)
1145 {
1146 previousd = myIntersectionOn2S.Direction();
1147 previousd1 = myIntersectionOn2S.DirectionOnS1();
1148 previousd2 = myIntersectionOn2S.DirectionOnS2();
1149 }
1150 //=====================================================
1151 //== Check on the previous Point
1152 {
1153 Standard_Real u1,v1,u2,v2;
1154 previousPoint.Parameters(u1,v1,u2,v2);
1155 if( u1 <= UM1 && u2 <= UM2 && v1 <= VM1 &&
1156 v2 <= VM2 && u1 >= Um1 && u2 >= Um2 &&
1157 v1 >= Vm1 && v2 >= Vm2)
1158 {
1159 pl = previousPoint.Value();
1160 if(bTestFirstPoint)
1161 {
1162 if(pf.SquareDistance(pl) < aSQDistMax)
1163 {
1164 IncKey++;
1165 if(IncKey == 5000)
1166 return;
1167 else
1168 continue;
1169 }
1170 else
1171 {
1172 bTestFirstPoint = Standard_False;
1173 }
1174 }
1175 //
1176 AddAPoint(line,previousPoint);
1177 RejectIndex++;
1178
1179 if(RejectIndex >= RejectIndexMAX)
1180 {
1181 break;
1182 }
1183
1184 //
1185 LevelOfIterWithoutAppend = 0;
1186 }
1187 }
1188 }//pointisvalid
1189 //====================================================
1190
1191 if(Status == IntWalk_ArretSurPoint)
1192 {
1193 RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
1194 }
1195 else
1196 {
1197 if (line->NbPoints() == 2)
1198 {
1199 pasSav[0] = pasuv[0];
1200 pasSav[1] = pasuv[1];
1201 pasSav[2] = pasuv[2];
1202 pasSav[3] = pasuv[3];
1203 }
1204 }
1205 }//005 if(!Arrive)
1206 else //004
1207 {
1208 if(close)
1209 {
1210 //================= la ligne est fermee ===============
1211 AddAPoint(line,line->Value(1)); //ligne fermee
1212 LevelOfIterWithoutAppend=0;
1213 }
1214 else //$$$
1215 {
1216 //====================================================
1217 //== Param was not in the limits (was reframed)
1218 //====================================================
1219 Standard_Boolean bPrevNotTangent = !previoustg || !myIntersectionOn2S.IsTangent();
1220
1221 IntImp_ConstIsoparametric SauvChoixIso = ChoixIso;
1222 ChoixIso = myIntersectionOn2S.Perform(Param,Rsnld,ChoixIso);
1223 //
1224 if(!myIntersectionOn2S.IsEmpty()) //002
1225 {
1226 // mutially outpasses in the square or intersection in corner
1227
1228 if(TestArret(Standard_True,Param,ChoixIso))
1229 {
1230 NbPasOKConseq = -10;
1231 ChoixIso = myIntersectionOn2S.Perform(Param,Rsnld,ChoixIso);
1232
1233 if(!myIntersectionOn2S.IsEmpty())
1234 {
1235 previousPoint = myIntersectionOn2S.Point();
1236 previoustg = myIntersectionOn2S.IsTangent();
1237
1238 if (!previoustg)
1239 {
1240 previousd = myIntersectionOn2S.Direction();
1241 previousd1 = myIntersectionOn2S.DirectionOnS1();
1242 previousd2 = myIntersectionOn2S.DirectionOnS2();
1243 }
1244
1245 pl = previousPoint.Value();
1246
1247 if(bTestFirstPoint)
1248 {
1249 if(pf.SquareDistance(pl) < aSQDistMax)
1250 {
1251 IncKey++;
1252 if(IncKey == 5000)
1253 return;
1254 else
1255 continue;
1256 }
1257 else
1258 {
1259 bTestFirstPoint = Standard_False;
1260 }
1261 }
1262 //
1263 AddAPoint(line,previousPoint);
1264 RejectIndex++;
1265
1266 if(RejectIndex >= RejectIndexMAX)
1267 {
1268 break;
1269 }
1270
1271 //
1272 LevelOfIterWithoutAppend=0;
1273 RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
1274 }
1275 else
1276 {
1277 //fail framing divides the step
1278 Arrive = Standard_False;
1279 RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
1280 NoTestDeflection = Standard_True;
1281 ChoixIso = SauvChoixIso;
1282 }
1283 }//if(TestArret())
1284 else
1285 {
1286 // save the last point
1287 // to revert to it if the current point is out of bounds
1288
1289 IntSurf_PntOn2S previousPointSave = previousPoint;
1290 Standard_Boolean previoustgSave = previoustg;
1291 gp_Dir previousdSave = previousd;
1292 gp_Dir2d previousd1Save = previousd1;
1293 gp_Dir2d previousd2Save = previousd2;
1294
1295 previousPoint = myIntersectionOn2S.Point();
1296 previoustg = myIntersectionOn2S.IsTangent();
1297 Arrive = Standard_False;
1298
1299 if(!previoustg)
1300 {
1301 previousd = myIntersectionOn2S.Direction();
1302 previousd1 = myIntersectionOn2S.DirectionOnS1();
1303 previousd2 = myIntersectionOn2S.DirectionOnS2();
1304 }
1305
1306 //========================================
1307 //== Check on PreviousPoint @@
1308
1309 {
1310 Standard_Real u1,v1,u2,v2;
1311 previousPoint.Parameters(u1,v1,u2,v2);
1312
b1c5c4e6 1313 //To save initial 2d points
1314 gp_Pnt2d ParamPntOnS1(Param(1), Param(2));
1315 gp_Pnt2d ParamPntOnS2(Param(3), Param(4));
00302ba4 1316
b1c5c4e6 1317 ///////////////////////////
00302ba4 1318 Param(1) = u1;
1319 Param(2) = v1;
1320 Param(3) = u2;
1321 Param(4) = v2;
1322 //
1323
1324 //xf
1325 Standard_Boolean bFlag1, bFlag2;
1326 Standard_Real aTol2D=1.e-11;
1327 //
1328 bFlag1=u1 >= Um1-aTol2D && v1 >= Vm1-aTol2D && u1 <= UM1+aTol2D && v1 <= VM1+aTol2D;
1329 bFlag2=u2 >= Um2-aTol2D && v2 >= Vm2-aTol2D && u2 <= UM2+aTol2D && v2 <= VM2+aTol2D;
1330 if (bFlag1 && bFlag2)
1331 {
1332 /*
1333 if(u1 <= UM1 && u2 <= UM2 && v1 <= VM1 &&
1334 v2 <= VM2 && u1 >= Um1 && u2 >= Um2 &&
1335 v1 >= Vm1 && v2 >= Vm2) {
1336 */
1337 //xt
1338 pl = previousPoint.Value();
1339
1340 if(bTestFirstPoint)
1341 {
1342 if(pf.SquareDistance(pl) < aSQDistMax)
1343 {
1344 IncKey++;
1345
1346 if(IncKey == 5000)
1347 return;
1348 else
1349 continue;
1350 }
1351 else
1352 {
1353 bTestFirstPoint = Standard_False;
1354 }
1355 }
1356
b1c5c4e6 1357 //To avoid walking around the same point
1358 //in the tangent zone near a border
00302ba4 1359
b1c5c4e6 1360 if (previoustg)
1361 {
1362 Standard_Real prevU1, prevV1, prevU2, prevV2;
1363 previousPointSave.Parameters(prevU1, prevV1, prevU2, prevV2);
1364 gp_Pnt2d prevPntOnS1(prevU1, prevV1), prevPntOnS2(prevU2, prevV2);
1365 gp_Pnt2d curPntOnS1(u1, v1), curPntOnS2(u2, v2);
1366 gp_Vec2d PrevToParamOnS1(prevPntOnS1, ParamPntOnS1);
1367 gp_Vec2d PrevToCurOnS1(prevPntOnS1, curPntOnS1);
1368 gp_Vec2d PrevToParamOnS2(prevPntOnS2, ParamPntOnS2);
1369 gp_Vec2d PrevToCurOnS2(prevPntOnS2, curPntOnS2);
1370 Standard_Real MaxAngle = 3*M_PI/4;
00302ba4 1371
b1c5c4e6 1372 if (Abs(PrevToParamOnS1.Angle(PrevToCurOnS1)) > MaxAngle &&
00302ba4 1373 Abs(PrevToParamOnS2.Angle(PrevToCurOnS2)) > MaxAngle)
b1c5c4e6 1374 {
1375 Arrive = Standard_True;
1376 break;
1377 }
1378 }
00302ba4 1379
b1c5c4e6 1380 ////////////////////////////////////////
00302ba4 1381 AddAPoint(line,previousPoint);
1382 RejectIndex++;
1383
1384 if(RejectIndex >= RejectIndexMAX)
1385 {
1386 break;
1387 }
1388
1389 //
1390
1391 LevelOfIterWithoutAppend=0;
1392 Arrive = Standard_True;
1393 }
1394 else
1395 {
1396 // revert to the last correctly calculated point
1397 previousPoint = previousPointSave;
1398 previoustg = previoustgSave;
1399 previousd = previousdSave;
1400 previousd1 = previousd1Save;
1401 previousd2 = previousd2Save;
1402 }
1403 }
1404
1405 //
1406 Standard_Boolean wasExtended = Standard_False;
1407
1408 if(Arrive && myIntersectionOn2S.IsTangent() && bPrevNotTangent)
1409 {
1410 if(ExtendLineInCommonZone(SauvChoixIso, DejaReparti))
1411 {
1412 wasExtended = Standard_True;
1413 Arrive = Standard_False;
1414 ChoixIso = SauvChoixIso;
1415 }
1416 }
1417
1418 RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
1419
1420 if(Arrive &&
1421 myIntersectionOn2S.IsDone() && !myIntersectionOn2S.IsEmpty() &&
1422 myIntersectionOn2S.IsTangent() && bPrevNotTangent &&
1423 !wasExtended)
1424 {
1425 if(ExtendLineInCommonZone(SauvChoixIso, DejaReparti))
1426 {
1427 wasExtended = Standard_True;
1428 Arrive = Standard_False;
1429 ChoixIso = SauvChoixIso;
1430 }
1431 }
1432 }//else !TestArret() $
1433 }//$$ end successful framing on border (!myIntersectionOn2S.IsEmpty())
1434 else
1435 {
1436 //echec framing on border; division of step
1437 Arrive = Standard_False;
1438 NoTestDeflection = Standard_True;
1439 RepartirOuDiviser(DejaReparti,ChoixIso,Arrive);
1440 }
1441 }//$$$ end framing on border (!close)
1442 }//004 fin TestArret return Arrive = True
1443 } // 006case IntWalk_ArretSurPoint: end Processing Status = OK or ArretSurPoint
1444 } //007 switch(Status)
b1c5c4e6 1445 } //008 end processing point (TEST DEFLECTION)
1446 } //009 end processing line (else if myIntersectionOn2S.IsDone())
1447 } //010 end if first departure point allows marching while (!Arrive)
00302ba4 1448
7fd59977 1449 done = Standard_True;
1450}
1451// ===========================================================================================================
1452// function: ExtendLineInCommonZone
1453// purpose: Extends already computed line inside tangent zone in the direction given by theChoixIso.
1454// Returns Standard_True if the line was extended through tangent zone and the last computed point
1455// is outside the tangent zone (but it is not put into the line). Otherwise returns Standard_False.
1456// ===========================================================================================================
1457Standard_Boolean IntWalk_PWalking::ExtendLineInCommonZone(const IntImp_ConstIsoparametric theChoixIso,
00302ba4 1458 const Standard_Boolean theDirectionFlag)
7fd59977 1459{
1460 Standard_Boolean bOutOfTangentZone = Standard_False;
1461 Standard_Boolean bStop = !myIntersectionOn2S.IsTangent();
1462 Standard_Integer dIncKey = 1;
1463 TColStd_Array1OfReal Param(1,4);
1464 IntWalk_StatusDeflection Status = IntWalk_OK;
1465 Standard_Integer nbIterWithoutAppend = 0;
1466 Standard_Integer nbEqualPoints = 0;
1467 Standard_Integer parit = 0;
1468 Standard_Integer uvit = 0;
1469 IntSurf_SequenceOfPntOn2S aSeqOfNewPoint;
1470
1471 while (!bStop) {
1472 nbIterWithoutAppend++;
1473
1474 if((nbIterWithoutAppend > 20) || (nbEqualPoints > 20)) {
1475#ifdef DEB
1476 cout<<"Compile with option DEB:";
1477 cout<<"Infinite loop has detected. Stop iterations (IntWalk_PWalking_1.gxx)" << endl;
1478#endif
1479 bStop = Standard_True;
1480 break;
1481 }
1482 Standard_Real f = 0.;
1483
1484 switch (theChoixIso)
00302ba4 1485 {
1486 case IntImp_UIsoparametricOnCaro1: f = Abs(previousd1.X()); break;
1487 case IntImp_VIsoparametricOnCaro1: f = Abs(previousd1.Y()); break;
1488 case IntImp_UIsoparametricOnCaro2: f = Abs(previousd2.X()); break;
1489 case IntImp_VIsoparametricOnCaro2: f = Abs(previousd2.Y()); break;
1490 }
7fd59977 1491
1492 if(f<0.1) f=0.1;
00302ba4 1493
7fd59977 1494 previousPoint.Parameters(Param(1),Param(2),Param(3),Param(4));
1495
1496 Standard_Real dP1 = sensCheminement * pasuv[0] * previousd1.X() /f;
1497 Standard_Real dP2 = sensCheminement * pasuv[1] * previousd1.Y() /f;
1498 Standard_Real dP3 = sensCheminement * pasuv[2] * previousd2.X() /f;
1499 Standard_Real dP4 = sensCheminement * pasuv[3] * previousd2.Y() /f;
1500
1501 if(theChoixIso == IntImp_UIsoparametricOnCaro1 && Abs(dP1) < 1.e-7) dP1 *= (5. * (Standard_Real)dIncKey);
1502 if(theChoixIso == IntImp_VIsoparametricOnCaro1 && Abs(dP2) < 1.e-7) dP2 *= (5. * (Standard_Real)dIncKey);
1503 if(theChoixIso == IntImp_UIsoparametricOnCaro2 && Abs(dP3) < 1.e-7) dP3 *= (5. * (Standard_Real)dIncKey);
1504 if(theChoixIso == IntImp_VIsoparametricOnCaro2 && Abs(dP4) < 1.e-7) dP4 *= (5. * (Standard_Real)dIncKey);
00302ba4 1505
7fd59977 1506 Param(1) += dP1;
1507 Param(2) += dP2;
1508 Param(3) += dP3;
1509 Param(4) += dP4;
1510 Standard_Real SvParam[4];
1511 IntImp_ConstIsoparametric ChoixIso = theChoixIso;
1512
1513 for(parit = 0; parit < 4; parit++) {
1514 SvParam[parit] = Param(parit+1);
1515 }
1516 math_FunctionSetRoot Rsnld(myIntersectionOn2S.Function());
1517 ChoixIso = myIntersectionOn2S.Perform(Param,Rsnld, theChoixIso);
1518
1519 if (!myIntersectionOn2S.IsDone()) {
1520 return bOutOfTangentZone;
1521 }
1522 else {
1523 if (myIntersectionOn2S.IsEmpty()) {
00302ba4 1524 return bOutOfTangentZone;
7fd59977 1525 }
1526
1527 Status = TestDeflection();
1528
1529 if(Status == IntWalk_OK) {
1530
00302ba4 1531 for(uvit = 0; uvit < 4; uvit++) {
1532 if(pasuv[uvit] < pasInit[uvit]) {
1533 pasuv[uvit] = pasInit[uvit];
1534 }
1535 }
7fd59977 1536 }
1537
1538 switch(Status) {
1539 case IntWalk_ArretSurPointPrecedent:
00302ba4 1540 {
1541 bStop = Standard_True;
1542 bOutOfTangentZone = !myIntersectionOn2S.IsTangent();
1543 break;
1544 }
7fd59977 1545 case IntWalk_PasTropGrand:
00302ba4 1546 {
1547 for(parit = 0; parit < 4; parit++) {
1548 Param(parit+1) = SvParam[parit];
1549 }
1550 Standard_Boolean bDecrease = Standard_False;
1551
1552 for(uvit = 0; uvit < 4; uvit++) {
1553 if(pasSav[uvit] < pasInit[uvit]) {
1554 pasInit[uvit] -= (pasInit[uvit] - pasSav[uvit]) * 0.1;
1555 bDecrease = Standard_True;
1556 }
1557 }
1558
1559 if(bDecrease) nbIterWithoutAppend--;
1560 break;
1561 }
7fd59977 1562 case IntWalk_PointConfondu:
00302ba4 1563 {
1564 for(uvit = 0; uvit < 4; uvit++) {
1565 if(pasuv[uvit] < pasInit[uvit]) {
1566 pasuv[uvit] += (pasInit[uvit] - pasuv[uvit]) * 0.1;
1567 }
1568 }
1569 break;
1570 }
7fd59977 1571 case IntWalk_OK:
1572 case IntWalk_ArretSurPoint:
00302ba4 1573 {
1574 //
1575 bStop = TestArret(theDirectionFlag, Param, ChoixIso);
1576 //
1577
1578 //
1579 if(!bStop) {
1580 Standard_Real u11,v11,u12,v12;
1581 myIntersectionOn2S.Point().Parameters(u11,v11,u12,v12);
1582 Standard_Real u21,v21,u22,v22;
1583 previousPoint.Parameters(u21,v21,u22,v22);
1584
1585 if(((fabs(u11-u21) < ResoU1) && (fabs(v11-v21) < ResoV1)) ||
1586 ((fabs(u12-u22) < ResoU2) && (fabs(v12-v22) < ResoV2))) {
1587 nbEqualPoints++;
1588 }
1589 else {
1590 nbEqualPoints = 0;
1591 }
1592 }
1593 //
1594
1595 bStop = bStop || !myIntersectionOn2S.IsTangent();
1596 bOutOfTangentZone = !myIntersectionOn2S.IsTangent();
1597
1598 if(!bStop) {
1599 Standard_Boolean pointisvalid = Standard_False;
1600 Standard_Real u1,v1,u2,v2;
1601 myIntersectionOn2S.Point().Parameters(u1,v1,u2,v2);
1602
1603 if(u1 <= UM1 && u2 <= UM2 && v1 <= VM1 &&
1604 v2 <= VM2 && u1 >= Um1 && u2 >= Um2 &&
1605 v1 >= Vm1 && v2 >= Vm2)
1606 pointisvalid = Standard_True;
1607
1608 if(pointisvalid) {
1609 previousPoint = myIntersectionOn2S.Point();
1610 previoustg = myIntersectionOn2S.IsTangent();
1611
1612 if(!previoustg) {
1613 previousd = myIntersectionOn2S.Direction();
1614 previousd1 = myIntersectionOn2S.DirectionOnS1();
1615 previousd2 = myIntersectionOn2S.DirectionOnS2();
1616 }
1617 Standard_Boolean bAddPoint = Standard_True;
1618
1619 if(line->NbPoints() >= 1) {
1620 gp_Pnt pf = line->Value(1).Value();
1621 gp_Pnt pl = previousPoint.Value();
1622
1623 if(pf.Distance(pl) < Precision::Confusion()) {
1624 dIncKey++;
1625 if(dIncKey == 5000) return bOutOfTangentZone;
1626 else bAddPoint = Standard_False;
1627 }
1628 }
1629
1630 if(bAddPoint) {
1631 aSeqOfNewPoint.Append(previousPoint);
1632 nbIterWithoutAppend = 0;
1633 }
1634 }
1635
1636 if (line->NbPoints() == 2) {
1637 for(uvit = 0; uvit < 4; uvit++) {
1638 pasSav[uvit] = pasuv[uvit];
1639 }
1640 }
1641
1642 if ( !pointisvalid ) {
1643 // decrease step if out of bounds
1644 // otherwise the same calculations will be
1645 // repeated several times
1646 if ( ( u1 > UM1 ) || ( u1 < Um1 ) )
1647 pasuv[0] *= 0.5;
1648
1649 if ( ( v1 > VM1 ) || ( v1 < Vm1 ) )
1650 pasuv[1] *= 0.5;
1651
1652 if ( ( u2 > UM2 ) || ( u2 < Um2 ) )
1653 pasuv[2] *= 0.5;
1654
1655 if ( ( v2 > VM2 ) || ( v2 < Vm2 ) )
1656 pasuv[3] *= 0.5;
1657 }
1658 } // end if(!bStop)
1659 else { //if(bStop)
1660 if(close && (line->NbPoints() >= 1)) {
1661
1662 if(!bOutOfTangentZone) {
1663 aSeqOfNewPoint.Append(line->Value(1)); // line end
1664 }
1665 nbIterWithoutAppend = 0;
1666 }
1667 else {
1668 ChoixIso = myIntersectionOn2S.Perform(Param, Rsnld, theChoixIso);
1669
1670 if(myIntersectionOn2S.IsEmpty()) {
1671 bStop = !myIntersectionOn2S.IsTangent();
1672 bOutOfTangentZone = !myIntersectionOn2S.IsTangent();
1673 }
1674 else {
1675 Standard_Boolean bAddPoint = Standard_True;
1676 Standard_Boolean pointisvalid = Standard_False;
1677
1678 previousPoint = myIntersectionOn2S.Point();
1679 Standard_Real u1,v1,u2,v2;
1680 previousPoint.Parameters(u1,v1,u2,v2);
1681
1682 if(u1 <= UM1 && u2 <= UM2 && v1 <= VM1 &&
1683 v2 <= VM2 && u1 >= Um1 && u2 >= Um2 &&
1684 v1 >= Vm1 && v2 >= Vm2)
1685 pointisvalid = Standard_True;
1686
1687 if(pointisvalid) {
1688
1689 if(line->NbPoints() >= 1) {
1690 gp_Pnt pf = line->Value(1).Value();
1691 gp_Pnt pl = previousPoint.Value();
1692
1693 if(pf.Distance(pl) < Precision::Confusion()) {
1694 dIncKey++;
1695 if(dIncKey == 5000) return bOutOfTangentZone;
1696 else bAddPoint = Standard_False;
1697 }
1698 }
1699
1700 if(bAddPoint && !bOutOfTangentZone) {
1701 aSeqOfNewPoint.Append(previousPoint);
1702 nbIterWithoutAppend = 0;
1703 }
1704 }
1705 }
1706 }
1707 }
1708 break;
1709 }
7fd59977 1710 default:
00302ba4 1711 {
1712 break;
1713 }
7fd59977 1714 }
1715 }
1716 }
1717 Standard_Boolean bExtendLine = Standard_False;
1718 Standard_Real u1 = 0., v1 = 0., u2 = 0., v2 = 0.;
1719
1720 Standard_Integer pit = 0;
1721
1722 for(pit = 0; !bExtendLine && (pit < 2); pit++) {
1723 if(pit == 0)
1724 previousPoint.Parameters(u1,v1,u2,v2);
1725 else {
1726 if(aSeqOfNewPoint.Length() > 0)
00302ba4 1727 aSeqOfNewPoint.Value(aSeqOfNewPoint.Length()).Parameters(u1,v1,u2,v2);
7fd59977 1728 else
00302ba4 1729 break;
7fd59977 1730 }
1731
1732 if(((u1 - Um1) < ResoU1) ||
00302ba4 1733 ((UM1 - u1) < ResoU1) ||
1734 ((u2 - Um2) < ResoU2) ||
1735 ((UM2 - u2) < ResoU2) ||
1736 ((v1 - Vm1) < ResoV1) ||
1737 ((VM1 - v1) < ResoV1) ||
1738 ((v2 - Vm2) < ResoV2) ||
1739 ((VM2 - v2) < ResoV2))
7fd59977 1740 bExtendLine = Standard_True;
1741 }
1742
1743 if(!bExtendLine) {
1744 // if(Status == IntWalk_OK || Status == IntWalk_ArretSurPoint) {
1745 if(Status == IntWalk_OK) {
1746 bExtendLine = Standard_True;
1747
1748 if(aSeqOfNewPoint.Length() > 1) {
00302ba4 1749 TColStd_Array1OfReal FirstParams(0, 3), LastParams(0, 3), Resolutions(0, 3);
1750 Resolutions(0) = ResoU1; Resolutions(1) = ResoV1; Resolutions(2) = ResoU2; Resolutions(3) = ResoV2;
1751
1752 aSeqOfNewPoint(1).Parameters(FirstParams.ChangeValue(0), FirstParams.ChangeValue(1),
1753 FirstParams.ChangeValue(2), FirstParams.ChangeValue(3));
1754 aSeqOfNewPoint(aSeqOfNewPoint.Length()).Parameters(LastParams.ChangeValue(0),
1755 LastParams.ChangeValue(1),
1756 LastParams.ChangeValue(2),
1757 LastParams.ChangeValue(3));
1758 Standard_Integer indexofiso = 0;
1759
1760 if(theChoixIso == IntImp_UIsoparametricOnCaro1) indexofiso = 0;
1761 if(theChoixIso == IntImp_VIsoparametricOnCaro1) indexofiso = 1;
1762 if(theChoixIso == IntImp_UIsoparametricOnCaro2) indexofiso = 2;
1763 if(theChoixIso == IntImp_VIsoparametricOnCaro2) indexofiso = 3;
1764
1765 Standard_Integer afirstindex = (indexofiso < 2) ? 0 : 2;
1766 gp_Vec2d aTangentZoneDir(gp_Pnt2d(FirstParams.Value(afirstindex), FirstParams.Value(afirstindex + 1)),
1767 gp_Pnt2d(LastParams.Value(afirstindex), LastParams.Value(afirstindex + 1)));
1768
1769 gp_Dir2d anIsoDir(0, 1);
1770
1771 if((indexofiso == 1) || (indexofiso == 3))
1772 anIsoDir = gp_Dir2d(1, 0);
1773
1774 if(aTangentZoneDir.SquareMagnitude() > gp::Resolution()) {
1775 Standard_Real piquota = M_PI*0.25;
1776
1777 if(fabs(aTangentZoneDir.Angle(anIsoDir)) > piquota) {
1778 Standard_Integer ii = 1, nextii = 2;
1779 gp_Vec2d d1(0, 0);
1780 Standard_Real asqresol = gp::Resolution();
1781 asqresol *= asqresol;
1782
1783 do {
1784 aSeqOfNewPoint(ii).Parameters(FirstParams.ChangeValue(0), FirstParams.ChangeValue(1),
1785 FirstParams.ChangeValue(2), FirstParams.ChangeValue(3));
1786 aSeqOfNewPoint(ii + 1).Parameters(LastParams.ChangeValue(0), LastParams.ChangeValue(1),
1787 LastParams.ChangeValue(2), LastParams.ChangeValue(3));
1788 d1 = gp_Vec2d(gp_Pnt2d(FirstParams.Value(afirstindex),
1789 FirstParams.Value(afirstindex + 1)),
1790 gp_Pnt2d(LastParams.Value(afirstindex),
1791 LastParams.Value(afirstindex + 1)));
1792 ii++;
1793 }
1794 while((d1.SquareMagnitude() < asqresol) &&
1795 (ii < aSeqOfNewPoint.Length()));
1796
1797 nextii = ii;
1798
1799 while(nextii < aSeqOfNewPoint.Length()) {
1800
1801 gp_Vec2d nextd1(0, 0);
1802 Standard_Integer jj = nextii;
1803
1804 do {
1805 aSeqOfNewPoint(jj).Parameters(FirstParams.ChangeValue(0), FirstParams.ChangeValue(1),
1806 FirstParams.ChangeValue(2), FirstParams.ChangeValue(3));
1807 aSeqOfNewPoint(jj + 1).Parameters(LastParams.ChangeValue(0), LastParams.ChangeValue(1),
1808 LastParams.ChangeValue(2), LastParams.ChangeValue(3));
1809 nextd1 = gp_Vec2d(gp_Pnt2d(FirstParams.Value(afirstindex),
1810 FirstParams.Value(afirstindex + 1)),
1811 gp_Pnt2d(LastParams.Value(afirstindex),
1812 LastParams.Value(afirstindex + 1)));
1813 jj++;
1814
1815 }
1816 while((nextd1.SquareMagnitude() < asqresol) &&
1817 (jj < aSeqOfNewPoint.Length()));
1818 nextii = jj;
1819
1820 if(fabs(d1.Angle(nextd1)) > piquota) {
1821 bExtendLine = Standard_False;
1822 break;
1823 }
1824 d1 = nextd1;
1825 }
1826 }
1827 // end if(fabs(aTangentZoneDir.Angle(anIsoDir)
1828 }
7fd59977 1829 }
1830 }
1831 }
1832
1833 if(!bExtendLine) {
1834 return Standard_False;
1835 }
1836 Standard_Integer i = 0;
1837
1838 for(i = 1; i <= aSeqOfNewPoint.Length(); i++) {
1839 AddAPoint(line, aSeqOfNewPoint.Value(i));
1840 }
1841
1842 return bOutOfTangentZone;
1843}
00302ba4 1844
c2c2f2b6 1845//=======================================================================
1846//function : DistanceMinimizeByGradient
1847//purpose :
1848//=======================================================================
1849Standard_Boolean IntWalk_PWalking::
47cbf134 1850DistanceMinimizeByGradient( const Handle(Adaptor3d_HSurface)& theASurf1,
1851 const Handle(Adaptor3d_HSurface)& theASurf2,
1852 Standard_Real& theU1,
1853 Standard_Real& theV1,
1854 Standard_Real& theU2,
1855 Standard_Real& theV2,
1856 const Standard_Real theStep0U1V1,
1857 const Standard_Real theStep0U2V2)
00302ba4 1858{
1859 const Standard_Integer aNbIterMAX = 60;
1860 const Standard_Real aTol = 1.0e-14;
1861 Handle(Geom_Surface) aS1, aS2;
1862
1863 switch(theASurf1->GetType())
1864 {
1865 case GeomAbs_BezierSurface:
1866 aS1 = theASurf1->Surface().Bezier();
1867 break;
1868 case GeomAbs_BSplineSurface:
1869 aS1 = theASurf1->Surface().BSpline();
1870 break;
1871 default:
1872 return Standard_True;
1873 }
1874
1875 switch(theASurf2->GetType())
1876 {
1877 case GeomAbs_BezierSurface:
1878 aS2 = theASurf2->Surface().Bezier();
1879 break;
1880 case GeomAbs_BSplineSurface:
1881 aS2 = theASurf2->Surface().BSpline();
1882 break;
1883 default:
1884 return Standard_True;
1885 }
1886
1887 Standard_Boolean aStatus = Standard_False;
1888
1889 gp_Pnt aP1, aP2;
1890 gp_Vec aD1u, aD1v, aD2U, aD2V;
1891
1892 aS1->D1(theU1, theV1, aP1, aD1u, aD1v);
1893 aS2->D1(theU2, theV2, aP2, aD2U, aD2V);
1894
1895 Standard_Real aSQDistPrev = aP1.SquareDistance(aP2);
1896
1897 gp_Vec aP12(aP1, aP2);
1898
1899 Standard_Real aGradFu(-aP12.Dot(aD1u));
1900 Standard_Real aGradFv(-aP12.Dot(aD1v));
1901 Standard_Real aGradFU( aP12.Dot(aD2U));
1902 Standard_Real aGradFV( aP12.Dot(aD2V));
1903
1904 Standard_Real aSTEPuv = theStep0U1V1, aStepUV = theStep0U2V2;
1905
1906 Standard_Boolean flRepeat = Standard_True;
1907 Standard_Integer aNbIter = aNbIterMAX;
1908
1909 while(flRepeat)
1910 {
1911 Standard_Real anAdd = aGradFu*aSTEPuv;
c2c2f2b6 1912 Standard_Real aPARu = (anAdd >= 0.0)?
47cbf134 1913 (theU1 - Max(anAdd, Epsilon(theU1))) :
1914 (theU1 + Max(-anAdd, Epsilon(theU1)));
00302ba4 1915 anAdd = aGradFv*aSTEPuv;
c2c2f2b6 1916 Standard_Real aPARv = (anAdd >= 0.0)?
47cbf134 1917 (theV1 - Max(anAdd, Epsilon(theV1))) :
1918 (theV1 + Max(-anAdd, Epsilon(theV1)));
00302ba4 1919 anAdd = aGradFU*aStepUV;
c2c2f2b6 1920 Standard_Real aParU = (anAdd >= 0.0)?
47cbf134 1921 (theU2 - Max(anAdd, Epsilon(theU2))) :
1922 (theU2 + Max(-anAdd, Epsilon(theU2)));
00302ba4 1923 anAdd = aGradFV*aStepUV;
c2c2f2b6 1924 Standard_Real aParV = (anAdd >= 0.0)?
47cbf134 1925 (theV2 - Max(anAdd, Epsilon(theV2))) :
1926 (theV2 + Max(-anAdd, Epsilon(theV2)));
00302ba4 1927
1928 gp_Pnt aPt1, aPt2;
1929
1930 aS1->D1(aPARu, aPARv, aPt1, aD1u, aD1v);
1931 aS2->D1(aParU, aParV, aPt2, aD2U, aD2V);
1932
1933 Standard_Real aSQDist = aPt1.SquareDistance(aPt2);
1934
1935 if(aSQDist < aSQDistPrev)
1936 {
1937 aSQDistPrev = aSQDist;
1938 theU1 = aPARu;
1939 theV1 = aPARv;
1940 theU2 = aParU;
1941 theV2 = aParV;
1942
1943 aStatus = aSQDistPrev < aTol;
1944 aSTEPuv *= 1.2;
1945 aStepUV *= 1.2;
1946 }
1947 else
1948 {
1949 if(--aNbIter < 0)
1950 {
1951 flRepeat = Standard_False;
1952 }
1953 else
1954 {
1955 aS1->D1(theU1, theV1, aPt1, aD1u, aD1v);
1956 aS2->D1(theU2, theV2, aPt2, aD2U, aD2V);
1957
1958 gp_Vec aP12(aPt1, aPt2);
1959 aGradFu = -aP12.Dot(aD1u);
1960 aGradFv = -aP12.Dot(aD1v);
1961 aGradFU = aP12.Dot(aD2U);
1962 aGradFV = aP12.Dot(aD2V);
1963 aSTEPuv = theStep0U1V1;
1964 aStepUV = theStep0U2V2;
1965 }
1966 }
1967 }
1968
1969 return aStatus;
1970}
1971
c2c2f2b6 1972//=======================================================================
1973//function : DistanceMinimizeByExtrema
1974//purpose :
1975//=======================================================================
1976Standard_Boolean IntWalk_PWalking::
47cbf134 1977DistanceMinimizeByExtrema(const Handle(Adaptor3d_HSurface)& theASurf,
1978 const gp_Pnt& theP0,
1979 Standard_Real& theU0,
1980 Standard_Real& theV0,
1981 const Standard_Real theStep0U,
1982 const Standard_Real theStep0V)
00302ba4 1983{
1984 const Standard_Real aTol = 1.0e-14;
1985 gp_Pnt aPS;
1986 gp_Vec aD1Su, aD1Sv, aD2Su, aD2Sv, aD2SuvTemp;
1987 Standard_Real aSQDistPrev = RealLast();
1988 Standard_Real aU = theU0, aV = theV0;
47cbf134 1989
00302ba4 1990 Standard_Integer aNbIter = 10;
1991 do
1992 {
1993 theASurf->D2(aU, aV, aPS, aD1Su, aD1Sv, aD2Su, aD2Sv, aD2SuvTemp);
47cbf134 1994
00302ba4 1995 gp_Vec aVec(theP0, aPS);
47cbf134 1996
00302ba4 1997 Standard_Real aSQDist = aVec.SquareMagnitude();
1998
1999 if(aSQDist >= aSQDistPrev)
2000 break;
2001
2002 aSQDistPrev = aSQDist;
2003 theU0 = aU;
2004 theV0 = aV;
2005 aNbIter--;
2006
2007 if(aSQDistPrev < aTol)
2008 break;
2009
2010 //Functions
2011 const Standard_Real aF1 = aD1Su.Dot(aVec), aF2 = aD1Sv.Dot(aVec);
2012
2013 //Derivatives
2014 const Standard_Real aDf1u = aD2Su.Dot(aVec) + aD1Su.Dot(aD1Su),
47cbf134 2015 aDf1v = aD2Su.Dot(aD1Sv),
2016 aDf2u = aDf1v,
2017 aDf2v = aD2Sv.Dot(aVec) + aD1Sv.Dot(aD1Sv);
00302ba4 2018
2019 const Standard_Real aDet = aDf1u*aDf2v - aDf1v*aDf2u;
2020 aU -= theStep0U*(aDf2v*aF1 - aDf1v*aF2)/aDet;
2021 aV += theStep0V*(aDf2u*aF1 - aDf1u*aF2)/aDet;
2022 }
2023 while(aNbIter > 0);
2024
2025 return (aSQDistPrev < aTol);
2026}
2027
c2c2f2b6 2028//=======================================================================
2029//function : SeekPointOnBoundary
2030//purpose :
2031//=======================================================================
2032Standard_Boolean IntWalk_PWalking::
47cbf134 2033SeekPointOnBoundary(const Handle(Adaptor3d_HSurface)& theASurf1,
2034 const Handle(Adaptor3d_HSurface)& theASurf2,
2035 const Standard_Real theU1,
2036 const Standard_Real theV1,
2037 const Standard_Real theU2,
2038 const Standard_Real theV2,
2039 const Standard_Boolean isTheFirst)
c2c2f2b6 2040{
2041 const Standard_Real aTol = 1.0e-14;
2042 Standard_Boolean isOK = Standard_False;
2043 Standard_Real U1prec = theU1, V1prec = theV1, U2prec = theU2, V2prec = theV2;
2044
2045 Standard_Boolean flFinish = Standard_False;
2046
2047 Standard_Integer aNbIter = 20;
2048 while(!flFinish)
2049 {
2050 flFinish = Standard_False;
2051 Standard_Boolean aStatus = Standard_False;
2052
2053 do
2054 {
2055 aNbIter--;
2056 aStatus = DistanceMinimizeByGradient(theASurf1, theASurf2, U1prec, V1prec, U2prec, V2prec);
2057 if(aStatus)
2058 {
2059 break;
2060 }
2061
2062 aStatus = DistanceMinimizeByExtrema(theASurf1, theASurf2->Value(U2prec, V2prec), U1prec, V1prec);
2063 if(aStatus)
2064 {
2065 break;
2066 }
2067
2068 aStatus = DistanceMinimizeByExtrema(theASurf2, theASurf1->Value(U1prec, V1prec), U2prec, V2prec);
2069 if(aStatus)
2070 {
2071 break;
2072 }
2073 }
2074 while(!aStatus && (aNbIter > 0));
2075
2076 if(aStatus)
2077 {
2078 const Standard_Real aTolMax = 1.0e-8;
2079 Standard_Real aTolF = 0.0;
2080
2081 Standard_Real u1 = U1prec, v1 = V1prec, u2 = U2prec, v2 = V2prec;
2082
2083 flFinish = Checking(theASurf1, theASurf2, U1prec, V1prec, U2prec, V2prec, aTolF);
47cbf134 2084
c2c2f2b6 2085 if(aTolF <= aTolMax)
2086 {
2087 gp_Pnt aP1 = theASurf1->Value(u1, v1),
47cbf134 2088 aP2 = theASurf2->Value(u2, v2);
c2c2f2b6 2089 gp_Pnt aPInt(0.5*(aP1.XYZ() + aP2.XYZ()));
2090
2091 const Standard_Real aSQDist1 = aPInt.SquareDistance(aP1),
47cbf134 2092 aSQDist2 = aPInt.SquareDistance(aP2);
c2c2f2b6 2093 if((aSQDist1 < aTol) && (aSQDist2 < aTol))
2094 {
2095 IntSurf_PntOn2S anIP;
2096 anIP.SetValue(aPInt, u1, v1, u2, v2);
47cbf134 2097
c2c2f2b6 2098 if(isTheFirst)
2099 line->InsertBefore(1,anIP);
2100 else
2101 line->Add(anIP);
2102
2103 isOK = Standard_True;
2104 }
2105 }
2106 }
2107 else
2108 {
2109 break;
2110 }
2111
2112 if(aNbIter < 0)
2113 break;
2114 }
2115
2116 return isOK;
2117}
2118
2119//=======================================================================
2120//function : PutToBoundary
2121//purpose :
2122//=======================================================================
2123Standard_Boolean IntWalk_PWalking::
47cbf134 2124PutToBoundary(const Handle(Adaptor3d_HSurface)& theASurf1,
2125 const Handle(Adaptor3d_HSurface)& theASurf2)
c2c2f2b6 2126{
2127 const Standard_Real aTolMin = Precision::Confusion();
2128
2129 Standard_Boolean hasBeenAdded = Standard_False;
2130
2131 const Standard_Real aU1bFirst = theASurf1->FirstUParameter();
2132 const Standard_Real aU1bLast = theASurf1->LastUParameter();
2133 const Standard_Real aU2bFirst = theASurf2->FirstUParameter();
2134 const Standard_Real aU2bLast = theASurf2->LastUParameter();
2135 const Standard_Real aV1bFirst = theASurf1->FirstVParameter();
2136 const Standard_Real aV1bLast = theASurf1->LastVParameter();
2137 const Standard_Real aV2bFirst = theASurf2->FirstVParameter();
2138 const Standard_Real aV2bLast = theASurf2->LastVParameter();
2139
2140 Standard_Real aTol = 1.0;
2141 aTol = Min(aTol, aU1bLast - aU1bFirst);
2142 aTol = Min(aTol, aU2bLast - aU2bFirst);
2143 aTol = Min(aTol, aV1bLast - aV1bFirst);
2144 aTol = Min(aTol, aV2bLast - aV2bFirst)*1.0e-3;
2145
2146 if(aTol <= 2.0*aTolMin)
2147 return hasBeenAdded;
2148
2149 Standard_Boolean isNeedAdding = Standard_False;
2150 Standard_Boolean isU1parallel = Standard_False, isV1parallel = Standard_False;
2151 Standard_Boolean isU2parallel = Standard_False, isV2parallel = Standard_False;
2152 IsParallel(line, Standard_True, aTol, isU1parallel, isV1parallel);
2153 IsParallel(line, Standard_False, aTol, isU2parallel, isV2parallel);
2154
2155 const Standard_Integer aNbPnts = line->NbPoints();
2156 Standard_Real u1, v1, u2, v2;
2157 line->Value(1).Parameters(u1, v1, u2, v2);
2158 Standard_Real aDelta = 0.0;
47cbf134 2159
c2c2f2b6 2160 if(!isV1parallel)
2161 {
2162 aDelta = u1 - aU1bFirst;
2163 if((aTolMin < aDelta) && (aDelta < aTol))
2164 {
2165 u1 = aU1bFirst - aDelta;
2166 isNeedAdding = Standard_True;
2167 }
2168 else
2169 {
2170 aDelta = aU1bLast - u1;
2171 if((aTolMin < aDelta) && (aDelta < aTol))
2172 {
2173 u1 = aU1bLast + aDelta;
2174 isNeedAdding = Standard_True;
2175 }
2176 }
2177 }
2178
2179 if(!isV2parallel)
2180 {
2181 aDelta = u2 - aU2bFirst;
2182 if((aTolMin < aDelta) && (aDelta < aTol))
2183 {
2184 u2 = aU2bFirst - aDelta;
2185 isNeedAdding = Standard_True;
2186 }
2187 else
2188 {
2189 aDelta = aU2bLast - u2;
2190 if((aTolMin < aDelta) && (aDelta < aTol))
2191 {
2192 u2 = aU2bLast + aDelta;
2193 isNeedAdding = Standard_True;
2194 }
2195 }
2196 }
2197
2198 if(!isU1parallel)
2199 {
2200 aDelta = v1 - aV1bFirst;
2201 if((aTolMin < aDelta) && (aDelta < aTol))
2202 {
2203 v1 = aV1bFirst - aDelta;
2204 isNeedAdding = Standard_True;
2205 }
2206 else
2207 {
2208 aDelta = aV1bLast - v1;
2209 if((aTolMin < aDelta) && (aDelta < aTol))
2210 {
2211 v1 = aV1bLast + aDelta;
2212 isNeedAdding = Standard_True;
2213 }
2214 }
2215 }
2216
2217 if(!isU2parallel)
2218 {
2219 aDelta = v2 - aV2bFirst;
2220 if((aTolMin < aDelta) && (aDelta < aTol))
2221 {
2222 v2 = aV2bFirst - aDelta;
2223 isNeedAdding = Standard_True;
2224 }
2225 else
2226 {
2227 aDelta = aV2bLast - v2;
2228 if((aTolMin < aDelta) && (aDelta < aTol))
2229 {
2230 v2 = aV2bLast + aDelta;
2231 isNeedAdding = Standard_True;
2232 }
2233 }
2234 }
2235
2236 if(isNeedAdding)
2237 {
2238 hasBeenAdded =
2239 SeekPointOnBoundary(theASurf1, theASurf2, u1,
47cbf134 2240 v1, u2, v2, Standard_True);
c2c2f2b6 2241 }
2242
2243 isNeedAdding = Standard_False;
2244 line->Value(aNbPnts).Parameters(u1, v1, u2, v2);
2245
2246 if(!isV1parallel)
2247 {
2248 aDelta = u1 - aU1bFirst;
2249 if((aTolMin < aDelta) && (aDelta < aTol))
2250 {
2251 u1 = aU1bFirst - aDelta;
2252 isNeedAdding = Standard_True;
2253 }
2254 else
2255 {
2256 aDelta = aU1bLast - u1;
2257 if((aTolMin < aDelta) && (aDelta < aTol))
2258 {
2259 u1 = aU1bLast + aDelta;
2260 isNeedAdding = Standard_True;
2261 }
2262 }
2263 }
2264
2265 if(!isV2parallel)
2266 {
2267 aDelta = u2 - aU2bFirst;
2268 if((aTolMin < aDelta) && (aDelta < aTol))
2269 {
2270 u2 = aU2bFirst - aDelta;
2271 isNeedAdding = Standard_True;
2272 }
2273 else
2274 {
2275 aDelta = aU2bLast - u2;
2276 if((aTolMin < aDelta) && (aDelta < aTol))
2277 {
2278 u2 = aU2bLast + aDelta;
2279 isNeedAdding = Standard_True;
2280 }
2281 }
2282 }
2283
2284 if(!isU1parallel)
2285 {
2286 aDelta = v1 - aV1bFirst;
2287 if((aTolMin < aDelta) && (aDelta < aTol))
2288 {
2289 v1 = aV1bFirst - aDelta;
2290 isNeedAdding = Standard_True;
2291 }
2292 else
2293 {
2294 aDelta = aV1bLast - v1;
2295 if((aTolMin < aDelta) && (aDelta < aTol))
2296 {
2297 v1 = aV1bLast + aDelta;
2298 isNeedAdding = Standard_True;
2299 }
2300 }
2301 }
2302
2303 if(!isU2parallel)
2304 {
2305 aDelta = v2 - aV2bFirst;
2306 if((aTolMin < aDelta) && (aDelta < aTol))
2307 {
2308 v2 = aV2bFirst - aDelta;
2309 isNeedAdding = Standard_True;
2310 }
2311 else
2312 {
2313 aDelta = aV2bLast - v2;
2314 if((aTolMin < aDelta) && (aDelta < aTol))
2315 {
2316 v2 = aV2bLast + aDelta;
2317 isNeedAdding = Standard_True;
2318 }
2319 }
2320 }
2321
2322 if(isNeedAdding)
2323 {
2324 hasBeenAdded =
2325 SeekPointOnBoundary(theASurf1, theASurf2, u1,
47cbf134 2326 v1, u2, v2, Standard_False);
c2c2f2b6 2327 }
2328
2329 return hasBeenAdded;
2330}
2331
2332//=======================================================================
2333//function : SeekAdditionalPoints
2334//purpose :
2335//=======================================================================
2336Standard_Boolean IntWalk_PWalking::
47cbf134 2337SeekAdditionalPoints( const Handle(Adaptor3d_HSurface)& theASurf1,
2338 const Handle(Adaptor3d_HSurface)& theASurf2,
2339 const Standard_Integer theMinNbPoints)
00302ba4 2340{
2341 const Standard_Real aTol = 1.0e-14;
2342 Standard_Integer aNbPoints = line->NbPoints();
2343 if(aNbPoints > theMinNbPoints)
2344 return Standard_True;
2345
2346 const Standard_Real aU1bFirst = theASurf1->FirstUParameter();
2347 const Standard_Real aU1bLast = theASurf1->LastUParameter();
2348 const Standard_Real aU2bFirst = theASurf2->FirstUParameter();
2349 const Standard_Real aU2bLast = theASurf2->LastUParameter();
2350 const Standard_Real aV1bFirst = theASurf1->FirstVParameter();
2351 const Standard_Real aV1bLast = theASurf1->LastVParameter();
2352 const Standard_Real aV2bFirst = theASurf2->FirstVParameter();
2353 const Standard_Real aV2bLast = theASurf2->LastVParameter();
2354
47cbf134 2355
00302ba4 2356 Standard_Boolean isPrecise = Standard_False;
2357
2358 Standard_Real U1prec = 0.0, V1prec = 0.0, U2prec = 0.0, V2prec = 0.0;
2359
2360 Standard_Integer aNbPointsPrev = 0;
2361 while(aNbPoints < theMinNbPoints && (aNbPoints != aNbPointsPrev))
2362 {
2363 aNbPointsPrev = aNbPoints;
2364 for(Standard_Integer fp = 1, lp = 2; fp < aNbPoints; fp = lp + 1)
2365 {
2366 Standard_Real U1f, V1f, U2f, V2f; //first point in 1st and 2nd surafaces
2367 Standard_Real U1l, V1l, U2l, V2l; //last point in 1st and 2nd surafaces
2368
2369 lp = fp+1;
2370 line->Value(fp).Parameters(U1f, V1f, U2f, V2f);
2371 line->Value(lp).Parameters(U1l, V1l, U2l, V2l);
2372
2373 U1prec = 0.5*(U1f+U1l);
2374 if(U1prec < aU1bFirst)
2375 U1prec = aU1bFirst;
2376 if(U1prec > aU1bLast)
2377 U1prec = aU1bLast;
2378
2379 V1prec = 0.5*(V1f+V1l);
2380 if(V1prec < aV1bFirst)
2381 V1prec = aV1bFirst;
2382 if(V1prec > aV1bLast)
2383 V1prec = aV1bLast;
2384
2385 U2prec = 0.5*(U2f+U2l);
2386 if(U2prec < aU2bFirst)
2387 U2prec = aU2bFirst;
2388 if(U2prec > aU2bLast)
2389 U2prec = aU2bLast;
2390
2391 V2prec = 0.5*(V2f+V2l);
2392 if(V2prec < aV2bFirst)
2393 V2prec = aV2bFirst;
2394 if(V2prec > aV2bLast)
2395 V2prec = aV2bLast;
2396
2397 Standard_Boolean aStatus = Standard_False;
2398 Standard_Integer aNbIter = 5;
2399 do
2400 {
2401 aStatus = DistanceMinimizeByGradient(theASurf1, theASurf2, U1prec, V1prec, U2prec, V2prec);
2402 if(aStatus)
2403 {
2404 break;
2405 }
2406
2407 aStatus = DistanceMinimizeByExtrema(theASurf1, theASurf2->Value(U2prec, V2prec), U1prec, V1prec);
2408 if(aStatus)
2409 {
2410 break;
2411 }
2412
2413 aStatus = DistanceMinimizeByExtrema(theASurf2, theASurf1->Value(U1prec, V1prec), U2prec, V2prec);
2414 if(aStatus)
2415 {
2416 break;
2417 }
2418 }
2419 while(!aStatus && (--aNbIter > 0));
2420
2421 if(aStatus)
2422 {
2423 gp_Pnt aP1 = theASurf1->Value(U1prec, V1prec),
47cbf134 2424 aP2 = theASurf2->Value(U2prec, V2prec);
00302ba4 2425 gp_Pnt aPInt(0.5*(aP1.XYZ() + aP2.XYZ()));
2426
2427 const Standard_Real aSQDist1 = aPInt.SquareDistance(aP1),
47cbf134 2428 aSQDist2 = aPInt.SquareDistance(aP2);
00302ba4 2429
2430 if((aSQDist1 < aTol) && (aSQDist2 < aTol))
2431 {
2432 IntSurf_PntOn2S anIP;
2433 anIP.SetValue(aPInt, U1prec, V1prec, U2prec, V2prec);
2434 line->InsertBefore(lp, anIP);
47cbf134 2435
00302ba4 2436 isPrecise = Standard_True;
2437
2438 if(++aNbPoints >= theMinNbPoints)
2439 break;
2440 }
2441 else
2442 {
2443 lp--;
2444 }
2445 }
2446 }
2447 }
2448
2449 return isPrecise;
2450}
c2c2f2b6 2451
47cbf134 2452void IntWalk_PWalking::
2453RepartirOuDiviser(Standard_Boolean& DejaReparti,
2454 IntImp_ConstIsoparametric& ChoixIso,
2455 Standard_Boolean& Arrive)
2456
2457 // at the neighborhood of a point, there is a fail of marching
2458 // it is required to divide the steps to try to continue
2459 // if the step is too small if we are on border
2460 // restart in another direction if it was not done, otherwise stop
2461
2462{
2463 // Standard_Integer i;
2464 if (Arrive) { //restart in the other direction
2465 if (!DejaReparti ) {
2466 Arrive = Standard_False;
2467 DejaReparti = Standard_True;
2468 previousPoint = line->Value(1);
2469 previoustg = Standard_False;
2470 previousd1 = firstd1;
2471 previousd2 = firstd2;
2472 previousd = tgdir;
2473 indextg = line->NbPoints();
2474 tgdir.Reverse();
2475 line->Reverse();
2476
2477 //-- printf("\nIntWalk_PWalking_2.gxx Reverse %3d\n",indextg);
2478 sensCheminement = -1;
2479 tgfirst = tglast;
2480 tglast = Standard_False;
2481 ChoixIso = choixIsoSav;
2482#if 0
2483 pasuv[0]=pasSav[0];
2484 pasuv[1]=pasSav[1];
2485 pasuv[2]=pasSav[2];
2486 pasuv[3]=pasSav[3];
2487#else
2488 Standard_Real u1,v1,u2,v2;
2489 Standard_Real U1,V1,U2,V2;
2490 Standard_Integer nn=line->NbPoints();
2491 if(nn>2) {
2492 line->Value(nn).Parameters(u1,v1,u2,v2);
2493 line->Value(nn-1).Parameters(U1,V1,U2,V2);
2494 pasuv[0]=Abs(u1-U1);
2495 pasuv[1]=Abs(v1-V1);
2496 pasuv[2]=Abs(u2-U2);
2497 pasuv[3]=Abs(v2-V2);
2498 }
2499#endif
2500
2501 }
2502 }
2503 else {
2504 if ( pasuv[0]*0.5 < ResoU1
2505 && pasuv[1]*0.5 < ResoV1
2506 && pasuv[2]*0.5 < ResoU2
2507 && pasuv[3]*0.5 < ResoV2
2508 ) {
2509 if (!previoustg) {
2510 tglast = Standard_True; // IS IT ENOUGH ????
2511 }
2512
2513 if (!DejaReparti) { //restart in the other direction
2514 DejaReparti = Standard_True;
2515 previousPoint = line->Value(1);
2516 previoustg = Standard_False;
2517 previousd1 = firstd1;
2518 previousd2 = firstd2;
2519 previousd = tgdir;
2520 indextg = line->NbPoints();
2521 tgdir.Reverse();
2522 line->Reverse();
2523
2524 //-- printf("\nIntWalk_PWalking_2.gxx Reverse %3d\n",indextg);
2525
2526 sensCheminement = -1;
2527 tgfirst = tglast;
2528 tglast = Standard_False;
2529 ChoixIso = choixIsoSav;
2530
2531#if 0
2532 pasuv[0]=pasSav[0];
2533 pasuv[1]=pasSav[1];
2534 pasuv[2]=pasSav[2];
2535 pasuv[3]=pasSav[3];
2536#else
2537 Standard_Real u1,v1,u2,v2;
2538 Standard_Real U1,V1,U2,V2;
2539 Standard_Integer nn=line->NbPoints();
2540 if(nn>2) {
2541 line->Value(nn).Parameters(u1,v1,u2,v2);
2542 line->Value(nn-1).Parameters(U1,V1,U2,V2);
2543 pasuv[0]=Abs(u1-U1);
2544 pasuv[1]=Abs(v1-V1);
2545 pasuv[2]=Abs(u2-U2);
2546 pasuv[3]=Abs(v2-V2);
2547 }
2548#endif
2549 }
2550 else Arrive = Standard_True;
2551 }
2552 else {
2553 pasuv[0]*=0.5;
2554 pasuv[1]*=0.5;
2555 pasuv[2]*=0.5;
2556 pasuv[3]*=0.5;
2557 }
2558 }
2559}
2560
2561namespace {
2562 //OCC431(apo): modified ->
2563 static const Standard_Real CosRef2D = Cos(M_PI/9.0), AngRef2D = M_PI/2.0;
2564
2565 static const Standard_Real d = 7.0;
2566}
2567
2568IntWalk_StatusDeflection IntWalk_PWalking::TestDeflection()
2569
2570// test if vector is observed by calculating an increase of vector
2571// or the previous point and its tangent, the new calculated point and its
2572// tangent; it is possible to find a cube passing by the 2 points and having as a
2573// derivative the tangents of the intersection
2574// calculate the point with parameter 0.5 on cube=p1
2575// calculate the medium point of 2 points of intersection=p2
2576// if arrow/2<=||p1p2||<= arrow consider that the vector is observed
2577// otherwise adjust the step depending on the ratio ||p1p2||/vector
2578// and the previous step
2579// test if in 2 tangent planes of surfaces there is no too great angle2d
2580// grand : if yes divide the step
2581// test if there is no change of side
2582//
2583{
2584 if(line->NbPoints() ==1 ) {
2585 STATIC_BLOCAGE_SUR_PAS_TROP_GRAND=STATIC_PRECEDENT_INFLEXION=0;
2586 }
2587
2588 IntWalk_StatusDeflection Status = IntWalk_OK;
2589 Standard_Real FlecheCourante ,Ratio;
2590
2591
2592 const IntSurf_PntOn2S& CurrentPoint = myIntersectionOn2S.Point();
2593 //==================================================================================
2594 //========= S t o p o n p o i n t ============
2595 //==================================================================================
2596 if (myIntersectionOn2S.IsTangent()) {
2597 return IntWalk_ArretSurPoint;
2598 }
2599
2600 const gp_Dir& TgCourante = myIntersectionOn2S.Direction();
2601
2602 //==================================================================================
2603 //========= R i s k o f i n f l e x i o n p o i n t ============
2604 //==================================================================================
2605 if (TgCourante.Dot(previousd)<0) {
2606 //------------------------------------------------------------
2607 //-- Risk of inflexion point : Divide the step by 2
2608 //-- Initialize STATIC_PRECEDENT_INFLEXION so that
2609 //-- at the next call to return Pas_OK if there is no
2610 //-- more risk of the point of inflexion
2611 //------------------------------------------------------------
2612
2613 pasuv[0]*=0.5;
2614 pasuv[1]*=0.5;
2615 pasuv[2]*=0.5;
2616 pasuv[3]*=0.5;
2617 STATIC_PRECEDENT_INFLEXION+=3;
2618 if (pasuv[0] < ResoU1 && pasuv[1] <ResoV1 && pasuv[2] <ResoU2 && pasuv[3] < ResoV2)
2619 return IntWalk_ArretSurPointPrecedent;
2620 else
2621 return IntWalk_PasTropGrand;
2622 }
2623
2624 else {
2625 if(STATIC_PRECEDENT_INFLEXION > 0) {
2626 STATIC_PRECEDENT_INFLEXION -- ;
2627 return IntWalk_OK;
2628 }
2629 }
2630
2631 //==================================================================================
2632 //========= D e t e c t c o n f u s e d P o in t s ===========
2633 //==================================================================================
2634
2635 Standard_Real Dist = previousPoint.Value().
2636 SquareDistance(CurrentPoint.Value());
2637
2638
2639 if (Dist < tolconf*tolconf ) {
2640 pasuv[0] = Max(5.*ResoU1,Min(1.5*pasuv[0],pasInit[0]));
2641 pasuv[1] = Max(5.*ResoV1,Min(1.5*pasuv[1],pasInit[1]));
2642 pasuv[2] = Max(5.*ResoU2,Min(1.5*pasuv[2],pasInit[2]));
2643 pasuv[3] = Max(5.*ResoV2,Min(1.5*pasuv[3],pasInit[3]));
2644 Status = IntWalk_PointConfondu;
2645 }
2646
2647 //==================================================================================
2648 Standard_Real Up1,Vp1,Uc1,Vc1,Du1,Dv1,AbsDu1,AbsDu2,AbsDv1,AbsDv2;
2649 Standard_Real Up2,Vp2,Uc2,Vc2,Du2,Dv2;
2650
2651 previousPoint.Parameters(Up1,Vp1,Up2,Vp2);
2652 CurrentPoint.Parameters(Uc1,Vc1,Uc2,Vc2);
2653
2654 Du1 = Uc1 - Up1; Dv1 = Vc1 - Vp1;
2655 Du2 = Uc2 - Up2; Dv2 = Vc2 - Vp2;
2656
2657 AbsDu1 = Abs(Du1);
2658 AbsDu2 = Abs(Du2);
2659 AbsDv1 = Abs(Dv1);
2660 AbsDv2 = Abs(Dv2);
2661 //=================================================================================
2662 //==== S t e p o f p r o g r e s s i o n (between previous and Current) =======
2663 //=================================================================================
2664 if ( AbsDu1 < ResoU1 && AbsDv1 < ResoV1
2665 && AbsDu2 < ResoU2 && AbsDv2 < ResoV2) {
2666 pasuv[0] = ResoU1; pasuv[1] = ResoV1; pasuv[2] = ResoU2; pasuv[3] = ResoV2;
2667 return(IntWalk_ArretSurPointPrecedent);
2668 }
2669 //==================================================================================
2670
2671 Standard_Real tolArea = 100.0;
2672 if (ResoU1 < Precision::PConfusion() ||
2673 ResoV1 < Precision::PConfusion() ||
2674 ResoU2 < Precision::PConfusion() ||
2675 ResoV2 < Precision::PConfusion() )
2676 tolArea = tolArea*2.0;
2677
2678 Standard_Real Cosi1, CosRef1, Ang1, AngRef1, ResoUV1, Duv1, d1, tolCoeff1;
2679 Standard_Real Cosi2, CosRef2, Ang2, AngRef2, ResoUV2, Duv2, d2, tolCoeff2;
2680 Cosi1 = Du1*previousd1.X() + Dv1*previousd1.Y();
2681 Cosi2 = Du2*previousd2.X() + Dv2*previousd2.Y();
2682 Duv1 = Du1*Du1 + Dv1*Dv1;
2683 Duv2 = Du2*Du2 + Dv2*Dv2;
2684 ResoUV1 = ResoU1*ResoU1 + ResoV1*ResoV1;
2685 ResoUV2 = ResoU2*ResoU2 + ResoV2*ResoV2;
2686 //
2687 //modified by NIZNHY-PKV Wed Nov 13 12:25:44 2002 f
2688 //
2689 Standard_Real aMinDiv2=Precision::Confusion();
2690 aMinDiv2=aMinDiv2*aMinDiv2;
2691 //
2692 d1=d;
2693 if (Duv1>aMinDiv2) {
2694 d1 = Abs(ResoUV1/Duv1);
2695 d1 = Min(Sqrt(d1)*tolArea, d);
2696 }
2697 //d1 = Abs(ResoUV1/Duv1);
2698 //d1 = Min(Sqrt(d1)*tolArea,d);
2699 //modified by NIZNHY-PKV Wed Nov 13 12:34:30 2002 t
2700 tolCoeff1 = Exp(d1);
2701 //
2702 //modified by NIZNHY-PKV Wed Nov 13 12:34:43 2002 f
2703 d2=d;
2704 if (Duv2>aMinDiv2) {
2705 d2 = Abs(ResoUV2/Duv2);
2706 d2 = Min(Sqrt(d2)*tolArea,d);
2707 }
2708 //d2 = Abs(ResoUV2/Duv2);
2709 //d2 = Min(Sqrt(d2)*tolArea,d);
2710 //modified by NIZNHY-PKV Wed Nov 13 12:34:53 2002 t
2711 tolCoeff2 = Exp(d2);
2712 CosRef1 = CosRef2D/tolCoeff1;
2713 CosRef2 = CosRef2D/tolCoeff2;
2714 //
2715 //==================================================================================
2716 //== The points are not confused : ==
2717 //== D e t e c t t h e S t o p a t p r e v i o u s p o i n t ==
2718 //== N o t T o o G r e a t (angle in space UV) ==
2719 //== C h a n g e o f s i d e ==
2720 //==================================================================================
2721 if (Status != IntWalk_PointConfondu) {
2722 if(Cosi1*Cosi1 < CosRef1*Duv1 || Cosi2*Cosi2 < CosRef2*Duv2) {
2723 pasuv[0]*=0.5; pasuv[1]*=0.5; pasuv[2]*=0.5; pasuv[3]*=0.5;
2724 if (pasuv[0]<ResoU1 && pasuv[1]<ResoV1 && pasuv[2]<ResoU2 && pasuv[3]<ResoV2) {
2725 return(IntWalk_ArretSurPointPrecedent);
2726 }
2727 else {
2728 pasuv[0]*=0.5; pasuv[1]*=0.5; pasuv[2]*=0.5; pasuv[3]*=0.5;
2729 return(IntWalk_PasTropGrand);
2730 }
2731 }
2732 const gp_Dir2d& Tg2dcourante1 = myIntersectionOn2S.DirectionOnS1();
2733 const gp_Dir2d& Tg2dcourante2 = myIntersectionOn2S.DirectionOnS2();
2734 Cosi1 = Du1*Tg2dcourante1.X() + Dv1*Tg2dcourante1.Y();
2735 Cosi2 = Du2*Tg2dcourante2.X() + Dv2*Tg2dcourante2.Y();
2736 Ang1 = Abs(previousd1.Angle(Tg2dcourante1));
2737 Ang2 = Abs(previousd2.Angle(Tg2dcourante2));
2738 AngRef1 = AngRef2D*tolCoeff1;
2739 AngRef2 = AngRef2D*tolCoeff2;
2740 //-------------------------------------------------------
2741 //-- Test : Angle too great in space UV -----
2742 //-- Change of side -----
2743 //-------------------------------------------------------
2744 if(Cosi1*Cosi1 < CosRef1*Duv1 || Cosi2*Cosi2 < CosRef2*Duv2 || Ang1 > AngRef1 || Ang2 > AngRef2) {
2745 pasuv[0]*=0.5; pasuv[1]*=0.5; pasuv[2]*=0.5; pasuv[3]*=0.5;
2746 if (pasuv[0]<ResoU1 && pasuv[1]<ResoV1 && pasuv[2]<ResoU2 && pasuv[3]<ResoV2)
2747 return(IntWalk_ArretSurPoint);
2748 else
2749 return(IntWalk_PasTropGrand);
2750 }
2751 }
2752 //<-OCC431(apo)
2753 //==================================================================================
2754 //== D e t e c t i o n o f : Step Too Small
2755 //== STEP TOO Great
2756 //==================================================================================
2757
2758 //---------------------------------------
2759 //-- Estimate of the vector --
2760 //---------------------------------------
2761 FlecheCourante =
2762 Sqrt(Abs((previousd.XYZ()-TgCourante.XYZ()).SquareModulus()*Dist))/8.;
2763
2764 if ( FlecheCourante<= fleche*0.5) { //-- Current step too small
2765 if(FlecheCourante>1e-16) {
2766 Ratio = 0.5*(fleche/FlecheCourante);
2767 }
2768 else {
2769 Ratio = 10.0;
2770 }
2771 Standard_Real pasSu1 = pasuv[0];
2772 Standard_Real pasSv1 = pasuv[1];
2773 Standard_Real pasSu2 = pasuv[2];
2774 Standard_Real pasSv2 = pasuv[3];
2775
2776 //-- In case if
2777 //-- a point at U+DeltaU is required, ....
2778 //-- return a point at U + Epsilon
2779 //-- Epsilon << DeltaU.
2780
2781 if(pasuv[0]< AbsDu1) pasuv[0] = AbsDu1;
2782 if(pasuv[1]< AbsDv1) pasuv[1] = AbsDv1;
2783 if(pasuv[2]< AbsDu2) pasuv[2] = AbsDu2;
2784 if(pasuv[3]< AbsDv2) pasuv[3] = AbsDv2;
2785
2786 if(pasuv[0]<ResoU1) pasuv[0]=ResoU1;
2787 if(pasuv[1]<ResoV1) pasuv[1]=ResoV1;
2788 if(pasuv[2]<ResoU2) pasuv[2]=ResoU2;
2789 if(pasuv[3]<ResoV2) pasuv[3]=ResoV2;
2790 //-- if(Ratio>10.0 ) { Ratio=10.0; }
2791 Standard_Real R1,R = pasInit[0]/pasuv[0];
2792 R1= pasInit[1]/pasuv[1]; if(R1<R) R=R1;
2793 R1= pasInit[2]/pasuv[2]; if(R1<R) R=R1;
2794 R1= pasInit[3]/pasuv[3]; if(R1<R) R=R1;
2795 if(Ratio > R) Ratio=R;
2796 pasuv[0] = Min(Ratio*pasuv[0],pasInit[0]);
2797 pasuv[1] = Min(Ratio*pasuv[1],pasInit[1]);
2798 pasuv[2] = Min(Ratio*pasuv[2],pasInit[2]);
2799 pasuv[3] = Min(Ratio*pasuv[3],pasInit[3]);
2800 if (pasuv[0] != pasSu1 || pasuv[2] != pasSu2||
2801 pasuv[1] != pasSv1 || pasuv[3] != pasSv2) {
2802 if(++STATIC_BLOCAGE_SUR_PAS_TROP_GRAND > 5) {
2803 STATIC_BLOCAGE_SUR_PAS_TROP_GRAND = 0;
2804 return IntWalk_PasTropGrand;
2805 }
2806 }
2807 if(Status == IntWalk_OK) {
2808 STATIC_BLOCAGE_SUR_PAS_TROP_GRAND=0;
2809 //-- Try to increase the step
2810 }
2811 return Status;
2812 }
2813 else { //-- CurrentVector > vector*0.5
2814 if (FlecheCourante > fleche) { //-- Current step too Great
2815 Ratio = fleche/FlecheCourante;
2816 pasuv[0] = Ratio*pasuv[0];
2817 pasuv[1] = Ratio*pasuv[1];
2818 pasuv[2] = Ratio*pasuv[2];
2819 pasuv[3] = Ratio*pasuv[3];
2820 //if(++STATIC_BLOCAGE_SUR_PAS_TROP_GRAND > 5) {
2821 // STATIC_BLOCAGE_SUR_PAS_TROP_GRAND = 0;
2822 return IntWalk_PasTropGrand;
2823 //}
2824 }
2825 else { //-- vector/2 < CurrentVector <= vector
2826 Ratio = 0.75 * (fleche / FlecheCourante);
2827 }
2828 }
2829 pasuv[0] = Max(5.*ResoU1,Min(Min(Ratio*AbsDu1,pasuv[0]),pasInit[0]));
2830 pasuv[1] = Max(5.*ResoV1,Min(Min(Ratio*AbsDv1,pasuv[1]),pasInit[1]));
2831 pasuv[2] = Max(5.*ResoU2,Min(Min(Ratio*AbsDu2,pasuv[2]),pasInit[2]));
2832 pasuv[3] = Max(5.*ResoV2,Min(Min(Ratio*AbsDv2,pasuv[3]),pasInit[3]));
2833 if(Status == IntWalk_OK) STATIC_BLOCAGE_SUR_PAS_TROP_GRAND=0;
2834 return Status;
2835}
2836
2837Standard_Boolean IntWalk_PWalking::
2838TestArret(const Standard_Boolean DejaReparti,
2839 TColStd_Array1OfReal& Param,
2840 IntImp_ConstIsoparametric& ChoixIso)
2841
2842 //
2843 // test if the point of intersection set by these parameters remains in the
2844 // natural domain of each square.
2845 // if the point outpasses reframe to find the best iso (border)
2846 // that intersects easiest the other square
2847 // otherwise test if closed line is present
2848 //
2849{
2850 Standard_Real Uvd[4],Uvf[4],Epsuv[4],Duv[4],Uvp[4],dv,dv2,ParC[4];
2851 Standard_Real DPc,DPb;
2852 Standard_Integer i = 0, k = 0;
2853 Epsuv[0] = ResoU1;
2854 Epsuv[1] = ResoV1;
2855 Epsuv[2] = ResoU2;
2856 Epsuv[3] = ResoV2;
2857 previousPoint.Parameters(Uvp[0],Uvp[1],Uvp[2],Uvp[3]);
2858
2859 Standard_Real SolParam[4];
2860 myIntersectionOn2S.Point().Parameters(SolParam[0],SolParam[1],SolParam[2],SolParam[3]);
2861
2862 Standard_Boolean Trouve = Standard_False;
2863
2864 Uvd[0]=Um1; Uvf[0]=UM1; Uvd[1]=Vm1; Uvf[1]=VM1;
2865 Uvd[2]=Um2; Uvf[2]=UM2; Uvd[3]=Vm2; Uvf[3]=VM2;
2866
2867 Standard_Integer im1;
2868 for ( i = 1,im1 = 0;i<=4;i++,im1++) {
2869 switch(i) {
2870 case 1: k=2; break;
2871 case 2: k=1; break;
2872 case 3: k=4; break;
2873 case 4: k=3; break;
2874 }
2875 if (Param(i) < (Uvd[im1]-Epsuv[im1]) ||
2876 SolParam[im1] < (Uvd[im1]-Epsuv[im1])) //-- Current ----- Bound Inf ----- Previous
2877 {
2878 Trouve = Standard_True; //--
2879 DPc = Uvp[im1]-Param(i); //-- Previous - Current
2880 DPb = Uvp[im1]-Uvd[im1]; //-- Previous - Bound Inf
2881 ParC[im1] = Uvd[im1]; //-- ParamCorrige
2882 dv = Param(k)-Uvp[k-1]; //-- Current - Previous (other Direction)
2883 dv2 = dv*dv;
2884 if(dv2>RealEpsilon()) { //-- Progress at the other Direction ?
2885 Duv[im1] = DPc*DPb + dv2;
2886 Duv[im1] = Duv[im1]*Duv[im1]/(DPc*DPc+dv2)/(DPb*DPb+dv2);
2887 }
2888 else {
2889 Duv[im1]=-1.0; //-- If no progress, do not change
2890 } //-- the choice of iso
2891 }
2892 else if (Param(i) > (Uvf[im1] + Epsuv[im1]) ||
2893 SolParam[im1] > (Uvf[im1] + Epsuv[im1]))//-- Previous ----- Bound Sup ----- Current
2894 {
2895 Trouve = Standard_True; //--
2896 DPc = Param(i)-Uvp[im1]; //-- Current - Previous
2897 DPb = Uvf[im1]-Uvp[im1]; //-- Bound Sup - Previous
2898 ParC[im1] = Uvf[im1]; //-- Param Corrige
2899 dv = Param(k)-Uvp[k-1]; //-- Current - Previous (other Direction)
2900 dv2 = dv*dv;
2901 if(dv2>RealEpsilon()) { //-- Progress in other Direction ?
2902 Duv[im1] = DPc*DPb + dv2;
2903 Duv[im1] = Duv[im1]*Duv[im1]/(DPc*DPc+dv2)/(DPb*DPb+dv2);
2904 }
2905 else {
2906 Duv[im1]=-1.0; //-- If no progress, do not change
2907 } //-- the choice of iso
2908 }
2909 else {
2910 Duv[im1]= -1.;
2911 ParC[im1]=Param(i);
2912 }
2913 }
2914
2915 if (Trouve) {
2916 //--------------------------------------------------
2917 //-- One of Parameters u1,v1,u2,v2 is outside of --
2918 //-- the natural limits. --
2919 //-- Find the best direction of --
2920 //-- progress and reframe the parameters. --
2921 //--------------------------------------------------
2922 Standard_Real ddv = -1.0;
2923 k=-1;
2924 for (i=0;i<=3;i++) {
2925 Param(i+1) = ParC[i];
2926 if(Duv[i]>ddv) {
2927 ddv = Duv[i];
2928 k=i;
2929 }
2930 }
2931 if(k!=-1) {
2932 ChoixIso = ChoixRef[k];
2933 }
2934 else {
2935 if((ParC[0]<=Uvd[0]+Epsuv[0]) || (ParC[0]>=Uvf[0]-Epsuv[0])) {
2936 ChoixIso = IntImp_UIsoparametricOnCaro1;
2937 }
2938 else if((ParC[1]<=Uvd[1]+Epsuv[1]) || (ParC[1]>=Uvf[1]-Epsuv[1])) {
2939 ChoixIso = IntImp_VIsoparametricOnCaro1;
2940 }
2941 else if((ParC[2]<=Uvd[2]+Epsuv[2]) || (ParC[2]>=Uvf[2]-Epsuv[2])) {
2942 ChoixIso = IntImp_UIsoparametricOnCaro2;
2943 }
2944 else if((ParC[3]<=Uvd[3]+Epsuv[3]) || (ParC[3]>=Uvf[3]-Epsuv[3])) {
2945 ChoixIso = IntImp_VIsoparametricOnCaro2;
2946 }
2947 }
2948 close = Standard_False;
2949 return Standard_True;
2950 }
2951 else
2952 {
2953 if (!DejaReparti) { // find if line closed
2954
2955 Standard_Real u,v;
2956 const IntSurf_PntOn2S& POn2S1=line->Value(1);
2957 //On S1
2958 POn2S1.ParametersOnS1(u,v);
2959 gp_Pnt2d P1uvS1(u,v);
2960 previousPoint.ParametersOnS1(u,v);
2961 gp_Pnt2d PrevuvS1(u,v);
2962 myIntersectionOn2S.Point().ParametersOnS1(u,v);
2963 gp_Pnt2d myIntersuvS1(u,v);
2964 Standard_Boolean close2dS1 = (P1uvS1.XY()-PrevuvS1.XY())*
2965 (P1uvS1.XY()-myIntersuvS1.XY()) < 0.0;
2966 //On S2
2967 POn2S1.ParametersOnS2(u,v);
2968 gp_Pnt2d P1uvS2(u,v);
2969 previousPoint.ParametersOnS2(u,v);
2970 gp_Pnt2d PrevuvS2(u,v);
2971 myIntersectionOn2S.Point().ParametersOnS2(u,v);
2972 gp_Pnt2d myIntersuvS2(u,v);
2973 Standard_Boolean close2dS2 = (P1uvS2.XY()-PrevuvS2.XY())*
2974 (P1uvS2.XY()-myIntersuvS2.XY()) < 0.0;
2975
2976 close = close2dS1 && close2dS2;
2977 return close;
2978 }
2979 else return Standard_False;
2980 }
2981}
c2c2f2b6 2982
Open CASCADE Technology repository