0026938: Boolean operations fail between two ellipsoids
[occt.git] / src / IntPatch / IntPatch_WLine.cxx
CommitLineData
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 29IMPLEMENT_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
39IntPatch_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
56IntPatch_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
73IntPatch_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
88void IntPatch_WLine::SetPoint(const Standard_Integer Index,
89 const IntPatch_Point& thepoint)
90{
91 curv->Value(Index,thepoint.PntOn2S());
92}
93
94
95Handle(IntSurf_LineOn2S) IntPatch_WLine::Curve() const
96{
97 return(curv);
98}
99
100static 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
125static 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 137static 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
143void 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}
149Standard_Real IntPatch_WLine::U1Period() const { return(u1period); }
150Standard_Real IntPatch_WLine::V1Period() const { return(v1period); }
151Standard_Real IntPatch_WLine::U2Period() const { return(u2period); }
152Standard_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
182Standard_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
233static 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
251inline Standard_Boolean CompareVerticesOnS1(const IntPatch_Point& vtx1, const IntPatch_Point& vtx2)
252{return CompareVerticesOnSurf (vtx1, vtx2, Standard_True);}
253
254inline Standard_Boolean CompareVerticesOnS2(const IntPatch_Point& vtx1, const IntPatch_Point& vtx2)
255{return CompareVerticesOnSurf (vtx1, vtx2, Standard_False);}
256
257
882e1d11 258void 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;
482 for(i=2; i<=nbponline; 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;
583 for(ind_point = 2; (ind_point <= nbponline && nbponline > 2); ind_point++) {
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
952Standard_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
975Standard_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
998Standard_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
1031Standard_Boolean IntPatch_WLine::HasArcOnS1() const {
1032 return(hasArcOnS1);
1033}
1034
1035void IntPatch_WLine::SetArcOnS1(const Handle(Adaptor2d_HCurve2d)& A) {
1036 hasArcOnS1=Standard_True;
1037 theArcOnS1=A;
1038}
1039
1040const Handle(Adaptor2d_HCurve2d)& IntPatch_WLine::GetArcOnS1() const {
1041 return(theArcOnS1);
1042}
1043
1044Standard_Boolean IntPatch_WLine::HasArcOnS2() const {
1045 return(hasArcOnS2);
1046}
1047
1048void IntPatch_WLine::SetArcOnS2(const Handle(Adaptor2d_HCurve2d)& A) {
1049 hasArcOnS2=Standard_True;
1050 theArcOnS2=A;
1051}
1052
1053const Handle(Adaptor2d_HCurve2d)& IntPatch_WLine::GetArcOnS2() const {
1054 return(theArcOnS2);
1055}
1056
1057
eb75e31c 1058void 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