1 // Created on: 1991-12-13
2 // Created by: Remi GILET
3 // Copyright (c) 1991-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 // This file is part of Open CASCADE Technology software library.
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
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.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
17 //=========================================================================
18 // Creation d un cercle tangent a deux elements : Droite. +
22 // centre sur un troisieme : Droite. +
25 //=========================================================================
27 #include <GccAna_Circ2d3Tan.hxx>
28 #include <GccEnt_BadQualifier.hxx>
29 #include <GccEnt_QualifiedCirc.hxx>
30 #include <GccEnt_QualifiedLin.hxx>
31 #include <Geom2dGcc_Circ2d3TanIter.hxx>
32 #include <Geom2dGcc_CurveTool.hxx>
33 #include <Geom2dGcc_FunctionTanCuCuCu.hxx>
34 #include <Geom2dGcc_QCurve.hxx>
36 #include <gp_Ax2d.hxx>
37 #include <gp_Circ2d.hxx>
38 #include <gp_Dir2d.hxx>
39 #include <gp_Pnt2d.hxx>
40 #include <gp_Vec2d.hxx>
41 #include <math_FunctionSetRoot.hxx>
42 #include <math_NewtonFunctionSetRoot.hxx>
43 #include <StdFail_NotDone.hxx>
45 Geom2dGcc_Circ2d3TanIter::
46 Geom2dGcc_Circ2d3TanIter (const Geom2dGcc_QCurve& Qualified1 ,
47 const Geom2dGcc_QCurve& Qualified2 ,
48 const Geom2dGcc_QCurve& Qualified3 ,
49 const Standard_Real Param1 ,
50 const Standard_Real Param2 ,
51 const Standard_Real Param3 ,
52 const Standard_Real Tolerance ) {
54 TheSame1 = Standard_False;
55 TheSame2 = Standard_False;
56 TheSame3 = Standard_False;
64 Standard_Real Tol = Abs(Tolerance);
65 WellDone = Standard_False;
66 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
67 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
68 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
69 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
70 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
71 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
72 throw GccEnt_BadQualifier();
75 Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
76 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
77 Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
78 Geom2dGcc_FunctionTanCuCuCu Func(Cu1,Cu2,Cu3);
79 math_Vector Umin(1,3);
80 math_Vector Umax(1,3);
81 math_Vector Ufirst(1,3);
83 Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
84 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
85 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
86 Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
87 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
88 Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
92 tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
93 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
94 tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
95 math_FunctionSetRoot Root(Func, tol);
96 Root.Perform(Func, Ufirst, Umin, Umax);
99 Func.Value(Ufirst,Umin);
100 gp_Pnt2d point1,point2,point3;
101 gp_Vec2d Tan1,Tan2,Tan3;
102 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
103 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
104 Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
105 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
107 cirsol = circ.ThisSolution(1);
108 gp_Pnt2d centre = cirsol.Location();
109 Standard_Real normetan1 = Tan1.Magnitude();
110 Standard_Real normetan2 = Tan2.Magnitude();
111 Standard_Real normetan3 = Tan3.Magnitude();
112 gp_Vec2d Vec1(point1,centre);
113 gp_Vec2d Vec2(point2,centre);
114 gp_Vec2d Vec3(point3,centre);
115 Standard_Real normevec1 = Vec1.Magnitude();
116 Standard_Real normevec2 = Vec2.Magnitude();
117 Standard_Real normevec3 = Vec3.Magnitude();
118 Standard_Real dot1,dot2,dot3;
119 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
120 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
123 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
124 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
127 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
128 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
132 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
133 Standard_Real Angle1 = Vec1.Angle(Tan1);
134 if (Qualified1.IsUnqualified()||
135 (Qualified1.IsEnclosing()&&Angle1<=0.)||
136 (Qualified1.IsOutside() && Angle1 >= 0.) ||
137 (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
138 Angle1 = Vec2.Angle(Tan2);
139 if (Qualified2.IsUnqualified() ||
140 (Qualified2.IsEnclosing()&&Angle1<=0.)||
141 (Qualified2.IsOutside() && Angle1 >= 0) ||
142 (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
143 Angle1 = Vec3.Angle(Tan3);
144 if (Qualified3.IsUnqualified() ||
145 (Qualified3.IsEnclosing()&&Angle1<=0.)||
146 (Qualified3.IsOutside() && Angle1 >= 0) ||
147 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
148 qualifier1 = Qualified1.Qualifier();
149 qualifier2 = Qualified2.Qualifier();
150 qualifier3 = Qualified3.Qualifier();
156 par2sol = pnttg2sol.Distance(pnttg1sol);
159 par3sol = pnttg3sol.Distance(pnttg1sol);
160 WellDone = Standard_True;
169 Geom2dGcc_Circ2d3TanIter::
170 Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedCirc& Qualified1 ,
171 const Geom2dGcc_QCurve& Qualified2 ,
172 const Geom2dGcc_QCurve& Qualified3 ,
173 const Standard_Real Param1 ,
174 const Standard_Real Param2 ,
175 const Standard_Real Param3 ,
176 const Standard_Real Tolerance ) {
178 TheSame1 = Standard_False;
179 TheSame2 = Standard_False;
180 TheSame3 = Standard_False;
188 Standard_Real Tol = Abs(Tolerance);
189 WellDone = Standard_False;
190 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
191 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
192 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
193 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
194 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
195 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
196 throw GccEnt_BadQualifier();
199 gp_Circ2d C1 = Qualified1.Qualified();
200 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
201 Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
202 Geom2dGcc_FunctionTanCuCuCu Func(C1,Cu2,Cu3);
203 math_Vector Umin(1,3);
204 math_Vector Umax(1,3);
205 math_Vector Ufirst(1,3);
206 math_Vector tol(1,3);
208 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
209 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
211 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
212 Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
216 tol(1) = 2.e-15*M_PI;
217 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
218 tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
219 math_FunctionSetRoot Root(Func, tol);
220 Root.Perform(Func, Ufirst, Umin, Umax);
223 Func.Value(Ufirst,Umin);
224 gp_Pnt2d centre1(C1.Location());
225 Standard_Real R1 = C1.Radius();
226 gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
227 gp_Vec2d Tan1(gp_XY(-Sin(Ufirst(1)),Cos(Ufirst(1))));
228 gp_Pnt2d point2,point3;
229 // gp_Vec2d Tan2,Tan3,Nor2,Nor3;
231 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
232 Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
233 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
235 cirsol = circ.ThisSolution(1);
236 gp_Pnt2d centre(cirsol.Location());
237 Standard_Real dist = centre1.Distance(centre);
238 Standard_Real Rsol = cirsol.Radius();
239 Standard_Real normetan1 = Tan1.Magnitude();
240 Standard_Real normetan2 = Tan2.Magnitude();
241 Standard_Real normetan3 = Tan3.Magnitude();
242 gp_Vec2d Vec1(point1,centre);
243 gp_Vec2d Vec2(point2,centre);
244 gp_Vec2d Vec3(point3,centre);
245 Standard_Real normevec1 = Vec1.Magnitude();
246 Standard_Real normevec2 = Vec2.Magnitude();
247 Standard_Real normevec3 = Vec3.Magnitude();
248 Standard_Real dot1,dot2,dot3;
249 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
250 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
253 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
254 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
257 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
258 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
262 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
263 if (Qualified1.IsUnqualified() ||
264 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
265 (Qualified1.IsOutside() && dist >= Rsol) ||
266 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
267 Standard_Real Angle1 = Vec2.Angle(Tan2);
268 if (Qualified2.IsUnqualified() ||
269 (Qualified2.IsEnclosing()&&Angle1<=0.)||
270 (Qualified2.IsOutside() && Angle1 >= 0) ||
271 (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
272 Angle1 = Vec3.Angle(Tan3);
273 if (Qualified3.IsUnqualified() ||
274 (Qualified3.IsEnclosing()&&Angle1<=0.)||
275 (Qualified3.IsOutside() && Angle1 >= 0) ||
276 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
277 qualifier1 = Qualified1.Qualifier();
278 qualifier2 = Qualified2.Qualifier();
279 qualifier3 = Qualified3.Qualifier();
289 WellDone = Standard_True;
298 Geom2dGcc_Circ2d3TanIter::
299 Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedCirc& Qualified1 ,
300 const GccEnt_QualifiedCirc& Qualified2 ,
301 const Geom2dGcc_QCurve& Qualified3 ,
302 const Standard_Real Param1 ,
303 const Standard_Real Param2 ,
304 const Standard_Real Param3 ,
305 const Standard_Real Tolerance ) {
307 TheSame1 = Standard_False;
308 TheSame2 = Standard_False;
309 TheSame3 = Standard_False;
317 Standard_Real Tol = Abs(Tolerance);
318 WellDone = Standard_False;
319 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
320 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
321 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
322 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
323 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
324 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
325 throw GccEnt_BadQualifier();
328 gp_Circ2d C1 = Qualified1.Qualified();
329 gp_Circ2d C2 = Qualified2.Qualified();
330 Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
331 Geom2dGcc_FunctionTanCuCuCu Func(C1,C2,Cu3);
332 math_Vector Umin(1,3);
333 math_Vector Umax(1,3);
334 math_Vector Ufirst(1,3);
335 math_Vector tol(1,3);
338 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
341 Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
345 tol(1) = 2.e-15*M_PI;
346 tol(2) = 2.e-15*M_PI;
347 tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
348 math_FunctionSetRoot Root(Func, tol);
349 Root.Perform(Func, Ufirst, Umin, Umax);
352 Func.Value(Ufirst,Umin);
353 gp_Pnt2d centre1(C1.Location());
354 Standard_Real R1 = C1.Radius();
355 gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
356 gp_Vec2d Tan1(gp_XY(-Sin(Ufirst(1)),Cos(Ufirst(1))));
357 gp_Pnt2d centre2(C2.Location());
358 Standard_Real R2 = C2.Radius();
359 gp_Pnt2d point2(centre2.XY()+R2*gp_XY(Cos(Ufirst(2)),Sin(Ufirst(2))));
360 gp_Vec2d Tan2(gp_XY(-Sin(Ufirst(2)),Cos(Ufirst(2))));
363 Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
364 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
366 cirsol = circ.ThisSolution(1);
367 gp_Pnt2d centre(cirsol.Location());
368 Standard_Real dist = centre1.Distance(centre);
369 Standard_Real Rsol = cirsol.Radius();
370 Standard_Real normetan1 = Tan1.Magnitude();
371 Standard_Real normetan2 = Tan2.Magnitude();
372 Standard_Real normetan3 = Tan3.Magnitude();
373 gp_Vec2d Vec1(point1,centre);
374 gp_Vec2d Vec2(point2,centre);
375 gp_Vec2d Vec3(point3,centre);
376 Standard_Real normevec1 = Vec1.Magnitude();
377 Standard_Real normevec2 = Vec2.Magnitude();
378 Standard_Real normevec3 = Vec3.Magnitude();
379 Standard_Real dot1,dot2,dot3;
380 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
381 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
384 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
385 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
388 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
389 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
393 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
394 if (Qualified1.IsUnqualified() ||
395 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
396 (Qualified1.IsOutside() && dist >= Rsol) ||
397 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
398 dist = centre2.Distance(centre);
399 if (Qualified1.IsUnqualified() ||
400 (Qualified1.IsEnclosing() && Rsol >= R2 && dist <= Rsol)||
401 (Qualified1.IsOutside() && dist >= Rsol) ||
402 (Qualified1.IsEnclosed() && Rsol <= R2 && dist <= Rsol)) {
403 gp_Vec2d Vec(point3,centre);
404 Standard_Real Angle1 = Vec.Angle(Tan3);
405 if (Qualified3.IsUnqualified() ||
406 (Qualified3.IsEnclosing()&&Angle1<=0.)||
407 (Qualified3.IsOutside() && Angle1 >= 0) ||
408 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
409 qualifier1 = Qualified1.Qualifier();
410 qualifier2 = Qualified2.Qualifier();
411 qualifier3 = Qualified3.Qualifier();
421 WellDone = Standard_True;
430 Geom2dGcc_Circ2d3TanIter::
431 Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedLin& Qualified1 ,
432 const Geom2dGcc_QCurve& Qualified2 ,
433 const Geom2dGcc_QCurve& Qualified3 ,
434 const Standard_Real Param1 ,
435 const Standard_Real Param2 ,
436 const Standard_Real Param3 ,
437 const Standard_Real Tolerance ) {
439 TheSame1 = Standard_False;
440 TheSame2 = Standard_False;
441 TheSame3 = Standard_False;
449 Standard_Real Tol = Abs(Tolerance);
450 WellDone = Standard_False;
451 if (!(Qualified1.IsEnclosed() ||
452 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
453 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
454 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
455 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
456 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
457 throw GccEnt_BadQualifier();
460 gp_Lin2d L1 = Qualified1.Qualified();
461 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
462 Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
463 Geom2dGcc_FunctionTanCuCuCu Func(L1,Cu2,Cu3);
464 math_Vector Umin(1,3);
465 math_Vector Umax(1,3);
466 math_Vector Ufirst(1,3);
467 math_Vector tol(1,3);
468 Umin(1) = RealFirst();
469 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
470 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
471 Umax(1) = RealLast();
472 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
473 Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
478 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
479 tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
480 math_FunctionSetRoot Root(Func, tol);
481 Root.Perform(Func, Ufirst, Umin, Umax);
484 Func.Value(Ufirst,Umin);
485 gp_Pnt2d centre1(L1.Location());
486 gp_Pnt2d point1(centre1.XY()+Ufirst(1)*L1.Direction().XY());
487 gp_Pnt2d point2,point3;
489 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
490 Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
491 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
493 cirsol = circ.ThisSolution(1);
494 gp_Pnt2d centre(cirsol.Location());
496 // creation vaariables intermediaires pour WNT
497 gp_XY dummy1 = centre.XY()-L1.Location().XY();
498 gp_XY dummy2 (-L1.Direction().Y(),L1.Direction().X());
499 Standard_Real pscal=dummy1.Dot(dummy2);
501 gp_Vec2d Tan1(L1.Direction().XY());
502 Standard_Real normetan1 = Tan1.Magnitude();
503 Standard_Real normetan2 = Tan2.Magnitude();
504 Standard_Real normetan3 = Tan3.Magnitude();
505 gp_Vec2d Vec1(point1,centre);
506 gp_Vec2d Vec2(point2,centre);
507 gp_Vec2d Vec3(point3,centre);
508 Standard_Real normevec1 = Vec1.Magnitude();
509 Standard_Real normevec2 = Vec2.Magnitude();
510 Standard_Real normevec3 = Vec3.Magnitude();
511 Standard_Real dot1,dot2,dot3;
512 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
513 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
516 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
517 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
520 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
521 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
525 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
526 if (Qualified1.IsUnqualified() ||
527 (Qualified1.IsOutside() && pscal <= 0.) ||
528 (Qualified1.IsEnclosed() && pscal >= 0.)) {
529 gp_Vec2d Vec(point2,centre);
530 Standard_Real Angle1 = Vec.Angle(Tan2);
531 if (Qualified2.IsUnqualified() ||
532 (Qualified2.IsEnclosing()&&Angle1<=0.)||
533 (Qualified2.IsOutside() && Angle1 >= 0) ||
534 (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
535 Vec = gp_Vec2d(point3,centre);
536 Angle1 = Vec.Angle(Tan3);
537 if (Qualified3.IsUnqualified() ||
538 (Qualified3.IsEnclosing()&&Angle1<=0.)||
539 (Qualified3.IsOutside() && Angle1 >= 0) ||
540 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
541 qualifier1 = Qualified1.Qualifier();
542 qualifier2 = Qualified2.Qualifier();
543 qualifier3 = Qualified3.Qualifier();
553 WellDone = Standard_True;
562 Geom2dGcc_Circ2d3TanIter::
563 Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedLin& Qualified1 ,
564 const GccEnt_QualifiedLin& Qualified2 ,
565 const Geom2dGcc_QCurve& Qualified3 ,
566 const Standard_Real Param1 ,
567 const Standard_Real Param2 ,
568 const Standard_Real Param3 ,
569 const Standard_Real Tolerance ){
571 TheSame1 = Standard_False;
572 TheSame2 = Standard_False;
573 TheSame3 = Standard_False;
581 Standard_Real Tol = Abs(Tolerance);
582 WellDone = Standard_False;
583 if (!(Qualified1.IsEnclosed() ||
584 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
585 !(Qualified2.IsEnclosed() ||
586 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
587 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
588 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
589 throw GccEnt_BadQualifier();
592 gp_Lin2d L1 = Qualified1.Qualified();
593 gp_Lin2d L2 = Qualified2.Qualified();
594 Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
595 Geom2dGcc_FunctionTanCuCuCu Func(L1,L2,Cu3);
596 math_Vector Umin(1,3);
597 math_Vector Umax(1,3);
598 math_Vector Ufirst(1,3);
599 math_Vector tol(1,3);
600 Umin(1) = RealFirst();
601 Umin(2) = RealFirst();
602 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
603 Umax(1) = RealLast();
604 Umax(2) = RealLast();
605 Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
611 tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
612 math_FunctionSetRoot Root(Func, tol);
613 Root.Perform(Func, Ufirst, Umin, Umax);
616 Func.Value(Ufirst,Umin);
617 gp_Pnt2d centre1(L1.Location());
618 gp_Pnt2d point1(centre1.XY()+Ufirst(1)*L1.Direction().XY());
619 gp_Pnt2d centre2(L2.Location());
620 gp_Pnt2d point2(centre2.XY()+Ufirst(2)*L2.Direction().XY());
623 Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
624 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
626 cirsol = circ.ThisSolution(1);
627 gp_Pnt2d centre(cirsol.Location());
628 Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
629 L1.Direction().X()));
630 if (Qualified1.IsUnqualified() ||
631 (Qualified1.IsOutside() && pscal <= 0.) ||
632 (Qualified1.IsEnclosed() && pscal >= 0.)) {
633 gp_Vec2d Tan1(L1.Direction().XY());
634 gp_Vec2d Tan2(L2.Direction().XY());
635 Standard_Real normetan1 = Tan1.Magnitude();
636 Standard_Real normetan2 = Tan2.Magnitude();
637 Standard_Real normetan3 = Tan3.Magnitude();
638 gp_Vec2d Vec1(point1,centre);
639 gp_Vec2d Vec2(point2,centre);
640 gp_Vec2d Vec3(point3,centre);
641 Standard_Real normevec1 = Vec1.Magnitude();
642 Standard_Real normevec2 = Vec2.Magnitude();
643 Standard_Real normevec3 = Vec3.Magnitude();
644 Standard_Real dot1,dot2,dot3;
645 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
646 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
649 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
650 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
653 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
654 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
658 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
659 if (Qualified2.IsUnqualified() ||
660 (Qualified2.IsOutside() && pscal <= 0.) ||
661 (Qualified2.IsEnclosed() && pscal >= 0.)) {
662 Standard_Real Angle1 = Vec3.Angle(Tan3);
663 if (Qualified3.IsUnqualified() ||
664 (Qualified3.IsEnclosing()&&Angle1<=0.)||
665 (Qualified3.IsOutside() && Angle1 >= 0) ||
666 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
667 qualifier1 = Qualified1.Qualifier();
668 qualifier2 = Qualified2.Qualifier();
669 qualifier3 = Qualified3.Qualifier();
679 WellDone = Standard_True;
688 Geom2dGcc_Circ2d3TanIter::
689 Geom2dGcc_Circ2d3TanIter (const Geom2dGcc_QCurve& Qualified1 ,
690 const Geom2dGcc_QCurve& Qualified2 ,
691 const gp_Pnt2d& Point3 ,
692 const Standard_Real Param1 ,
693 const Standard_Real Param2 ,
694 const Standard_Real Tolerance ) {
696 TheSame1 = Standard_False;
697 TheSame2 = Standard_False;
698 TheSame3 = Standard_False;
706 Standard_Real Tol = Abs(Tolerance);
707 WellDone = Standard_False;
708 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
709 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
710 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
711 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
712 throw GccEnt_BadQualifier();
715 gp_Circ2d C1(gp_Ax2d(Point3,gp_Dir2d(1.,0.)),0.);
716 Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
717 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
718 Geom2dGcc_FunctionTanCuCuCu Func(C1,Cu1,Cu2);
719 math_Vector Umin(1,3);
720 math_Vector Umax(1,3);
721 math_Vector Ufirst(1,3);
722 math_Vector tol(1,3);
724 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
725 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
727 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu1);
728 Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu2);
732 tol(1) = 2.e-15*M_PI;
733 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
734 tol(3) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
735 math_FunctionSetRoot Root(Func, tol);
736 Root.Perform(Func, Ufirst, Umin, Umax);
739 Func.Value(Ufirst,Umin);
740 gp_Pnt2d point1,point2;
741 // gp_Vec2d Tan1,Tan2,Nor1,Nor2;
743 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(2),point1,Tan1);
744 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(3),point2,Tan2);
745 GccAna_Circ2d3Tan circ(Point3,point1,point2,Tol);
747 cirsol = circ.ThisSolution(1);
748 gp_Pnt2d centre(cirsol.Location());
749 gp_Vec2d Tan3(-Sin(Ufirst(1)),Cos(Ufirst(1)));
750 Standard_Real normetan1 = Tan1.Magnitude();
751 Standard_Real normetan2 = Tan2.Magnitude();
752 Standard_Real normetan3 = Tan3.Magnitude();
753 gp_Vec2d Vec1(point1,centre);
754 gp_Vec2d Vec2(point2,centre);
755 gp_Vec2d Vec3(Point3,centre);
756 Standard_Real normevec1 = Vec1.Magnitude();
757 Standard_Real normevec2 = Vec2.Magnitude();
758 Standard_Real normevec3 = Vec3.Magnitude();
759 Standard_Real dot1,dot2,dot3;
760 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
761 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
764 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
765 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
768 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
769 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
773 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
774 Standard_Real Angle1 = Vec1.Angle(Tan1);
775 if (Qualified1.IsUnqualified()||
776 (Qualified1.IsEnclosing()&&Angle1<=0.)||
777 (Qualified1.IsOutside() && Angle1 >= 0) ||
778 (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
779 Angle1 = Vec2.Angle(Tan2);
780 if (Qualified1.IsUnqualified() ||
781 (Qualified1.IsEnclosing()&&Angle1<=0.)||
782 (Qualified1.IsOutside() && Angle1 >= 0) ||
783 (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
784 qualifier1 = Qualified1.Qualifier();
785 qualifier2 = Qualified2.Qualifier();
786 qualifier3 = GccEnt_noqualifier;
796 WellDone = Standard_True;
804 Geom2dGcc_Circ2d3TanIter::
805 Geom2dGcc_Circ2d3TanIter (const Geom2dGcc_QCurve& Qualified1 ,
806 const gp_Pnt2d& Point2 ,
807 const gp_Pnt2d& Point3 ,
808 const Standard_Real Param1 ,
809 const Standard_Real Tolerance ) {
811 TheSame1 = Standard_False;
812 TheSame2 = Standard_False;
813 TheSame3 = Standard_False;
821 Standard_Real Tol = Abs(Tolerance);
822 WellDone = Standard_False;
823 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
824 Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
825 throw GccEnt_BadQualifier();
828 gp_Dir2d dirx(1.,0.);
829 gp_Circ2d C1(gp_Ax2d(Point2,dirx),0.);
830 gp_Circ2d C2(gp_Ax2d(Point3,dirx),0.);
831 Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
832 Geom2dGcc_FunctionTanCuCuCu Func(C1,C2,Cu1);
833 math_Vector Umin(1,3);
834 math_Vector Umax(1,3);
835 math_Vector Ufirst(1,3);
836 math_Vector tol(1,3);
839 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
842 Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu1);
846 tol(1) = 2.e-15*M_PI;
847 tol(2) = 2.e-15*M_PI;
848 tol(3) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
849 math_FunctionSetRoot Root(Func, tol);
850 Root.Perform(Func, Ufirst, Umin, Umax);
853 Func.Value(Ufirst,Umin);
855 // gp_Vec2d Tan3,Nor3;
857 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(3),point3,Tan3);
858 GccAna_Circ2d3Tan circ(Point2,Point3,point3,Tol);
860 cirsol = circ.ThisSolution(1);
861 gp_Pnt2d centre(cirsol.Location());
862 gp_Vec2d Tan2(-Sin(Ufirst(2)),Cos(Ufirst(2)));
863 gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
864 Standard_Real normetan1 = Tan1.Magnitude();
865 Standard_Real normetan2 = Tan2.Magnitude();
866 Standard_Real normetan3 = Tan3.Magnitude();
867 gp_Vec2d Vec1(Point2,centre);
868 gp_Vec2d Vec2(Point3,centre);
869 gp_Vec2d Vec3(point3,centre);
870 Standard_Real normevec1 = Vec1.Magnitude();
871 Standard_Real normevec2 = Vec2.Magnitude();
872 Standard_Real normevec3 = Vec3.Magnitude();
873 Standard_Real dot1,dot2,dot3;
874 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
875 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
878 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
879 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
882 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
883 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
887 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
888 Standard_Real Angle1 = Vec1.Angle(Tan1);
889 if (Qualified1.IsUnqualified() ||
890 (Qualified1.IsEnclosing()&&Angle1<=0.)||
891 (Qualified1.IsOutside() && Angle1 >= 0) ||
892 (Qualified1.IsEnclosed() && Angle1 <= 0.)) {
893 qualifier1 = Qualified1.Qualifier();
894 qualifier2 = GccEnt_noqualifier;
895 qualifier3 = GccEnt_noqualifier;
905 WellDone = Standard_True;
912 Geom2dGcc_Circ2d3TanIter::
913 Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedLin& Qualified1 ,
914 const Geom2dGcc_QCurve& Qualified2 ,
915 const gp_Pnt2d& Point3 ,
916 const Standard_Real Param1 ,
917 const Standard_Real Param2 ,
918 const Standard_Real Tolerance ) {
920 TheSame1 = Standard_False;
921 TheSame2 = Standard_False;
922 TheSame3 = Standard_False;
930 Standard_Real Tol = Abs(Tolerance);
931 WellDone = Standard_False;
932 if (!(Qualified1.IsEnclosed() ||
933 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
934 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
935 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
936 throw GccEnt_BadQualifier();
939 gp_Dir2d dirx(1.,0.);
940 gp_Lin2d L1 = Qualified1.Qualified();
941 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
942 gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
943 Geom2dGcc_FunctionTanCuCuCu Func(C3,L1,Cu2);
944 math_Vector Umin(1,3);
945 math_Vector Umax(1,3);
946 math_Vector Ufirst(1,3);
947 math_Vector tol(1,3);
948 Umin(2) = RealFirst();
949 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
951 Umax(2) = RealLast();
952 Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu2);
959 tol(3) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
960 math_FunctionSetRoot Root(Func, tol);
961 Root.Perform(Func, Ufirst, Umin, Umax);
964 Func.Value(Ufirst,Umin);
965 gp_Pnt2d centre1(L1.Location());
966 gp_Pnt2d point1(centre1.XY()+Ufirst(2)*L1.Direction().XY());
969 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
970 GccAna_Circ2d3Tan circ(point1,point2,Point3,Tol);
972 cirsol = circ.ThisSolution(1);
973 gp_Pnt2d centre(cirsol.Location());
974 Standard_Real pscal=centre.XY().Dot(gp_XY(-L1.Direction().Y(),
975 L1.Direction().X()));
976 gp_Vec2d Tan1(L1.Direction().XY());
977 gp_Vec2d Tan3(-Sin(Ufirst(1)),Cos(Ufirst(1)));
978 Standard_Real normetan1 = Tan1.Magnitude();
979 Standard_Real normetan2 = Tan2.Magnitude();
980 Standard_Real normetan3 = Tan3.Magnitude();
981 gp_Vec2d Vec1(point1,centre);
982 gp_Vec2d Vec2(point2,centre);
983 gp_Vec2d Vec3(Point3,centre);
984 Standard_Real normevec1 = Vec1.Magnitude();
985 Standard_Real normevec2 = Vec2.Magnitude();
986 Standard_Real normevec3 = Vec3.Magnitude();
987 Standard_Real dot1,dot2,dot3;
988 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
989 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
992 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
993 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
996 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
997 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
1001 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
1002 if (Qualified1.IsUnqualified() ||
1003 (Qualified1.IsOutside() && pscal <= 0.) ||
1004 (Qualified1.IsEnclosed() && pscal >= 0.)) {
1005 Standard_Real Angle1 = Vec2.Angle(Tan2);
1006 if (Qualified2.IsUnqualified() ||
1007 (Qualified2.IsEnclosing()&&Angle1<=0.)||
1008 (Qualified2.IsOutside() && Angle1 >= 0) ||
1009 (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
1010 qualifier1 = Qualified1.Qualifier();
1011 qualifier2 = Qualified2.Qualifier();
1012 qualifier3 = GccEnt_noqualifier;
1013 pararg1 = Ufirst(2);
1016 pararg2 = Ufirst(3);
1022 WellDone = Standard_True;
1030 Geom2dGcc_Circ2d3TanIter::
1031 Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedCirc& Qualified1 ,
1032 const GccEnt_QualifiedLin& Qualified2 ,
1033 const Geom2dGcc_QCurve& Qualified3 ,
1034 const Standard_Real Param1 ,
1035 const Standard_Real Param2 ,
1036 const Standard_Real Param3 ,
1037 const Standard_Real Tolerance ) {
1039 TheSame1 = Standard_False;
1040 TheSame2 = Standard_False;
1041 TheSame3 = Standard_False;
1049 Standard_Real Tol = Abs(Tolerance);
1050 WellDone = Standard_False;
1051 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
1052 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
1053 !(Qualified2.IsEnclosed() ||
1054 Qualified2.IsOutside() || Qualified2.IsUnqualified()) ||
1055 !(Qualified3.IsEnclosed() || Qualified3.IsEnclosing() ||
1056 Qualified3.IsOutside() || Qualified3.IsUnqualified())) {
1057 throw GccEnt_BadQualifier();
1060 gp_Circ2d C1 = Qualified1.Qualified();
1061 gp_Lin2d L2 = Qualified2.Qualified();
1062 Geom2dAdaptor_Curve Cu3 = Qualified3.Qualified();
1063 Geom2dGcc_FunctionTanCuCuCu Func(C1,L2,Cu3);
1064 math_Vector Umin(1,3);
1065 math_Vector Umax(1,3);
1066 math_Vector Ufirst(1,3);
1067 math_Vector tol(1,3);
1069 Umin(2) = RealFirst();
1070 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu3);
1072 Umax(2) = RealLast();
1073 Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu3);
1077 tol(1) = 2.e-15*M_PI;
1079 tol(3) = Geom2dGcc_CurveTool::EpsX(Cu3,Abs(Tolerance));
1080 math_FunctionSetRoot Root(Func, tol);
1081 Root.Perform(Func, Ufirst, Umin, Umax);
1082 if (Root.IsDone()) {
1083 Func.Value(Ufirst,Umin);
1085 gp_Pnt2d centre1(C1.Location());
1086 Standard_Real R1 = C1.Radius();
1087 gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
1088 gp_Pnt2d centre2(L2.Location());
1089 gp_Pnt2d point2(centre2.XY()+Ufirst(2)*L2.Direction().XY());
1092 Geom2dGcc_CurveTool::D1(Cu3,Ufirst(3),point3,Tan3);
1093 GccAna_Circ2d3Tan circ(point1,point2,point3,Tol);
1094 if (circ.IsDone()) {
1095 cirsol = circ.ThisSolution(1);
1096 gp_Pnt2d centre(cirsol.Location());
1097 gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
1098 gp_Vec2d Tan2(L2.Direction().XY());
1099 Standard_Real normetan1 = Tan1.Magnitude();
1100 Standard_Real normetan2 = Tan2.Magnitude();
1101 Standard_Real normetan3 = Tan3.Magnitude();
1102 gp_Vec2d Vec1(point1,centre);
1103 gp_Vec2d Vec2(point2,centre);
1104 gp_Vec2d Vec3(point3,centre);
1105 Standard_Real normevec1 = Vec1.Magnitude();
1106 Standard_Real normevec2 = Vec2.Magnitude();
1107 Standard_Real normevec3 = Vec3.Magnitude();
1108 Standard_Real dot1,dot2,dot3;
1109 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
1110 dot1 = Vec1.Dot(Tan1)/(normevec1*normetan1);
1113 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
1114 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
1117 if (normevec3 >= gp::Resolution() && normetan3 >= gp::Resolution()) {
1118 dot3 = Vec3.Dot(Tan3)/(normevec3*normetan3);
1122 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
1123 Standard_Real dist = centre1.Distance(centre);
1124 Standard_Real Rsol = cirsol.Radius();
1125 if (Qualified1.IsUnqualified() ||
1126 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
1127 (Qualified1.IsOutside() && dist >= Rsol) ||
1128 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
1129 Standard_Real pscal=centre.XY().Dot(gp_XY(-L2.Direction().Y(),
1130 L2.Direction().X()));
1131 if (Qualified2.IsUnqualified() ||
1132 (Qualified2.IsOutside() && pscal <= 0.) ||
1133 (Qualified2.IsEnclosed() && pscal >= 0.)) {
1134 Standard_Real Angle1 = Vec3.Angle(Tan3);
1135 if (Qualified3.IsUnqualified() ||
1136 (Qualified3.IsEnclosing()&&Angle1<=0.)||
1137 (Qualified3.IsOutside() && Angle1 >= 0) ||
1138 (Qualified3.IsEnclosed() && Angle1 <= 0.)) {
1139 qualifier1 = Qualified1.Qualifier();
1140 qualifier2 = Qualified2.Qualifier();
1141 qualifier3 = Qualified3.Qualifier();
1142 pararg1 = Ufirst(1);
1145 pararg2 = Ufirst(2);
1148 pararg3 = Ufirst(3);
1151 WellDone = Standard_True;
1160 Geom2dGcc_Circ2d3TanIter::
1161 Geom2dGcc_Circ2d3TanIter (const GccEnt_QualifiedCirc& Qualified1 ,
1162 const Geom2dGcc_QCurve& Qualified2 ,
1163 const gp_Pnt2d& Point3 ,
1164 const Standard_Real Param1 ,
1165 const Standard_Real Param2 ,
1166 const Standard_Real Tolerance ) {
1168 TheSame1 = Standard_False;
1169 TheSame2 = Standard_False;
1170 TheSame3 = Standard_False;
1178 Standard_Real Tol = Abs(Tolerance);
1179 WellDone = Standard_False;
1180 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
1181 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
1182 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
1183 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
1184 throw GccEnt_BadQualifier();
1187 gp_Circ2d C1 = Qualified1.Qualified();
1188 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
1189 gp_Dir2d dirx(1.,0.);
1190 gp_Circ2d C3(gp_Ax2d(Point3,dirx),0.);
1191 Geom2dGcc_FunctionTanCuCuCu Func(C1,C3,Cu2);
1192 math_Vector Umin(1,3);
1193 math_Vector Umax(1,3);
1194 math_Vector Ufirst(1,3);
1195 math_Vector tol(1,3);
1197 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
1200 Umax(3) = Geom2dGcc_CurveTool::LastParameter(Cu2);
1205 tol(1) = 2.e-15*M_PI;
1206 tol(2) = 2.e-15*M_PI;
1207 tol(3) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
1208 math_FunctionSetRoot Root(Func, tol);
1209 Root.Perform(Func, Ufirst, Umin, Umax);
1210 if (Root.IsDone()) {
1212 Func.Value(Ufirst,Umin);
1213 gp_Pnt2d centre1(C1.Location());
1214 Standard_Real R1 = C1.Radius();
1215 gp_Pnt2d point1(centre1.XY()+R1*gp_XY(Cos(Ufirst(1)),Sin(Ufirst(1))));
1217 // gp_Vec2d Tan2,Nor2;
1219 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
1220 GccAna_Circ2d3Tan circ(point1,point2,Point3,Tol);
1221 if (circ.IsDone()) {
1222 cirsol = circ.ThisSolution(1);
1223 gp_Pnt2d centre(cirsol.Location());
1224 gp_Vec2d Tan1(-Sin(Ufirst(1)),Cos(Ufirst(1)));
1225 gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
1226 Standard_Real normetan2 = Tan2.Magnitude();
1227 gp_Vec2d Vec1(point1,centre);
1228 gp_Vec2d Vec2(point2,centre);
1229 gp_Vec2d Vec3(Point3,centre);
1230 Standard_Real normevec1 = Vec1.Magnitude();
1231 Standard_Real normevec2 = Vec2.Magnitude();
1232 Standard_Real normevec3 = Vec3.Magnitude();
1233 Standard_Real dot1,dot2,dot3;
1234 if (normevec1 >= gp::Resolution()) {
1235 dot1 = Vec1.Dot(Tan1)/(normevec1);
1238 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
1239 dot2 = Vec2.Dot(Tan2)/(normevec2*normetan2);
1242 if (normevec3 >= gp::Resolution()) {
1243 dot3 = Vec3.Dot(Tan3)/(normevec3);
1247 if (dot1 <= Tol && dot2 <=Tol && dot3 <= Tol) {
1248 Standard_Real dist = centre1.Distance(centre);
1249 Standard_Real Rsol = cirsol.Radius();
1250 if (Qualified1.IsUnqualified() ||
1251 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
1252 (Qualified1.IsOutside() && dist >= Rsol) ||
1253 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
1254 Standard_Real Angle1 = Vec2.Angle(Tan2);
1255 if (Qualified2.IsUnqualified() ||
1256 (Qualified2.IsEnclosing()&&Angle1<=0.)||
1257 (Qualified2.IsOutside() && Angle1 >= 0) ||
1258 (Qualified2.IsEnclosed() && Angle1 <= 0.)) {
1259 qualifier1 = Qualified1.Qualifier();
1260 qualifier2 = Qualified2.Qualifier();
1261 qualifier3 = GccEnt_noqualifier;
1262 pararg1 = Ufirst(1);
1265 pararg2 = Ufirst(2);
1271 WellDone = Standard_True;
1279 Standard_Boolean Geom2dGcc_Circ2d3TanIter::
1280 IsDone () const{ return WellDone; }
1282 gp_Circ2d Geom2dGcc_Circ2d3TanIter::
1283 ThisSolution () const{ return cirsol; }
1285 void Geom2dGcc_Circ2d3TanIter::
1286 WhichQualifier (GccEnt_Position& Qualif1 ,
1287 GccEnt_Position& Qualif2 ,
1288 GccEnt_Position& Qualif3 ) const
1290 if (!WellDone) { throw StdFail_NotDone(); }
1292 Qualif1 = qualifier1;
1293 Qualif2 = qualifier2;
1294 Qualif3 = qualifier3;
1298 void Geom2dGcc_Circ2d3TanIter::
1299 Tangency1 (Standard_Real& ParSol ,
1300 Standard_Real& ParArg ,
1301 gp_Pnt2d& PntSol ) const{
1302 if (!WellDone) { throw StdFail_NotDone(); }
1304 if (TheSame1 == 0) {
1309 else { throw StdFail_NotDone(); }
1313 void Geom2dGcc_Circ2d3TanIter::
1314 Tangency2 (Standard_Real& ParSol ,
1315 Standard_Real& ParArg ,
1316 gp_Pnt2d& PntSol ) const{
1317 if (!WellDone) { throw StdFail_NotDone(); }
1325 void Geom2dGcc_Circ2d3TanIter::
1326 Tangency3 (Standard_Real& ParSol ,
1327 Standard_Real& ParArg ,
1328 gp_Pnt2d& PntSol ) const{
1329 if (!WellDone) { throw StdFail_NotDone(); }
1337 Standard_Boolean Geom2dGcc_Circ2d3TanIter::
1340 if (!WellDone) throw StdFail_NotDone();
1343 return Standard_False;
1345 return Standard_True;
1349 Standard_Boolean Geom2dGcc_Circ2d3TanIter::
1352 if (!WellDone) throw StdFail_NotDone();
1355 return Standard_False;
1357 return Standard_True;
1361 Standard_Boolean Geom2dGcc_Circ2d3TanIter::
1364 if (!WellDone) throw StdFail_NotDone();
1366 return Standard_True;