1 // File: GccIter_Circ2d3Tan.gxx
2 // Created: Fri Dec 13 15:27:54 1991
6 //=========================================================================
7 // Creation d un cercle tangent a deux elements : Droite. +
11 // centre sur un troisieme : Droite. +
14 //=========================================================================
16 #include <gp_Dir2d.hxx>
17 #include <gp_Ax2d.hxx>
18 #include <gp_Vec2d.hxx>
20 #include <StdFail_NotDone.hxx>
21 #include <GccEnt_BadQualifier.hxx>
22 #include <math_FunctionSetRoot.hxx>
23 #include <math_NewtonFunctionSetRoot.hxx>
24 #include <GccAna_Circ2d3Tan.hxx>
27 GccIter_Circ2d3Tan (const TheQualifiedCurve& Qualified1 ,
28 const TheQualifiedCurve& Qualified2 ,
29 const TheQualifiedCurve& Qualified3 ,
30 const Standard_Real Param1 ,
31 const Standard_Real Param2 ,
32 const Standard_Real Param3 ,
33 const Standard_Real Tolerance ) {
35 TheSame1 = Standard_False;
36 TheSame2 = Standard_False;
37 TheSame3 = Standard_False;
45 Standard_Real Tol = Abs(Tolerance);
46 WellDone = Standard_False;
47 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
48 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
49 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
50 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
51 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
52 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
53 GccEnt_BadQualifier::Raise();
56 TheCurve Cu1 = Qualified1.Qualified();
57 TheCurve Cu2 = Qualified2.Qualified();
58 TheCurve Cu3 = Qualified3.Qualified();
59 GccIter_FuncTCuCuCu Func(Cu1,Cu2,Cu3);
60 math_Vector Umin(1,3);
61 math_Vector Umax(1,3);
62 math_Vector Ufirst(1,3);
64 Umin(1) = TheCurveTool::FirstParameter(Cu1);
65 Umin(2) = TheCurveTool::FirstParameter(Cu2);
66 Umin(3) = TheCurveTool::FirstParameter(Cu3);
67 Umax(1) = TheCurveTool::LastParameter(Cu1);
68 Umax(2) = TheCurveTool::LastParameter(Cu2);
69 Umax(3) = TheCurveTool::LastParameter(Cu3);
73 tol(1) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
74 tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
75 tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
76 math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
79 Func.Value(Ufirst,Umin);
80 gp_Pnt2d point1,point2,point3;
81 gp_Vec2d Tan1,Tan2,Tan3;
82 TheCurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
83 TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
84 TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
85 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
87 cirsol = circ.ThisSolution(1);
88 gp_Pnt2d centre = cirsol.Location();
89 Standard_Real normetan1 = Tan1.Magnitude();
90 Standard_Real normetan2 = Tan2.Magnitude();
91 Standard_Real normetan3 = Tan3.Magnitude();
92 gp_Vec2d Vec1(point1,centre);
93 gp_Vec2d Vec2(point2,centre);
94 gp_Vec2d Vec3(point3,centre);
95 Standard_Real normevec1 = Vec1.Magnitude();
96 Standard_Real normevec2 = Vec2.Magnitude();
97 Standard_Real normevec3 = Vec3.Magnitude();
98 Standard_Real dot1,dot2,dot3;
99 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
100 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
103 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
104 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
107 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
108 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
112 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
113 Standard_Real Angle1 = Vec1.Angle(Tan1);
114 if (Qualified1.IsUnqualified()||
115 (Qualified1.IsEnclosing()&&Angle1<=0.)||
116 (Qualified1.IsOutside() && Angle1 >= 0.) ||
117 (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
118 Angle1 = Vec2.Angle(Tan2);
119 if (Qualified2.IsUnqualified() ||
120 (Qualified2.IsEnclosing()&&Angle1<=0.)||
121 (Qualified2.IsOutside() && Angle1 >= 0) ||
122 (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
123 Angle1 = Vec3.Angle(Tan3);
124 if (Qualified3.IsUnqualified() ||
125 (Qualified3.IsEnclosing()&&Angle1<=0.)||
126 (Qualified3.IsOutside() && Angle1 >= 0) ||
127 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
128 qualifier1 = Qualified1.Qualifier();
129 qualifier2 = Qualified2.Qualifier();
130 qualifier3 = Qualified3.Qualifier();
136 par2sol = pnttg2sol.Distance(pnttg1sol);
139 par3sol = pnttg3sol.Distance(pnttg1sol);
140 WellDone = Standard_True;
150 GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 ,
151 const TheQualifiedCurve& Qualified2 ,
152 const TheQualifiedCurve& Qualified3 ,
153 const Standard_Real Param1 ,
154 const Standard_Real Param2 ,
155 const Standard_Real Param3 ,
156 const Standard_Real Tolerance ) {
158 TheSame1 = Standard_False;
159 TheSame2 = Standard_False;
160 TheSame3 = Standard_False;
168 Standard_Real Tol = Abs(Tolerance);
169 WellDone = Standard_False;
170 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
171 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
172 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
173 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
174 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
175 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
176 GccEnt_BadQualifier::Raise();
179 gp_Circ2d C1 = Qualified1.Qualified();
180 TheCurve Cu2 = Qualified2.Qualified();
181 TheCurve Cu3 = Qualified3.Qualified();
182 GccIter_FuncTCuCuCu Func(C1,Cu2,Cu3);
183 math_Vector Umin(1,3);
184 math_Vector Umax(1,3);
185 math_Vector Ufirst(1,3);
186 math_Vector tol(1,3);
188 Umin(2) = TheCurveTool::FirstParameter(Cu2);
189 Umin(3) = TheCurveTool::FirstParameter(Cu3);
191 Umax(2) = TheCurveTool::LastParameter(Cu2);
192 Umax(3) = TheCurveTool::LastParameter(Cu3);
196 tol(1) = 2.e-15*M_PI;
197 tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
198 tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
199 math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
202 Func.Value(Ufirst,Umin);
203 gp_Pnt2d centre1(C1.Location());
204 Standard_Real R1 = C1.Radius();
205 gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
206 gp_Vec2d Tan1(gp_XY(-Sin(Ufirst(1)),Cos(Ufirst(1))));
207 gp_Pnt2d point2,point3;
208 // gp_Vec2d Tan2,Tan3,Nor2,Nor3;
210 TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
211 TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
212 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
214 cirsol = circ.ThisSolution(1);
215 gp_Pnt2d centre(cirsol.Location());
216 Standard_Real dist = centre1.Distance(centre);
217 Standard_Real Rsol = cirsol.Radius();
218 Standard_Real normetan1 = Tan1.Magnitude();
219 Standard_Real normetan2 = Tan2.Magnitude();
220 Standard_Real normetan3 = Tan3.Magnitude();
221 gp_Vec2d Vec1(point1,centre);
222 gp_Vec2d Vec2(point2,centre);
223 gp_Vec2d Vec3(point3,centre);
224 Standard_Real normevec1 = Vec1.Magnitude();
225 Standard_Real normevec2 = Vec2.Magnitude();
226 Standard_Real normevec3 = Vec3.Magnitude();
227 Standard_Real dot1,dot2,dot3;
228 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
229 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
232 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
233 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
236 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
237 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
241 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
242 if (Qualified1.IsUnqualified() ||
243 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
244 (Qualified1.IsOutside() && dist >= Rsol) ||
245 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
246 Standard_Real Angle1 = Vec2.Angle(Tan2);
247 if (Qualified2.IsUnqualified() ||
248 (Qualified2.IsEnclosing()&&Angle1<=0.)||
249 (Qualified2.IsOutside() && Angle1 >= 0) ||
250 (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
251 Angle1 = Vec3.Angle(Tan3);
252 if (Qualified3.IsUnqualified() ||
253 (Qualified3.IsEnclosing()&&Angle1<=0.)||
254 (Qualified3.IsOutside() && Angle1 >= 0) ||
255 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
256 qualifier1 = Qualified1.Qualifier();
257 qualifier2 = Qualified2.Qualifier();
258 qualifier3 = Qualified3.Qualifier();
268 WellDone = Standard_True;
278 GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 ,
279 const GccEnt_QualifiedCirc& Qualified2 ,
280 const TheQualifiedCurve& Qualified3 ,
281 const Standard_Real Param1 ,
282 const Standard_Real Param2 ,
283 const Standard_Real Param3 ,
284 const Standard_Real Tolerance ) {
286 TheSame1 = Standard_False;
287 TheSame2 = Standard_False;
288 TheSame3 = Standard_False;
296 Standard_Real Tol = Abs(Tolerance);
297 WellDone = Standard_False;
298 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
299 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
300 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
301 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
302 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
303 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
304 GccEnt_BadQualifier::Raise();
307 gp_Circ2d C1 = Qualified1.Qualified();
308 gp_Circ2d C2 = Qualified2.Qualified();
309 TheCurve Cu3 = Qualified3.Qualified();
310 GccIter_FuncTCuCuCu Func(C1,C2,Cu3);
311 math_Vector Umin(1,3);
312 math_Vector Umax(1,3);
313 math_Vector Ufirst(1,3);
314 math_Vector tol(1,3);
317 Umin(3) = TheCurveTool::FirstParameter(Cu3);
320 Umax(3) = TheCurveTool::LastParameter(Cu3);
324 tol(1) = 2.e-15*M_PI;
325 tol(2) = 2.e-15*M_PI;
326 tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
327 math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
330 Func.Value(Ufirst,Umin);
331 gp_Pnt2d centre1(C1.Location());
332 Standard_Real R1 = C1.Radius();
333 gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
334 gp_Vec2d Tan1(gp_XY(-Sin(Ufirst(1)),Cos(Ufirst(1))));
335 gp_Pnt2d centre2(C2.Location());
336 Standard_Real R2 = C2.Radius();
337 gp_Pnt2d point2(centre2.XY()+R2*gp_XY(Cos(Ufirst(2)),Sin(Ufirst(2))));
338 gp_Vec2d Tan2(gp_XY(-Sin(Ufirst(2)),Cos(Ufirst(2))));
341 TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
342 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
344 cirsol = circ.ThisSolution(1);
345 gp_Pnt2d centre(cirsol.Location());
346 Standard_Real dist = centre1.Distance(centre);
347 Standard_Real Rsol = cirsol.Radius();
348 Standard_Real normetan1 = Tan1.Magnitude();
349 Standard_Real normetan2 = Tan2.Magnitude();
350 Standard_Real normetan3 = Tan3.Magnitude();
351 gp_Vec2d Vec1(point1,centre);
352 gp_Vec2d Vec2(point2,centre);
353 gp_Vec2d Vec3(point3,centre);
354 Standard_Real normevec1 = Vec1.Magnitude();
355 Standard_Real normevec2 = Vec2.Magnitude();
356 Standard_Real normevec3 = Vec3.Magnitude();
357 Standard_Real dot1,dot2,dot3;
358 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
359 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
362 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
363 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
366 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
367 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
371 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
372 if (Qualified1.IsUnqualified() ||
373 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
374 (Qualified1.IsOutside() && dist >= Rsol) ||
375 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
376 dist = centre2.Distance(centre);
377 if (Qualified1.IsUnqualified() ||
378 (Qualified1.IsEnclosing() && Rsol >= R2 && dist <= Rsol)||
379 (Qualified1.IsOutside() && dist >= Rsol) ||
380 (Qualified1.IsEnclosed() && Rsol <= R2 && dist <= Rsol)) {
381 gp_Vec2d Vec(point3,centre);
382 Standard_Real Angle1 = Vec.Angle(Tan3);
383 if (Qualified3.IsUnqualified() ||
384 (Qualified3.IsEnclosing()&&Angle1<=0.)||
385 (Qualified3.IsOutside() && Angle1 >= 0) ||
386 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
387 qualifier1 = Qualified1.Qualifier();
388 qualifier2 = Qualified2.Qualifier();
389 qualifier3 = Qualified3.Qualifier();
399 WellDone = Standard_True;
409 GccIter_Circ2d3Tan (const GccEnt_QualifiedLin& Qualified1 ,
410 const TheQualifiedCurve& Qualified2 ,
411 const TheQualifiedCurve& Qualified3 ,
412 const Standard_Real Param1 ,
413 const Standard_Real Param2 ,
414 const Standard_Real Param3 ,
415 const Standard_Real Tolerance ) {
417 TheSame1 = Standard_False;
418 TheSame2 = Standard_False;
419 TheSame3 = Standard_False;
427 Standard_Real Tol = Abs(Tolerance);
428 WellDone = Standard_False;
429 if (!(Qualified1.IsEnclosed() ||
430 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
431 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
432 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
433 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
434 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
435 GccEnt_BadQualifier::Raise();
438 gp_Lin2d L1 = Qualified1.Qualified();
439 TheCurve Cu2 = Qualified2.Qualified();
440 TheCurve Cu3 = Qualified3.Qualified();
441 GccIter_FuncTCuCuCu Func(L1,Cu2,Cu3);
442 math_Vector Umin(1,3);
443 math_Vector Umax(1,3);
444 math_Vector Ufirst(1,3);
445 math_Vector tol(1,3);
446 Umin(1) = RealFirst();
447 Umin(2) = TheCurveTool::FirstParameter(Cu2);
448 Umin(3) = TheCurveTool::FirstParameter(Cu3);
449 Umax(1) = RealLast();
450 Umax(2) = TheCurveTool::LastParameter(Cu2);
451 Umax(3) = TheCurveTool::LastParameter(Cu3);
456 tol(2) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
457 tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
458 math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
461 Func.Value(Ufirst,Umin);
462 gp_Pnt2d centre1(L1.Location());
463 gp_Pnt2d point1(centre1.XY()+Ufirst(1)*L1.Direction().XY());
464 gp_Pnt2d point2,point3;
466 TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
467 TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
468 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
470 cirsol = circ.ThisSolution(1);
471 gp_Pnt2d centre(cirsol.Location());
473 // creation vaariables intermediaires pour WNT
474 gp_XY dummy1 = centre.XY()-L1.Location().XY();
475 gp_XY dummy2 (-L1.Direction().Y(),L1.Direction().X());
476 Standard_Real pscal=dummy1.Dot(dummy2);
478 gp_Vec2d Tan1(L1.Direction().XY());
479 Standard_Real normetan1 = Tan1.Magnitude();
480 Standard_Real normetan2 = Tan2.Magnitude();
481 Standard_Real normetan3 = Tan3.Magnitude();
482 gp_Vec2d Vec1(point1,centre);
483 gp_Vec2d Vec2(point2,centre);
484 gp_Vec2d Vec3(point3,centre);
485 Standard_Real normevec1 = Vec1.Magnitude();
486 Standard_Real normevec2 = Vec2.Magnitude();
487 Standard_Real normevec3 = Vec3.Magnitude();
488 Standard_Real dot1,dot2,dot3;
489 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
490 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
493 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
494 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
497 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
498 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
502 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
503 if (Qualified1.IsUnqualified() ||
504 (Qualified1.IsOutside() && pscal <= 0.) ||
505 (Qualified1.IsEnclosed() && pscal >= 0.)) {
506 gp_Vec2d Vec(point2,centre);
507 Standard_Real Angle1 = Vec.Angle(Tan2);
508 if (Qualified2.IsUnqualified() ||
509 (Qualified2.IsEnclosing()&&Angle1<=0.)||
510 (Qualified2.IsOutside() && Angle1 >= 0) ||
511 (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
512 Vec = gp_Vec2d(point3,centre);
513 Angle1 = Vec.Angle(Tan3);
514 if (Qualified3.IsUnqualified() ||
515 (Qualified3.IsEnclosing()&&Angle1<=0.)||
516 (Qualified3.IsOutside() && Angle1 >= 0) ||
517 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
518 qualifier1 = Qualified1.Qualifier();
519 qualifier2 = Qualified2.Qualifier();
520 qualifier3 = Qualified3.Qualifier();
530 WellDone = Standard_True;
540 GccIter_Circ2d3Tan (const GccEnt_QualifiedLin& Qualified1 ,
541 const GccEnt_QualifiedLin& Qualified2 ,
542 const TheQualifiedCurve& Qualified3 ,
543 const Standard_Real Param1 ,
544 const Standard_Real Param2 ,
545 const Standard_Real Param3 ,
546 const Standard_Real Tolerance ){
548 TheSame1 = Standard_False;
549 TheSame2 = Standard_False;
550 TheSame3 = Standard_False;
558 Standard_Real Tol = Abs(Tolerance);
559 WellDone = Standard_False;
560 if (!(Qualified1.IsEnclosed() ||
561 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
562 !(Qualified2.IsEnclosed() ||
563 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
564 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
565 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
566 GccEnt_BadQualifier::Raise();
569 gp_Lin2d L1 = Qualified1.Qualified();
570 gp_Lin2d L2 = Qualified2.Qualified();
571 TheCurve Cu3 = Qualified3.Qualified();
572 GccIter_FuncTCuCuCu Func(L1,L2,Cu3);
573 math_Vector Umin(1,3);
574 math_Vector Umax(1,3);
575 math_Vector Ufirst(1,3);
576 math_Vector tol(1,3);
577 Umin(1) = RealFirst();
578 Umin(2) = RealFirst();
579 Umin(3) = TheCurveTool::FirstParameter(Cu3);
580 Umax(1) = RealLast();
581 Umax(2) = RealLast();
582 Umax(3) = TheCurveTool::LastParameter(Cu3);
588 tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
589 math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
592 Func.Value(Ufirst,Umin);
593 gp_Pnt2d centre1(L1.Location());
594 gp_Pnt2d point1(centre1.XY()+Ufirst(1)*L1.Direction().XY());
595 gp_Pnt2d centre2(L2.Location());
596 gp_Pnt2d point2(centre2.XY()+Ufirst(2)*L2.Direction().XY());
599 TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
600 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
602 cirsol = circ.ThisSolution(1);
603 gp_Pnt2d centre(cirsol.Location());
604 Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
605 L1.Direction().X()));
606 if (Qualified1.IsUnqualified() ||
607 (Qualified1.IsOutside() && pscal <= 0.) ||
608 (Qualified1.IsEnclosed() && pscal >= 0.)) {
609 Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
610 L1.Direction().X()));
611 gp_Vec2d Tan1(L1.Direction().XY());
612 gp_Vec2d Tan2(L2.Direction().XY());
613 Standard_Real normetan1 = Tan1.Magnitude();
614 Standard_Real normetan2 = Tan2.Magnitude();
615 Standard_Real normetan3 = Tan3.Magnitude();
616 gp_Vec2d Vec1(point1,centre);
617 gp_Vec2d Vec2(point2,centre);
618 gp_Vec2d Vec3(point3,centre);
619 Standard_Real normevec1 = Vec1.Magnitude();
620 Standard_Real normevec2 = Vec2.Magnitude();
621 Standard_Real normevec3 = Vec3.Magnitude();
622 Standard_Real dot1,dot2,dot3;
623 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
624 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
627 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
628 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
631 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
632 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
636 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
637 if (Qualified2.IsUnqualified() ||
638 (Qualified2.IsOutside() && pscal <= 0.) ||
639 (Qualified2.IsEnclosed() && pscal >= 0.)) {
640 Standard_Real Angle1 = Vec3.Angle(Tan3);
641 if (Qualified3.IsUnqualified() ||
642 (Qualified3.IsEnclosing()&&Angle1<=0.)||
643 (Qualified3.IsOutside() && Angle1 >= 0) ||
644 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
645 qualifier1 = Qualified1.Qualifier();
646 qualifier2 = Qualified2.Qualifier();
647 qualifier3 = Qualified3.Qualifier();
657 WellDone = Standard_True;
667 GccIter_Circ2d3Tan (const TheQualifiedCurve& Qualified1 ,
668 const TheQualifiedCurve& Qualified2 ,
669 const gp_Pnt2d& Point3 ,
670 const Standard_Real Param1 ,
671 const Standard_Real Param2 ,
672 const Standard_Real Tolerance ) {
674 TheSame1 = Standard_False;
675 TheSame2 = Standard_False;
676 TheSame3 = Standard_False;
684 Standard_Real Tol = Abs(Tolerance);
685 WellDone = Standard_False;
686 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
687 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
688 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
689 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
690 GccEnt_BadQualifier::Raise();
693 gp_Circ2d C1(gp_Ax2d(Point3,gp_Dir2d(1.,0.)),0.);
694 TheCurve Cu1 = Qualified1.Qualified();
695 TheCurve Cu2 = Qualified2.Qualified();
696 GccIter_FuncTCuCuCu Func(C1,Cu1,Cu2);
697 math_Vector Umin(1,3);
698 math_Vector Umax(1,3);
699 math_Vector Ufirst(1,3);
700 math_Vector tol(1,3);
702 Umin(2) = TheCurveTool::FirstParameter(Cu1);
703 Umin(3) = TheCurveTool::FirstParameter(Cu2);
705 Umax(2) = TheCurveTool::LastParameter(Cu1);
706 Umax(3) = TheCurveTool::LastParameter(Cu2);
710 tol(1) = 2.e-15*M_PI;
711 tol(2) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
712 tol(3) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
713 math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
716 Func.Value(Ufirst,Umin);
717 gp_Pnt2d point1,point2;
718 // gp_Vec2d Tan1,Tan2,Nor1,Nor2;
720 TheCurveTool::D1(Cu1,Ufirst(2),point1,Tan1);
721 TheCurveTool::D1(Cu2,Ufirst(3),point2,Tan2);
722 GccAna_Circ2d3Tan circ(Point3,point1,point2,Tol);
724 cirsol = circ.ThisSolution(1);
725 gp_Pnt2d centre(cirsol.Location());
726 gp_Vec2d Tan3(-Sin(Ufirst(1)),Cos(Ufirst(1)));
727 Standard_Real normetan1 = Tan1.Magnitude();
728 Standard_Real normetan2 = Tan2.Magnitude();
729 Standard_Real normetan3 = Tan3.Magnitude();
730 gp_Vec2d Vec1(point1,centre);
731 gp_Vec2d Vec2(point2,centre);
732 gp_Vec2d Vec3(Point3,centre);
733 Standard_Real normevec1 = Vec1.Magnitude();
734 Standard_Real normevec2 = Vec2.Magnitude();
735 Standard_Real normevec3 = Vec3.Magnitude();
736 Standard_Real dot1,dot2,dot3;
737 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
738 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
741 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
742 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
745 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
746 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
750 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
751 Standard_Real Angle1 = Vec1.Angle(Tan1);
752 if (Qualified1.IsUnqualified()||
753 (Qualified1.IsEnclosing()&&Angle1<=0.)||
754 (Qualified1.IsOutside() && Angle1 >= 0) ||
755 (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
756 Angle1 = Vec2.Angle(Tan2);
757 if (Qualified1.IsUnqualified() ||
758 (Qualified1.IsEnclosing()&&Angle1<=0.)||
759 (Qualified1.IsOutside() && Angle1 >= 0) ||
760 (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
761 qualifier1 = Qualified1.Qualifier();
762 qualifier2 = Qualified2.Qualifier();
763 qualifier3 = GccEnt_noqualifier;
773 WellDone = Standard_True;
782 GccIter_Circ2d3Tan (const TheQualifiedCurve& Qualified1 ,
783 const gp_Pnt2d& Point2 ,
784 const gp_Pnt2d& Point3 ,
785 const Standard_Real Param1 ,
786 const Standard_Real Tolerance ) {
788 TheSame1 = Standard_False;
789 TheSame2 = Standard_False;
790 TheSame3 = Standard_False;
798 Standard_Real Tol = Abs(Tolerance);
799 WellDone = Standard_False;
800 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
801 Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
802 GccEnt_BadQualifier::Raise();
805 gp_Dir2d dirx(1.,0.);
806 gp_Circ2d C1(gp_Ax2d(Point2,dirx),0.);
807 gp_Circ2d C2(gp_Ax2d(Point3,dirx),0.);
808 TheCurve Cu1 = Qualified1.Qualified();
809 GccIter_FuncTCuCuCu Func(C1,C2,Cu1);
810 math_Vector Umin(1,3);
811 math_Vector Umax(1,3);
812 math_Vector Ufirst(1,3);
813 math_Vector tol(1,3);
816 Umin(3) = TheCurveTool::FirstParameter(Cu1);
819 Umax(3) = TheCurveTool::LastParameter(Cu1);
823 tol(1) = 2.e-15*M_PI;
824 tol(2) = 2.e-15*M_PI;
825 tol(3) = TheCurveTool::EpsX(Cu1,Abs(Tolerance));
826 math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
829 Func.Value(Ufirst,Umin);
831 // gp_Vec2d Tan3,Nor3;
833 TheCurveTool::D1(Cu1,Ufirst(3),point3,Tan3);
834 GccAna_Circ2d3Tan circ(Point2,Point3,point3,Tol);
836 cirsol = circ.ThisSolution(1);
837 gp_Pnt2d centre(cirsol.Location());
838 gp_Vec2d Tan2(-Sin(Ufirst(2)),Cos(Ufirst(2)));
839 gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
840 Standard_Real normetan1 = Tan1.Magnitude();
841 Standard_Real normetan2 = Tan2.Magnitude();
842 Standard_Real normetan3 = Tan3.Magnitude();
843 gp_Vec2d Vec1(Point2,centre);
844 gp_Vec2d Vec2(Point3,centre);
845 gp_Vec2d Vec3(point3,centre);
846 Standard_Real normevec1 = Vec1.Magnitude();
847 Standard_Real normevec2 = Vec2.Magnitude();
848 Standard_Real normevec3 = Vec3.Magnitude();
849 Standard_Real dot1,dot2,dot3;
850 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
851 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
854 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
855 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
858 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
859 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
863 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
864 Standard_Real Angle1 = Vec1.Angle(Tan1);
865 if (Qualified1.IsUnqualified() ||
866 (Qualified1.IsEnclosing()&&Angle1<=0.)||
867 (Qualified1.IsOutside() && Angle1 >= 0) ||
868 (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
869 qualifier1 = Qualified1.Qualifier();
870 qualifier2 = GccEnt_noqualifier;
871 qualifier3 = GccEnt_noqualifier;
881 WellDone = Standard_True;
889 GccIter_Circ2d3Tan (const GccEnt_QualifiedLin& Qualified1 ,
890 const TheQualifiedCurve& Qualified2 ,
891 const gp_Pnt2d& Point3 ,
892 const Standard_Real Param1 ,
893 const Standard_Real Param2 ,
894 const Standard_Real Tolerance ) {
896 TheSame1 = Standard_False;
897 TheSame2 = Standard_False;
898 TheSame3 = Standard_False;
906 Standard_Real Tol = Abs(Tolerance);
907 WellDone = Standard_False;
908 if (!(Qualified1.IsEnclosed() ||
909 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
910 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
911 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
912 GccEnt_BadQualifier::Raise();
915 gp_Dir2d dirx(1.,0.);
916 gp_Lin2d L1 = Qualified1.Qualified();
917 TheCurve Cu2 = Qualified2.Qualified();
918 gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
919 GccIter_FuncTCuCuCu Func(C3,L1,Cu2);
920 math_Vector Umin(1,3);
921 math_Vector Umax(1,3);
922 math_Vector Ufirst(1,3);
923 math_Vector tol(1,3);
924 Umin(2) = RealFirst();
925 Umin(3) = TheCurveTool::FirstParameter(Cu2);
927 Umax(2) = RealLast();
928 Umax(3) = TheCurveTool::LastParameter(Cu2);
935 tol(3) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
936 math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
939 Func.Value(Ufirst,Umin);
940 gp_Pnt2d centre1(L1.Location());
941 gp_Pnt2d point1(centre1.XY()+Ufirst(2)*L1.Direction().XY());
944 TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
945 GccAna_Circ2d3Tan circ(point1,point2,Point3,Tol);
947 cirsol = circ.ThisSolution(1);
948 gp_Pnt2d centre(cirsol.Location());
949 Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
950 L1.Direction().X()));
951 gp_Vec2d Tan1(L1.Direction().XY());
952 gp_Vec2d Tan3(-Sin(Ufirst(1)),Cos(Ufirst(1)));
953 Standard_Real normetan1 = Tan1.Magnitude();
954 Standard_Real normetan2 = Tan2.Magnitude();
955 Standard_Real normetan3 = Tan3.Magnitude();
956 gp_Vec2d Vec1(point1,centre);
957 gp_Vec2d Vec2(point2,centre);
958 gp_Vec2d Vec3(Point3,centre);
959 Standard_Real normevec1 = Vec1.Magnitude();
960 Standard_Real normevec2 = Vec2.Magnitude();
961 Standard_Real normevec3 = Vec3.Magnitude();
962 Standard_Real dot1,dot2,dot3;
963 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
964 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
967 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
968 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
971 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
972 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
976 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
977 if (Qualified1.IsUnqualified() ||
978 (Qualified1.IsOutside() && pscal <= 0.) ||
979 (Qualified1.IsEnclosed() && pscal >= 0.)) {
980 Standard_Real Angle1 = Vec2.Angle(Tan2);
981 if (Qualified2.IsUnqualified() ||
982 (Qualified2.IsEnclosing()&&Angle1<=0.)||
983 (Qualified2.IsOutside() && Angle1 >= 0) ||
984 (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
985 qualifier1 = Qualified1.Qualifier();
986 qualifier2 = Qualified2.Qualifier();
987 qualifier3 = GccEnt_noqualifier;
997 WellDone = Standard_True;
1005 GccIter_Circ2d3Tan::
1006 GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 ,
1007 const GccEnt_QualifiedLin& Qualified2 ,
1008 const TheQualifiedCurve& Qualified3 ,
1009 const Standard_Real Param1 ,
1010 const Standard_Real Param2 ,
1011 const Standard_Real Param3 ,
1012 const Standard_Real Tolerance ) {
1014 TheSame1 = Standard_False;
1015 TheSame2 = Standard_False;
1016 TheSame3 = Standard_False;
1024 Standard_Real Tol = Abs(Tolerance);
1025 WellDone = Standard_False;
1026 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
1027 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
1028 !(Qualified2.IsEnclosed() ||
1029 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
1030 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
1031 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
1032 GccEnt_BadQualifier::Raise();
1035 gp_Circ2d C1 = Qualified1.Qualified();
1036 gp_Lin2d L2 = Qualified2.Qualified();
1037 TheCurve Cu3 = Qualified3.Qualified();
1038 GccIter_FuncTCuCuCu Func(C1,L2,Cu3);
1039 math_Vector Umin(1,3);
1040 math_Vector Umax(1,3);
1041 math_Vector Ufirst(1,3);
1042 math_Vector tol(1,3);
1044 Umin(2) = RealFirst();
1045 Umin(3) = TheCurveTool::FirstParameter(Cu3);
1047 Umax(2) = RealLast();
1048 Umax(3) = TheCurveTool::LastParameter(Cu3);
1052 tol(1) = 2.e-15*M_PI;
1054 tol(3) = TheCurveTool::EpsX(Cu3,Abs(Tolerance));
1055 math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
1056 if (Root.IsDone()) {
1057 Func.Value(Ufirst,Umin);
1059 gp_Pnt2d centre1(C1.Location());
1060 Standard_Real R1 = C1.Radius();
1061 gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
1062 gp_Pnt2d centre2(L2.Location());
1063 gp_Pnt2d point2(centre2.XY()+Ufirst(2)*L2.Direction().XY());
1066 TheCurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
1067 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
1068 if (circ.IsDone()) {
1069 cirsol = circ.ThisSolution(1);
1070 gp_Pnt2d centre(cirsol.Location());
1071 gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
1072 gp_Vec2d Tan2(L2.Direction().XY());
1073 Standard_Real normetan1 = Tan1.Magnitude();
1074 Standard_Real normetan2 = Tan2.Magnitude();
1075 Standard_Real normetan3 = Tan3.Magnitude();
1076 gp_Vec2d Vec1(point1,centre);
1077 gp_Vec2d Vec2(point2,centre);
1078 gp_Vec2d Vec3(point3,centre);
1079 Standard_Real normevec1 = Vec1.Magnitude();
1080 Standard_Real normevec2 = Vec2.Magnitude();
1081 Standard_Real normevec3 = Vec3.Magnitude();
1082 Standard_Real dot1,dot2,dot3;
1083 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
1084 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
1087 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
1088 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
1091 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
1092 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
1096 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
1097 Standard_Real dist = centre1.Distance(centre);
1098 Standard_Real Rsol = cirsol.Radius();
1099 if (Qualified1.IsUnqualified() ||
1100 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
1101 (Qualified1.IsOutside() && dist >= Rsol) ||
1102 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
1103 Standard_Real pscal=centre.XY().Dot(gp_XY(-L2.Direction().Y(),
1104 L2.Direction().X()));
1105 if (Qualified2.IsUnqualified() ||
1106 (Qualified2.IsOutside() && pscal <= 0.) ||
1107 (Qualified2.IsEnclosed() && pscal >= 0.)) {
1108 Standard_Real Angle1 = Vec3.Angle(Tan3);
1109 if (Qualified3.IsUnqualified() ||
1110 (Qualified3.IsEnclosing()&&Angle1<=0.)||
1111 (Qualified3.IsOutside() && Angle1 >= 0) ||
1112 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
1113 qualifier1 = Qualified1.Qualifier();
1114 qualifier2 = Qualified2.Qualifier();
1115 qualifier3 = Qualified3.Qualifier();
1116 pararg1 = Ufirst(1);
1119 pararg2 = Ufirst(2);
1122 pararg3 = Ufirst(3);
1125 WellDone = Standard_True;
1134 GccIter_Circ2d3Tan::
1135 GccIter_Circ2d3Tan (const GccEnt_QualifiedCirc& Qualified1 ,
1136 const TheQualifiedCurve& Qualified2 ,
1137 const gp_Pnt2d& Point3 ,
1138 const Standard_Real Param1 ,
1139 const Standard_Real Param2 ,
1140 const Standard_Real Tolerance ) {
1142 TheSame1 = Standard_False;
1143 TheSame2 = Standard_False;
1144 TheSame3 = Standard_False;
1152 Standard_Real Tol = Abs(Tolerance);
1153 WellDone = Standard_False;
1154 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
1155 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
1156 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
1157 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
1158 GccEnt_BadQualifier::Raise();
1161 gp_Circ2d C1 = Qualified1.Qualified();
1162 TheCurve Cu2 = Qualified2.Qualified();
1163 gp_Dir2d dirx(1.,0.);
1164 gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
1165 GccIter_FuncTCuCuCu Func(C1,C3,Cu2);
1166 math_Vector Umin(1,3);
1167 math_Vector Umax(1,3);
1168 math_Vector Ufirst(1,3);
1169 math_Vector tol(1,3);
1171 Umin(3) = TheCurveTool::FirstParameter(Cu2);
1174 Umax(3) = TheCurveTool::LastParameter(Cu2);
1179 tol(1) = 2.e-15*M_PI;
1180 tol(2) = 2.e-15*M_PI;
1181 tol(3) = TheCurveTool::EpsX(Cu2,Abs(Tolerance));
1182 math_FunctionSetRoot Root(Func,Ufirst,tol,Umin,Umax);
1183 if (Root.IsDone()) {
1185 Func.Value(Ufirst,Umin);
1186 gp_Pnt2d centre1(C1.Location());
1187 Standard_Real R1 = C1.Radius();
1188 gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
1190 // gp_Vec2d Tan2,Nor2;
1192 TheCurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
1193 GccAna_Circ2d3Tan circ(point1,point2,Point3,Tol);
1194 if (circ.IsDone()) {
1195 cirsol = circ.ThisSolution(1);
1196 gp_Pnt2d centre(cirsol.Location());
1197 gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
1198 gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
1199 Standard_Real normetan2 = Tan2.Magnitude();
1200 gp_Vec2d Vec1(point1,centre);
1201 gp_Vec2d Vec2(point2,centre);
1202 gp_Vec2d Vec3(Point3,centre);
1203 Standard_Real normevec1 = Vec1.Magnitude();
1204 Standard_Real normevec2 = Vec2.Magnitude();
1205 Standard_Real normevec3 = Vec3.Magnitude();
1206 Standard_Real dot1,dot2,dot3;
1207 if (normevec1 >= gp::Resolution()) {
1208 dot1 = Vec1.Dot(Tan1)/(normevec1);
1211 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
1212 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
1215 if (normevec3 >= gp::Resolution()) {
1216 dot3 = Vec3.Dot(Tan3)/(normevec3);
1220 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
1221 Standard_Real dist = centre1.Distance(centre);
1222 Standard_Real Rsol = cirsol.Radius();
1223 if (Qualified1.IsUnqualified() ||
1224 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
1225 (Qualified1.IsOutside() && dist >= Rsol) ||
1226 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
1227 Standard_Real Angle1 = Vec2.Angle(Tan2);
1228 if (Qualified2.IsUnqualified() ||
1229 (Qualified2.IsEnclosing()&&Angle1<=0.)||
1230 (Qualified2.IsOutside() && Angle1 >= 0) ||
1231 (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
1232 qualifier1 = Qualified1.Qualifier();
1233 qualifier2 = Qualified2.Qualifier();
1234 qualifier3 = GccEnt_noqualifier;
1235 pararg1 = Ufirst(1);
1238 pararg2 = Ufirst(2);
1244 WellDone = Standard_True;
1252 Standard_Boolean GccIter_Circ2d3Tan::
1253 IsDone () const{ return WellDone; }
1255 gp_Circ2d GccIter_Circ2d3Tan::
1256 ThisSolution () const{ return cirsol; }
1258 void GccIter_Circ2d3Tan::
1259 WhichQualifier (GccEnt_Position& Qualif1 ,
1260 GccEnt_Position& Qualif2 ,
1261 GccEnt_Position& Qualif3 ) const
1263 if (!WellDone) { StdFail_NotDone::Raise(); }
1265 Qualif1 = qualifier1;
1266 Qualif2 = qualifier2;
1267 Qualif3 = qualifier3;
1271 void GccIter_Circ2d3Tan::
1272 Tangency1 (Standard_Real& ParSol ,
1273 Standard_Real& ParArg ,
1274 gp_Pnt2d& PntSol ) const{
1275 if (!WellDone) { StdFail_NotDone::Raise(); }
1277 if (TheSame1 == 0) {
1282 else { StdFail_NotDone::Raise(); }
1286 void GccIter_Circ2d3Tan::
1287 Tangency2 (Standard_Real& ParSol ,
1288 Standard_Real& ParArg ,
1289 gp_Pnt2d& PntSol ) const{
1290 if (!WellDone) { StdFail_NotDone::Raise(); }
1298 void GccIter_Circ2d3Tan::
1299 Tangency3 (Standard_Real& ParSol ,
1300 Standard_Real& ParArg ,
1301 gp_Pnt2d& PntSol ) const{
1302 if (!WellDone) { StdFail_NotDone::Raise(); }
1310 Standard_Boolean GccIter_Circ2d3Tan::
1313 if (!WellDone) StdFail_NotDone::Raise();
1316 return Standard_False;
1318 return Standard_True;
1322 Standard_Boolean GccIter_Circ2d3Tan::
1325 if (!WellDone) StdFail_NotDone::Raise();
1328 return Standard_False;
1330 return Standard_True;
1334 Standard_Boolean GccIter_Circ2d3Tan::
1337 if (!WellDone) StdFail_NotDone::Raise();
1339 return Standard_True;