Commit | Line | Data |
---|---|---|
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 | // |
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 | |
a9f7b6b5 P |
17 | //modified by NIZNHY-PKV Thu Sep 15 11:09:12 2011 |
18 | static | |
19 | void SeamPosition(const gp_Pnt& aPLoc, | |
7eed5d29 | 20 | const gp_Ax3& aPos, |
21 | gp_Ax2& aSeamPos); | |
a9f7b6b5 P |
22 | static |
23 | void AdjustToSeam (const gp_Cylinder& aQuad, | |
7eed5d29 | 24 | gp_Circ& aCirc); |
a9f7b6b5 P |
25 | static |
26 | void AdjustToSeam (const gp_Sphere& aQuad, | |
7eed5d29 | 27 | gp_Circ& aCirc, |
28 | const Standard_Real aTolAng); | |
a9f7b6b5 P |
29 | static |
30 | void AdjustToSeam (const gp_Cone& aQuad, | |
7eed5d29 | 31 | gp_Circ& aCirc); |
32 | static | |
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 | 42 | Standard_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 | 87 | Standard_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 | 259 | Standard_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 | 345 | Standard_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 | //======================================================================= | |
660 | Standard_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 | //======================================================================= | |
729 | void 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 | //======================================================================= | |
743 | void 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 | //======================================================================= | |
765 | void 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 | //======================================================================= | |
779 | void 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 | //======================================================================= | |
793 | void 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 |