Integration of OCCT 6.5.0 from SVN
[occt.git] / src / IntPatch / IntPatch_RstInt.cxx
CommitLineData
7fd59977 1// File: IntPatch_RstInt.cxx
2// Created: Fri May 7 12:45:18 1993
3// Author: Jacques GOUSSARD
4// Copyright: Matra Datavision 1993
5
6// ----------------------------------------------------------------------
7//-- lbr: Modifs importantes du 16-17 Nov 95
8//-- - Chercher APointOnRstStillExist et OnDifferentRst
9//-- On veut pouvoir creer un Vtx (A1 sur S1, A2 sur S2)
10//-- et le Vtx (A1 sur S1, A2bis sur S2)
11//-- ce qui revient a distinguer un point deja pose sur une
12//-- restriction de S avec un point pose sur une nouvelle
13//-- restriction de S.
14//-- - Pour rester coherent avec cette facon de faire,
15//-- Chercher(Nbvtx++).
16
17#include <IntPatch_RstInt.ixx>
18
19#include <IntSurf.hxx>
20
21#include <TColgp_SequenceOfPnt.hxx>
22#include <TColgp_SequenceOfPnt2d.hxx>
23#include <Intf_SectionPoint.hxx>
24#include <Intf_TangentZone.hxx>
25#include <gp_Pnt2d.hxx>
26#include <Precision.hxx>
27
28#include <Adaptor2d_HCurve2d.hxx>
29#include <IntPatch_PolygoTool.hxx>
30#include <IntPatch_WLine.hxx>
31#include <IntPatch_RLine.hxx>
32#include <IntPatch_HInterTool.hxx>
33#include <IntPatch_SearchPnt.hxx>
34#include <IntPatch_PolyLine.hxx>
35#include <IntPatch_PolyArc.hxx>
36#include <IntPatch_CSFunction.hxx>
37#include <IntPatch_CurvIntSurf.hxx>
38
39
40static void Recadre(GeomAbs_SurfaceType typeS1,
41 GeomAbs_SurfaceType typeS2,
42 const Handle(IntPatch_WLine)& wlin,
43 Standard_Integer Param,
44 Standard_Real& U1,
45 Standard_Real& V1,
46 Standard_Real& U2,
47 Standard_Real& V2)
48{
49 Standard_Integer nbpnts = wlin->NbPnts();
50 if(Param<1) Param=1; else if(Param>nbpnts) Param=nbpnts;
51 Standard_Real U1p,V1p,U2p,V2p;
52
53 wlin->Point(Param).Parameters(U1p,V1p,U2p,V2p);
54 switch(typeS1) {
55 case GeomAbs_Cylinder:
56 case GeomAbs_Cone:
57 case GeomAbs_Sphere:
58 case GeomAbs_Torus:
59 while(U1<(U1p-1.5*PI)) U1+=PI+PI;
60 while(U1>(U1p+1.5*PI)) U1-=PI+PI;
61 break;
62 default:
63 break;
64 }
65 if(typeS1==GeomAbs_Torus) {
66 while(V1<(V1p-1.5*PI)) V1+=PI+PI;
67 while(V1>(V1p+1.5*PI)) V1-=PI+PI;
68 }
69
70 switch(typeS2) {
71 case GeomAbs_Cylinder:
72 case GeomAbs_Cone:
73 case GeomAbs_Sphere:
74 case GeomAbs_Torus:
75 while(U2<(U2p-1.5*PI)) U2+=PI+PI;
76 while(U2>(U2p+1.5*PI)) U2-=PI+PI;
77 break;
78 default:
79 break;
80 }
81 if(typeS2==GeomAbs_Torus) {
82 while(V2<(V1p-1.5*PI)) V2+=PI+PI;
83 while(V2>(V2p+1.5*PI)) V2-=PI+PI;
84 }
85}
86
87const Standard_Real Confusion = Precision::Confusion();
88
89inline Standard_Real Tol3d (const Handle(Adaptor3d_HVertex)& vtx,
90 const Handle(Adaptor3d_TopolTool)& Domain,
91 const Standard_Real tolDef = 0.)
92{
93 return (Domain->Has3d() ? Domain->Tol3d(vtx)
94 : tolDef < Confusion ? Confusion
95 : tolDef);
96}
97
98inline Standard_Real Tol3d (const Handle(Adaptor2d_HCurve2d)& arc,
99 const Handle(Adaptor3d_TopolTool)& Domain,
100 const Standard_Real tolDef = 0.)
101{
102 return (Domain->Has3d() ? Domain->Tol3d(arc)
103 : tolDef < Confusion ? Confusion
104 : tolDef);
105}
106
107static Standard_Boolean CoincideOnArc(const gp_Pnt& Ptsommet,
108 const Handle(Adaptor2d_HCurve2d)& A,
109 const Handle(Adaptor3d_HSurface)& Surf,
110 const Standard_Real Toler,
111 const Handle(Adaptor3d_TopolTool)& Domain,
112 Handle(Adaptor3d_HVertex)& Vtx)
113{
114 Standard_Real distmin = RealLast();
115 Standard_Real tolarc = Max(Toler,Tol3d(A,Domain));
116
117 Domain->Initialize(A);
118 Domain->InitVertexIterator();
119 while (Domain->MoreVertex()) {
120 Handle(Adaptor3d_HVertex) vtx1 = Domain->Vertex();
121 Standard_Real prm = IntPatch_HInterTool::Parameter(vtx1,A);
122 gp_Pnt2d p2d = A->Value(prm);
123 gp_Pnt point = Surf->Value(p2d.X(),p2d.Y());
124 const Standard_Real dist = point.Distance(Ptsommet);
125 Standard_Real tol = Max (tolarc, Tol3d(vtx1,Domain));
126
127 if (dist <= tol && dist <= distmin) { // the best coincidence
128 distmin = dist;
129 Vtx = vtx1;
130 }
131 Domain->NextVertex();
132 }
133 return distmin < RealLast();
134}
135
136
137static void VerifyTgline(const Handle(IntPatch_WLine)& wlin,
138 const Standard_Integer param,
139 const Standard_Real Tol,
140 gp_Vec& Tgl) {
141
142 if( Abs(Tgl.X())<Tol
143 && Abs(Tgl.Y())<Tol
144 && Abs(Tgl.Z())<Tol) {
145 //-- On construit une tangente plus grande
146 //-- (Eviter des points tres proches ds Walking)
147 Standard_Integer i, n, nbpt=wlin->NbPnts();
148 Standard_Boolean forward = (nbpt-param) >= (param-1);
149 for (n = 2; n > 0; n--, forward = !forward) {
150 if (forward) {
151 for(i=param+1; i<=nbpt; i++) {
152 gp_Vec T(wlin->Point(param).Value(),wlin->Point(i).Value());
153 if( Abs(T.X())>=Tol
154 || Abs(T.Y())>=Tol
155 || Abs(T.Z())>=Tol) {
156 Tgl = T ;
157 return;
158 }
159 }
160 }
161 else {
162 for(i=param-1; i>=1; i--) {
163 gp_Vec T(wlin->Point(i).Value(),wlin->Point(param).Value());
164 if( Abs(T.X())>=Tol
165 || Abs(T.Y())>=Tol
166 || Abs(T.Z())>=Tol) {
167 Tgl = T ;
168 return;
169 }
170 }
171 }
172 }
173 }
174}
175
176static void GetLinePoint2d (const Handle(IntPatch_Line)& L,
177 const Standard_Real param,
178 const Standard_Boolean OnFirst,
179 Standard_Real& U, Standard_Real& V)
180{
181 IntPatch_IType typL = L->ArcType();
182 const Handle(IntPatch_WLine)& wlin = (const Handle(IntPatch_WLine)&)L;
183 const Handle(IntPatch_RLine)& rlin = (const Handle(IntPatch_RLine)&)L;
184 Standard_Integer Nbptlin = (typL == IntPatch_Walking
185 ? wlin->NbPnts()
186 : rlin->NbPnts());
187
188 Standard_Real par = IntegerPart(param);
189 Standard_Integer Irang = Standard_Integer(par);
190 if (Irang == Nbptlin) {
191 Irang--;
192 par = 1.0;
193 }
194 else
195 par = Abs(param-par);
196
197 Standard_Real us1,vs1,us2,vs2;
198 if (typL == IntPatch_Walking) {
199 if (OnFirst) {
200 wlin->Point(Irang).ParametersOnS1(us1,vs1);
201 wlin->Point(Irang+1).ParametersOnS1(us2,vs2);
202 }
203 else {
204 wlin->Point(Irang).ParametersOnS2(us1,vs1);
205 wlin->Point(Irang+1).ParametersOnS2(us2,vs2);
206 }
207 }
208 else {
209 if (OnFirst) {
210 rlin->Point(Irang).ParametersOnS1(us1,vs1);
211 rlin->Point(Irang+1).ParametersOnS1(us2,vs2);
212 }
213 else {
214 rlin->Point(Irang).ParametersOnS2(us1,vs1);
215 rlin->Point(Irang+1).ParametersOnS2(us2,vs2);
216 }
217 }
218
219 U = (1.-par)*us1+par*us2;
220 V = (1.-par)*vs1+par*vs2;
221}
222
223static void GetWLinePoint (const Handle(IntPatch_WLine)& wlin,
224 const Standard_Real param,
225 Standard_Real& U1, Standard_Real& V1,
226 Standard_Real& U2, Standard_Real& V2,
227 gp_Pnt& P)
228{
229 Standard_Integer Nbptlin = wlin->NbPnts();
230 Standard_Real par = IntegerPart(param);
231 Standard_Integer Irang = Standard_Integer(par);
232 if (Irang == Nbptlin) {
233 Irang--;
234 par = 1.0;
235 }
236 else
237 par = Abs(param-par);
238
239 const IntSurf_PntOn2S& p2s1 = wlin->Point(Irang);
240 const IntSurf_PntOn2S& p2s2 = wlin->Point(Irang+1);
241 const gp_Pnt& p1 = p2s1.Value();
242 const gp_Pnt& p2 = p2s2.Value();
243 P.ChangeCoord().SetLinearForm(1.-par, p1.XYZ(), par, p2.XYZ());
244
245 Standard_Real us1,vs1,us2,vs2;
246 p2s1.ParametersOnS1(us1,vs1);
247 p2s2.ParametersOnS1(us2,vs2);
248 U1 = (1.-par)*us1+par*us2;
249 V1 = (1.-par)*vs1+par*vs2;
250
251 p2s1.ParametersOnS2(us1,vs1);
252 p2s2.ParametersOnS2(us2,vs2);
253 U2 = (1.-par)*us1+par*us2;
254 V2 = (1.-par)*vs1+par*vs2;
255}
256
257static Standard_Boolean FindParameter(const Handle(IntPatch_Line)& L,
258 const Handle(Adaptor3d_HSurface)& OtherSurf,
259 const Standard_Real Tol,
260 const gp_Pnt& Ptsom,
261 const gp_Pnt2d& Ptsom2d,
262 Standard_Real& Param,
263 gp_Vec& Tgl,
264 const Standard_Integer ParamApproche,
265 const Standard_Boolean OnFirst)
266
267{
268 // MSV 28.03.2002: find parameter on WLine in 2d space
269
270 //Si la ligne est de type restriction, c est qu on provient necessairement
271 // du cas implicite/parametree, et que la ligne est restriction de
272 // la surface bi-parametree. Cette surface bi-parametree est necessairement
273 // passee en argument a PutVertexOnline dans la variable OtherSurf.
274
275 // Dans le cas d une ligne de cheminement, il faudrait voir la projection
276 // et le calcul de la tangente.
277
278 const Handle(IntPatch_RLine)& rlin = (*((Handle(IntPatch_RLine)*)&L)); //-- aucune verification n est
279 const Handle(IntPatch_WLine)& wlin = (*((Handle(IntPatch_WLine)*)&L)); //-- faite au cast.
280 gp_Pnt ptbid;
281 gp_Vec d1u,d1v;
282 gp_Pnt2d p2d;
283 gp_Vec2d d2d;
284 Standard_Real Tol2 = Tol*Tol;
285 IntPatch_IType typL = L->ArcType();
286 Tgl.SetCoord(0.0,0.0,0.0);
287
288 if ( typL == IntPatch_Restriction) {
289 if (!OnFirst && rlin->IsArcOnS1()) {
290 IntPatch_HInterTool::Project(rlin->ArcOnS1(),Ptsom2d,Param,p2d);
291 rlin->ArcOnS1()->D1(Param,p2d,d2d);
292 }
293 else if (OnFirst && rlin->IsArcOnS2()) {
294 IntPatch_HInterTool::Project(rlin->ArcOnS2(),Ptsom2d,Param,p2d);
295 rlin->ArcOnS2()->D1(Param,p2d,d2d);
296 }
297 else {
298 return(Standard_False);
299 }
300 OtherSurf->D1(p2d.X(),p2d.Y(),ptbid,d1u,d1v);
301 if (ptbid.SquareDistance(Ptsom) > Tol2) {
302 return Standard_False;
303 }
304 Tgl.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
305 return(Standard_True);
306 }
307
308 else if (typL == IntPatch_Walking) {
309 Standard_Integer i, is, nbpt=wlin->NbPnts();
310 Standard_Real norm1,norm2;
311 Standard_Integer ParamSearchInf=1;
312 Standard_Integer ParamSearchSup=nbpt;
313
314 if((ParamApproche-2) > ParamSearchInf) {
315 ParamSearchInf = ParamApproche-2;
316 }
317 if((ParamApproche+2) < ParamSearchSup) {
318 ParamSearchSup = ParamApproche+2;
319 }
320
321 Standard_Integer inf[3],sup[3];
322 // first search inside close bounding around ParamApproche;
323 // then search to the nearest end of line;
324 // and then search to the farest end of line.
325 inf[0] = ParamSearchInf; sup[0] = ParamSearchSup;
326 if (ParamSearchInf-1 < nbpt-ParamSearchSup) {
327 inf[1] = 1; sup[1] = ParamSearchInf;
328 inf[2] = ParamSearchSup; sup[2] = nbpt;
329 }
330 else {
331 inf[1] = ParamSearchSup; sup[1] = nbpt;
332 inf[2] = 1; sup[2] = ParamSearchInf;
333 }
334
335 Standard_Boolean found = Standard_False;
336 for (is=0; is < 3 && !found; is++) {
337 gp_Vec v1,v2;
338 gp_Pnt p1,p2;
339 p1 = wlin->Point(inf[is]).Value();
340 v1 = gp_Vec (Ptsom,p1);
341 norm1 = v1.SquareMagnitude();
342 Standard_Real normmin = Tol2;
343 Standard_Integer ibest = 0;
344 if (norm1 <= normmin) {
345 normmin = norm1;
346 ibest = inf[is];
347 }
348 for (i=inf[is]+1; i <= sup[is] && !found; i++) {
349 p2 = wlin->Point(i).Value();
350 v2 = gp_Vec (Ptsom,p2);
351 norm2 = v2.SquareMagnitude();
352 if (v1.Dot(v2) < 0.) {
353 Param = (Standard_Real)(i-1) + 1./(1.+Sqrt(norm2/norm1));
354 Tgl = gp_Vec (p1,p2);
355 found = Standard_True;
356 }
357 else if (norm2 < normmin) {
358 normmin = norm2;
359 ibest = i;
360 }
361 v1 = v2; p1 = p2; norm1 = norm2;
362 }
363 if (!found && ibest) {
364 Param = (Standard_Real)ibest;
365 found = Standard_True;
366 }
367 }
368 if (found) return Standard_True;
369 }
370 else {
371 Standard_DomainError::Raise();
372 }
373 return Standard_False;
374}
375
376inline Standard_Boolean ArePnt2dEqual(const gp_Pnt2d& p1, const gp_Pnt2d& p2,
377 const Standard_Real tolU,
378 const Standard_Real tolV)
379{
380 return Abs(p1.X()-p2.X()) < tolU && Abs(p1.Y()-p2.Y()) < tolV;
381}
382
383static gp_Pnt2d GetPointOnPolygo(const IntPatch_Polygo& Pol,
384 const Standard_Real param)
385{
386 Standard_Real par = IntegerPart(param);
387 Standard_Integer irang = Standard_Integer(par) + 1;
388 if (irang == Pol.NbPoints()) {
389 irang--;
390 par = 1.;
391 }
392 else {
393 par = Abs(param-par);
394 }
395 gp_Pnt2d p1 = Pol.Point(irang);
396 gp_Pnt2d p2 = Pol.Point(irang+1);
397 gp_Pnt2d p;
398 p.ChangeCoord().SetLinearForm(1.-par,p1.XY(),par,p2.XY());
399 return p;
400}
401
402static Standard_Boolean IsSegment2dSmall(const IntPatch_Polygo& Pol,
403 const Standard_Real parmin,
404 const Standard_Real parmax,
405 const Standard_Real URes,
406 const Standard_Real VRes)
407{
408 Standard_Integer irang1 = Standard_Integer(IntegerPart(parmin)) + 2;
409 Standard_Integer irang2 = Standard_Integer(IntegerPart(parmax)) + 1;
410 gp_Pnt2d p1,p2;
411 Standard_Real du=0.,dv=0.;
412 p1 = GetPointOnPolygo(Pol,parmin);
413 for (Standard_Integer i=irang1; i <= irang2 && du <= URes && dv <= VRes; i++) {
414 p2 = Pol.Point(i);
415 du += Abs(p2.X()-p1.X());
416 dv += Abs(p2.Y()-p1.Y());
417 p1 = p2;
418 }
419 if (du <= URes && dv <= VRes) {
420 p2 = GetPointOnPolygo(Pol,parmax);
421 du += Abs(p2.X()-p1.X());
422 dv += Abs(p2.Y()-p1.Y());
423 }
424 return du <= URes && dv <= VRes;
425}
426
427//=======================================================================
428//function : PutVertexOnLine
429//purpose :
430//=======================================================================
431
432void IntPatch_RstInt::PutVertexOnLine (Handle(IntPatch_Line)& L,
433 const Handle(Adaptor3d_HSurface)& Surf,
434 const Handle(Adaptor3d_TopolTool)& Domain,
435 const Handle(Adaptor3d_HSurface)& OtherSurf,
436 const Standard_Boolean OnFirst,
437 const Standard_Real Tol )
438 {
439
440// Domain est le domaine de restriction de la surface Surf.
441// On intersectera un arc de Surf avec la surface OtherSurf.
442// Si OnFirst = True, c est que la surface Surf correspond a la 1ere
443// surface donnee aux algo d intersection.
444
445 static IntPatch_SearchPnt Commun;
446
447 Standard_Real U,V,W;
448 Standard_Real U1,V1,U2,V2;
449 Standard_Real paramarc=0.,paramline=0.;
450 Standard_Integer i,j,k;
451 TColgp_SequenceOfPnt locpt;
452 TColgp_SequenceOfPnt2d locpt2;
453 const Handle(IntPatch_RLine)& rlin = (*((Handle(IntPatch_RLine)*)&L)); //-- aucune verification n est
454 const Handle(IntPatch_WLine)& wlin = (*((Handle(IntPatch_WLine)*)&L)); //-- faite au cast.
455 Standard_Integer Nbvtx =0;
456 Standard_Integer Nbptlin =0;
457 Standard_Real tolPLin = Surf->UResolution(Precision::Confusion());
458 tolPLin = Max (tolPLin, Surf->VResolution(Precision::Confusion()));
459 tolPLin = Min (tolPLin, Precision::Confusion());
460 IntPatch_PolyLine PLin(tolPLin);
461
462 Standard_Real PFirst,PLast;
463 Standard_Integer NbEchant;
464 gp_Pnt ptsommet, ptbid;
465 gp_Vec tgline, tgrst, d1u, d1v, normsurf;
466
467 gp_Pnt2d p2d;
468 gp_Vec2d d2d;
469
470 IntPatch_Point Sommet, ptline;
471 Handle(Adaptor3d_HVertex) vtxarc,vtxline;
472 Handle(Adaptor2d_HCurve2d) arc;
473 Standard_Boolean VtxOnArc, duplicate, found;
474 IntSurf_Transition transarc,transline;
475
476 IntPatch_IType typL = L->ArcType();
477 if (typL == IntPatch_Walking) {
478 Nbvtx = wlin->NbVertex();
479 PLin.SetWLine(OnFirst,wlin);
480 Nbptlin = wlin->NbPnts();
481 }
482 else if ( typL == IntPatch_Restriction) {
483 Nbvtx = rlin->NbVertex();
484 PLin.SetRLine(OnFirst,rlin);
485 Nbptlin = rlin->NbPnts();
486 }
487 else {
488 Standard_DomainError::Raise();
489 }
490 if (!Domain->Has3d())
491 // don't use computed deflection in the mode of pure geometric intersection
492 PLin.ResetError();
493
494 const Standard_Boolean SurfaceIsUClosed = Surf->IsUClosed();
495 const Standard_Boolean SurfaceIsVClosed = Surf->IsVClosed();
496 const Standard_Boolean OSurfaceIsUClosed = OtherSurf->IsUClosed();
497 const Standard_Boolean OSurfaceIsVClosed = OtherSurf->IsVClosed();
498 const Standard_Boolean possiblyClosed = (SurfaceIsUClosed || SurfaceIsVClosed ||
499 OSurfaceIsUClosed || OSurfaceIsVClosed);
500 Standard_Real tolUClosed=0., tolVClosed=0., tolOUClosed=0., tolOVClosed=0.;
501 if (possiblyClosed) {
502 if (SurfaceIsUClosed)
503 tolUClosed = (Surf->LastUParameter() - Surf->FirstUParameter()) * 0.01;
504 if (SurfaceIsVClosed)
505 tolVClosed = (Surf->LastVParameter() - Surf->FirstVParameter()) * 0.01;
506 if (OSurfaceIsUClosed)
507 tolOUClosed = (OtherSurf->LastUParameter() - OtherSurf->FirstUParameter()) * 0.01;
508 if (OSurfaceIsVClosed)
509 tolOVClosed = (OtherSurf->LastVParameter() - OtherSurf->FirstVParameter()) * 0.01;
510 }
511
512 //------------------------------------------------------------------------
513 //-- On traite le cas ou la surface est periodique --
514 //-- il faut dans ce cas considerer la restriction --
515 //-- la restriction decalee de +-2PI --
516 //------------------------------------------------------------------------
517 const Handle(Adaptor3d_HSurface)& Surf1 = (OnFirst ? Surf : OtherSurf);
518 const Handle(Adaptor3d_HSurface)& Surf2 = (OnFirst ? OtherSurf : Surf);
519 GeomAbs_SurfaceType TypeS1 = Surf1->GetType();
520 GeomAbs_SurfaceType TypeS2 = Surf2->GetType();
521 Standard_Boolean SurfaceIsPeriodic = Standard_False;
522 Standard_Boolean SurfaceIsBiPeriodic = Standard_False;
523 GeomAbs_SurfaceType surfacetype = (OnFirst ? TypeS1 : TypeS2);
524 if( surfacetype == GeomAbs_Cylinder
525 || surfacetype == GeomAbs_Cone
526 || surfacetype == GeomAbs_Torus
527 || surfacetype == GeomAbs_Sphere) {
528 SurfaceIsPeriodic = Standard_True;
529 if(surfacetype == GeomAbs_Torus) {
530 SurfaceIsBiPeriodic = Standard_True;
531 }
532 }
533
534 Standard_Integer NumeroEdge=0;
535 Domain->Init();
536 while (Domain->More()) {
537 NumeroEdge++;
538 arc = Domain->Value();
539
540 // MSV Oct 15, 2001: use tolerance of this edge if possible
541 Standard_Real edgeTol = Tol3d(arc,Domain,Tol);
542 Standard_Real URes = Surf->UResolution(edgeTol);
543 Standard_Real VRes = Surf->VResolution(edgeTol);
544
545 IntPatch_HInterTool::Bounds(arc,PFirst,PLast);
546 if (Precision::IsNegativeInfinite(PFirst) ||
547 Precision::IsPositiveInfinite(PLast)) {
548 //-- cout<<" IntPatch_RstInt::PutVertexOnLine ---> Restrictions Infinies :"<<endl;
549 return;
550 }
551
552 Standard_Boolean isVFirst = Standard_False, isVLast = Standard_False;
553 gp_Pnt2d p2dFirst,p2dLast;
554 Standard_Real tolUFirst=0.,tolVFirst=0.,tolULast=0.,tolVLast=0.;
555 Domain->Initialize(arc);
556 for (Domain->InitVertexIterator(); Domain->MoreVertex(); Domain->NextVertex()) {
557 Handle(Adaptor3d_HVertex) vtx = Domain->Vertex();
558 Standard_Real prm = IntPatch_HInterTool::Parameter(vtx,arc);
559 if (Abs(prm - PFirst) < Precision::PConfusion()) {
560 arc->D0(PFirst,p2dFirst);
561 Standard_Real tol3d = Max (Tol3d(vtx,Domain), edgeTol);
562 tolUFirst = Surf->UResolution(tol3d);
563 tolVFirst = Surf->VResolution(tol3d);
564 isVFirst = Standard_True;
565 }
566 else if (Abs(prm - PLast) < Precision::PConfusion()) {
567 arc->D0(PLast,p2dLast);
568 Standard_Real tol3d = Max (edgeTol, Tol3d(vtx,Domain));
569 tolULast = Surf->UResolution(tol3d);
570 tolVLast = Surf->VResolution(tol3d);
571 isVLast = Standard_True;
572 }
573 }
574
575 Bnd_Box2d BPLin = IntPatch_PolygoTool::Bounding(PLin);
576
577 if(SurfaceIsPeriodic) {
578 Standard_Real xmin,ymin,xmax,ymax,g;
579 BPLin.Get(xmin,ymin,xmax,ymax);
580 g = BPLin.GetGap();
581 BPLin.SetVoid();
582 BPLin.Update(xmin-PI-PI,ymin,
583 xmax+PI+PI,ymax);
584 BPLin.SetGap(g);
585 }
586 if(SurfaceIsBiPeriodic) {
587 Standard_Real xmin,ymin,xmax,ymax,g;
588 BPLin.Get(xmin,ymin,xmax,ymax);
589 g = BPLin.GetGap();
590 BPLin.SetVoid();
591 BPLin.Update(xmin,ymin-PI-PI,
592 xmax,ymax+PI+PI);
593 BPLin.SetGap(g);
594 }
595
596 switch(arc->GetType())
597 {
598 case GeomAbs_Line: NbEchant=10; break;
599 case GeomAbs_BezierCurve:
600 {
601 NbEchant = (3 + arc->NbPoles());
602 if(NbEchant<10) NbEchant=10;
603 else if(NbEchant>50) NbEchant=50;
604 }
605 break;
606 case GeomAbs_BSplineCurve:
607 {
608 //szv:const Standard_Real nbs = (arc->NbKnots() * arc->Degree())*(arc->LastParameter() - arc->FirstParameter())/(PLast-PFirst);
609 const Standard_Real nbs = (arc->NbKnots() * arc->Degree())*(PLast-PFirst)/(arc->LastParameter() - arc->FirstParameter());
610 NbEchant = (nbs < 2.0 ? 2 : (Standard_Integer)nbs);
611 if(NbEchant<10) NbEchant=10;
612 else if (NbEchant>50) NbEchant=50;
613 }
614 break;
615 default:
616 {
617 NbEchant = 25;
618 }
619 }
620
621 IntPatch_PolyArc Brise(arc,NbEchant,PFirst,PLast,BPLin);
622
623 Standard_Integer IndiceOffsetBiPeriodic = 0;
624 Standard_Integer IndiceOffsetPeriodic = 0;
625 Standard_Real OffsetV = 0.0;
626 Standard_Real OffsetU = 0.0;
627
628 do {
629 if(IndiceOffsetBiPeriodic == 1)
630 OffsetV = -PI-PI;
631 else if(IndiceOffsetBiPeriodic == 2)
632 OffsetV = PI+PI;
633
634 do {
635 if(IndiceOffsetPeriodic == 1)
636 OffsetU = -PI-PI;
637 else if(IndiceOffsetPeriodic == 2)
638 OffsetU = PI+PI;
639
640 Brise.SetOffset(OffsetU,OffsetV);
641
642 static int debug_polygon2d =0;
643 if(debug_polygon2d) {
644 cout<<" ***** Numero Restriction : "<<NumeroEdge<<" *****"<<endl;
645 IntPatch_PolygoTool::Dump(PLin);
646 IntPatch_PolygoTool::Dump(Brise);
647 }
648
649 Commun.Perform(PLin,Brise);
650 locpt.Clear();
651 locpt2.Clear();
652 Standard_Integer Commun_NbSectionPoints = Commun.NbSectionPoints();
653 Standard_Integer Commun_NbTangentZones = Commun.NbTangentZones();
654 Standard_Integer Commun_Section_Tangent = Commun_NbSectionPoints
655 + Commun_NbTangentZones;
656 for (i=1;i<=Commun_Section_Tangent;i++) {
657 Standard_Real W1[2],W2[2];
658 Standard_Boolean refine[2],useWL[2];
659 Standard_Integer nbpt = 1;
660 if(i<=Commun_NbSectionPoints) {
661 // intersection point
662 W1[0] = Commun.PntValue(i).ParamOnFirst();
663 W2[0] = Commun.PntValue(i).ParamOnSecond();
664 refine[0] = Standard_True;
665 }
666 else {
667 // tangent zone
668 Standard_Real UMinCh,UMaxCh; //-- ligne de cheminement 0..(Nbptlin-1)
669 Standard_Real UMinAr,UMaxAr; //-- polyline of arc 0..(NbEchant-1)
670 Commun.ZoneValue(i-Commun_NbSectionPoints).ParamOnFirst(UMinCh,UMaxCh);
671 Commun.ZoneValue(i-Commun_NbSectionPoints).ParamOnSecond(UMinAr,UMaxAr);
672 gp_Pnt2d p1Ar = GetPointOnPolygo(Brise,UMinAr);
673 gp_Pnt2d p2Ar = GetPointOnPolygo(Brise,UMaxAr);
674 Standard_Real tolU = URes*2.;
675 Standard_Real tolV = VRes*2.;
676 if (isVFirst && ArePnt2dEqual(p1Ar,p2dFirst,tolUFirst,tolVFirst)) {
677 tolU = Max(tolUFirst,tolU); tolV = Max(tolVFirst,tolV);
678 }
679 if (isVLast && ArePnt2dEqual(p2Ar,p2dLast,tolULast,tolVLast)) {
680 tolU = Max(tolULast,tolU); tolV = Max(tolVLast,tolV);
681 }
682 Standard_Real nptCh = UMaxCh-UMinCh;
683 Standard_Boolean isNptLow = nptCh < 10. && nptCh < Nbptlin/100. ||
684 !Domain->Has3d() && Standard_Integer(nptCh)+1 < Nbptlin;
685 if (!isNptLow && !IsSegment2dSmall(Brise,UMinAr,UMaxAr,tolU,tolV)) {
686 // treat both ends
687 Standard_Real UMinChP,UMaxChP,UMinArP,UMaxArP;
688 UMinChP = IntegerPart(UMinCh); UMinArP = IntegerPart(UMinAr);
689 UMaxChP = IntegerPart(UMaxCh); UMaxArP = IntegerPart(UMaxAr);
690 Standard_Integer irangCh1,irangCh2,irangAr1,irangAr2;
691 irangCh1 = Standard_Integer(UMinChP)+1; irangCh2 = Standard_Integer(UMaxChP)+1;
692 irangAr1 = Standard_Integer(UMinArP)+1; irangAr2 = Standard_Integer(UMaxArP)+1;
693 UMinChP = UMinCh - UMinChP; UMinArP = UMinAr - UMinArP;
694 //UMaxChP = UMaxCh - UMaxChP; UMaxArP = UMaxAr - UMaxArP;
695 const Standard_Real eps = 1e-10;
696// Standard_Boolean isChExtr1 = irangCh1==1 && UMinChP<eps;
697// Standard_Boolean isChExtr2 = irangCh2==Nbptlin;
698 Standard_Boolean isArExtr1 = irangAr1==1 && UMinArP<eps;
699 Standard_Boolean isArExtr2 = irangAr2==NbEchant;
700 // detect orientation
701 gp_Pnt2d p1Ch = GetPointOnPolygo(PLin,UMinCh);
702 Standard_Real d11 = p1Ch.SquareDistance(p1Ar);
703 Standard_Real d12 = p1Ch.SquareDistance(p2Ar);
704 Standard_Boolean sameOri = d11 < d12;
705 if (!sameOri) {
706 Standard_Boolean itmp=isArExtr1; isArExtr1=isArExtr2; isArExtr2=itmp;
707 Standard_Real dtmp=UMinAr; UMinAr=UMaxAr; UMaxAr=dtmp;
708 }
709 W1[0] = UMinCh; W1[1] = UMaxCh;
710 W2[0] = UMinAr; W2[1] = UMaxAr;
711 //refine[0] = ! (isChExtr1 || isArExtr1);
712 //refine[1] = ! (isChExtr2 || isArExtr2);
713 refine[0] = refine[1] = Standard_False;
714 useWL[0] = !isArExtr1;
715 useWL[1] = !isArExtr2;
716 nbpt = 2;
717 }
718 else {
719 // treat the middle point as an intersection point
720 W1[0] = 0.5*(UMinCh+UMaxCh);
721 W2[0] = 0.5*(UMinAr+UMaxAr);
722 refine[0] = Standard_True;
723 }
724 }
725
726 Standard_Boolean nbTreated = 0;
727 for (Standard_Integer ip=0; ip < nbpt; ip++) {
728 GetLinePoint2d (L, W1[ip]+1, !OnFirst, U,V);
729
730 if (!refine[ip] && useWL[ip]) {
731 Standard_Real aU1,aV1;
732 GetLinePoint2d (L, W1[ip]+1, OnFirst, aU1,aV1);
733 p2d.SetCoord(aU1,aV1);
734 Standard_Real paramProj;
735 if (!IntPatch_HInterTool::Project(arc,p2d,paramProj,p2d)) continue;
736 W = paramProj;
737 }
738 else {
739 Standard_Real par = IntegerPart(W2[ip]);
740 Standard_Integer Irang = Standard_Integer(par) + 1;
741 if (Irang == Brise.NbPoints()) {
742 Irang--;
743 par = 1.;
744 }
745 else {
746 par =Abs(W2[ip]-par);
747 }
748 W = (1.-par)*Brise.Parameter(Irang) + par*Brise.Parameter(Irang+1);
749 }
750
751 Standard_Boolean refined = Standard_False;
752 if (refine[ip]) {
753 //------------------------------------------------------------------------
754 //-- On a trouve un point 2d approche Ua,Va intersection de la ligne
755 //-- de cheminement et de la restriction.
756 //--
757 //-- On injecte ce point ds les intersections Courbe-Surface
758 //--
759 IntPatch_CSFunction thefunc(OtherSurf,arc,Surf);
760 // MSV: extend UV bounds to not miss solution near the boundary
761 Standard_Real margCoef = 0.004;
762 IntPatch_CurvIntSurf IntCS(U,V,W,thefunc,edgeTol,margCoef);
763 if (IntCS.IsDone()) {
764 if (!IntCS.IsEmpty()) {
765 ptsommet = IntCS.Point();
766 IntCS.ParameterOnSurface(U2,V2);
767 paramarc = IntCS.ParameterOnCurve();
768 refined = Standard_True;
769 }
770 }
771 }
772 else {
773 U2 = U; V2 = V;
774 paramarc = W;
775 arc->D0(paramarc,p2d);
776 Surf->D0(p2d.X(),p2d.Y(),ptsommet);
777 }
778
779 if (!refine[ip] || refined) {
780 duplicate = Standard_False;
781 for (j=1; j<=locpt.Length();j++) {
782 if (ptsommet.Distance(locpt(j)) <= edgeTol) {
783 if (possiblyClosed) {
784 locpt2(j).Coord(U,V);
785 if (OSurfaceIsUClosed && Abs(U-U2) > tolOUClosed ||
786 OSurfaceIsVClosed && Abs(V-V2) > tolOVClosed)
787 continue;
788 }
789 duplicate = Standard_True;
790 break;
791 }
792 }
793
794 if (!duplicate) {
795 Standard_Integer ParamApproxOnLine = Standard_Integer(W1[ip])+1;
796
797 arc->D1(paramarc,p2d,d2d);
798 U1 = p2d.X(); V1 = p2d.Y();
799 if (typL == IntPatch_Walking && SurfaceIsPeriodic)
800 if (OnFirst)
801 Recadre(TypeS1,TypeS2,wlin,ParamApproxOnLine,U1,V1,U2,V2);
802 else
803 Recadre(TypeS1,TypeS2,wlin,ParamApproxOnLine,U2,V2,U1,V1);
804
805 locpt.Append(ptsommet);
806 locpt2.Append(gp_Pnt2d(U2,V2));
807
808 found = FindParameter(L,OtherSurf,edgeTol,ptsommet,gp_Pnt2d(U2,V2),
809 paramline,tgline,ParamApproxOnLine,OnFirst);
810
811 if (typL == IntPatch_Walking && found && possiblyClosed) {
812 // check in 2d
813 if (SurfaceIsUClosed || SurfaceIsVClosed) {
814 GetLinePoint2d (L, paramline, OnFirst, U,V);
815 if (SurfaceIsUClosed && Abs(U-U1) > tolUClosed ||
816 SurfaceIsVClosed && Abs(V-V1) > tolVClosed)
817 found = Standard_False;
818 }
819 if (found && (OSurfaceIsUClosed || OSurfaceIsVClosed)) {
820 GetLinePoint2d (L, paramline, !OnFirst, U,V);
821 if (OSurfaceIsUClosed && Abs(U-U2) > tolOUClosed ||
822 OSurfaceIsVClosed && Abs(V-V2) > tolOVClosed)
823 found = Standard_False;
824 }
825 }
826 if (!found) {
827 continue;
828 }
829
830 VtxOnArc = CoincideOnArc(ptsommet,arc,Surf,edgeTol,Domain,vtxarc);
831 Standard_Real vtxTol;
832 if (VtxOnArc) {
833 vtxTol = Tol3d(vtxarc,Domain);
834 if (edgeTol > vtxTol) vtxTol = edgeTol;
835 }
836 else vtxTol = edgeTol;
837
838 //-- It is necessary to test that the point does not already exist
839 //-- - It can be already a point on arc
840 //-- BUT on a different arc
841 // MSV 27.03.2002: find the nearest point; add check in 2d
842 Standard_Integer ivtx = 0;
843 Standard_Real dmin = RealLast();
844 for (j=1; j<=Nbvtx; j++) {
845 const IntPatch_Point& Rptline = (typL == IntPatch_Walking
846 ? wlin->Vertex(j)
847 : rlin->Vertex(j));
848 Standard_Boolean APointOnRstStillExist =
849 (OnFirst && Rptline.IsOnDomS1() && Rptline.ArcOnS1() == arc ||
850 !OnFirst && Rptline.IsOnDomS2() && Rptline.ArcOnS2() == arc);
851 if(!APointOnRstStillExist) {
852 if (possiblyClosed) {
853 if (SurfaceIsUClosed || SurfaceIsVClosed) {
854 if (OnFirst) Rptline.ParametersOnS1(U,V);
855 else Rptline.ParametersOnS2(U,V);
856 if (SurfaceIsUClosed && Abs(U-U1) > tolUClosed ||
857 SurfaceIsVClosed && Abs(V-V1) > tolVClosed)
858 continue;
859 }
860 if (OSurfaceIsUClosed || OSurfaceIsVClosed) {
861 if (OnFirst) Rptline.ParametersOnS2(U,V);
862 else Rptline.ParametersOnS1(U,V);
863 if (OSurfaceIsUClosed && Abs(U-U2) > tolOUClosed ||
864 OSurfaceIsVClosed && Abs(V-V2) > tolOVClosed)
865 continue;
866 }
867 }
868 Standard_Real dist = ptsommet.Distance(Rptline.Value());
869 Standard_Real dt = Max(vtxTol, Rptline.Tolerance());
870 if (dist < dmin) {
871 if (dist <= dt) {
872 ptline = Rptline;
873 ivtx = j;
874 if( surfacetype == GeomAbs_Cone ) {
875 ivtx = 0;
876 }
877 }
878 else {
879 // cancel previous solution because this point is better
880 // but its tolerance is not large enough
881 ivtx = 0;
882 }
883 dmin = dist;
884 }
885 }
886 }
887 if (ivtx) {
888 if (ptline.Tolerance() > vtxTol) {
889 vtxTol = ptline.Tolerance();
890 if (!VtxOnArc) {
891 // now we should repeat attempt to coincide on a bound of arc
892 VtxOnArc = CoincideOnArc(ptsommet,arc,Surf,vtxTol,Domain,vtxarc);
893 if (VtxOnArc) {
894 Standard_Real tol = Tol3d(vtxarc,Domain);
895 if (tol > vtxTol) vtxTol = tol;
896 }
897 }
898 }
899 }
900
901 if (typL == IntPatch_Walking)
902 VerifyTgline(wlin,(Standard_Integer)paramline,edgeTol,tgline);
903
904 Surf->D1(U1,V1,ptbid,d1u,d1v);
905 tgrst.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
906
907 normsurf = d1u.Crossed(d1v);
908 if (normsurf.Magnitude() < gp::Resolution()) {
909 transline.SetValue(Standard_True,IntSurf_Undecided);
910 transarc.SetValue(Standard_True,IntSurf_Undecided);
911 }
912 else
913 IntSurf::MakeTransition(tgline,tgrst,normsurf,transline,transarc);
914
915 if (typL == IntPatch_Walking && !refine[ip]) {
916 // for new vertex use coordinates from Line
917 if (OnFirst)
918 GetWLinePoint (wlin, paramline, U1,V1,U2,V2,ptsommet);
919 else
920 GetWLinePoint (wlin, paramline, U2,V2,U1,V1,ptsommet);
921 }
922
923 nbTreated++;
924 if (!ivtx) {
925 Sommet.SetValue(ptsommet,vtxTol,Standard_False); // pour tangence
926 if (OnFirst)
927 Sommet.SetParameters(U1,V1,U2,V2);
928 else
929 Sommet.SetParameters(U2,V2,U1,V1);
930
931 if (VtxOnArc)
932 Sommet.SetVertex(OnFirst,vtxarc);
933
934 //---------------------------------------------------------
935 //-- lbr : On remplace le point d indice paramline sur la -
936 //-- ligne par le vertex . -
937 //---------------------------------------------------------
938 Sommet.SetParameter(paramline); // sur ligne d intersection
939 Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc);
940
941 if (typL == IntPatch_Walking) {
942 wlin->AddVertex(Sommet);
943 Nbvtx++;
944 }
945 else {
946 rlin->AddVertex(Sommet);
947 Nbvtx++;
948 }
949 }
950 else {
951 // CAS DE FIGURE : en appelant s1 la surf sur laquelle on
952 // connait les pts sur restriction, et s2 celle sur laquelle
953 // on les cherche. Le point trouve verifie necessairement
954 // IsOnDomS1 = True.
955 // Pas vtxS1, pas vtxS2 :
956 // on recupere le point et on applique SetArcOnS2 et
957 // eventuellement SetVertexOnS2. Si on a deja IsOnDomS2,
958 // on considere que le point est deja traite, mais ne devrait
959 // pas se produire.
960 // vtxS1, pas vtxS2 :
961 // si pas IsOnDomS2 : pour chaque occurrence, faire SetArcOnS2,
962 // et eventuellement SetVertexOnS2.
963 // si IsOnDomS2 : impossible, on doit avoir IsVtxOnS2.
964 // vtxS1,vtxS2 :
965 // on doit avoir VtxOnArc = True. On duplique chaque occurrence
966 // "sur S1" du point en changeant ArcOnS2.
967 // pas vtxS1, vtxS2 :
968 // on doit avoir VtxOnArc = True. On duplique le point sur S1
969 // en changeant ArcOnS2.
970 Standard_Boolean OnDifferentRst =
971 (OnFirst && ptline.IsOnDomS1() && ptline.ArcOnS1() != arc ||
972 !OnFirst && ptline.IsOnDomS2() && ptline.ArcOnS2() != arc);
973 ptline.SetTolerance(vtxTol);
974 if ( (!ptline.IsVertexOnS1() && OnFirst)
975 || (!ptline.IsVertexOnS2() && !OnFirst)
976 || (OnDifferentRst)) {
977 if ( (!ptline.IsOnDomS2() && !OnFirst)
978 ||(!ptline.IsOnDomS1() && OnFirst)
979 ||(OnDifferentRst)) {
980 ptline.SetArc(OnFirst,arc,paramarc,transline,transarc);
981 //ptline.SetParameter(paramline); //-- rajout lbr le 20 nov 97
982 if (VtxOnArc)
983 ptline.SetVertex(OnFirst,vtxarc);
984 if (typL == IntPatch_Walking) {
985 if(OnDifferentRst) {
986 wlin->AddVertex(ptline);
987 Nbvtx++;
988 }
989 else {
990 wlin->Replace(ivtx,ptline);
991 }
992 }
993 else {
994 if(OnDifferentRst) {
995 rlin->AddVertex(ptline);
996 Nbvtx++;
997 }
998 else {
999 rlin->Replace(ivtx,ptline);
1000 }
1001 }
1002 }
1003 else if ( ( OnFirst && ptline.IsVertexOnS2())
1004 ||(!OnFirst && ptline.IsVertexOnS1())) {
1005 Sommet = ptline;
1006 Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc);
1007 if (VtxOnArc)
1008 Sommet.SetVertex(OnFirst,vtxarc);
1009 if (typL == IntPatch_Walking) {
1010 wlin->AddVertex(Sommet);
1011 Nbvtx++;
1012 }
1013 else {
1014 rlin->AddVertex(Sommet);
1015 Nbvtx++;
1016 }
1017 }
1018 else {
1019 //-- cout << "pb dans RstInt Type 1 " << endl;
1020 }
1021 }
1022 else {
1023 Handle(Adaptor3d_HVertex) vtxref = (OnFirst)? (ptline.VertexOnS1()) : (ptline.VertexOnS2()) ;
1024 if ( ( OnFirst && !ptline.IsOnDomS2())
1025 ||(!OnFirst && !ptline.IsOnDomS1())) {
1026 ptline.SetArc(OnFirst,arc,paramarc,transline,transarc);
1027 if (VtxOnArc)
1028 ptline.SetVertex(OnFirst,vtxarc);
1029 if (typL == IntPatch_Walking) {
1030 wlin->Replace(ivtx,ptline);
1031 }
1032 else {
1033 rlin->Replace(ivtx,ptline);
1034 }
1035
1036 for (k=1; k<=Nbvtx; k++) if (k != ivtx) {
1037 if (typL == IntPatch_Walking) {
1038 ptline = wlin->Vertex(k);
1039 }
1040 else {
1041 ptline = rlin->Vertex(k);
1042 }
1043 if ( ( OnFirst && ptline.IsVertexOnS1())
1044 || (!OnFirst && ptline.IsVertexOnS2())) {
1045 if (Domain->Identical(vtxref, (OnFirst)? (ptline.VertexOnS1()) : (ptline.VertexOnS2()))) {
1046 if (ptline.Tolerance() < vtxTol) ptline.SetTolerance(vtxTol);
1047 ptline.SetArc(OnFirst,arc,paramarc,transline,transarc);
1048 if (VtxOnArc)
1049 ptline.SetVertex(OnFirst,vtxarc);
1050 if (typL == IntPatch_Walking) {
1051 wlin->Replace(k,ptline);
1052 }
1053 else {
1054 rlin->Replace(k,ptline);
1055 }
1056 }
1057 }
1058 }
1059 }
1060 else if( ( OnFirst && ptline.IsVertexOnS2())
1061 || (!OnFirst && ptline.IsVertexOnS1())) {
1062 // on doit avoir vtxons2 = vtxarc... pas de verif...
1063 Sommet = ptline;
1064 Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc);
1065 if (typL == IntPatch_Walking) {
1066 wlin->AddVertex(Sommet);
1067 Nbvtx++;
1068 }
1069 else {
1070 rlin->AddVertex(Sommet);
1071 Nbvtx++;
1072 }
1073 for (k=1; k<=Nbvtx; k++) if (k != ivtx) {
1074 if (typL == IntPatch_Walking) {
1075 ptline = wlin->Vertex(k);
1076 }
1077 else {
1078 ptline = rlin->Vertex(k);
1079 }
1080 if ( ( OnFirst && ptline.IsVertexOnS1())
1081 ||(!OnFirst && ptline.IsVertexOnS2())) {
1082 if (Domain->Identical(vtxref,(OnFirst)? (ptline.VertexOnS1()) : (ptline.VertexOnS2()))) {
1083 if (ptline.Tolerance() < vtxTol) ptline.SetTolerance(vtxTol);
1084 Sommet = ptline;
1085 Sommet.SetArc(OnFirst,arc,paramarc,transline,transarc);
1086 if (typL == IntPatch_Walking) {
1087 wlin->Replace(k,ptline);
1088 wlin->AddVertex(Sommet);
1089 Nbvtx++;
1090 }
1091 else {
1092 rlin->Replace(k,ptline);
1093 rlin->AddVertex(Sommet);
1094 Nbvtx++;
1095 }
1096 }
1097 }
1098 }
1099
1100 }
1101 else {
1102 //-- cout << "pb dans RstInt Type 2 " << endl;
1103 }
1104 }
1105 }
1106 }
1107 }
1108 }
1109 if (nbTreated == 2 && typL == IntPatch_Walking) {
1110 // We processed a tangent zone, and both ends have been treated.
1111 // So mark WLine as having arc
1112 if(OnFirst) wlin->SetArcOnS1(arc);
1113 else wlin->SetArcOnS2(arc);
1114 }
1115 }
1116
1117 IndiceOffsetPeriodic++;
1118 }
1119 while(SurfaceIsPeriodic && IndiceOffsetPeriodic<=2);
1120
1121 IndiceOffsetBiPeriodic++;
1122 }
1123 while(SurfaceIsBiPeriodic && IndiceOffsetBiPeriodic<=2);
1124 Domain->Next();
1125 }
1126
1127 //--------------------------------------------------------------------------------
1128 //-- On reprend la ligne et on recale les parametres des vertex.
1129 //--
1130 if (typL == IntPatch_Walking) {
1131 Standard_Real pu1,pv1,pu2,pv2;
1132 pu1=pv1=pu2=pv2=0.0;
1133 switch(TypeS1) {
1134 case GeomAbs_Cylinder:
1135 case GeomAbs_Cone:
1136 case GeomAbs_Sphere:
1137 pu1=PI+PI;
1138 break;
1139 case GeomAbs_Torus:
1140 pu1=pv1=PI+PI;
1141 break;
1142 default:
1143 {
1144 if( Surf1->IsUPeriodic()) {
1145 pu1=Surf1->UPeriod();
1146 }
1147 else if(Surf1->IsUClosed()) {
1148 pu1=Surf1->LastUParameter() - Surf1->FirstUParameter();
1149 //cout<<" UClosed1 "<<pu1<<endl;
1150 }
1151 if( Surf1->IsVPeriodic()) {
1152 pv1=Surf1->VPeriod();
1153 }
1154 else if(Surf1->IsVClosed()) {
1155 pv1=Surf1->LastVParameter() - Surf1->FirstVParameter();
1156 //cout<<" VClosed1 "<<pv1<<endl;
1157 }
1158
1159 break;
1160 }
1161 }
1162
1163 switch(TypeS2) {
1164 case GeomAbs_Cylinder:
1165 case GeomAbs_Cone:
1166 case GeomAbs_Sphere:
1167
1168 pu2=PI+PI;
1169 break;
1170 case GeomAbs_Torus:
1171 pu2=pv2=PI+PI;
1172 break;
1173 default:
1174 {
1175 if( Surf2->IsUPeriodic()) {
1176 pu2=Surf2->UPeriod();
1177 }
1178 else if(Surf2->IsUClosed()) {
1179 pu2=Surf2->LastUParameter() - Surf2->FirstUParameter();
1180 //cout<<" UClosed2 "<<pu2<<endl;
1181 }
1182
1183 if( Surf2->IsVPeriodic()) {
1184 pv2=Surf2->VPeriod();
1185 }
1186 else if(Surf2->IsVClosed()) {
1187 pv2=Surf2->LastVParameter() - Surf2->FirstVParameter();
1188 //cout<<" VClosed2 "<<pv2<<endl;
1189 }
1190
1191 break;
1192 }
1193 }
1194
1195/*
1196 if(pu1==0) {
1197 pu1=Surf1->LastUParameter() - Surf1->FirstUParameter();
1198 pu1+=pu1;
1199 }
1200 if(pu2==0) {
1201 pu2=Surf2->LastUParameter() - Surf2->FirstUParameter();
1202 pu2+=pu2;
1203 }
1204 if(pv1==0) {
1205 pv1=Surf1->LastVParameter() - Surf1->FirstVParameter();
1206 pv1+=pv1;
1207 }
1208 if(pv2==0) {
1209 pv2=Surf2->LastVParameter() - Surf2->FirstVParameter();
1210 pv2+=pv2;
1211 }
1212*/
1213
1214 wlin->SetPeriod(pu1,pv1,pu2,pv2);
1215 wlin->ComputeVertexParameters(Tol);
1216 }
1217 else {
1218#ifdef DEB
1219 //if(rlin->NbVertex()==0) {
1220 // cout<<" \n *** IntPatch RstInt.gxx : nbvtx = 0 sur rline *** \n"<<endl;
1221 //}
1222#endif
1223 rlin->ComputeVertexParameters(Tol);
1224 }
1225}