projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0024470: Wrong result done by General Fuse algorithm.
[occt.git] / src / IntPatch / IntPatch_ImpImpIntersection_3.gxx
CommitLineData
b311480e 1// Created on: 1992-05-07
2// Created by: Jacques GOUSSARD
3// Copyright (c) 1992-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//
973c2be1 8// This library is free software; you can redistribute it and / or modify it
9// under the terms of the GNU Lesser General Public version 2.1 as published
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
a9f7b6b5
P		 17//modified by NIZNHY-PKV Thu Sep 15 11:09:12 2011
18static
19 void SeamPosition(const gp_Pnt& aPLoc,
7eed5d29 20 const gp_Ax3& aPos,
21 gp_Ax2& aSeamPos);
a9f7b6b5
P		 22static
23 void AdjustToSeam (const gp_Cylinder& aQuad,
7eed5d29 24 gp_Circ& aCirc);
a9f7b6b5
P		 25static
26 void AdjustToSeam (const gp_Sphere& aQuad,
7eed5d29 27 gp_Circ& aCirc,
28 const Standard_Real aTolAng);
a9f7b6b5
P		 29static
30 void AdjustToSeam (const gp_Cone& aQuad,
7eed5d29 31 gp_Circ& aCirc);
32static
33 void AdjustToSeam (const gp_Torus& aQuad,
34 gp_Circ& aCirc);
a9f7b6b5
P		 35//modified by NIZNHY-PKV Thu Sep 15 11:09:13 2011
36
37//=======================================================================
38//function : IntPP
39//purpose :
40// Traitement du cas Plan/Plan
41//=======================================================================
7fd59977 42Standard_Boolean IntPP (const IntSurf_Quadric& Quad1,
7eed5d29 43 const IntSurf_Quadric& Quad2,
44 const Standard_Real Tolang,
45 const Standard_Real TolTang,
46 Standard_Boolean& Same,
47 IntPatch_SequenceOfLine& slin)
a9f7b6b5 48
7fd59977 49{
50 IntSurf_TypeTrans trans1,trans2;
51 IntAna_ResultType typint;
52 gp_Pln pl1(Quad1.Plane());
53 gp_Pln pl2(Quad2.Plane());
54
55 IntAna_QuadQuadGeo inter(pl1,pl2,Tolang,TolTang);
56 if (!inter.IsDone()) {return Standard_False;}
57 Same = Standard_False;
58 typint = inter.TypeInter();
59 if (typint == IntAna_Same) { // cas faces confondues
60 Same = Standard_True;
61 }
62 else if (typint != IntAna_Empty) { // on a une ligne
63 gp_Lin linsol = inter.Line(1);
64 Standard_Real discri = linsol.Direction().DotCross
65 (Quad2.Normale(linsol.Location()),
66 Quad1.Normale(linsol.Location()));
67
68 if (discri>0.0) {
69 trans1 = IntSurf_Out;
70 trans2 = IntSurf_In;
71 }
72 else {
73 trans1 = IntSurf_In;
74 trans2 = IntSurf_Out;
75 }
a9f7b6b5
P		 76 Handle(IntPatch_GLine) glig =
77 new IntPatch_GLine (linsol,Standard_False,trans1,trans2);
7fd59977 78 slin.Append(glig);
79 }
80 return Standard_True;
81}
a9f7b6b5
P		 82//=======================================================================
83//function : IntPCy
84//purpose :
85// Traitement du cas Plan/Cylindre et reciproquement
86//=======================================================================
7fd59977 87Standard_Boolean IntPCy (const IntSurf_Quadric& Quad1,
7eed5d29 88 const IntSurf_Quadric& Quad2,
89 const Standard_Real Tolang,
90 const Standard_Real TolTang,
91 const Standard_Boolean Reversed,
92 Standard_Boolean& Empty,
93 IntPatch_SequenceOfLine& slin,
04cbc9d3 94 const Standard_Real H)
7fd59977 95
7fd59977 96{
97 gp_Pln Pl;
98 gp_Cylinder Cy;
99
100 IntSurf_TypeTrans trans1,trans2;
101 IntAna_ResultType typint;
102
103 IntAna_QuadQuadGeo inter;
104 if (!Reversed) {
105 Pl = Quad1.Plane();
106 Cy = Quad2.Cylinder();
107 }
108 else {
109 Pl = Quad2.Plane();
110 Cy = Quad1.Cylinder();
111 }
04cbc9d3 112 inter.Perform(Pl,Cy,Tolang,TolTang,H);
7fd59977 113 if (!inter.IsDone()) {return Standard_False;}
114 typint = inter.TypeInter();
115 Standard_Integer NbSol = inter.NbSolutions();
116 Empty = Standard_False;
117
118 switch (typint) {
7eed5d29 119
a9f7b6b5 120 case IntAna_Empty : {
7fd59977 121 Empty = Standard_True;
122 }
a9f7b6b5 123 break;
7fd59977 124
a9f7b6b5 125 case IntAna_Line: {
7fd59977 126 gp_Lin linsol = inter.Line(1);
127 gp_Pnt orig(linsol.Location());
128 if (NbSol == 1) { // ligne de tangence
7eed5d29 129 gp_Vec TestCurvature(orig,Cy.Location());
130 gp_Vec Normp,Normcyl;
131 if (!Reversed) {
132 Normp = Quad1.Normale(orig);
133 Normcyl = Quad2.Normale(orig);
134 }
135 else {
136 Normp = Quad2.Normale(orig);
137 Normcyl = Quad1.Normale(orig);
138 }
139
140 IntSurf_Situation situcyl;
141 IntSurf_Situation situp;
7fd59977 142
7eed5d29 143 if (Normp.Dot(TestCurvature) > 0.) {
144 situcyl = IntSurf_Outside;
145 if (Normp.Dot(Normcyl) > 0.) {
146 situp = IntSurf_Inside;
147 }
148 else {
149 situp = IntSurf_Outside;
150 }
151 }
152 else {
153 situcyl = IntSurf_Inside;
154 if (Normp.Dot(Normcyl) > 0.) {
155 situp = IntSurf_Outside;
156 }
157 else {
158 situp = IntSurf_Inside;
159 }
160 }
161 Handle(IntPatch_GLine) glig;
162 if (!Reversed) {
163 glig = new IntPatch_GLine(linsol, Standard_True, situp, situcyl);
164 }
165 else {
166 glig = new IntPatch_GLine(linsol, Standard_True, situcyl, situp);
167 }
168 slin.Append(glig);
7fd59977 169 }
a9f7b6b5 170 else {
7eed5d29 171 // on a 2 droites. Il faut determiner les transitions
172 // de chacune.
173
174 if (linsol.Direction().DotCross(Quad2.Normale(orig),
175 Quad1.Normale(orig)) >0.) {
176 trans1 = IntSurf_Out;
177 trans2 = IntSurf_In;
178 }
179 else {
180 trans1 = IntSurf_In;
181 trans2 = IntSurf_Out;
182 }
183 Handle(IntPatch_GLine) glig =
184 new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
185 slin.Append(glig);
186
187 linsol = inter.Line(2);
188 orig = linsol.Location();
7fd59977 189
7eed5d29 190 if (linsol.Direction().DotCross(Quad2.Normale(orig),
191 Quad1.Normale(orig)) >0.) {
192 trans1 = IntSurf_Out;
193 trans2 = IntSurf_In;
194 }
195 else {
196 trans1 = IntSurf_In;
197 trans2 = IntSurf_Out;
198 }
199 glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
200 slin.Append(glig);
7fd59977 201 }
202 }
a9f7b6b5
P		 203 break;
204 //
205 case IntAna_Circle: {
206 gp_Circ cirsol;
7fd59977 207 gp_Pnt ptref;
208 gp_Vec Tgt;
a9f7b6b5
P		 209 //
210 cirsol = inter.Circle(1);
211 //modified by NIZNHY-PKV Thu Sep 15 11:30:03 2011f
212 AdjustToSeam(Cy, cirsol);
213 //modified by NIZNHY-PKV Thu Sep 15 11:30:15 2011t
7fd59977 214 ElCLib::D1(0.,cirsol,ptref,Tgt);
a9f7b6b5 215
7fd59977 216 if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) > 0.0) {
7eed5d29 217 trans1 = IntSurf_Out;
218 trans2 = IntSurf_In;
7fd59977 219 }
220 else {
7eed5d29 221 trans1 = IntSurf_In;
222 trans2 = IntSurf_Out;
7fd59977 223 }
224 Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
225 slin.Append(glig);
226 }
a9f7b6b5
P		 227 break;
228 //
229 case IntAna_Ellipse: {
7fd59977 230 gp_Elips elipsol = inter.Ellipse(1);
231 gp_Pnt ptref;
232 gp_Vec Tgt;
233 ElCLib::D1(0.,elipsol,ptref,Tgt);
a9f7b6b5 234
7fd59977 235 if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) > 0.0) {
7eed5d29 236 trans1 = IntSurf_Out;
237 trans2 = IntSurf_In;
7fd59977 238 }
239 else {
7eed5d29 240 trans1 = IntSurf_In;
241 trans2 = IntSurf_Out;
7fd59977 242 }
243 Handle(IntPatch_GLine) glig = new IntPatch_GLine(elipsol,Standard_False,trans1,trans2);
244 slin.Append(glig);
245 }
a9f7b6b5
P		 246 break;
247 //
248 default: {
7fd59977 249 return Standard_False; // on ne doit pas passer ici
250 }
251 }
252 return Standard_True;
253}
a9f7b6b5
P		 254//=======================================================================
255//function : IntPSp
256//purpose :
257// Traitement du cas Plan/Sphere et reciproquement
258//=======================================================================
7fd59977 259Standard_Boolean IntPSp (const IntSurf_Quadric& Quad1,
7eed5d29 260 const IntSurf_Quadric& Quad2,
261 //modified by NIZNHY-PKV Tue Sep 20 08:59:36 2011f
262 const Standard_Real Tolang,
263 //modified by NIZNHY-PKV Tue Sep 20 08:59:39 2011t
264 const Standard_Real TolTang,
265 const Standard_Boolean Reversed,
266 Standard_Boolean& Empty,
267 IntPatch_SequenceOfLine& slin,
268 IntPatch_SequenceOfPoint& spnt)
7fd59977 269
a9f7b6b5 270
7fd59977 271{
272 gp_Circ cirsol;
273 gp_Pln Pl;
274 gp_Sphere Sp;
275 IntSurf_TypeTrans trans1,trans2;
276 IntAna_ResultType typint;
277
278 IntAna_QuadQuadGeo inter;
279 if (!Reversed) {
280 Pl = Quad1.Plane();
281 Sp = Quad2.Sphere();
282 }
283 else {
284 Pl = Quad2.Plane();
285 Sp = Quad1.Sphere();
286 }
287 inter.Perform(Pl,Sp);
288
289 if (!inter.IsDone()) {return Standard_False;}
290
291 typint = inter.TypeInter();
292 Empty = Standard_False;
293
294 switch (typint) {
a9f7b6b5 295 case IntAna_Empty : {
7fd59977 296 Empty = Standard_True;
297 }
a9f7b6b5
P		 298 break;
299 //
300 case IntAna_Point: {
7fd59977 301 gp_Pnt psol = inter.Point(1);
302 Standard_Real U1,V1,U2,V2;
303 Quad1.Parameters(psol,U1,V1);
304 Quad2.Parameters(psol,U2,V2);
305 IntPatch_Point ptsol;
306 ptsol.SetValue(psol,TolTang,Standard_True);
307 ptsol.SetParameters(U1,V1,U2,V2);
308 spnt.Append(ptsol);
309 }
a9f7b6b5
P		 310 break;
311 //
312 case IntAna_Circle: {
7fd59977 313 cirsol = inter.Circle(1);
a9f7b6b5
P		 314 //modified by NIZNHY-PKV Thu Sep 15 11:30:03 2011f
315 AdjustToSeam(Sp, cirsol, Tolang);
316 //modified by NIZNHY-PKV Thu Sep 15 11:30:15 2011t
7fd59977 317 gp_Pnt ptref;
318 gp_Vec Tgt;
319 ElCLib::D1(0.,cirsol,ptref,Tgt);
320
321 if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) >0.) {
7eed5d29 322 trans1 = IntSurf_Out;
323 trans2 = IntSurf_In;
7fd59977 324 }
325 else {
7eed5d29 326 trans1 = IntSurf_In;
327 trans2 = IntSurf_Out;
7fd59977 328 }
329 Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
330 slin.Append(glig);
331 }
a9f7b6b5
P		 332 break;
333
334 default: {
7fd59977 335 return Standard_False; // on ne doit pas passer ici
336 }
337 }
338 return Standard_True;
339}
a9f7b6b5
P		 340//=======================================================================
341//function : IntPCo
342//purpose :
343// Traitement du cas Plan/Cone et reciproquement
344//=======================================================================
7fd59977 345Standard_Boolean IntPCo (const IntSurf_Quadric& Quad1,
7eed5d29 346 const IntSurf_Quadric& Quad2,
347 const Standard_Real Tolang,
348 const Standard_Real TolTang,
349 const Standard_Boolean Reversed,
350 Standard_Boolean& Empty,
351 Standard_Boolean& Multpoint,
352 IntPatch_SequenceOfLine& slin,
353 IntPatch_SequenceOfPoint& spnt)
7fd59977 354
a9f7b6b5 355
7fd59977 356{
357 gp_Pnt apex;
358
359 gp_Pln Pl;
360 gp_Cone Co;
361
362 IntSurf_TypeTrans trans1,trans2;
363 IntAna_ResultType typint;
364
365 IntAna_QuadQuadGeo inter;
366 if (!Reversed) {
367 Pl = Quad1.Plane();
368 Co = Quad2.Cone();
369 apex = Co.Apex();
370 }
371 else {
372 Pl = Quad2.Plane();
373 Co = Quad1.Cone();
374 apex = Co.Apex();
375 }
376
377 inter.Perform(Pl,Co,Tolang,TolTang);
a9f7b6b5
P		 378 if (!inter.IsDone()) {
379 return Standard_False;
380 }
381 //
7fd59977 382 typint = inter.TypeInter();
383 Standard_Integer NbSol = inter.NbSolutions();
384 Empty = Standard_False;
385
386 switch (typint) {
a9f7b6b5 387 case IntAna_Point: {
7fd59977 388 gp_Pnt psol = inter.Point(1);
389 Standard_Real U1,V1,U2,V2;
390 Quad1.Parameters(psol,U1,V1);
391 Quad2.Parameters(psol,U2,V2);
392 IntPatch_Point ptsol;
393 ptsol.SetValue(psol,TolTang,Standard_False);
394 ptsol.SetParameters(U1,V1,U2,V2);
395 spnt.Append(ptsol);
396 }
a9f7b6b5
P		 397 break;
398
399 case IntAna_Line: {
7fd59977 400 gp_Lin linsol = inter.Line(1);
401 if (linsol.Direction().Dot(Co.Axis().Direction()) <0.) {
7eed5d29 402 linsol.SetDirection(linsol.Direction().Reversed());
7fd59977 403 }
404 Standard_Real para = ElCLib::Parameter(linsol, apex);
405 gp_Pnt ptbid (ElCLib::Value(para+5.,linsol));
406 Standard_Real U1,V1,U2,V2;
407 Quad1.Parameters(apex,U1,V1);
408 Quad2.Parameters(apex,U2,V2);
a9f7b6b5 409
7fd59977 410 if (NbSol == 1) { // ligne de tangence
7eed5d29 411 IntPatch_Point ptsol;
412 ptsol.SetValue(apex,TolTang,Standard_False);
413 ptsol.SetParameters(U1,V1,U2,V2);
414 ptsol.SetParameter(para);
415 gp_Pnt ptbid2(apex.XYZ() + 5.*Co.Axis().Direction().XYZ());
416 gp_Vec TestCurvature(ptbid,ptbid2);
417 gp_Vec Normp,Normco;
418 if (!Reversed) {
419 Normp = Quad1.Normale(ptbid);
420 Normco = Quad2.Normale(ptbid);
421 }
422 else {
423 Normp = Quad2.Normale(ptbid);
424 Normco = Quad1.Normale(ptbid);
425 }
426 IntSurf_Situation situco,situco_otherside;
427 IntSurf_Situation situp,situp_otherside;
428
429 if (Normp.Dot(TestCurvature) > 0.) {
430 situco = IntSurf_Outside;
431 situco_otherside = IntSurf_Inside;
432 if (Normp.Dot(Normco) > 0.) {
433 situp = IntSurf_Inside;
434 situp_otherside = IntSurf_Outside;
435 }
436 else {
437 situp = IntSurf_Outside;
438 situp_otherside = IntSurf_Inside;
439 }
440 }
441 else {
442 situco = IntSurf_Inside;
443 situco_otherside = IntSurf_Outside;
444 if (Normp.Dot(Normco) > 0.) {
445 situp = IntSurf_Outside;
446 situp_otherside = IntSurf_Inside;
447 }
448 else {
449 situp = IntSurf_Inside;
450 situp_otherside = IntSurf_Outside;
451 }
452 }
453 //----------------------------------------------------------
454 //-- Apex ---> Cone.Direction
455 //--
456 Handle(IntPatch_GLine) glig;
457 if (!Reversed) {
458 glig = new IntPatch_GLine(linsol, Standard_True, situp, situco);
459 }
460 else {
461 glig = new IntPatch_GLine(linsol, Standard_True, situco, situp);
462 }
463 glig->AddVertex(ptsol);
464 glig->SetFirstPoint(1);
465 slin.Append(glig);
466 //----------------------------------------------------------
467 //-- -Cone.Direction <------- Apex
468 //--
469 linsol.SetDirection(linsol.Direction().Reversed());
470 if (!Reversed) {
471 glig = new IntPatch_GLine(linsol, Standard_True, situp_otherside, situco_otherside);
472 }
473 else {
474 glig = new IntPatch_GLine(linsol, Standard_True, situco_otherside, situp_otherside);
475 }
476 glig->AddVertex(ptsol);
477 glig->SetFirstPoint(1);
478 slin.Append(glig);
7fd59977 479 }
480 else {
7eed5d29 481 // on a 2 droites. Il faut determiner les transitions
482 // de chacune. On oriente chaque ligne dans le sens
483 // de l axe du cone. Les transitions de chaque ligne seront
484 // inverses l une de l autre => on ne fait le calcul que sur
485 // la premiere.
486 if (linsol.Direction().DotCross
487 (Quad2.Normale(ptbid),Quad1.Normale(ptbid)) >0.) {
488 trans1 = IntSurf_Out;
489 trans2 = IntSurf_In;
490 }
491 else {
492 trans1 = IntSurf_In;
493 trans2 = IntSurf_Out;
494 }
7fd59977 495
7eed5d29 496 Multpoint = Standard_True;
497 //------------------------------------------- Ligne 1 -------
498 IntPatch_Point ptsol;
499 ptsol.SetValue(apex,TolTang,Standard_False);
500 ptsol.SetParameters(U1,V1,U2,V2);
501 ptsol.SetParameter(para);
502 ptsol.SetMultiple(Standard_True);
503 Handle(IntPatch_GLine) glig;
504 glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
505 glig->AddVertex(ptsol);
506 glig->SetFirstPoint(1);
507 slin.Append(glig);
508 //-----------------------------------------------------------
509 //-- Other Side : Les transitions restent les memes
510 //-- linsol -> -linsol et Quad1(2).N -> -Quad1(2).N
511 //--
512 linsol.SetDirection(linsol.Direction().Reversed());
513 glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
514 para = ElCLib::Parameter(linsol, apex);
515 ptsol.SetParameter(para);
516 glig->AddVertex(ptsol);
517 glig->SetFirstPoint(1);
518 slin.Append(glig);
519
520 //------------------------------------------- Ligne 2 -------
521 linsol = inter.Line(2);
522 if (linsol.Direction().Dot(Co.Axis().Direction()) <0.) {
523 linsol.SetDirection(linsol.Direction().Reversed());
524 }
525 para = ElCLib::Parameter(linsol, apex);
526 ptbid = ElCLib::Value(para+5.,linsol);
527 if (linsol.Direction().DotCross
528 (Quad2.Normale(ptbid),Quad1.Normale(ptbid)) >0.) {
529 trans1 = IntSurf_Out;
530 trans2 = IntSurf_In;
531 }
532 else {
533 trans1 = IntSurf_In;
534 trans2 = IntSurf_Out;
535 }
536 ptsol.SetParameter(para);
537 glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
538 para = ElCLib::Parameter(linsol, apex);
539 ptsol.SetParameter(para);
540 glig->AddVertex(ptsol);
541 glig->SetFirstPoint(1);
542 slin.Append(glig);
543 //-----------------------------------------------------------
544 //-- Other Side : Les transitions restent les memes
545 //-- linsol -> -linsol et Quad1(2).N -> -Quad1(2).N
546 //--
547 linsol.SetDirection(linsol.Direction().Reversed());
548 glig = new IntPatch_GLine(linsol, Standard_False,trans1,trans2);
549 para = ElCLib::Parameter(linsol, apex);
550 ptsol.SetParameter(para);
551 glig->AddVertex(ptsol);
552 glig->SetFirstPoint(1);
553 slin.Append(glig);
7fd59977 554 }
555 }
556 break;
a9f7b6b5
P		 557
558 case IntAna_Circle: {
7fd59977 559 gp_Circ cirsol = inter.Circle(1);
a9f7b6b5
P		 560 //modified by NIZNHY-PKV Thu Sep 15 11:34:04 2011f
561 AdjustToSeam(Co, cirsol);
562 //modified by NIZNHY-PKV Thu Sep 15 11:36:08 2011t
563 gp_Pnt ptref;
564 gp_Vec Tgt;
565 ElCLib::D1(0.,cirsol,ptref,Tgt);
566
567 if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) >0.) {
7eed5d29 568 trans1 = IntSurf_Out;
569 trans2 = IntSurf_In;
7fd59977 570 }
7fd59977 571 else {
7eed5d29 572 trans1 = IntSurf_In;
573 trans2 = IntSurf_Out;
7fd59977 574 }
a9f7b6b5
P		 575 Handle(IntPatch_GLine) glig = new IntPatch_GLine(cirsol,Standard_False,trans1,trans2);
576 slin.Append(glig);
7fd59977 577 }
a9f7b6b5
P		 578 break;
579
580 case IntAna_Ellipse: {
7fd59977 581 gp_Elips elipsol = inter.Ellipse(1);
a9f7b6b5
P		 582 gp_Pnt ptref;
583 gp_Vec Tgt;
584 ElCLib::D1(0.,elipsol,ptref,Tgt);
585
586 if (Tgt.DotCross(Quad2.Normale(ptref),Quad1.Normale(ptref)) >0.) {
7eed5d29 587 trans1 = IntSurf_Out;
588 trans2 = IntSurf_In;
7fd59977 589 }
7fd59977 590 else {
7eed5d29 591 trans1 = IntSurf_In;
592 trans2 = IntSurf_Out;
7fd59977 593 }
a9f7b6b5
P		 594 Handle(IntPatch_GLine) glig = new IntPatch_GLine(elipsol,Standard_False,trans1,trans2);
595 slin.Append(glig);
7fd59977 596 }
a9f7b6b5
P		 597 break;
598
599 case IntAna_Parabola: {
7fd59977 600 gp_Parab parabsol = inter.Parabola(1);
a9f7b6b5
P		 601
602 gp_Vec Tgtorig(parabsol.YAxis().Direction());
603 Standard_Real ptran = Tgtorig.DotCross(Quad2.Normale(parabsol.Location()),
7eed5d29 604 Quad1.Normale(parabsol.Location()));
a9f7b6b5 605 if (ptran >0.00000001) {
7eed5d29 606 trans1 = IntSurf_Out;
607 trans2 = IntSurf_In;
7fd59977 608 }
a9f7b6b5 609 else if (ptran <-0.00000001) {
7eed5d29 610 trans1 = IntSurf_In;
611 trans2 = IntSurf_Out;
7fd59977 612 }
a9f7b6b5 613 else {
7eed5d29 614 trans1=trans2=IntSurf_Undecided;
a9f7b6b5
P		 615 }
616 Handle(IntPatch_GLine) glig = new IntPatch_GLine(parabsol,Standard_False,trans1,trans2);
617 slin.Append(glig);
7fd59977 618 }
a9f7b6b5
P		 619 break;
620
621 case IntAna_Hyperbola: {
7fd59977 622 gp_Pnt tophypr;
623 gp_Vec Tgttop;
624
625 for(Standard_Integer i=1; i<=2; i++) {
7eed5d29 626 gp_Hypr hyprsol = inter.Hyperbola(i);
627 tophypr = ElCLib::Value(hyprsol.MajorRadius(),
628 hyprsol.XAxis());
629 Tgttop = hyprsol.YAxis().Direction();
630 Standard_Real qwe = Tgttop.DotCross(Quad2.Normale(tophypr),
631 Quad1.Normale(tophypr));
632
633 if (qwe>0.00000001) {
634 trans1 = IntSurf_Out;
635 trans2 = IntSurf_In;
636 }
637 else if (qwe<-0.00000001){
638 trans1 = IntSurf_In;
639 trans2 = IntSurf_Out;
640 }
641 else {
642 trans1=trans2=IntSurf_Undecided;
643 }
644 Handle(IntPatch_GLine) glig = new IntPatch_GLine(hyprsol,Standard_False,trans1,trans2);
645 slin.Append(glig);
7fd59977 646 }
647 }
a9f7b6b5
P		 648 break;
649
650 default: {
7fd59977 651 return Standard_False;
652 }
653 }
654 return Standard_True;
655}
7eed5d29 656//=======================================================================
657//function : IntPTo
658//purpose :
659//=======================================================================
660Standard_Boolean IntPTo(const IntSurf_Quadric& theQuad1,
661 const IntSurf_Quadric& theQuad2,
662 const Standard_Real theTolTang,
663 const Standard_Boolean bReversed,
664 Standard_Boolean& bEmpty,
665 IntPatch_SequenceOfLine& theSeqLin)
666{
667 const gp_Pln aPln = bReversed ? theQuad2.Plane() : theQuad1.Plane();
668 const gp_Torus aTorus = bReversed ? theQuad1.Torus() : theQuad2.Torus();
669 //
670 IntAna_QuadQuadGeo inter(aPln, aTorus, theTolTang);
671 Standard_Boolean bRet = inter.IsDone();
672 //
673 if (!bRet) {
674 return bRet;
675 }
676 //
677 IntAna_ResultType typint = inter.TypeInter();
678 Standard_Integer NbSol = inter.NbSolutions();
679 bEmpty = Standard_False;
680 //
681 switch (typint) {
682 case IntAna_Empty :
683 bEmpty = Standard_True;
684 break;
685 //
686 case IntAna_Circle : {
687 Standard_Integer i;
688 IntSurf_TypeTrans trans1, trans2;
689 gp_Pnt ptref;
690 gp_Vec Tgt;
691 //
692 for (i = 1; i <= NbSol; ++i) {
693 gp_Circ aC = inter.Circle(i);
694 if (!aPln.Axis().IsNormal(aTorus.Axis(), Precision::Angular())) {
695 AdjustToSeam(aTorus, aC);
696 }
697 ElCLib::D1(0., aC, ptref, Tgt);
698 //
699 if (Tgt.DotCross(theQuad2.Normale(ptref),theQuad1.Normale(ptref)) > 0.0) {
700 trans1 = IntSurf_Out;
701 trans2 = IntSurf_In;
702 }
703 else {
704 trans1 = IntSurf_In;
705 trans2 = IntSurf_Out;
706 }
707 //
708 Handle(IntPatch_GLine) glig =
709 new IntPatch_GLine(aC, Standard_False, trans1, trans2);
710 theSeqLin.Append(glig);
711 }
712 }
713 break;
714 //
715 case IntAna_NoGeometricSolution:
716 default:
717 bRet = Standard_False;
718 break;
719 }
720 //
721 return bRet;
722}
a9f7b6b5
P		 723//
724//modified by NIZNHY-PKV Thu Sep 15 10:53:39 2011f
725//=======================================================================
726//function : AdjustToSeam
727//purpose :
728//=======================================================================
729void AdjustToSeam (const gp_Cone& aQuad,
7eed5d29 730 gp_Circ& aCirc)
a9f7b6b5
P		 731{
732 gp_Ax2 aAx2;
733 //
734 const gp_Pnt& aPLoc=aCirc.Location();
735 const gp_Ax3& aAx3=aQuad.Position();
736 SeamPosition(aPLoc, aAx3, aAx2);
737 aCirc.SetPosition(aAx2);
738}
739//=======================================================================
740//function : AdjustToSeam
741//purpose :
742//=======================================================================
743void AdjustToSeam (const gp_Sphere& aQuad,
7eed5d29 744 gp_Circ& aCirc,
745 const Standard_Real aTolAng)
a9f7b6b5
P		 746{
747 gp_Ax2 aAx2;
748 //
749 const gp_Ax1& aAx1C=aCirc.Axis();
750 const gp_Ax3& aAx3=aQuad.Position();
751 const gp_Ax1& aAx1Q=aAx3.Axis();
752 //
753 const gp_Dir& aDirC=aAx1C.Direction();
754 const gp_Dir& aDirQ=aAx1Q.Direction();
755 if (aDirC.IsParallel(aDirQ, aTolAng)) {
756 const gp_Pnt& aPLoc=aCirc.Location();
757 SeamPosition(aPLoc, aAx3, aAx2);
758 aCirc.SetPosition(aAx2);
759 }
760}
761//=======================================================================
762//function : AdjustToSeam
763//purpose :
764//=======================================================================
765void AdjustToSeam (const gp_Cylinder& aQuad,
7eed5d29 766 gp_Circ& aCirc)
a9f7b6b5
P		 767{
768 gp_Ax2 aAx2;
769 //
770 const gp_Pnt& aPLoc=aCirc.Location();
771 const gp_Ax3& aAx3=aQuad.Position();
772 SeamPosition(aPLoc, aAx3, aAx2);
773 aCirc.SetPosition(aAx2);
774}
775//=======================================================================
7eed5d29 776//function : AdjustToSeam
777//purpose :
778//=======================================================================
779void AdjustToSeam (const gp_Torus& aQuad,
780 gp_Circ& aCirc)
781{
782 gp_Ax2 aAx2;
783 //
784 const gp_Pnt& aPLoc=aCirc.Location();
785 const gp_Ax3& aAx3=aQuad.Position();
786 SeamPosition(aPLoc, aAx3, aAx2);
787 aCirc.SetPosition(aAx2);
788}
789//=======================================================================
a9f7b6b5
P		 790//function : SeamPosition
791//purpose :
792//=======================================================================
793void SeamPosition(const gp_Pnt& aPLoc,
7eed5d29 794 const gp_Ax3& aPos,
795 gp_Ax2& aSeamPos)
a9f7b6b5
P		 796{
797 const gp_Dir& aDZ=aPos.Direction();
798 const gp_Dir& aDX=aPos.XDirection();
799 gp_Ax2 aAx2(aPLoc, aDZ, aDX);
800 aSeamPos=aAx2;
801}
7eed5d29 802
a9f7b6b5 803//modified by NIZNHY-PKV Thu Sep 15 10:53:41 2011t
Open CASCADE Technology repository