b311480e |
1 | // Created on: 1991-05-27 |
2 | // Created by: Isabelle GRIGNON |
3 | // Copyright (c) 1991-1999 Matra Datavision |
973c2be1 |
4 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e |
5 | // |
973c2be1 |
6 | // This file is part of Open CASCADE Technology software library. |
b311480e |
7 | // |
d5f74e42 |
8 | // This library is free software; you can redistribute it and/or modify it under |
9 | // the terms of the GNU Lesser General Public License version 2.1 as published |
973c2be1 |
10 | // by the Free Software Foundation, with special exception defined in the file |
11 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
12 | // distribution for complete text of the license and disclaimer of any warranty. |
b311480e |
13 | // |
973c2be1 |
14 | // Alternatively, this file may be used under the terms of Open CASCADE |
15 | // commercial license or contractual agreement. |
7fd59977 |
16 | |
42cf5bc1 |
17 | |
18 | #include <Adaptor2d_HCurve2d.hxx> |
19 | #include <gp_Pnt.hxx> |
20 | #include <gp_Pnt2d.hxx> |
21 | #include <IntPatch_Point.hxx> |
22 | #include <IntPatch_WLine.hxx> |
23 | #include <IntSurf_LineOn2S.hxx> |
24 | #include <IntSurf_PntOn2S.hxx> |
25 | #include <Standard_DomainError.hxx> |
26 | #include <Standard_OutOfRange.hxx> |
27 | #include <Standard_Type.hxx> |
7fd59977 |
28 | |
92efcf78 |
29 | IMPLEMENT_STANDARD_RTTIEXT(IntPatch_WLine,IntPatch_PointLine) |
30 | |
7fd59977 |
31 | #define DEBUG 0 |
32 | #define DEBUGV 0 |
33 | |
34 | #include <IntSurf_PntOn2S.hxx> |
35 | #include <Precision.hxx> |
36 | #include <stdio.h> |
37 | |
38 | |
39 | IntPatch_WLine::IntPatch_WLine (const Handle(IntSurf_LineOn2S)& Line, |
40 | const Standard_Boolean Tang, |
41 | const IntSurf_TypeTrans Trans1, |
42 | const IntSurf_TypeTrans Trans2) : |
d4b867e6 |
43 | IntPatch_PointLine(Tang,Trans1,Trans2),fipt(Standard_False),lapt(Standard_False), |
716037dd |
44 | hasArcOnS1(Standard_False),hasArcOnS2(Standard_False), |
45 | myIsPurgerAllowed(Standard_True) |
7fd59977 |
46 | { |
47 | typ = IntPatch_Walking; |
48 | curv = Line; |
49 | Buv1.SetWhole(); |
50 | Buv2.SetWhole(); |
51 | Bxyz.SetWhole(); |
52 | u1period=v1period=u2period=v2period=0.0; |
53 | } |
54 | |
55 | |
56 | IntPatch_WLine::IntPatch_WLine (const Handle(IntSurf_LineOn2S)& Line, |
57 | const Standard_Boolean Tang, |
58 | const IntSurf_Situation Situ1, |
59 | const IntSurf_Situation Situ2) : |
d4b867e6 |
60 | IntPatch_PointLine(Tang,Situ1,Situ2),fipt(Standard_False),lapt(Standard_False), |
716037dd |
61 | hasArcOnS1(Standard_False),hasArcOnS2(Standard_False), |
62 | myIsPurgerAllowed(Standard_True) |
7fd59977 |
63 | { |
64 | typ = IntPatch_Walking; |
65 | curv = Line; |
66 | Buv1.SetWhole(); |
67 | Buv2.SetWhole(); |
68 | Bxyz.SetWhole(); |
69 | u1period=v1period=u2period=v2period=0.0; |
70 | } |
71 | |
72 | |
73 | IntPatch_WLine::IntPatch_WLine (const Handle(IntSurf_LineOn2S)& Line, |
74 | const Standard_Boolean Tang) : |
d4b867e6 |
75 | IntPatch_PointLine(Tang),fipt(Standard_False),lapt(Standard_False), |
716037dd |
76 | hasArcOnS1(Standard_False),hasArcOnS2(Standard_False), |
77 | myIsPurgerAllowed(Standard_True) |
7fd59977 |
78 | { |
79 | typ = IntPatch_Walking; |
80 | curv = Line; |
81 | Buv1.SetWhole(); |
82 | Buv2.SetWhole(); |
83 | Bxyz.SetWhole(); |
84 | u1period=v1period=u2period=v2period=0.0; |
85 | } |
86 | |
87 | |
88 | void IntPatch_WLine::SetPoint(const Standard_Integer Index, |
89 | const IntPatch_Point& thepoint) |
90 | { |
91 | curv->Value(Index,thepoint.PntOn2S()); |
92 | } |
93 | |
94 | |
95 | Handle(IntSurf_LineOn2S) IntPatch_WLine::Curve() const |
96 | { |
97 | return(curv); |
98 | } |
99 | |
100 | static void RecadreMemePeriode(Standard_Real& u1,Standard_Real& v1, |
101 | Standard_Real& u2,Standard_Real& v2, |
102 | const Standard_Real anu1,const Standard_Real anv1, |
103 | const Standard_Real anu2,const Standard_Real anv2, |
104 | const Standard_Real U1Period,const Standard_Real V1Period, |
105 | const Standard_Real U2Period,const Standard_Real V2Period) { |
106 | if(U1Period) { |
107 | while(anu1-u1 > 0.8*U1Period) { u1+=U1Period; } |
108 | while(u1-anu1 > 0.8*U1Period) { u1-=U1Period; } |
109 | } |
110 | if(U2Period) { |
111 | while(anu2-u2 > 0.8*U2Period) { u2+=U2Period; } |
112 | while(u2-anu2 > 0.8*U2Period) { u2-=U2Period; } |
113 | } |
114 | if(V1Period) { |
115 | while(anv1-v1 > 0.8*V1Period) { v1+=V1Period; } |
116 | while(v1-anv1 > 0.8*V1Period) { v1-=V1Period; } |
117 | } |
118 | if(V2Period) { |
119 | while(anv2-v2 > 0.8*V2Period) { v2+=V2Period; } |
120 | while(v2-anv2 > 0.8*V2Period) { v2-=V2Period; } |
121 | } |
122 | |
123 | } |
124 | |
125 | static void RecadreMemePeriode(IntSurf_PntOn2S& POn2S,const IntSurf_PntOn2S& RefPOn2S, |
126 | const Standard_Real up1, |
127 | const Standard_Real vp1, |
128 | const Standard_Real up2, |
129 | const Standard_Real vp2) { |
130 | Standard_Real u1,v1,u2,v2,pu1,pv1,pu2,pv2; |
131 | POn2S.Parameters(u1,v1,u2,v2); |
132 | RefPOn2S.Parameters(pu1,pv1,pu2,pv2); |
133 | RecadreMemePeriode(u1,v1,u2,v2,pu1,pv1,pu2,pv2,up1,vp1,up2,vp2); |
134 | POn2S.SetValue(u1,v1,u2,v2); |
135 | } |
136 | |
68cdb44b |
137 | static Standard_Boolean CompareVertexAndPoint(const gp_Pnt& V, const gp_Pnt& P, const Standard_Real& Tol) { |
c0e32b3c |
138 | const Standard_Real aSQDist = V.SquareDistance(P); |
139 | const Standard_Real aSQTol = Tol*Tol; |
140 | return (aSQDist <= aSQTol); |
7fd59977 |
141 | } |
142 | |
143 | void IntPatch_WLine::SetPeriod(const Standard_Real pu1, |
144 | const Standard_Real pv1, |
145 | const Standard_Real pu2, |
146 | const Standard_Real pv2) { |
147 | u1period=pu1; v1period=pv1; u2period=pu2; v2period=pv2; |
148 | } |
149 | Standard_Real IntPatch_WLine::U1Period() const { return(u1period); } |
150 | Standard_Real IntPatch_WLine::V1Period() const { return(v1period); } |
151 | Standard_Real IntPatch_WLine::U2Period() const { return(u2period); } |
152 | Standard_Real IntPatch_WLine::V2Period() const { return(v2period); } |
153 | |
154 | |
155 | //------------------------------------------------------------------------ |
156 | //-- En Entree : Une ligne de cheminement + Une Liste de Vetex |
157 | //-- |
158 | //-- LineOn2S : 1------2-------3-------4-----5---- ----nbp |
159 | //-- |
160 | //-- Vertex : a b c d e f |
161 | //-- |
162 | //-- |
163 | //-- En Sortie |
164 | //-- |
165 | //-- 1--2-3-4--5--------6----7--8--9--10-------- |
166 | //-- |
167 | //-- avec a de parametre 1 |
168 | //-- b 3 |
169 | //-- |
170 | //-- etc ... |
171 | //-- |
172 | //-- |
173 | //-- !!!!!!!!!!!!!!! On considere que deux vertex ne peuvent pas etre |
174 | //-- !!!!!!!!!!!!!!! a une distance inferieure a Tol |
175 | //------------------------------------------------------------------------ |
176 | //-- |
177 | //-- On Teste si la LineOn2S contient des points confondus. |
178 | //-- Dans ce cas, on remove ces points. |
179 | //-- |
180 | //------------------------------------------------------------------------ |
181 | |
182 | Standard_Boolean SameVtxRst(const IntPatch_Point& vtx1,const IntPatch_Point& vtx2) { |
183 | if(vtx1.IsOnDomS1()) { |
184 | if(vtx2.IsOnDomS1()) { |
185 | if(vtx1.ArcOnS1() == vtx2.ArcOnS1()) { |
186 | if(vtx1.ParameterOnArc1() == vtx2.ParameterOnArc1()) { |
187 | |
188 | } |
189 | else { |
190 | return(Standard_False); |
191 | } |
192 | } |
193 | else { |
194 | return(Standard_False); |
195 | } |
196 | } |
197 | else { |
198 | return(Standard_False); |
199 | } |
200 | } |
201 | else { |
202 | if(vtx2.IsOnDomS1()) { |
203 | return(Standard_False); |
204 | } |
205 | } |
206 | if(vtx1.IsOnDomS2()) { |
207 | if(vtx2.IsOnDomS2()) { |
208 | if(vtx1.ArcOnS2() == vtx2.ArcOnS2()) { |
209 | if(vtx1.ParameterOnArc2() == vtx2.ParameterOnArc2()) { |
210 | |
211 | } |
212 | else { |
213 | return(Standard_False); |
214 | } |
215 | } |
216 | else { |
217 | return(Standard_False); |
218 | } |
219 | } |
220 | else { |
221 | return(Standard_False); |
222 | } |
223 | } |
224 | else { |
225 | if(vtx2.IsOnDomS2()) { |
226 | return(Standard_False); |
227 | } |
228 | } |
229 | return(Standard_True); |
230 | } |
231 | |
232 | |
233 | static Standard_Boolean CompareVerticesOnSurf(const IntPatch_Point& vtx1, |
234 | const IntPatch_Point& vtx2, |
235 | const Standard_Boolean onFirst) |
236 | { |
237 | Standard_Real u1,v1,u2,v2, tolU, tolV; |
238 | if (onFirst) { |
239 | vtx1.ParametersOnS1(u1,v1); |
240 | vtx2.ParametersOnS1(u2,v2); |
241 | } |
242 | else { |
243 | vtx1.ParametersOnS2(u1,v1); |
244 | vtx2.ParametersOnS2(u2,v2); |
245 | } |
246 | tolU = Precision::PConfusion(); |
247 | tolV = Precision::PConfusion(); |
248 | return (Abs(u1-u2) <= tolU && Abs(v1-v2) <= tolV); |
249 | } |
250 | |
251 | inline Standard_Boolean CompareVerticesOnS1(const IntPatch_Point& vtx1, const IntPatch_Point& vtx2) |
252 | {return CompareVerticesOnSurf (vtx1, vtx2, Standard_True);} |
253 | |
254 | inline Standard_Boolean CompareVerticesOnS2(const IntPatch_Point& vtx1, const IntPatch_Point& vtx2) |
255 | {return CompareVerticesOnSurf (vtx1, vtx2, Standard_False);} |
256 | |
257 | |
882e1d11 |
258 | void IntPatch_WLine::ComputeVertexParameters( const Standard_Real RTol) |
c2c2f2b6 |
259 | { |
7fd59977 |
260 | // MSV Oct 15, 2001: use tolerance of vertex instead of RTol where |
261 | // it is possible |
262 | |
263 | Standard_Integer i,j,k,nbvtx,nbponline; |
264 | Standard_Integer indicevertexonline; |
265 | Standard_Real indicevertex; |
266 | |
7fd59977 |
267 | Standard_Boolean APointDeleted = Standard_False; |
268 | //---------------------------------------------------------- |
269 | //-- F i l t r e s u r r e s t r i c t i o n s -- |
270 | //---------------------------------------------------------- |
271 | //-- deux vertex sur la meme restriction et seulement |
272 | //-- sur celle ci ne doivent pas avoir le meme parametre |
273 | //-- |
274 | Standard_Real Tol=RTol; |
275 | nbvtx = NbVertex(); |
276 | |
277 | #if DEBUGV |
278 | cout<<"\n----------- avant ComputeVertexParameters -------------"<<endl; |
279 | for(i=1;i<=nbvtx;i++) { |
280 | Vertex(i).Dump(); |
281 | Standard_Real polr = Vertex(i).ParameterOnLine(); |
282 | Standard_Real pol = (Standard_Integer)polr; |
283 | if(pol>=1 && pol<=nbvtx) { |
284 | cout<<"----> IntSurf_PntOn2S : "<<polr<<" Pnt ("<<Vertex(pol).Value().X() |
285 | <<","<<Vertex(pol).Value().Y() |
286 | <<","<<Vertex(pol).Value().Z()<<")"<<endl; |
287 | } |
288 | } |
289 | cout<<"\n----------------------------------------------------------"<<endl; |
290 | #endif |
291 | |
292 | |
293 | //-- ---------------------------------------------------------------------- |
294 | //-- Traitement des aretes de couture : On duplique les points situes |
295 | //-- sur des restrictions differentes |
296 | //-- |
297 | //-- Phase Creation de nouveaux points sur S1 |
298 | Standard_Boolean encoreunefois; |
299 | do { |
300 | nbvtx=NbVertex(); |
301 | encoreunefois=Standard_False; |
302 | for(i=1; i<=nbvtx && encoreunefois==Standard_False; i++) { |
303 | IntPatch_Point& VTXi = svtx.ChangeValue(i); |
304 | for(j=1; j<=nbvtx && encoreunefois==Standard_False; j++) { |
305 | if(i!=j) { |
306 | IntPatch_Point& VTXj = svtx.ChangeValue(j); |
307 | if(VTXi.ParameterOnLine() != VTXj.ParameterOnLine()) { |
308 | Standard_Real d = VTXi.Value().Distance(VTXj.Value()); |
309 | Standard_Real toli = VTXi.Tolerance(); |
310 | Standard_Real tolj = VTXj.Tolerance(); |
311 | Standard_Real maxtol = Max(toli,tolj); |
312 | // MSV Oct 30, 2001: compare in 2D space also; |
313 | // increase tolerances |
314 | if (d < maxtol || |
315 | CompareVerticesOnS1(VTXi,VTXj) || CompareVerticesOnS2(VTXi,VTXj)) { |
316 | //-- Creation Vtx (REF:S1(i) S2(j)) (On Garde S1(i)) |
317 | Standard_Real newtoli = Max (toli, tolj+d*1.01); |
318 | Standard_Real newtolj = Max (tolj, toli+d*1.01); |
319 | Standard_Boolean acreer=Standard_False; |
320 | if(VTXi.IsOnDomS1()) { |
321 | if(VTXj.IsOnDomS1()) { |
322 | if(VTXj.ArcOnS1() != VTXi.ArcOnS1()) { |
323 | acreer=Standard_True; |
324 | } |
325 | } |
326 | else { |
327 | acreer=Standard_True; |
328 | } |
329 | } |
330 | if(acreer) { |
331 | IntPatch_Point vtx; |
332 | vtx = VTXj; |
333 | vtx.SetArc(Standard_True, |
334 | VTXi.ArcOnS1(), |
335 | VTXi.ParameterOnArc1(), |
336 | VTXi.TransitionLineArc1(), |
337 | VTXi.TransitionOnS1()); |
338 | for(k=1; encoreunefois==Standard_False && k<=nbvtx; k++) { |
339 | const IntPatch_Point& VTXk = svtx.Value(k); |
340 | if(SameVtxRst(VTXk,vtx)) { |
341 | encoreunefois=Standard_True; |
342 | } |
343 | } |
344 | if(encoreunefois==Standard_False) { |
345 | VTXi.SetTolerance(newtoli); |
346 | VTXj.SetTolerance(newtolj); |
347 | vtx.SetTolerance(newtolj); |
348 | svtx.Append(vtx); |
349 | encoreunefois=Standard_True; |
350 | } |
351 | else { |
352 | encoreunefois=Standard_False; |
353 | } |
354 | } |
355 | //-- ----------------------------------------------------- |
356 | //-- Creation Vtx (REF:S2(i) S1(j)) (On Garde S2(i)) |
357 | acreer=Standard_False; |
358 | if(VTXi.IsOnDomS2()) { |
359 | if(VTXj.IsOnDomS2()) { |
360 | if(VTXj.ArcOnS2() != VTXi.ArcOnS2()) { |
361 | acreer=Standard_True; |
362 | } |
363 | } |
364 | else { |
365 | acreer=Standard_True; |
366 | } |
367 | } |
368 | if(acreer) { |
369 | IntPatch_Point vtx; |
370 | vtx = VTXj; |
371 | vtx.SetArc(Standard_False, |
372 | VTXi.ArcOnS2(), |
373 | VTXi.ParameterOnArc2(), |
374 | VTXi.TransitionLineArc2(), |
375 | VTXi.TransitionOnS2()); |
376 | for(k=1; encoreunefois==Standard_False && k<=nbvtx; k++) { |
377 | const IntPatch_Point& VTXk = svtx.Value(k); |
378 | if(SameVtxRst(VTXk,vtx)) { |
379 | encoreunefois=Standard_True; |
380 | } |
381 | } |
382 | if(encoreunefois==Standard_False) { |
383 | VTXi.SetTolerance(newtoli); |
384 | VTXj.SetTolerance(newtolj); |
385 | vtx.SetTolerance(newtolj); |
386 | svtx.Append(vtx); |
387 | encoreunefois=Standard_True; |
388 | } |
389 | else { |
390 | encoreunefois=Standard_False; |
391 | } |
392 | } |
393 | } |
394 | } |
395 | } |
396 | } |
397 | } |
398 | } |
399 | while(encoreunefois); |
400 | |
401 | |
402 | |
403 | //-- ---------------------------------------------------------------------- |
404 | |
405 | |
406 | |
407 | do { |
408 | APointDeleted = Standard_False; |
409 | for(i=1; (i<=nbvtx) && (APointDeleted==Standard_False) ;i++) { |
410 | const IntPatch_Point& VTXi = svtx.Value(i); |
411 | if(VTXi.Tolerance() > Tol) Tol = VTXi.Tolerance(); //-- 9 oct 97 |
412 | if((VTXi.IsOnDomS1()==Standard_True) && (VTXi.IsOnDomS2()==Standard_False)) { |
413 | for(j=1; (j<=nbvtx) && (APointDeleted==Standard_False) ;j++) { |
414 | if(i!=j) { |
415 | const IntPatch_Point& VTXj = svtx.Value(j); |
416 | if((VTXj.IsOnDomS1()==Standard_True) && (VTXj.IsOnDomS2()==Standard_False)) { |
417 | if(VTXi.ParameterOnLine() == VTXj.ParameterOnLine()) { |
418 | if(VTXi.ArcOnS1() == VTXj.ArcOnS1()) { |
419 | svtx.Remove(j); |
420 | nbvtx--; |
421 | if(lapt) { if(indl>=j) indl--; } |
422 | if(fipt) { if(indf>=j) indf--; } |
423 | APointDeleted = Standard_True; |
424 | } |
425 | } |
426 | } |
427 | } |
428 | } |
429 | } |
430 | } |
431 | } |
432 | while(APointDeleted == Standard_True); |
433 | |
434 | |
435 | do { |
436 | APointDeleted = Standard_False; |
437 | for(i=1; (i<=nbvtx) && (APointDeleted==Standard_False) ;i++) { |
438 | const IntPatch_Point& VTXi = svtx.Value(i); |
439 | if((VTXi.IsOnDomS2()==Standard_True) && (VTXi.IsOnDomS1()==Standard_False)) { |
440 | for(j=1; (j<=nbvtx) && (APointDeleted==Standard_False) ;j++) { |
441 | if(i!=j) { |
442 | const IntPatch_Point& VTXj = svtx.Value(j); |
443 | if((VTXj.IsOnDomS2()==Standard_True) && (VTXj.IsOnDomS1()==Standard_False)) { |
444 | if(VTXi.ParameterOnLine() == VTXj.ParameterOnLine()) { |
445 | if(VTXi.ArcOnS2() == VTXj.ArcOnS2()) { |
446 | svtx.Remove(j); |
447 | nbvtx--; |
448 | if(lapt) { if(indl>=j) indl--; } |
449 | if(fipt) { if(indf>=j) indf--; } |
450 | APointDeleted = Standard_True; |
451 | } |
452 | } |
453 | } |
454 | } |
455 | } |
456 | } |
457 | } |
458 | } |
459 | while(APointDeleted == Standard_True); |
460 | |
461 | nbvtx = NbVertex(); |
462 | nbponline = NbPnts(); |
463 | |
464 | //---------------------------------------------------- |
465 | //-- On trie les Vertex |
466 | Standard_Boolean SortIsOK; |
467 | do { |
468 | SortIsOK = Standard_True; |
469 | for(i=2; i<=nbvtx; i++) { |
470 | if(svtx.Value(i-1).ParameterOnLine() > svtx.Value(i).ParameterOnLine()) { |
471 | SortIsOK = Standard_False; |
472 | svtx.Exchange(i-1,i); |
473 | } |
474 | } |
475 | } |
476 | while(!SortIsOK); |
477 | |
478 | //---------------------------------------------------- |
479 | //-- On detecte les points confondus dans la LineOn2S |
480 | Standard_Real dmini = Precision::Confusion(); |
481 | dmini*=dmini; |
f73c584c |
482 | for(i=2; (i<=nbponline) && (nbponline > 2); i++) { |
c2c2f2b6 |
483 | const IntSurf_PntOn2S& aPnt1=curv->Value(i-1); |
484 | const IntSurf_PntOn2S& aPnt2=curv->Value(i); |
485 | Standard_Real d = (aPnt1.Value()).SquareDistance((aPnt2.Value())); |
7fd59977 |
486 | if(d < dmini) { |
487 | curv->RemovePoint(i); |
488 | nbponline--; |
489 | //---------------------------------------------- |
490 | //-- On recadre les Vertex si besoin |
491 | //-- |
492 | for(j=1; j<=nbvtx; j++) { |
c2c2f2b6 |
493 | indicevertex = svtx.Value(j).ParameterOnLine(); |
494 | if(indicevertex >= i) { |
495 | svtx.ChangeValue(j).SetParameter(indicevertex-1.0); |
496 | } |
7fd59977 |
497 | } |
498 | //modified by NIZNHY-PKV Mon Feb 11 09:28:02 2002 f |
499 | i--; |
500 | //modified by NIZNHY-PKV Mon Feb 11 09:28:04 2002 t |
501 | } |
502 | } |
503 | //---------------------------------------------------- |
504 | for(i=1; i<=nbvtx; i++) { |
505 | const gp_Pnt& P = svtx.Value(i).Value(); |
506 | Standard_Real vTol = svtx.Value(i).Tolerance(); |
882e1d11 |
507 | |
508 | indicevertex = svtx.Value(i).ParameterOnLine(); |
7fd59977 |
509 | indicevertexonline = (Standard_Integer)indicevertex; |
510 | //-------------------------------------------------- |
511 | //-- On Compare le vertex avec les points de la ligne |
512 | //-- d indice indicevertexOnLine-1 |
513 | //-- indicevertexOnLine |
514 | //-- indicevertexOnLine+1 |
515 | //-------------------------------------------------- |
516 | if(indicevertexonline<1) { |
517 | if(CompareVertexAndPoint(P,curv->Value(1).Value(),vTol)) { |
518 | //------------------------------------------------------- |
519 | //-- On remplace le point cheminement(1) par vertex(i) |
520 | //-- et vertex(i) prend pour parametre 1 |
521 | //------------------------------------------------------- |
522 | |
523 | IntSurf_PntOn2S POn2S = svtx.Value(i).PntOn2S(); |
524 | RecadreMemePeriode(POn2S,curv->Value(1),U1Period(),V1Period(),U2Period(),V2Period()); |
525 | curv->Value(1,POn2S); |
526 | |
527 | //--curv->Value(1,svtx.Value(i).PntOn2S()); |
528 | svtx.ChangeValue(i).SetParameter(1.0); |
529 | } |
530 | else { |
531 | //------------------------------------------------------- |
532 | //-- On insere le point de cheminement Vertex(i) |
533 | //-- On recadre les parametres des autres vertex |
534 | //------------------------------------------------------- |
535 | IntSurf_PntOn2S POn2S = svtx.Value(i).PntOn2S(); |
536 | RecadreMemePeriode(POn2S,curv->Value(1),U1Period(),V1Period(),U2Period(),V2Period()); |
537 | curv->InsertBefore(1,POn2S); |
538 | |
539 | //-- curv->InsertBefore(1,svtx.Value(i).PntOn2S()); |
540 | svtx.ChangeValue(i).SetParameter(1.0); |
541 | nbponline++; |
542 | for(j=1;j<=nbvtx;j++) { |
543 | if(j!=1) { |
544 | Standard_Real t = svtx.Value(j).ParameterOnLine(); |
545 | if(t>1.0) { |
546 | svtx.ChangeValue(j).SetParameter(t+1.0); |
547 | } |
548 | } |
549 | } |
550 | } |
551 | } //--- fin : if(indicevertexonline<1) |
552 | else { |
553 | //--------------------------------------------------------- |
554 | //-- vertex(i) == cheminement (indicevertexonline-1) |
555 | //-- vertex(i) == cheminement (indicevertexonline) |
556 | //-- vertex(i) == cheminement (indicevertexonline+1) |
557 | //--------------------------------------------------------- |
558 | Standard_Boolean Substitution = Standard_False; |
559 | //-- for(k=indicevertexonline+1; !Substitution && k>=indicevertexonline-1;k--) { avant le 9 oct 97 |
560 | for(k=indicevertexonline+1; k>=indicevertexonline-1;k--) { |
561 | if(k>0 && k<=nbponline) { |
562 | if(CompareVertexAndPoint(P,curv->Value(k).Value(),vTol)) { |
563 | //------------------------------------------------------- |
564 | //-- On remplace le point cheminement(k) |
565 | //-- par vertex(i) et vertex(i) prend pour parametre k |
566 | //------------------------------------------------------- |
567 | IntSurf_PntOn2S POn2S = svtx.Value(i).PntOn2S(); |
568 | RecadreMemePeriode(POn2S,curv->Value(k),U1Period(),V1Period(),U2Period(),V2Period()); |
569 | curv->Value(k,POn2S); |
570 | Standard_Real mu1,mv1,mu2,mv2; |
571 | POn2S.Parameters(mu1,mv1,mu2,mv2); |
572 | svtx.ChangeValue(i).SetParameter(k); |
573 | svtx.ChangeValue(i).SetParameters(mu1,mv1,mu2,mv2); |
574 | Substitution = Standard_True; |
575 | } |
576 | } |
577 | } |
e9a6ce82 |
578 | |
579 | //Remove duplicating points |
580 | if (Substitution) |
581 | { |
582 | Standard_Integer ind_point; |
1406e955 |
583 | for(ind_point = 2; (ind_point <= nbponline && nbponline > 1); ind_point++) { |
e9a6ce82 |
584 | Standard_Real d = (curv->Value(ind_point-1).Value()).SquareDistance((curv->Value(ind_point).Value())); |
585 | if(d < dmini) { |
586 | curv->RemovePoint(ind_point); |
587 | nbponline--; |
588 | //---------------------------------------------- |
589 | //-- On recadre les Vertex si besoin |
590 | //-- |
591 | for(j=1; j<=nbvtx; j++) { |
592 | indicevertex = svtx.Value(j).ParameterOnLine(); |
593 | if(indicevertex >= ind_point) { |
594 | svtx.ChangeValue(j).SetParameter(indicevertex-1.0); |
595 | } |
596 | } |
597 | //modified by NIZNHY-PKV Mon Feb 11 09:28:02 2002 f |
598 | ind_point--; |
599 | //modified by NIZNHY-PKV Mon Feb 11 09:28:04 2002 t |
600 | } |
601 | } |
602 | } |
7fd59977 |
603 | |
604 | //--static int deb6nov98=1; Ne resout rien (a part partiellement BUC60409) |
605 | //--if(deb6nov98) { |
606 | //--Substitution=Standard_True; |
607 | //-- } |
608 | |
609 | if(Substitution==Standard_False) { |
610 | //------------------------------------------------------- |
611 | //-- On insere le point de cheminement Vertex(i) |
612 | //-- On recadre les parametres des autres vertex |
613 | //------------------------------------------------------- |
614 | IntSurf_PntOn2S POn2S = svtx.Value(i).PntOn2S(); |
615 | if(indicevertexonline >= nbponline) { |
616 | RecadreMemePeriode(POn2S,curv->Value(nbponline),U1Period(),V1Period(),U2Period(),V2Period()); |
617 | curv->Add(POn2S); |
618 | } |
619 | else { |
620 | RecadreMemePeriode(POn2S,curv->Value(indicevertexonline+1),U1Period(),V1Period(),U2Period(),V2Period()); |
621 | curv->InsertBefore(indicevertexonline+1,POn2S); |
622 | } |
623 | //-- curv->InsertBefore(indicevertexonline+1,svtx.Value(i).PntOn2S()); |
624 | svtx.ChangeValue(i).SetParameter(indicevertexonline+1); |
625 | nbponline++; |
626 | for(j=1;j<=nbvtx;j++) { |
627 | if(j!=i) { |
628 | Standard_Real t = svtx.Value(j).ParameterOnLine(); |
629 | if(t>(Standard_Real)indicevertexonline) { |
630 | svtx.ChangeValue(j).SetParameter(t+1.0); |
631 | } |
632 | } |
633 | } |
634 | } //-- Substitution |
635 | } //-- indicevertexonline>=1 |
636 | |
637 | } //-- boucle i sur vertex |
638 | |
639 | |
640 | |
641 | |
642 | do { |
643 | APointDeleted = Standard_False; |
644 | for(i=1; i<=nbvtx && (APointDeleted == Standard_False); i++) { |
645 | const IntPatch_Point& VTX = svtx.Value(i); |
646 | for(j=1; j<=nbvtx && (APointDeleted == Standard_False) ; j++) { |
647 | if(i!=j) { |
648 | const IntPatch_Point& VTXM1 = svtx.Value(j); |
649 | |
650 | Standard_Boolean kill = Standard_False; |
651 | Standard_Boolean killm1 = Standard_False; |
652 | if(VTXM1.ParameterOnLine() == VTX.ParameterOnLine()) { |
653 | if(VTXM1.IsOnDomS1() && VTX.IsOnDomS1()) { //-- OnS1 OnS1 |
654 | if(VTXM1.ArcOnS1() == VTX.ArcOnS1()) { //-- OnS1 == OnS1 |
655 | if(VTXM1.IsOnDomS2()) { //-- OnS1 == OnS1 OnS2 |
656 | if(VTX.IsOnDomS2()==Standard_False) { //-- OnS1 == OnS1 OnS2 PasOnS2 |
657 | kill=Standard_True; |
658 | } |
659 | else { |
660 | if(VTXM1.ArcOnS2() == VTX.ArcOnS2()) { //-- OnS1 == OnS1 OnS2 == OnS2 |
661 | kill=Standard_True; |
662 | } |
663 | } |
664 | } |
665 | else { //-- OnS1 == OnS1 PasOnS2 |
666 | if(VTX.IsOnDomS2()) { //-- OnS1 == OnS1 PasOnS2 OnS2 |
667 | killm1=Standard_True; |
668 | } |
669 | } |
670 | } |
671 | } |
672 | |
673 | if(!(kill || killm1)) { |
674 | if(VTXM1.IsOnDomS2() && VTX.IsOnDomS2()) { //-- OnS2 OnS2 |
675 | if(VTXM1.ArcOnS2() == VTX.ArcOnS2()) { //-- OnS2 == OnS2 |
676 | if(VTXM1.IsOnDomS1()) { //-- OnS2 == OnS2 OnS1 |
677 | if(VTX.IsOnDomS1()==Standard_False) { //-- OnS2 == OnS2 OnS1 PasOnS1 |
678 | kill=Standard_True; |
679 | } |
680 | else { |
681 | if(VTXM1.ArcOnS1() == VTX.ArcOnS1()) { //-- OnS2 == OnS2 OnS1 == OnS1 |
682 | kill=Standard_True; |
683 | } |
684 | } |
685 | } |
686 | else { //-- OnS2 == OnS2 PasOnS1 |
687 | if(VTX.IsOnDomS1()) { //-- OnS2 == OnS2 PasOnS1 OnS1 |
688 | killm1=Standard_True; |
689 | } |
690 | } |
691 | } |
692 | } |
693 | } |
694 | if(kill) { |
695 | APointDeleted = Standard_True; |
696 | svtx.Remove(i); |
697 | nbvtx--; |
698 | } |
699 | else if(killm1) { |
700 | APointDeleted = Standard_True; |
701 | svtx.Remove(j); |
702 | nbvtx--; |
703 | } |
704 | } |
705 | } |
706 | } |
707 | } |
708 | } |
709 | while(APointDeleted == Standard_True); |
710 | |
711 | do { |
712 | SortIsOK = Standard_True; |
713 | for(i=2; i<=nbvtx && SortIsOK; i++) { |
714 | const IntPatch_Point& Pim1=svtx.Value(i-1); |
715 | const IntPatch_Point& Pii =svtx.Value(i); |
716 | if(Pim1.ParameterOnLine()==Pii.ParameterOnLine()) { |
717 | if( (Pii.IsOnDomS1() == Standard_False) |
718 | && (Pii.IsOnDomS2() == Standard_False)) { |
719 | SortIsOK = Standard_False; |
720 | svtx.Remove(i); |
721 | nbvtx--; |
722 | } |
723 | else { |
724 | if( (Pim1.IsOnDomS1() == Standard_False) |
725 | && (Pim1.IsOnDomS2() == Standard_False)) { |
726 | SortIsOK = Standard_False; |
727 | svtx.Remove(i-1); |
728 | nbvtx--; |
729 | } |
730 | } |
731 | } |
732 | } |
733 | } |
734 | while(!SortIsOK); |
735 | //-- ---------------------------------------------------------------------------- |
736 | //-- On ajoute les vertex de debut et de fin de ligne s il ne sont pas presents. |
737 | //-- |
738 | //-- Existe t il un vertex de debut de ligne, de fin . |
739 | //-- |
740 | //-- Si Besoin : il faudra dedoubler les points de debut et de fin sur les periodiques ?????? |
741 | |
742 | |
743 | |
744 | |
745 | Standard_Boolean bFirst = Standard_False; |
746 | Standard_Boolean bLast = Standard_False; |
747 | nbponline = NbPnts(); |
748 | for(i=1;i<=nbvtx;i++) { |
749 | Standard_Real pol = svtx.Value(i).ParameterOnLine(); |
750 | if(pol==1.0) { |
751 | bFirst = fipt = Standard_True; |
752 | indf = i; |
753 | } |
754 | if(pol==nbponline) { |
755 | bLast = lapt = Standard_True; |
756 | indl = i; |
757 | } |
758 | } |
759 | if(bFirst == Standard_False) { |
760 | Standard_Real pu1,pv1,pu2,pv2; |
761 | Standard_Boolean vtxfound = Standard_False; |
762 | IntPatch_Point vtx; |
763 | curv->Value(1).Parameters(pu1,pv1,pu2,pv2); |
764 | for(i=1; |
765 | (vtxfound==Standard_False) && (i<=nbvtx);i++) { |
766 | const IntPatch_Point& V = svtx.Value(i); |
68cdb44b |
767 | //jgv: to avoid loops |
768 | //Standard_Real vTol = V.Tolerance(); |
769 | if(CompareVertexAndPoint(V.Value(), curv->Value(1).Value(), Precision::Confusion()/*vTol*/)) { |
7fd59977 |
770 | vtx = V; |
771 | vtx.SetParameters(pu1,pv1,pu2,pv2); |
772 | vtxfound = Standard_True; |
773 | } |
774 | } |
775 | if(vtxfound == Standard_False) { |
776 | vtx.SetValue(curv->Value(1).Value(),Tol,Standard_False); |
777 | vtx.SetParameters(pu1,pv1,pu2,pv2); |
778 | } |
779 | vtx.SetParameter(1); |
780 | svtx.Prepend(vtx); nbvtx++; |
781 | fipt = Standard_True; |
782 | indf = 1; |
783 | } |
784 | if(bLast == Standard_False) { |
785 | Standard_Real pu1,pv1,pu2,pv2; |
786 | Standard_Boolean vtxfound = Standard_False; |
787 | IntPatch_Point vtx; |
788 | curv->Value(nbponline).Parameters(pu1,pv1,pu2,pv2); |
789 | for(i=1; |
790 | (vtxfound==Standard_False) && (i<=nbvtx);i++) { |
791 | const IntPatch_Point& V = svtx.Value(i); |
68cdb44b |
792 | //jgv: to avoid loops |
793 | //Standard_Real vTol = V.Tolerance(); |
794 | if(CompareVertexAndPoint(V.Value(), curv->Value(nbponline).Value(), Precision::Confusion()/*vTol*/)) { |
7fd59977 |
795 | vtx = V; |
796 | vtx.SetParameters(pu1,pv1,pu2,pv2); |
797 | vtxfound = Standard_True; |
798 | } |
799 | } |
800 | if(vtxfound == Standard_False) { |
801 | vtx.SetValue(curv->Value(nbponline).Value(),Tol,Standard_False); |
802 | vtx.SetParameters(pu1,pv1,pu2,pv2); |
803 | } |
804 | vtx.SetParameter(nbponline); |
805 | svtx.Append(vtx); nbvtx++; |
806 | lapt = Standard_True; |
807 | indl = nbvtx; |
808 | } |
809 | |
810 | |
811 | |
812 | |
813 | //-------------------------------------------------------------- |
814 | //-- ** Detection de points trouves sur une meme restriction |
815 | //-- avec la meme transition et avec des params on line |
816 | //-- voisins. |
817 | //-- ** Dans ce cas (-> donnerait un baillemenmt) on supprime |
818 | //-- le point 'intermediaire'. |
819 | //-- ** (exemple Vtx(1) ..... Vtx(204) Vtx(205)) |
820 | //-- on supprime le Vtx(204) |
821 | //-- ** (exemple Vtx(1) Vtx(2) ..... Vtx(205)) |
822 | //-- on supprime le Vtx(2) |
823 | //-- ** (exemple Vtx(1) ... Vtx(100) Vtx(101) ... Vtx(205)) |
824 | //-- on supprime le Vtx(100) (Vtx(100)et101 sur m restr) |
825 | |
826 | //-------------------------------------------------------------- |
827 | nbvtx = NbVertex(); |
828 | do { |
829 | APointDeleted = Standard_False; |
830 | for(i=1; (i<=nbvtx) && (APointDeleted==Standard_False) ;i++) { |
831 | const IntPatch_Point& VTXi = svtx.Value(i); |
832 | if((VTXi.IsOnDomS1()==Standard_True) && (VTXi.IsOnDomS2()==Standard_False)) { |
833 | for(j=1; (j<=nbvtx) && (APointDeleted==Standard_False) ;j++) { |
834 | if(i!=j) { |
835 | const IntPatch_Point& VTXj = svtx.Value(j); |
836 | if((VTXj.IsOnDomS1()==Standard_True) && (VTXj.IsOnDomS2()==Standard_False)) { |
837 | if( (VTXi.ParameterOnLine() == VTXj.ParameterOnLine()+1) |
838 | || (VTXi.ParameterOnLine() == VTXj.ParameterOnLine()-1)) { |
839 | if(VTXi.ArcOnS1() == VTXj.ArcOnS1()) { |
840 | IntSurf_Transition t1 = VTXi.TransitionLineArc1(); |
841 | IntSurf_Transition t2 = VTXj.TransitionLineArc1(); |
842 | if(t1.TransitionType()==t2.TransitionType()) { |
843 | if((VTXj.ParameterOnLine()!=1) && (VTXj.ParameterOnLine()!=NbPnts())) { |
844 | svtx.Remove(j); |
845 | nbvtx--; |
846 | if(lapt) { if(indl>=j) indl--; } |
847 | if(fipt) { if(indf>=j) indf--; } |
848 | APointDeleted = Standard_True; |
849 | } |
850 | } |
851 | } |
852 | } |
853 | } |
854 | } |
855 | } |
856 | } |
857 | } |
858 | } |
859 | |
860 | //-- meme traitement sur les restrictions du second shape |
861 | |
862 | while(APointDeleted == Standard_True); |
863 | nbvtx = NbVertex(); |
864 | do { |
865 | APointDeleted = Standard_False; |
866 | for(i=1; (i<=nbvtx) && (APointDeleted==Standard_False) ;i++) { |
867 | const IntPatch_Point& VTXi = svtx.Value(i); |
868 | if((VTXi.IsOnDomS1()==Standard_False) && (VTXi.IsOnDomS2()==Standard_True)) { |
869 | for(j=1; (j<=nbvtx) && (APointDeleted==Standard_False) ;j++) { |
870 | if(i!=j) { |
871 | const IntPatch_Point& VTXj = svtx.Value(j); |
872 | if((VTXj.IsOnDomS1()==Standard_False) && (VTXj.IsOnDomS2()==Standard_True)) { |
873 | if( (VTXi.ParameterOnLine() == VTXj.ParameterOnLine()+1) |
874 | || (VTXi.ParameterOnLine() == VTXj.ParameterOnLine()-1)) { |
875 | if(VTXi.ArcOnS2() == VTXj.ArcOnS2()) { |
876 | IntSurf_Transition t1 = VTXi.TransitionLineArc2(); |
877 | IntSurf_Transition t2 = VTXj.TransitionLineArc2(); |
878 | if(t1.TransitionType()==t2.TransitionType()) { |
879 | if((VTXj.ParameterOnLine()!=1) && (VTXj.ParameterOnLine()!=NbPnts())) { |
880 | svtx.Remove(j); |
881 | nbvtx--; |
882 | if(lapt) { if(indl>=j) indl--; } |
883 | if(fipt) { if(indf>=j) indf--; } |
884 | APointDeleted = Standard_True; |
885 | } |
886 | } |
887 | } |
888 | } |
889 | } |
890 | } |
891 | } |
892 | } |
893 | } |
894 | } |
895 | while(APointDeleted == Standard_True); |
896 | //-------------------------------------------------------------- |
897 | |
898 | //-------------------------------------------------------------- |
899 | //-- dans le cas de lignes periodiques du type : |
900 | //-- Un point sur restriction R1 de param p1 -> P3d1 Vtx1 |
901 | //-- Un point sur restriction R2 de param p2 -> P3d1 Vtx2 |
902 | //-- |
903 | //-- Un point sur restriction R1 de param p1 -> P3d1 Vtx3 |
904 | //-- pas de point sur R2 |
905 | //-- |
906 | //-- On doit dans ce cas creer un nouveau Vtx4 = Vtx3 sur la |
907 | //-- restriction R2 |
908 | //-- |
909 | //-- Ce cas se produit qd on a corrige un baillement avec le filtre |
910 | //-- precedent |
911 | //-- |
912 | |
913 | |
914 | |
915 | |
916 | |
917 | |
918 | nbvtx = NbVertex(); |
919 | do { |
920 | SortIsOK = Standard_True; |
921 | for(i=2; i<=nbvtx; i++) { |
922 | if(svtx.Value(i-1).ParameterOnLine() > svtx.Value(i).ParameterOnLine()) { |
923 | SortIsOK = Standard_False; |
924 | svtx.Exchange(i-1,i); |
925 | } |
926 | } |
927 | } |
928 | while(!SortIsOK); |
929 | |
930 | //-- Dump(); |
931 | |
932 | #if DEBUGV |
933 | cout<<"\n----------- apres ComputeVertexParameters -------------"<<endl; |
934 | for(i=1;i<=nbvtx;i++) { |
935 | Vertex(i).Dump(); |
936 | Standard_Real polr = Vertex(i).ParameterOnLine(); |
937 | Standard_Real pol = (Standard_Integer)polr; |
938 | if(pol>=1 && pol<=nbvtx) { |
939 | cout<<"----> IntSurf_PntOn2S : "<<polr<<" Pnt ("<<Vertex(pol).Value().X() |
940 | <<","<<Vertex(pol).Value().Y() |
941 | <<","<<Vertex(pol).Value().Z()<<")"<<endl; |
942 | } |
943 | } |
944 | cout<<"\n----------------------------------------------------------"<<endl; |
945 | #endif |
946 | |
947 | |
948 | } |
949 | |
950 | |
951 | |
952 | Standard_Boolean IntPatch_WLine::IsOutSurf1Box(const gp_Pnt2d& P1uv) { |
953 | if(Buv1.IsWhole()) { |
954 | Standard_Integer n=NbPnts(); |
955 | Standard_Real pu1,pu2,pv1,pv2; |
956 | Buv1.SetVoid(); |
957 | for(Standard_Integer i=1;i<=n;i++) { |
958 | curv->Value(i).Parameters(pu1,pv1,pu2,pv2); |
959 | Buv1.Add(gp_Pnt2d(pu1,pv1)); |
960 | } |
961 | Buv1.Get(pu1,pv1,pu2,pv2); |
962 | pu2-=pu1; |
963 | pv2-=pv1; |
964 | if(pu2>pv2) { |
965 | Buv1.Enlarge(pu2*0.01); |
966 | } |
967 | else { |
968 | Buv1.Enlarge(pv2*0.01); |
969 | } |
970 | } |
971 | Standard_Boolean out=Buv1.IsOut(P1uv); |
972 | return(out); |
973 | } |
974 | |
975 | Standard_Boolean IntPatch_WLine::IsOutSurf2Box(const gp_Pnt2d& P2uv) { |
976 | if(Buv2.IsWhole()) { |
977 | Standard_Integer n=NbPnts(); |
978 | Standard_Real pu1,pu2,pv1,pv2; |
979 | Buv2.SetVoid(); |
980 | for(Standard_Integer i=1;i<=n;i++) { |
981 | curv->Value(i).Parameters(pu1,pv1,pu2,pv2); |
982 | Buv2.Add(gp_Pnt2d(pu2,pv2)); |
983 | } |
984 | Buv2.Get(pu1,pv1,pu2,pv2); |
985 | pu2-=pu1; |
986 | pv2-=pv1; |
987 | if(pu2>pv2) { |
988 | Buv2.Enlarge(pu2*0.01); |
989 | } |
990 | else { |
991 | Buv2.Enlarge(pv2*0.01); |
992 | } |
993 | } |
994 | Standard_Boolean out=Buv2.IsOut(P2uv); |
995 | return(out); |
996 | } |
997 | |
998 | Standard_Boolean IntPatch_WLine::IsOutBox(const gp_Pnt& Pxyz) { |
999 | if(Bxyz.IsWhole()) { |
1000 | Standard_Integer n=NbPnts(); |
1001 | Bxyz.SetVoid(); |
1002 | for(Standard_Integer i=1;i<=n;i++) { |
1003 | gp_Pnt P=curv->Value(i).Value(); |
1004 | Bxyz.Add(P); |
1005 | } |
1006 | Standard_Real x0,y0,z0,x1,y1,z1; |
1007 | Bxyz.Get(x0,y0,z0,x1,y1,z1); |
1008 | x1-=x0; y1-=y0; z1-=z0; |
1009 | if(x1>y1) { |
1010 | if(x1>z1) { |
1011 | Bxyz.Enlarge(x1*0.01); |
1012 | } |
1013 | else { |
1014 | Bxyz.Enlarge(z1*0.01); |
1015 | } |
1016 | } |
1017 | else { |
1018 | if(y1>z1) { |
1019 | Bxyz.Enlarge(y1*0.01); |
1020 | } |
1021 | else { |
1022 | Bxyz.Enlarge(z1*0.01); |
1023 | } |
1024 | } |
1025 | } |
1026 | Standard_Boolean out=Bxyz.IsOut(Pxyz); |
1027 | return(out); |
1028 | } |
1029 | |
1030 | |
1031 | Standard_Boolean IntPatch_WLine::HasArcOnS1() const { |
1032 | return(hasArcOnS1); |
1033 | } |
1034 | |
1035 | void IntPatch_WLine::SetArcOnS1(const Handle(Adaptor2d_HCurve2d)& A) { |
1036 | hasArcOnS1=Standard_True; |
1037 | theArcOnS1=A; |
1038 | } |
1039 | |
1040 | const Handle(Adaptor2d_HCurve2d)& IntPatch_WLine::GetArcOnS1() const { |
1041 | return(theArcOnS1); |
1042 | } |
1043 | |
1044 | Standard_Boolean IntPatch_WLine::HasArcOnS2() const { |
1045 | return(hasArcOnS2); |
1046 | } |
1047 | |
1048 | void IntPatch_WLine::SetArcOnS2(const Handle(Adaptor2d_HCurve2d)& A) { |
1049 | hasArcOnS2=Standard_True; |
1050 | theArcOnS2=A; |
1051 | } |
1052 | |
1053 | const Handle(Adaptor2d_HCurve2d)& IntPatch_WLine::GetArcOnS2() const { |
1054 | return(theArcOnS2); |
1055 | } |
1056 | |
1057 | |
eb75e31c |
1058 | void IntPatch_WLine::Dump(const Standard_Integer theMode) const |
1059 | { |
1060 | cout<<" ----------- D u m p I n t P a t c h _ W L i n e -(begin)------"<<endl; |
1061 | const Standard_Integer aNbPoints = NbPnts(); |
1062 | const Standard_Integer aNbVertex = NbVertex(); |
1063 | |
1064 | switch(theMode) |
1065 | { |
1066 | case 0: |
1067 | printf("Num [X Y Z] [U1 V1] [U2 V2]\n"); |
1068 | for(Standard_Integer i=1; i<=aNbPoints; i++) |
1069 | { |
1070 | Standard_Real u1,v1,u2,v2; |
1071 | Point(i).Parameters(u1,v1,u2,v2); |
1072 | printf("%4d [%+10.20f %+10.20f %+10.20f] [%+10.20f %+10.20f] [%+10.20f %+10.20f]\n", |
1073 | i,Point(i).Value().X(),Point(i).Value().Y(),Point(i).Value().Z(), |
1074 | u1,v1,u2,v2); |
1075 | } |
7fd59977 |
1076 | |
eb75e31c |
1077 | for(Standard_Integer i=1;i<=aNbVertex;i++) |
1078 | { |
1079 | Vertex(i).Dump(); |
1080 | Standard_Real polr = Vertex(i).ParameterOnLine(); |
1081 | Standard_Integer pol = static_cast<Standard_Integer>(polr); |
1082 | |
1083 | if(pol>=1 && pol<=aNbVertex) |
1084 | { |
1085 | cout<<"----> IntSurf_PntOn2S : "<< |
1086 | polr <<", Pnt (" << Vertex(pol).Value().X() << "," << |
1087 | Vertex(pol).Value().Y() << "," << |
1088 | Vertex(pol).Value().Z() <<")" <<endl; |
1089 | } |
1090 | } |
1091 | |
1092 | break; |
1093 | case 1: |
1094 | for(Standard_Integer i = 1; i <= aNbPoints; i++) |
1095 | { |
1096 | Standard_Real u1,v1,u2,v2; |
1097 | Point(i).Parameters(u1,v1,u2,v2); |
1098 | printf("point p%d %+10.20f %+10.20f %+10.20f\n", |
1099 | i,Point(i).Value().X(),Point(i).Value().Y(),Point(i).Value().Z()); |
1100 | } |
1101 | |
1102 | break; |
1103 | case 2: |
1104 | for(Standard_Integer i = 1; i <= aNbPoints; i++) |
1105 | { |
1106 | Standard_Real u1,v1,u2,v2; |
1107 | Point(i).Parameters(u1,v1,u2,v2); |
1108 | printf("point p%d %+10.20f %+10.20f\n", i, u1, v1); |
1109 | } |
1110 | |
1111 | break; |
1112 | default: |
1113 | for(Standard_Integer i = 1; i <= aNbPoints; i++) |
1114 | { |
1115 | Standard_Real u1,v1,u2,v2; |
1116 | Point(i).Parameters(u1,v1,u2,v2); |
1117 | printf("point p%d %+10.20f %+10.20f\n", i, u2, v2); |
7fd59977 |
1118 | } |
eb75e31c |
1119 | |
1120 | break; |
7fd59977 |
1121 | } |
eb75e31c |
1122 | cout<<"\n--------------------------------------------------- (end) -------"<<endl; |
7fd59977 |
1123 | } |
1124 | |