projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0031007: Coding - eliminate warnings issued while compiling with -pedantic flag
[occt.git] / src / Geom2dGcc / Geom2dGcc_Circ2d2TanOnIter.cxx
CommitLineData
54e37688 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
5//
6// This file is part of Open CASCADE Technology software library.
7//
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.
13//
14// Alternatively, this file may be used under the terms of Open CASCADE
15// commercial license or contractual agreement.
16
17//=========================================================================
18// Creation d un cercle tangent a deux elements : Droite. +
19// Cercle. +
20// Point. +
21// Courbes. +
22// centre sur un troisieme : Droite. +
23// Cercle. +
24// Courbes. +
25//=========================================================================
26
54e37688 27#include <ElCLib.hxx>
42cf5bc1 28#include <GccEnt_BadQualifier.hxx>
29#include <GccEnt_QualifiedCirc.hxx>
30#include <GccEnt_QualifiedLin.hxx>
31#include <Geom2dAdaptor_Curve.hxx>
32#include <Geom2dGcc_Circ2d2TanOnIter.hxx>
54e37688 33#include <Geom2dGcc_CurveTool.hxx>
34#include <Geom2dGcc_FunctionTanCuCuOnCu.hxx>
42cf5bc1 35#include <Geom2dGcc_QCurve.hxx>
36#include <gp.hxx>
37#include <gp_Ax2d.hxx>
38#include <gp_Circ2d.hxx>
39#include <gp_Dir2d.hxx>
40#include <gp_Lin2d.hxx>
41#include <gp_Pnt2d.hxx>
42#include <math_FunctionSetRoot.hxx>
43#include <StdFail_NotDone.hxx>
54e37688 44
45Geom2dGcc_Circ2d2TanOnIter::
46Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin& Qualified1 ,
47 const Geom2dGcc_QCurve& Qualified2 ,
48 const gp_Lin2d& OnLine ,
49 const Standard_Real Param1 ,
50 const Standard_Real Param2 ,
51 const Standard_Real Param3 ,
52 const Standard_Real Tolang ) {
53
54 TheSame1 = Standard_False;
55 TheSame2 = Standard_False;
56 par1sol = 0.;
57 par2sol = 0.;
58 pararg1 = 0.;
59 pararg2 = 0.;
60 parcen3 = 0.;
61
62 WellDone = Standard_False;
63 Standard_Real Tol = Abs(Tolang);
64 WellDone = Standard_False;
65 if (!(Qualified1.IsEnclosed() ||
66 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
67 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
68 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
9775fa61 69 throw GccEnt_BadQualifier();
54e37688 70 return;
71 }
72 gp_Dir2d dirx(1.,0.);
73 gp_Lin2d L1 = Qualified1.Qualified();
74 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
75 math_Vector Umin(1,4);
76 math_Vector Umax(1,4);
77 math_Vector Ufirst(1,4);
78 math_Vector tol(1,4);
79 Umin(1) = RealFirst();
80 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
81 Umin(3) = RealFirst();
82 Umin(4) = 0.;
83 Umax(1) = RealLast();
84 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
85 Umax(3) = RealLast();
86 Umax(4) = RealLast();
87 Ufirst(1) = Param1;
88 Ufirst(2) = Param2;
89 Ufirst(3) = Param3;
90 tol(1) = 1.e-15;
91 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Tolang);
92 tol(3) = tol(1);
93 tol(4) = tol(1);
94 gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
95 gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
96 gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
97 Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
f4dee9bb 98 Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnLine,Max(Ufirst(4), Tol));
859a47c3 99 math_FunctionSetRoot Root(Func, tol);
100 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 101 Func.Value(Ufirst,Umin);
102 if (Root.IsDone()) {
103 Root.Root(Ufirst);
104 // gp_Vec2d Tan1,Tan2,Nor1,Nor2;
105 gp_Vec2d Tan1,Tan2;
106 ElCLib::D1(Ufirst(1),L1,point1,Tan1);
107 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
108 gp_Vec2d Tan3(OnLine.Direction().XY());
51740958 109 gp_Pnt2d point3new(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
110 Standard_Real dist1 = point3new.Distance(point1);
111 Standard_Real dist2 = point3new.Distance(point2);
54e37688 112 if ( Abs(dist1-dist2)/2. <= Tol) {
51740958 113 cirsol = gp_Circ2d(gp_Ax2d(point3new,dirx),(dist1+dist2)/2.);
54e37688 114 Standard_Real normetan2 = Tan2.Magnitude();
51740958 115 gp_Vec2d Vec1(point1,point3new);
116 gp_Vec2d Vec2(point2,point3new);
54e37688 117 Standard_Real normevec2 = Vec2.Magnitude();
118 Standard_Real angle2;
119 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
120 angle2 = Vec2.Angle(Tan2);
121 }
122 else { angle2 = 0.; }
51740958 123 Standard_Real pscal=point3new.XY().Dot(gp_XY(-L1.Direction().Y(),
54e37688 124 L1.Direction().X()));
125 if (Qualified1.IsUnqualified() ||
126 (Qualified1.IsOutside() && pscal <= 0.) ||
127 (Qualified1.IsEnclosed() && pscal >= 0.)) {
128 if (Qualified2.IsUnqualified() ||
129 (Qualified2.IsEnclosing()&&angle2<=0.)||
130 (Qualified2.IsOutside() && angle2 >= 0) ||
131 (Qualified2.IsEnclosed() && angle2 <= 0.)) {
132 qualifier1 = Qualified1.Qualifier();
133 qualifier2 = Qualified2.Qualifier();
134 pnttg1sol = point1;
135 pararg1 = Ufirst(1);
136 par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
137 pnttg2sol = point2;
138 pararg2 = Ufirst(2);
139 par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
51740958 140 pntcen = point3new;
54e37688 141 parcen3 = Ufirst(3);
142 WellDone = Standard_True;
143 }
144 }
145 }
146 }
147}
148
149Geom2dGcc_Circ2d2TanOnIter::
150Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
151 const Geom2dGcc_QCurve& Qualified2 ,
152 const gp_Lin2d& OnLine ,
153 const Standard_Real Param1 ,
154 const Standard_Real Param2 ,
155 const Standard_Real Param3 ,
156 const Standard_Real Tolerance ) {
157 TheSame1 = Standard_False;
158 TheSame2 = Standard_False;
159 par1sol = 0.;
160 par2sol = 0.;
161 pararg1 = 0.;
162 pararg2 = 0.;
163 parcen3 = 0.;
164
165 WellDone = Standard_False;
166 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
167 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
168 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
169 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
9775fa61 170 throw GccEnt_BadQualifier();
54e37688 171 return;
172 }
173 Standard_Real Tol = Abs(Tolerance);
174 gp_Dir2d dirx(1.,0.);
175 Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
176 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
177 math_Vector Umin(1,4);
178 math_Vector Umax(1,4);
179 math_Vector Ufirst(1,4);
180 math_Vector tol(1,4);
181 Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
182 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
f4dee9bb 183 Umin(3) = RealFirst();
54e37688 184 Umin(4) = 0.;
185 Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
186 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
187 Umax(3) = RealLast();
188 Umax(4) = RealLast();
189 Ufirst(1) = Param1;
190 Ufirst(2) = Param2;
191 Ufirst(3) = Param3;
192 tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
193 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
194 tol(3) = 1.e-15;
195 tol(4) = Tol/10.;
196 gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
197 gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
198 gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
199 Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
f4dee9bb 200 Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnLine,Max(Ufirst(4), Tol));
859a47c3 201 math_FunctionSetRoot Root(Func, tol);
202 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 203 Func.Value(Ufirst,Umin);
204 if (Root.IsDone()) {
205 Root.Root(Ufirst);
206 gp_Vec2d Tan1,Tan2;
207 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
208 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
209 gp_Vec2d Tan3(OnLine.Direction().XY());
51740958 210 gp_Pnt2d point3new(OnLine.Location().XY()+Ufirst(3)*Tan3.XY());
211 Standard_Real dist1 = point3new.Distance(point1);
212 Standard_Real dist2 = point3new.Distance(point2);
f4dee9bb 213 if((dist1+dist2)/2. < Tol)
214 {
215 return;
216 }
54e37688 217 if ( Abs(dist1-dist2)/2. <= Tol) {
51740958 218 cirsol = gp_Circ2d(gp_Ax2d(point3new,dirx),(dist1+dist2)/2.);
54e37688 219 Standard_Real normetan1 = Tan1.Magnitude();
220 Standard_Real normetan2 = Tan2.Magnitude();
51740958 221 gp_Vec2d Vec1(point1,point3new);
222 gp_Vec2d Vec2(point2,point3new);
54e37688 223 Standard_Real normevec1 = Vec1.Magnitude();
224 Standard_Real normevec2 = Vec2.Magnitude();
225 Standard_Real angle1,angle2;
226 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
227 angle1 = Vec1.Angle(Tan1);
228 }
229 else { angle1 = 0.; }
230 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
231 angle2 = Vec2.Angle(Tan2);
232 }
233 else { angle2 = 0.; }
234 if (Qualified1.IsUnqualified()||
235 (Qualified1.IsEnclosing()&&angle1<=0.)||
236 (Qualified1.IsOutside() && angle1 >= 0.) ||
237 (Qualified1.IsEnclosed() && angle1 <= 0.)) {
238 if (Qualified2.IsUnqualified() ||
239 (Qualified2.IsEnclosing()&&angle2<=0.)||
240 (Qualified2.IsOutside() && angle2 >= 0) ||
241 (Qualified2.IsEnclosed() && angle2 <= 0.)) {
242 qualifier1 = Qualified1.Qualifier();
243 qualifier2 = Qualified2.Qualifier();
244 pnttg1sol = point1;
245 pararg1 = Ufirst(1);
246 par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
247 pnttg2sol = point2;
248 pararg2 = Ufirst(2);
249 par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
51740958 250 pntcen = point3new;
54e37688 251 parcen3 = Ufirst(3);
252 WellDone = Standard_True;
253 }
254 }
255 }
256 }
257}
258
259Geom2dGcc_Circ2d2TanOnIter::
260Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
261 const gp_Pnt2d& Point2 ,
262 const gp_Lin2d& OnLine ,
263 const Standard_Real Param1 ,
264 const Standard_Real Param2 ,
265 const Standard_Real Tolerance ) {
266 TheSame1 = Standard_False;
267 TheSame2 = Standard_False;
268 par1sol = 0.;
269 par2sol = 0.;
270 pararg1 = 0.;
271 pararg2 = 0.;
272 parcen3 = 0.;
273
274 WellDone = Standard_False;
275 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
276 Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
9775fa61 277 throw GccEnt_BadQualifier();
54e37688 278 return;
279 }
280 Standard_Real Tol = Abs(Tolerance);
281 gp_Dir2d dirx(1.,0.);
282 Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
283 math_Vector Umin(1,3);
284 math_Vector Umax(1,3);
285 math_Vector Ufirst(1,3);
286 math_Vector tol(1,3);
287 Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
288 Umin(2) = RealFirst();
289 Umin(3) = 0.;
290 Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
291 Umax(2) = RealLast();
292 Umax(3) = RealLast();
293 Ufirst(1) = Param1;
294 Ufirst(2) = Param2;
295 tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
296 tol(2) = 1.e-15;
297 tol(3) = Tol/10.;
298 gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
299 gp_Pnt2d point3 = ElCLib::Value(Param2,OnLine);
300 Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
f4dee9bb 301 Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnLine,Max(Ufirst(3), Tol));
859a47c3 302 math_FunctionSetRoot Root(Func, tol);
303 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 304 Func.Value(Ufirst,Umin);
305 if (Root.IsDone()) {
306 Root.Root(Ufirst);
51740958 307 gp_Pnt2d point1new,point3new;
54e37688 308 gp_Vec2d Tan1,Tan3;
51740958 309 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1new,Tan1);
310 ElCLib::D1(Ufirst(2),OnLine,point3new,Tan3);
311 Standard_Real dist1 = point3new.Distance(point1new);
312 Standard_Real dist2 = point3new.Distance(Point2);
54e37688 313 if ( Abs(dist1-dist2)/2. <= Tol) {
51740958 314 cirsol = gp_Circ2d(gp_Ax2d(point3new,dirx),(dist1+dist2)/2.);
54e37688 315 Standard_Real normetan1 = Tan1.Magnitude();
51740958 316 gp_Vec2d Vec1(point1new,point3new);
54e37688 317 Standard_Real normevec1 = Vec1.Magnitude();
318 Standard_Real angle1;
319 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
320 angle1 = Vec1.Angle(Tan1);
321 }
322 else { angle1 = 0.; }
323 if (Qualified1.IsUnqualified()||
324 (Qualified1.IsEnclosing()&&angle1<=0.)||
325 (Qualified1.IsOutside() && angle1 >= 0.) ||
326 (Qualified1.IsEnclosed() && angle1 <= 0.)) {
327 qualifier1 = Qualified1.Qualifier();
328 qualifier2 = GccEnt_noqualifier;
51740958 329 pnttg1sol = point1new;
54e37688 330 pararg1 = Ufirst(1);
331 par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
332 pnttg2sol = Point2;
333 pararg2 = Ufirst(2);
334 par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
51740958 335 pntcen = point3new;
54e37688 336 parcen3 = Ufirst(3);
337 WellDone = Standard_True;
338 }
339 }
340 }
341}
342
343Geom2dGcc_Circ2d2TanOnIter::
344Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 ,
345 const Geom2dGcc_QCurve& Qualified2 ,
346 const gp_Lin2d& OnLine ,
347 const Standard_Real Param1 ,
348 const Standard_Real Param2 ,
349 const Standard_Real Param3 ,
350 const Standard_Real Tolerance ) {
351 TheSame1 = Standard_False;
352 TheSame2 = Standard_False;
353 par1sol = 0.;
354 par2sol = 0.;
355 pararg1 = 0.;
356 pararg2 = 0.;
357 parcen3 = 0.;
358
359 WellDone = Standard_False;
360 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
361 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
362 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
363 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
9775fa61 364 throw GccEnt_BadQualifier();
54e37688 365 return;
366 }
367 Standard_Real Tol = Abs(Tolerance);
368 gp_Dir2d dirx(1.,0.);
369 gp_Circ2d C1 = Qualified1.Qualified();
370 Standard_Real R1 = C1.Radius();
371 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
372 math_Vector Umin(1,4);
373 math_Vector Umax(1,4);
374 math_Vector Ufirst(1,4);
375 math_Vector tol(1,4);
376 Umin(1) = RealFirst();
377 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
378 Umin(3) = RealFirst();
379 Umin(4) = 0.;
380 Umax(1) = RealLast();
381 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
382 Umax(3) = RealLast();
383 Umax(4) = RealLast();
384 Ufirst(1) = Param1;
385 Ufirst(2) = Param2;
386 Ufirst(3) = Param3;
387 tol(1) = 2.e-15*M_PI;
388 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
389 tol(3) = 1.e-15;
390 tol(4) = Tol/10.;
391 gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
392 gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
393 gp_Pnt2d point3 = ElCLib::Value(Param3,OnLine);
394 Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
f4dee9bb 395 Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnLine,Max(Ufirst(4), Tol));
859a47c3 396 math_FunctionSetRoot Root(Func, tol);
397 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 398 Func.Value(Ufirst,Umin);
399 if (Root.IsDone()) {
400 Root.Root(Ufirst);
401 // gp_Vec2d Tan1,Tan2,Nor1,Nor2;
402 gp_Vec2d Tan1,Tan2,Nor2;
403 ElCLib::D2(Ufirst(1),C1,point1,Tan1,Nor2);
404 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
0797d9d3 405#ifdef OCCT_DEBUG
54e37688 406 gp_Vec2d Tan3(OnLine.Direction().XY());
407#else
408 OnLine.Direction().XY();
409#endif
410 point3 = ElCLib::Value(Ufirst(1),OnLine);
411 Standard_Real dist1 = point3.Distance(point1);
412 Standard_Real dist2 = point3.Distance(point2);
413 if ( Abs(dist1-dist2)/2. <= Tol) {
414 cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
415 Standard_Real normetan2 = Tan2.Magnitude();
416 gp_Vec2d Vec1(point1,point3);
417 gp_Vec2d Vec2(point2,point3);
418 Standard_Real normevec2 = Vec2.Magnitude();
419 Standard_Real angle2;
420 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
421 angle2 = Vec2.Angle(Tan2);
422 }
423 else { angle2 = 0.; }
424 Standard_Real dist = C1.Location().Distance(point3);
425 Standard_Real Rsol = cirsol.Radius();
426 if (Qualified1.IsUnqualified() ||
427 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
428 (Qualified1.IsOutside() && dist >= Rsol) ||
429 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
430 if (Qualified2.IsUnqualified() ||
431 (Qualified2.IsEnclosing()&&angle2<=0.)||
432 (Qualified2.IsOutside() && angle2 >= 0) ||
433 (Qualified2.IsEnclosed() && angle2 <= 0.)) {
434 qualifier1 = Qualified1.Qualifier();
435 qualifier2 = Qualified2.Qualifier();
436 pnttg1sol = point1;
437 pararg1 = Ufirst(1);
438 par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
439 pnttg2sol = point2;
440 pararg2 = Ufirst(2);
441 par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
442 pntcen = point3;
443 parcen3 = Ufirst(3);
444 WellDone = Standard_True;
445 }
446 }
447 }
448 }
449}
450
451Geom2dGcc_Circ2d2TanOnIter::
452Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 ,
453 const Geom2dGcc_QCurve& Qualified2 ,
454 const gp_Circ2d& OnCirc ,
455 const Standard_Real Param1 ,
456 const Standard_Real Param2 ,
457 const Standard_Real Param3 ,
458 const Standard_Real Tolerance ) {
459 TheSame1 = Standard_False;
460 TheSame2 = Standard_False;
461 par1sol = 0.;
462 par2sol = 0.;
463 pararg1 = 0.;
464 pararg2 = 0.;
465 parcen3 = 0.;
466
467 WellDone = Standard_False;
468 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
469 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
470 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
471 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
9775fa61 472 throw GccEnt_BadQualifier();
54e37688 473 return;
474 }
475 Standard_Real Tol = Abs(Tolerance);
476 gp_Dir2d dirx(1.,0.);
477 gp_Circ2d C1 = Qualified1.Qualified();
478 Standard_Real R1 = C1.Radius();
479 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
480 math_Vector Umin(1,4);
481 math_Vector Umax(1,4);
482 math_Vector Ufirst(1,4);
483 math_Vector tol(1,4);
484 Umin(1) = RealFirst();
485 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
486 Umin(3) = RealFirst();
487 Umin(4) = 0.;
488 Umax(1) = RealLast();
489 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
490 Umax(3) = RealLast();
491 Umax(4) = RealLast();
492 Ufirst(1) = Param1;
493 Ufirst(2) = Param2;
494 Ufirst(3) = Param3;
495 tol(1) = 2.e-15*M_PI;
496 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
497 tol(3) = 2.e-15*M_PI;
498 tol(4) = Tol/10.;
499 gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
500 gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
501 gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
502 Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
f4dee9bb 503 Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCirc,Max(Ufirst(4), Tol));
859a47c3 504 math_FunctionSetRoot Root(Func, tol);
505 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 506 Func.Value(Ufirst,Umin);
507 if (Root.IsDone()) {
508 Root.Root(Ufirst);
509 // gp_Vec2d Tan1,Tan2,Nor1;
510 gp_Vec2d Tan1,Tan2;
511 ElCLib::D1(Ufirst(1),C1,point1,Tan1);
512 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
0797d9d3 513#ifdef OCCT_DEBUG
54e37688 514 gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
515#endif
516 point3 = ElCLib::Value(Ufirst(3),OnCirc);
517 Standard_Real dist1 = point3.Distance(point1);
518 Standard_Real dist2 = point3.Distance(point2);
519 if ( Abs(dist1-dist2)/2. <= Tol) {
520 cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
521 Standard_Real normetan2 = Tan2.Magnitude();
522 gp_Vec2d Vec1(point1,point3);
523 gp_Vec2d Vec2(point2,point3);
524 Standard_Real normevec2 = Vec2.Magnitude();
525 Standard_Real angle2;
526 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
527 angle2 = Vec2.Angle(Tan2);
528 }
529 else { angle2 = 0.; }
530 Standard_Real dist = C1.Location().Distance(point3);
531 Standard_Real Rsol = cirsol.Radius();
532 if (Qualified1.IsUnqualified() ||
533 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
534 (Qualified1.IsOutside() && dist >= Rsol) ||
535 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
536 if (Qualified2.IsUnqualified() ||
537 (Qualified2.IsEnclosing()&&angle2<=0.)||
538 (Qualified2.IsOutside() && angle2 >= 0) ||
539 (Qualified2.IsEnclosed() && angle2 <= 0.)) {
540 qualifier1 = Qualified1.Qualifier();
541 qualifier2 = Qualified2.Qualifier();
542 pnttg1sol = point1;
543 pararg1 = Ufirst(1);
544 par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
545 pnttg2sol = point2;
546 pararg2 = Ufirst(2);
547 par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
548 pntcen = point3;
549 parcen3 = Ufirst(3);
550 WellDone = Standard_True;
551 }
552 }
553 }
554 }
555}
556
557Geom2dGcc_Circ2d2TanOnIter::
558Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin& Qualified1 ,
559 const Geom2dGcc_QCurve& Qualified2 ,
560 const gp_Circ2d& OnCirc ,
561 const Standard_Real Param1 ,
562 const Standard_Real Param2 ,
563 const Standard_Real Param3 ,
564 const Standard_Real Tolerance ) {
565 TheSame1 = Standard_False;
566 TheSame2 = Standard_False;
567 par1sol = 0.;
568 par2sol = 0.;
569 pararg1 = 0.;
570 pararg2 = 0.;
571 parcen3 = 0.;
572
573 WellDone = Standard_False;
574 if (!(Qualified1.IsEnclosed() ||
575 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
576 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
577 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
9775fa61 578 throw GccEnt_BadQualifier();
54e37688 579 return;
580 }
581 Standard_Real Tol = Abs(Tolerance);
582 gp_Dir2d dirx(1.,0.);
583 gp_Lin2d L1 = Qualified1.Qualified();
584 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
585 math_Vector Umin(1,4);
586 math_Vector Umax(1,4);
587 math_Vector Ufirst(1,4);
588 math_Vector tol(1,4);
589 Umin(1) = RealFirst();
590 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
591 Umin(3) = RealFirst();
592 Umin(4) = 0.;
593 Umax(1) = RealLast();
594 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
595 Umax(3) = RealLast();
596 Umax(4) = RealLast();
597 Ufirst(1) = Param1;
598 Ufirst(2) = Param2;
599 Ufirst(3) = Param3;
600 tol(1) = 1.e-15;
601 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
602 tol(3) = 2.e-15*M_PI;
603 tol(4) = Tol/10.;
604 gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
605 gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
606 gp_Pnt2d point3 = ElCLib::Value(Param3,OnCirc);
607 Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
f4dee9bb 608 Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCirc,Max(Ufirst(4), Tol));
859a47c3 609 math_FunctionSetRoot Root(Func, tol);
610 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 611 Func.Value(Ufirst,Umin);
612 if (Root.IsDone()) {
613 Root.Root(Ufirst);
51740958 614 gp_Pnt2d point1new,point2new;
54e37688 615 gp_Vec2d Tan1,Tan2;
51740958 616 ElCLib::D1(Ufirst(1),L1,point1new,Tan1);
617 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2new,Tan2);
0797d9d3 618#ifdef OCCT_DEBUG
54e37688 619 gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
620#endif
621 point3 = ElCLib::Value(Ufirst(3),OnCirc);
51740958 622 Standard_Real dist1 = point3.Distance(point1new);
623 Standard_Real dist2 = point3.Distance(point2new);
54e37688 624 if ( Abs(dist1-dist2)/2. <= Tol) {
625 cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
626 Standard_Real normetan2 = Tan2.Magnitude();
51740958 627 gp_Vec2d Vec1(point1new,point3);
628 gp_Vec2d Vec2(point2new,point3);
54e37688 629 Standard_Real normevec2 = Vec2.Magnitude();
630 Standard_Real angle2;
631 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
632 angle2 = Vec2.Angle(Tan2);
633 }
634 else { angle2 = 0.; }
635 Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
636 L1.Direction().X()));
637 if (Qualified1.IsUnqualified() ||
638 (Qualified1.IsOutside() && pscal <= 0.) ||
639 (Qualified1.IsEnclosed() && pscal >= 0.)) {
640 if (Qualified2.IsUnqualified() ||
641 (Qualified2.IsEnclosing()&&angle2<=0.)||
642 (Qualified2.IsOutside() && angle2 >= 0) ||
643 (Qualified2.IsEnclosed() && angle2 <= 0.)) {
644 qualifier1 = Qualified1.Qualifier();
645 qualifier2 = Qualified2.Qualifier();
51740958 646 pnttg1sol = point1new;
54e37688 647 pararg1 = Ufirst(1);
648 par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
51740958 649 pnttg2sol = point2new;
54e37688 650 pararg2 = Ufirst(2);
651 par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
652 pntcen = point3;
653 parcen3 = Ufirst(3);
654 WellDone = Standard_True;
655 }
656 }
657 }
658 }
659}
660
661Geom2dGcc_Circ2d2TanOnIter::
662Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
663 const Geom2dGcc_QCurve& Qualified2 ,
664 const gp_Circ2d& OnCirc ,
665 const Standard_Real Param1 ,
666 const Standard_Real Param2 ,
667 const Standard_Real Param3 ,
668 const Standard_Real Tolerance ) {
669 TheSame1 = Standard_False;
670 TheSame2 = Standard_False;
671 par1sol = 0.;
672 par2sol = 0.;
673 pararg1 = 0.;
674 pararg2 = 0.;
675 parcen3 = 0.;
676
677 WellDone = Standard_False;
678 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
679 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
680 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
681 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
9775fa61 682 throw GccEnt_BadQualifier();
54e37688 683 return;
684 }
685 Standard_Real Tol = Abs(Tolerance);
686 gp_Dir2d dirx(1.,0.);
687 Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
688 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
689 math_Vector Umin(1,4);
690 math_Vector Umax(1,4);
691 math_Vector Ufirst(1,4);
692 math_Vector tol(1,4);
693 Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
694 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
695 Umin(3) = RealFirst();
696 Umin(4) = 0.;
697 Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
698 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
699 Umax(3) = RealLast();
700 Umax(4) = RealLast();
701 Ufirst(1) = Param1;
702 Ufirst(2) = Param2;
703 Ufirst(3) = Param3;
704 tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
705 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
706 tol(3) = 2.e-15*M_PI;
707 tol(4) = Tol/10.;
708 gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
709 gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
710 Standard_Real R1 = OnCirc.Radius();
711 gp_Pnt2d point3(OnCirc.Location().XY()+R1*gp_XY(Cos(Param3),Sin(Param3)));
712 Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
f4dee9bb 713 Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCirc,Max(Ufirst(4), Tol));
859a47c3 714 math_FunctionSetRoot Root(Func, tol);
715 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 716 Func.Value(Ufirst,Umin);
717 if (Root.IsDone()) {
718 Root.Root(Ufirst);
719 // gp_Vec2d Tan1,Tan2,Nor1;
720 gp_Vec2d Tan1,Tan2;
721 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
722 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
0797d9d3 723#ifdef OCCT_DEBUG
54e37688 724 gp_Vec2d Tan3(-Sin(Ufirst(3)),Cos(Ufirst(3)));
725#endif
726 point3 = gp_Pnt2d(OnCirc.Location().XY()+
727 R1*gp_XY(Cos(Ufirst(3)),Sin(Ufirst(3))));
728 Standard_Real dist1 = point3.Distance(point1);
729 Standard_Real dist2 = point3.Distance(point2);
730 if ( Abs(dist1-dist2)/2. <= Tol) {
731 cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
732 Standard_Real normetan1 = Tan1.Magnitude();
733 Standard_Real normetan2 = Tan2.Magnitude();
734 gp_Vec2d Vec1(point1,point3);
735 gp_Vec2d Vec2(point2,point3);
736 Standard_Real normevec1 = Vec1.Magnitude();
737 Standard_Real normevec2 = Vec2.Magnitude();
738 Standard_Real angle1,angle2;
739 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
740 angle1 = Vec1.Angle(Tan1);
741 }
742 else { angle1 = 0.; }
743 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
744 angle2 = Vec2.Angle(Tan2);
745 }
746 else { angle2 = 0.; }
747 if (Qualified1.IsUnqualified()||
748 (Qualified1.IsEnclosing()&&angle1<=0.)||
749 (Qualified1.IsOutside() && angle1 >= 0.) ||
750 (Qualified1.IsEnclosed() && angle1 <= 0.)) {
751 if (Qualified2.IsUnqualified() ||
752 (Qualified2.IsEnclosing()&&angle2<=0.)||
753 (Qualified2.IsOutside() && angle2 >= 0) ||
754 (Qualified2.IsEnclosed() && angle2 <= 0.)) {
755 qualifier1 = Qualified1.Qualifier();
756 qualifier2 = Qualified2.Qualifier();
757 pararg1 = Ufirst(1);
758 par1sol = 0.;
759 pnttg1sol = point1;
760 pararg2 = Ufirst(2);
761 pnttg2sol = point2;
762 par2sol = pnttg2sol.Distance(pnttg1sol);
763 pntcen = point3;
764 parcen3 = Ufirst(3);
765 WellDone = Standard_True;
766 }
767 }
768 }
769 }
770}
771
772Geom2dGcc_Circ2d2TanOnIter::
773Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
774 const gp_Pnt2d& Point2 ,
775 const gp_Circ2d& OnCirc ,
776 const Standard_Real Param1 ,
777 const Standard_Real Param2 ,
778 const Standard_Real Tolerance ) {
779 TheSame1 = Standard_False;
780 TheSame2 = Standard_False;
781 par1sol = 0.;
782 par2sol = 0.;
783 pararg1 = 0.;
784 pararg2 = 0.;
785 parcen3 = 0.;
786
787 WellDone = Standard_False;
788 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
789 Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
9775fa61 790 throw GccEnt_BadQualifier();
54e37688 791 return;
792 }
793 Standard_Real Tol = Abs(Tolerance);
794 gp_Dir2d dirx(1.,0.);
795 Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
796 math_Vector Umin(1,3);
797 math_Vector Umax(1,3);
798 math_Vector Ufirst(1,3);
799 math_Vector tol(1,3);
800 Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
801 Umin(2) = RealFirst();
802 Umin(3) = 0.;
803 Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
804 Umax(2) = RealLast();
805 Umax(3) = RealLast();
806 Ufirst(1) = Param1;
807 Ufirst(2) = Param2;
808 tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
809 tol(2) = 2.e-15*M_PI;
810 tol(3) = Tol/10.;
811 gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
812 gp_Pnt2d point3 = ElCLib::Value(Param2,OnCirc);
813 Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
f4dee9bb 814 Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCirc,Max(Ufirst(3), Tol));
859a47c3 815 math_FunctionSetRoot Root(Func, tol);
816 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 817 Func.Value(Ufirst,Umin);
818 if (Root.IsDone()) {
819 Root.Root(Ufirst);
51740958 820 gp_Pnt2d point1new,point3new;
54e37688 821 gp_Vec2d Tan1,Tan3;
51740958 822 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1new,Tan1);
823 ElCLib::D1(Ufirst(2),OnCirc,point3new,Tan3);
824 Standard_Real dist1 = point3new.Distance(point1new);
825 Standard_Real dist2 = point3new.Distance(Point2);
54e37688 826 if ( Abs(dist1-dist2)/2. <= Tol) {
51740958 827 cirsol = gp_Circ2d(gp_Ax2d(point3new,dirx),(dist1+dist2)/2.);
54e37688 828 Standard_Real normetan1 = Tan1.Magnitude();
51740958 829 gp_Vec2d Vec1(point1new,point3new);
54e37688 830 Standard_Real normevec1 = Vec1.Magnitude();
831 Standard_Real angle1;
832 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
833 angle1 = Vec1.Angle(Tan1);
834 }
835 else { angle1 = 0.; }
836 if (Qualified1.IsUnqualified()||
837 (Qualified1.IsEnclosing()&&angle1<=0.)||
838 (Qualified1.IsOutside() && angle1 >= 0.) ||
839 (Qualified1.IsEnclosed() && angle1 <= 0.)) {
840 qualifier1 = Qualified1.Qualifier();
841 qualifier2 = GccEnt_noqualifier;
51740958 842 pnttg1sol = point1new;
54e37688 843 pararg1 = Ufirst(1);
844 par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
845 pnttg2sol = Point2;
846 pararg2 = 0.;
847 par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
51740958 848 pntcen = point3new;
54e37688 849 parcen3 = Ufirst(3);
850 WellDone = Standard_True;
851 }
852 }
853 }
854}
855
856Geom2dGcc_Circ2d2TanOnIter::
857Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
858 const Geom2dGcc_QCurve& Qualified2 ,
859 const Geom2dAdaptor_Curve& OnCurv ,
860 const Standard_Real Param1 ,
861 const Standard_Real Param2 ,
862 const Standard_Real Param3 ,
863 const Standard_Real Tolerance ) {
864 TheSame1 = Standard_False;
865 TheSame2 = Standard_False;
866 par1sol = 0.;
867 par2sol = 0.;
868 pararg1 = 0.;
869 pararg2 = 0.;
870 parcen3 = 0.;
871
872 WellDone = Standard_False;
873 Standard_Real Tol = Abs(Tolerance);
874 WellDone = Standard_False;
875 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
876 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
877 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
878 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
9775fa61 879 throw GccEnt_BadQualifier();
54e37688 880 return;
881 }
882 gp_Dir2d dirx(1.,0.);
883 Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
884 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
885 math_Vector Umin(1,4);
886 math_Vector Umax(1,4);
887 math_Vector Ufirst(1,4);
888 math_Vector tol(1,4);
889 Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
890 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
891 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
892 Umin(4) = 0.;
893 Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
894 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
895 Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
896 Umax(4) = RealLast();
897 Ufirst(1) = Param1;
898 Ufirst(2) = Param2;
899 Ufirst(3) = Param3;
900 tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
901 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
902 tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
903 tol(4) = Tol/10.;
904 gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
905 gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
906 gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,Param3);
907 Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
f4dee9bb 908 Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Cu2,OnCurv,Max(Ufirst(4), Tol));
859a47c3 909 math_FunctionSetRoot Root(Func, tol);
910 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 911 Func.Value(Ufirst,Umin);
912 if (Root.IsDone()) {
913 Root.Root(Ufirst);
914 gp_Vec2d Tan1,Tan2,Tan3;
915 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
916 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
917 Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
918 Standard_Real dist1 = point3.Distance(point1);
919 Standard_Real dist2 = point3.Distance(point2);
920 if ( Abs(dist1-dist2)/2. <= Tol) {
921 cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
922 Standard_Real normetan1 = Tan1.Magnitude();
923 Standard_Real normetan2 = Tan2.Magnitude();
924 gp_Vec2d Vec1(point1,point3);
925 gp_Vec2d Vec2(point2,point3);
926 Standard_Real normevec1 = Vec1.Magnitude();
927 Standard_Real normevec2 = Vec2.Magnitude();
928 Standard_Real angle1,angle2;
929 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
930 angle1 = Vec1.Angle(Tan1);
931 }
932 else { angle1 = 0.; }
933 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
934 angle2 = Vec2.Angle(Tan2);
935 }
936 else { angle2 = 0.; }
937 if (Qualified1.IsUnqualified()||
938 (Qualified1.IsEnclosing()&&angle1<=0.)||
939 (Qualified1.IsOutside() && angle1 >= 0.) ||
940 (Qualified1.IsEnclosed() && angle1 <= 0.)) {
941 if (Qualified2.IsUnqualified() ||
942 (Qualified2.IsEnclosing()&&angle2<=0.)||
943 (Qualified2.IsOutside() && angle2 >= 0) ||
944 (Qualified2.IsEnclosed() && angle2 <= 0.)) {
945 qualifier1 = Qualified1.Qualifier();
946 qualifier2 = Qualified2.Qualifier();
947 pararg1 = Ufirst(1);
948 par1sol = 0.;
949 pnttg1sol = point1;
950 pararg2 = Ufirst(2);
951 pnttg2sol = point2;
952 par2sol = pnttg2sol.Distance(pnttg1sol);
953 pntcen = point3;
954 parcen3 = Ufirst(3);
955 WellDone = Standard_True;
956 }
957 }
958 }
959 }
960}
961
962Geom2dGcc_Circ2d2TanOnIter::
963Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedCirc& Qualified1 ,
964 const Geom2dGcc_QCurve& Qualified2 ,
965 const Geom2dAdaptor_Curve& OnCurv ,
966 const Standard_Real Param1 ,
967 const Standard_Real Param2 ,
968 const Standard_Real ParamOn ,
969 const Standard_Real Tolerance ) {
970
971 TheSame1 = Standard_False;
972 TheSame2 = Standard_False;
973 par1sol = 0.;
974 par2sol = 0.;
975 pararg1 = 0.;
976 pararg2 = 0.;
977 parcen3 = 0.;
978
979 WellDone = Standard_False;
980 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
981 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
982 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
983 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
9775fa61 984 throw GccEnt_BadQualifier();
54e37688 985 return;
986 }
987 Standard_Real Tol = Abs(Tolerance);
988 gp_Circ2d C1 = Qualified1.Qualified();
989 Standard_Real R1 = C1.Radius();
990 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
991 math_Vector Umin(1,4);
992 math_Vector Umax(1,4);
993 math_Vector Ufirst(1,4);
994 math_Vector tol(1,4);
995 Umin(1) = RealFirst();
996 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
997 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
998 Umin(4) = 0.;
999 Umax(1) = RealLast();
1000 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
1001 Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
1002 Umax(4) = RealLast();
1003 Ufirst(1) = Param1;
1004 Ufirst(2) = Param2;
1005 Ufirst(3) = ParamOn;
1006 tol(1) = 2.e-15*M_PI;
1007 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
1008 tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
8c2d3314 1009 tol(4) = Tol/10.;
54e37688 1010 gp_Pnt2d point1 = ElCLib::Value(Param1,C1);
1011 gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
1012 gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
1013 Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
f4dee9bb 1014 Geom2dGcc_FunctionTanCuCuOnCu Func(C1,Cu2,OnCurv,Max(Ufirst(4), Tol));
859a47c3 1015 math_FunctionSetRoot Root(Func, tol);
1016 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 1017 Func.Value(Ufirst,Umin);
1018 if (Root.IsDone()) {
1019 Root.Root(Ufirst);
1020 gp_Vec2d Tan1,Tan2,Tan3;
1021 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
1022 Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
1023 ElCLib::D1(Ufirst(1),C1,point1,Tan1);
1024 Standard_Real dist1 = point3.Distance(point1);
1025 Standard_Real dist2 = point3.Distance(point2);
1026 if ( Abs(dist1-dist2)/2. <= Tol) {
1027 gp_Dir2d dirx(1.,0.);
1028 cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
1029 Standard_Real normetan2 = Tan2.Magnitude();
1030 gp_Vec2d Vec1(point1.XY(),point3.XY());
1031 gp_Vec2d Vec2(point2.XY(),point3.XY());
1032 Standard_Real normevec2 = Vec2.Magnitude();
1033 Standard_Real angle2;
1034 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
1035 angle2 = Vec2.Angle(Tan2);
1036 }
1037 else { angle2 = 0.; }
1038 Standard_Real dist = C1.Location().Distance(point3);
1039 Standard_Real Rsol = cirsol.Radius();
1040 if (Qualified1.IsUnqualified() ||
1041 (Qualified1.IsEnclosing() && Rsol >= R1 && dist <= Rsol)||
1042 (Qualified1.IsOutside() && dist >= Rsol) ||
1043 (Qualified1.IsEnclosed() && Rsol <= R1 && dist <= Rsol)) {
1044 if (Qualified2.IsUnqualified() ||
1045 (Qualified2.IsEnclosing()&&angle2<=0.)||
1046 (Qualified2.IsOutside() && angle2 >= 0) ||
1047 (Qualified2.IsEnclosed() && angle2 <= 0.)) {
1048 qualifier1 = Qualified1.Qualifier();
1049 qualifier2 = Qualified2.Qualifier();
1050 pnttg1sol = point1;
1051 pararg1 = Ufirst(1);
1052 par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
1053 pnttg2sol = point2;
1054 pararg2 = Ufirst(2);
1055 par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
1056 pntcen = point3;
1057 parcen3 = Ufirst(3);
1058 WellDone = Standard_True;
1059 }
1060 }
1061 }
1062 }
1063}
1064
1065Geom2dGcc_Circ2d2TanOnIter::
1066Geom2dGcc_Circ2d2TanOnIter (const GccEnt_QualifiedLin& Qualified1 ,
1067 const Geom2dGcc_QCurve& Qualified2 ,
1068 const Geom2dAdaptor_Curve& OnCurv ,
1069 const Standard_Real Param1 ,
1070 const Standard_Real Param2 ,
1071 const Standard_Real ParamOn ,
1072 const Standard_Real Tolerance ) {
1073 TheSame1 = Standard_False;
1074 TheSame2 = Standard_False;
1075 par1sol = 0.;
1076 par2sol = 0.;
1077 pararg1 = 0.;
1078 pararg2 = 0.;
1079 parcen3 = 0.;
1080
1081 WellDone = Standard_False;
1082 if (!(Qualified1.IsEnclosed() ||
1083 Qualified1.IsOutside() || Qualified1.IsUnqualified()) ||
1084 !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() ||
1085 Qualified2.IsOutside() || Qualified2.IsUnqualified())) {
9775fa61 1086 throw GccEnt_BadQualifier();
54e37688 1087 return;
1088 }
1089 Standard_Real Tol = Abs(Tolerance);
1090 gp_Dir2d dirx(1.,0.);
1091 gp_Lin2d L1 = Qualified1.Qualified();
1092 Geom2dAdaptor_Curve Cu2 = Qualified2.Qualified();
1093 math_Vector Umin(1,4);
1094 math_Vector Umax(1,4);
1095 math_Vector Ufirst(1,4);
1096 math_Vector tol(1,4);
1097 Umin(1) = RealFirst();
1098 Umin(2) = Geom2dGcc_CurveTool::FirstParameter(Cu2);
1099 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
1100 Umin(4) = 0.;
1101 Umax(1) = RealLast();
1102 Umax(2) = Geom2dGcc_CurveTool::LastParameter(Cu2);
1103 Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
1104 Umax(4) = RealLast();
1105 Ufirst(1) = Param1;
1106 Ufirst(2) = Param2;
1107 Ufirst(3) = ParamOn;
1108 tol(1) = 1.e-15;
1109 tol(2) = Geom2dGcc_CurveTool::EpsX(Cu2,Abs(Tolerance));
1110 tol(3) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
1111 tol(4) = Tol/10.;
1112 gp_Pnt2d point1 = ElCLib::Value(Param1,L1);
1113 gp_Pnt2d point2 = Geom2dGcc_CurveTool::Value(Cu2,Param2);
1114 gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
1115 Ufirst(4) = (point3.Distance(point2)+point3.Distance(point1))/2.;
f4dee9bb 1116 Geom2dGcc_FunctionTanCuCuOnCu Func(L1,Cu2,OnCurv,Max(Ufirst(4), Tol));
859a47c3 1117 math_FunctionSetRoot Root(Func, tol);
1118 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 1119 Func.Value(Ufirst,Umin);
1120 if (Root.IsDone()) {
1121 Root.Root(Ufirst);
1122 gp_Vec2d Tan1,Tan2,Tan3;
1123 ElCLib::D1(Ufirst(1),L1,point1,Tan1);
1124 Geom2dGcc_CurveTool::D1(Cu2,Ufirst(2),point2,Tan2);
1125 Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
1126 Standard_Real dist1 = point3.Distance(point1);
1127 Standard_Real dist2 = point3.Distance(point2);
1128 if ( Abs(dist1-dist2)/2. <= Tol) {
1129 cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
1130 Standard_Real normetan2 = Tan2.Magnitude();
1131 gp_Vec2d Vec1(point1,point3);
1132 gp_Vec2d Vec2(point2,point3);
1133 Standard_Real normevec2 = Vec2.Magnitude();
1134 Standard_Real angle2;
1135 if (normevec2 >= gp::Resolution() && normetan2 >= gp::Resolution()) {
1136 angle2 = Vec2.Angle(Tan2);
1137 }
1138 else { angle2 = 0.; }
1139 Standard_Real pscal=point3.XY().Dot(gp_XY(-L1.Direction().Y(),
1140 L1.Direction().X()));
1141 if (Qualified1.IsUnqualified() ||
1142 (Qualified1.IsOutside() && pscal <= 0.) ||
1143 (Qualified1.IsEnclosed() && pscal >= 0.)) {
1144 if (Qualified2.IsUnqualified() ||
1145 (Qualified2.IsEnclosing()&&angle2<=0.)||
1146 (Qualified2.IsOutside() && angle2 >= 0) ||
1147 (Qualified2.IsEnclosed() && angle2 <= 0.)) {
1148 qualifier1 = Qualified1.Qualifier();
1149 qualifier2 = Qualified2.Qualifier();
1150 pnttg1sol = point1;
1151 pararg1 = Ufirst(1);
1152 par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
1153 pnttg2sol = point2;
1154 pararg2 = Ufirst(2);
1155 par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
1156 pntcen = point3;
1157 parcen3 = Ufirst(3);
1158 WellDone = Standard_True;
1159 }
1160 }
1161 }
1162 }
1163}
1164
1165Geom2dGcc_Circ2d2TanOnIter::
1166Geom2dGcc_Circ2d2TanOnIter (const Geom2dGcc_QCurve& Qualified1 ,
1167 const gp_Pnt2d& Point2 ,
1168 const Geom2dAdaptor_Curve& OnCurv ,
1169 const Standard_Real Param1 ,
1170 const Standard_Real ParamOn ,
1171 const Standard_Real Tolerance )
1172{
1173 TheSame1 = Standard_False;
1174 TheSame2 = Standard_False;
1175 par1sol = 0.;
1176 par2sol = 0.;
1177 pararg1 = 0.;
1178 pararg2 = 0.;
1179 parcen3 = 0.;
1180
1181 WellDone = Standard_False;
1182 if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() ||
1183 Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
9775fa61 1184 throw GccEnt_BadQualifier();
54e37688 1185 return;
1186 }
1187 Standard_Real Tol = Abs(Tolerance);
1188 gp_Dir2d dirx(1.,0.);
1189 Geom2dAdaptor_Curve Cu1 = Qualified1.Qualified();
1190 math_Vector Umin(1,3);
1191 math_Vector Umax(1,3);
1192 math_Vector Ufirst(1,3);
1193 math_Vector tol(1,3);
1194 Umin(1) = Geom2dGcc_CurveTool::FirstParameter(Cu1);
1195 Umin(2) = RealFirst();
1196 Umin(3) = Geom2dGcc_CurveTool::FirstParameter(OnCurv);
1197 Umax(1) = Geom2dGcc_CurveTool::LastParameter(Cu1);
1198 Umax(2) = RealLast();
1199 Umax(3) = Geom2dGcc_CurveTool::LastParameter(OnCurv);
1200 Ufirst(1) = Param1;
1201 Ufirst(2) = ParamOn;
1202 tol(1) = Geom2dGcc_CurveTool::EpsX(Cu1,Abs(Tolerance));
1203 tol(2) = Geom2dGcc_CurveTool::EpsX(OnCurv,Abs(Tolerance));
1204 tol(3) = Tol/10.;
1205 gp_Pnt2d point1 = Geom2dGcc_CurveTool::Value(Cu1,Param1);
1206 gp_Pnt2d point3 = Geom2dGcc_CurveTool::Value(OnCurv,ParamOn);
1207 Ufirst(3) = (point3.Distance(Point2)+point3.Distance(point1))/2.;
f4dee9bb 1208 Geom2dGcc_FunctionTanCuCuOnCu Func(Cu1,Point2,OnCurv,Max(Ufirst(3), Tol));
859a47c3 1209 math_FunctionSetRoot Root(Func, tol);
1210 Root.Perform(Func, Ufirst, Umin, Umax);
54e37688 1211 Func.Value(Ufirst,Umin);
1212 if (Root.IsDone()) {
1213 Root.Root(Ufirst);
1214 // gp_Vec2d Tan1,Tan2,Tan3;
1215 gp_Vec2d Tan1,Tan3;
1216 Geom2dGcc_CurveTool::D1(Cu1,Ufirst(1),point1,Tan1);
1217 Geom2dGcc_CurveTool::D1(OnCurv,Ufirst(3),point3,Tan3);
1218 Standard_Real dist1 = point3.Distance(point1);
1219 Standard_Real dist2 = point3.Distance(Point2);
1220 if ( Abs(dist1-dist2)/2. <= Tol) {
1221 cirsol = gp_Circ2d(gp_Ax2d(point3,dirx),(dist1+dist2)/2.);
1222 Standard_Real normetan1 = Tan1.Magnitude();
1223 gp_Vec2d Vec1(point1,point3);
1224 Standard_Real normevec1 = Vec1.Magnitude();
1225 Standard_Real angle1;
1226 if (normevec1 >= gp::Resolution() && normetan1 >= gp::Resolution()) {
1227 angle1 = Vec1.Angle(Tan1);
1228 }
1229 else { angle1 = 0.; }
1230 if (Qualified1.IsUnqualified()||
1231 (Qualified1.IsEnclosing()&&angle1<=0.)||
1232 (Qualified1.IsOutside() && angle1 >= 0.) ||
1233 (Qualified1.IsEnclosed() && angle1 <= 0.)) {
1234 qualifier1 = Qualified1.Qualifier();
1235 qualifier2 = GccEnt_noqualifier;
1236 pnttg1sol = point1;
1237 pararg1 = Ufirst(1);
1238 par1sol = ElCLib::Parameter(cirsol,pnttg1sol);
1239 pnttg2sol = Point2;
1240 pararg2 = 0.;
1241 par2sol = ElCLib::Parameter(cirsol,pnttg2sol);
1242 pntcen = point3;
1243 parcen3 = Ufirst(3);
1244 WellDone = Standard_True;
1245 }
1246 }
1247 }
1248}
1249
1250Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
1251IsDone () const{ return WellDone; }
1252
1253gp_Circ2d Geom2dGcc_Circ2d2TanOnIter::
1254ThisSolution () const{ return cirsol; }
1255
1256void Geom2dGcc_Circ2d2TanOnIter::
1257WhichQualifier (GccEnt_Position& Qualif1 ,
1258 GccEnt_Position& Qualif2 ) const
1259{
9775fa61 1260 if (!WellDone) { throw StdFail_NotDone(); }
54e37688 1261 else {
1262 Qualif1 = qualifier1;
1263 Qualif2 = qualifier2;
1264 }
1265}
1266
1267void Geom2dGcc_Circ2d2TanOnIter::
1268Tangency1 (Standard_Real& ParSol ,
1269 Standard_Real& ParArg ,
1270 gp_Pnt2d& PntSol ) const
1271{
9775fa61 1272 if (!WellDone) { throw StdFail_NotDone(); }
54e37688 1273 else {
1274 if (TheSame1 == 0) {
1275 ParSol = 0;
1276 ParArg = 0;
1277 PntSol = pnttg1sol;
1278 }
9775fa61 1279 else { throw StdFail_NotDone(); }
54e37688 1280 }
1281}
1282
1283void Geom2dGcc_Circ2d2TanOnIter::
1284Tangency2 (Standard_Real& ParSol ,
1285 Standard_Real& ParArg ,
1286 gp_Pnt2d& PntSol ) const
1287{
9775fa61 1288 if (!WellDone) { throw StdFail_NotDone(); }
54e37688 1289 else {
1290 ParSol = 0;
1291 ParArg = 0;
1292 PntSol = pnttg2sol;
1293 }
1294}
1295
1296void Geom2dGcc_Circ2d2TanOnIter::
1297CenterOn3 (Standard_Real& ParArg ,
1298 gp_Pnt2d& PntSol ) const
1299{
9775fa61 1300 if (!WellDone) { throw StdFail_NotDone(); }
54e37688 1301 else {
1302 ParArg = 0;
1303 PntSol = pntcen;
1304 }
1305}
1306
1307Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
1308IsTheSame1 () const
1309{
9775fa61 1310 if (!WellDone) throw StdFail_NotDone();
54e37688 1311
1312 if (TheSame1 == 0)
1313 return Standard_False;
1314 return Standard_True;
1315}
1316
1317
1318Standard_Boolean Geom2dGcc_Circ2d2TanOnIter::
1319IsTheSame2 () const
1320{
9775fa61 1321 if (!WellDone) throw StdFail_NotDone();
54e37688 1322 return Standard_False;
1323}
Open CASCADE Technology repository