578ce4be |
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 | |
5201d3e6 |
27 | #include <Adaptor2d_OffsetCurve.hxx> |
578ce4be |
28 | #include <ElCLib.hxx> |
29 | #include <GccAna_Circ2dBisec.hxx> |
30 | #include <GccAna_CircLin2dBisec.hxx> |
578ce4be |
31 | #include <GccAna_CircPnt2dBisec.hxx> |
42cf5bc1 |
32 | #include <GccAna_Lin2dBisec.hxx> |
578ce4be |
33 | #include <GccAna_LinPnt2dBisec.hxx> |
34 | #include <GccAna_Pnt2dBisec.hxx> |
42cf5bc1 |
35 | #include <GccEnt_BadQualifier.hxx> |
36 | #include <GccEnt_QualifiedCirc.hxx> |
37 | #include <GccEnt_QualifiedLin.hxx> |
578ce4be |
38 | #include <GccInt_BHyper.hxx> |
42cf5bc1 |
39 | #include <Geom2dAdaptor_Curve.hxx> |
578ce4be |
40 | #include <Geom2dAdaptor_HCurve.hxx> |
42cf5bc1 |
41 | #include <Geom2dGcc_Circ2d2TanOnGeo.hxx> |
578ce4be |
42 | #include <Geom2dInt_TheIntConicCurveOfGInter.hxx> |
42cf5bc1 |
43 | #include <gp_Circ2d.hxx> |
44 | #include <gp_Pnt2d.hxx> |
45 | #include <IntRes2d_IntersectionPoint.hxx> |
46 | #include <Standard_OutOfRange.hxx> |
47 | #include <StdFail_NotDone.hxx> |
578ce4be |
48 | |
49 | Geom2dGcc_Circ2d2TanOnGeo:: |
50 | Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedCirc& Qualified1 , |
51 | const GccEnt_QualifiedCirc& Qualified2 , |
52 | const Geom2dAdaptor_Curve& OnCurv , |
53 | const Standard_Real Tolerance ): |
54 | cirsol(1,8) , |
55 | qualifier1(1,8), |
56 | qualifier2(1,8), |
57 | TheSame1(1,8) , |
58 | TheSame2(1,8) , |
59 | pnttg1sol(1,8) , |
60 | pnttg2sol(1,8) , |
61 | pntcen(1,8) , |
62 | par1sol(1,8) , |
63 | par2sol(1,8) , |
64 | pararg1(1,8) , |
65 | pararg2(1,8) , |
66 | parcen3(1,8) |
67 | { |
68 | WellDone = Standard_False; |
69 | Standard_Real thefirst = -100000.; |
70 | Standard_Real thelast = 100000.; |
71 | Standard_Real firstparam; |
72 | Standard_Real lastparam; |
73 | Standard_Real Tol = Abs(Tolerance); |
74 | NbrSol = 0; |
75 | TColStd_Array1OfReal Rbid(1,2); |
76 | TColStd_Array1OfReal RBid(1,2); |
77 | TColStd_Array1OfReal Radius(1,2); |
78 | if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || |
79 | Qualified1.IsOutside() || Qualified1.IsUnqualified()) || |
80 | !(Qualified2.IsEnclosed() || Qualified2.IsEnclosing() || |
81 | Qualified2.IsOutside() || Qualified2.IsUnqualified())) { |
9775fa61 |
82 | throw GccEnt_BadQualifier(); |
578ce4be |
83 | return; |
84 | } |
85 | gp_Circ2d C1 = Qualified1.Qualified(); |
86 | gp_Circ2d C2 = Qualified2.Qualified(); |
87 | Standard_Real R1 = C1.Radius(); |
88 | Standard_Real R2 = C2.Radius(); |
89 | gp_Dir2d dirx(1.,0.); |
90 | gp_Pnt2d center1(C1.Location()); |
91 | gp_Pnt2d center2(C2.Location()); |
92 | GccAna_Circ2dBisec Bis(C1,C2); |
93 | if (Bis.IsDone()) { |
94 | Geom2dInt_TheIntConicCurveOfGInter Intp; |
95 | Standard_Integer nbsolution = Bis.NbSolutions(); |
96 | Handle(Geom2dAdaptor_HCurve) HCu2 = new Geom2dAdaptor_HCurve(OnCurv); |
5201d3e6 |
97 | Adaptor2d_OffsetCurve Cu2(HCu2,0.); |
98 | firstparam = Max(Cu2.FirstParameter(),thefirst); |
99 | lastparam = Min(Cu2.LastParameter(),thelast); |
100 | IntRes2d_Domain D2(Cu2.Value(firstparam), firstparam, Tol, |
101 | Cu2.Value(lastparam), lastparam, Tol); |
578ce4be |
102 | Standard_Real Tol1 = Abs(Tolerance); |
103 | Standard_Real Tol2 = Tol1; |
104 | for (Standard_Integer i = 1 ; i <= nbsolution; i++) { |
105 | Handle(GccInt_Bisec) Sol = Bis.ThisSolution(i); |
106 | GccInt_IType type = Sol->ArcType(); |
107 | switch (type) { |
108 | case GccInt_Cir: |
109 | { |
110 | gp_Circ2d Circ(Sol->Circle()); |
111 | IntRes2d_Domain D1(ElCLib::Value(0.,Circ), 0.,Tol1, |
112 | ElCLib::Value(2.*M_PI,Circ),2.*M_PI,Tol2); |
113 | D1.SetEquivalentParameters(0.,2.*M_PI); |
114 | Intp.Perform(Circ,D1,Cu2,D2,Tol1,Tol2); |
115 | } |
116 | break; |
117 | case GccInt_Ell: |
118 | { |
119 | gp_Elips2d Elips(Sol->Ellipse()); |
120 | IntRes2d_Domain D1(ElCLib::Value(0.,Elips), 0.,Tol1, |
121 | ElCLib::Value(2.*M_PI,Elips),2.*M_PI,Tol2); |
122 | D1.SetEquivalentParameters(0.,2.*M_PI); |
123 | Intp.Perform(Elips,D1,Cu2,D2,Tol1,Tol2); |
124 | } |
125 | break; |
126 | case GccInt_Hpr: |
127 | { |
128 | gp_Hypr2d Hypr(Sol->Hyperbola()); |
129 | IntRes2d_Domain D1(ElCLib::Value(-4.,Hypr),-4.,Tol1, |
130 | ElCLib::Value(4.,Hypr),4.,Tol2); |
131 | Intp.Perform(Hypr,D1,Cu2,D2,Tol1,Tol2); |
132 | } |
133 | break; |
134 | case GccInt_Lin: |
135 | { |
136 | gp_Lin2d Line(Sol->Line()); |
137 | IntRes2d_Domain D1; |
138 | Intp.Perform(Line,D1,Cu2,D2,Tol1,Tol2); |
139 | } |
140 | break; |
141 | default: |
142 | { |
9775fa61 |
143 | throw Standard_ConstructionError(); |
578ce4be |
144 | } |
145 | } |
146 | if (Intp.IsDone()) { |
147 | if ((!Intp.IsEmpty())) { |
148 | for (Standard_Integer j = 1 ; j <= Intp.NbPoints() ; j++) { |
149 | gp_Pnt2d Center(Intp.Point(j).Value()); |
150 | Standard_Real dist1 = Center.Distance(C1.Location()); |
151 | Standard_Real dist2 = Center.Distance(C2.Location()); |
152 | Standard_Integer nbsol = 0; |
153 | Standard_Integer nnsol = 0; |
154 | R1 = C1.Radius(); |
155 | R2 = C2.Radius(); |
156 | if (Qualified1.IsEnclosed()) { |
157 | if (dist1-R1 < Tol) { |
158 | nbsol = 1; |
159 | Rbid(1) = Abs(R1-dist1); |
160 | } |
161 | } |
162 | else if (Qualified1.IsOutside()) { |
163 | if (R1-dist1 < Tol) { |
164 | nbsol = 1; |
165 | Rbid(1) = Abs(dist1-R1); |
166 | } |
167 | } |
168 | else if (Qualified1.IsEnclosing()) { |
169 | nbsol = 1; |
170 | Rbid(1) = dist1+R1; |
171 | } |
172 | else if (Qualified1.IsUnqualified()) { |
173 | nbsol = 2; |
174 | Rbid(1) = dist1+R1; |
175 | Rbid(1) = Abs(dist1-R1); |
176 | } |
177 | if (Qualified2.IsEnclosed() && nbsol != 0) { |
178 | if (dist2-R2 < Tol) { |
179 | RBid(1) = Abs(R2-dist2); |
180 | } |
181 | } |
182 | else if (Qualified2.IsOutside() && nbsol != 0) { |
183 | if (R2-dist2 < Tol) { |
184 | RBid(1) = Abs(R2-dist2); |
185 | } |
186 | } |
187 | else if (Qualified2.IsEnclosing() && nbsol != 0) { |
188 | RBid(1) = dist2+R2; |
189 | } |
190 | else if (Qualified2.IsUnqualified() && nbsol != 0) { |
191 | RBid(1) = dist2+R2; |
192 | RBid(2) = Abs(R2-dist2); |
193 | } |
194 | for (Standard_Integer isol = 1; isol <= nbsol ; isol++) { |
195 | for (Standard_Integer jsol = 1; jsol <= nbsol ; jsol++) { |
196 | if (Abs(Rbid(isol)-RBid(jsol)) <= Tol) { |
197 | nnsol++; |
198 | Radius(nnsol) = (RBid(jsol)+Rbid(isol))/2.; |
199 | } |
200 | } |
201 | } |
202 | if (nnsol > 0) { |
203 | for (Standard_Integer k = 1 ; k <= nnsol ; k++) { |
204 | NbrSol++; |
205 | cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Center,dirx),Radius(k)); |
206 | // ========================================================== |
207 | Standard_Real distcc1 = Center.Distance(center1); |
208 | Standard_Real distcc2 = Center.Distance(center2); |
209 | if (!Qualified1.IsUnqualified()) { |
210 | qualifier1(NbrSol) = Qualified1.Qualifier(); |
211 | } |
212 | else if (Abs(distcc1+Radius(i)-R1) < Tol) { |
213 | qualifier1(NbrSol) = GccEnt_enclosed; |
214 | } |
215 | else if (Abs(distcc1-R1-Radius(i)) < Tol) { |
216 | qualifier1(NbrSol) = GccEnt_outside; |
217 | } |
218 | else { qualifier1(NbrSol) = GccEnt_enclosing; } |
219 | if (!Qualified2.IsUnqualified()) { |
220 | qualifier2(NbrSol) = Qualified2.Qualifier(); |
221 | } |
222 | else if (Abs(distcc2+Radius(i)-R2) < Tol) { |
223 | qualifier2(NbrSol) = GccEnt_enclosed; |
224 | } |
225 | else if (Abs(distcc2-R2-Radius(i)) < Tol) { |
226 | qualifier2(NbrSol) = GccEnt_outside; |
227 | } |
228 | else { qualifier2(NbrSol) = GccEnt_enclosing; } |
229 | if (dist1 <= Tol && Abs(Radius(k)-C1.Radius()) <= Tol) { |
230 | TheSame1(NbrSol) = 1; |
231 | } |
232 | else { |
233 | TheSame1(NbrSol) = 0; |
234 | gp_Dir2d dc1(C1.Location().XY()-Center.XY()); |
235 | pnttg1sol(NbrSol)=gp_Pnt2d(Center.XY()+Radius(k)*dc1.XY()); |
236 | par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
237 | pnttg1sol(NbrSol)); |
238 | pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol)); |
239 | } |
240 | if (dist2 <= Tol && Abs(Radius(k)-C2.Radius()) <= Tol) { |
241 | TheSame2(NbrSol) = 1; |
242 | } |
243 | else { |
244 | TheSame2(NbrSol) = 0; |
245 | gp_Dir2d dc2(C2.Location().XY()-Center.XY()); |
246 | pnttg2sol(NbrSol)=gp_Pnt2d(Center.XY()+Radius(k)*dc2.XY()); |
247 | par2sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
248 | pnttg2sol(NbrSol)); |
249 | pararg2(NbrSol)=ElCLib::Parameter(C2,pnttg2sol(NbrSol)); |
250 | } |
251 | pntcen(NbrSol) = Center; |
252 | parcen3(NbrSol) = Intp.Point(j).ParamOnSecond(); |
253 | } |
254 | WellDone = Standard_True; |
255 | } |
256 | } |
257 | } |
258 | } |
259 | } |
260 | } |
261 | } |
262 | |
263 | //========================================================================= |
264 | // Creation d un cercle tangent a un Cercle C1 et a une Droite L2. + |
265 | // centre sur une courbe OnCurv. + |
266 | // Nous calculons les bissectrices a C1 et L2 qui nous donnent + |
267 | // l ensemble des lieux possibles des centres de tous les cercles + |
268 | // tangents a C1 et L2. + |
269 | // Nous intersectons ces bissectrices avec la courbe OnCurv ce qui nous + |
270 | // donne les points parmis lesquels nous allons choisir les solutions. + |
271 | // Les choix s effectuent a partir des Qualifieurs qualifiant C1 et L2. + |
272 | //========================================================================= |
273 | |
274 | Geom2dGcc_Circ2d2TanOnGeo:: |
275 | Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedCirc& Qualified1 , |
276 | const GccEnt_QualifiedLin& Qualified2 , |
277 | const Geom2dAdaptor_Curve& OnCurv , |
278 | const Standard_Real Tolerance ): |
279 | cirsol(1,8) , |
280 | qualifier1(1,8), |
281 | qualifier2(1,8), |
282 | TheSame1(1,8) , |
283 | TheSame2(1,8) , |
284 | pnttg1sol(1,8) , |
285 | pnttg2sol(1,8) , |
286 | pntcen(1,8) , |
287 | par1sol(1,8) , |
288 | par2sol(1,8) , |
289 | pararg1(1,8) , |
290 | pararg2(1,8) , |
291 | parcen3(1,8) |
292 | { |
293 | |
294 | WellDone = Standard_False; |
295 | Standard_Real thefirst = -100000.; |
296 | Standard_Real thelast = 100000.; |
297 | Standard_Real firstparam; |
298 | Standard_Real lastparam; |
299 | NbrSol = 0; |
300 | Standard_Real Tol = Abs(Tolerance); |
301 | Standard_Real Radius; |
302 | if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || |
303 | Qualified1.IsOutside() || Qualified1.IsUnqualified()) || |
304 | !(Qualified2.IsEnclosed() || |
305 | Qualified2.IsOutside() || Qualified2.IsUnqualified())) { |
9775fa61 |
306 | throw GccEnt_BadQualifier(); |
578ce4be |
307 | return; |
308 | } |
309 | gp_Dir2d dirx(1.,0.); |
310 | gp_Circ2d C1 = Qualified1.Qualified(); |
311 | gp_Lin2d L2 = Qualified2.Qualified(); |
312 | Standard_Real R1 = C1.Radius(); |
313 | gp_Pnt2d center1(C1.Location()); |
314 | gp_Pnt2d origin2(L2.Location()); |
315 | gp_Dir2d dir2(L2.Direction()); |
316 | gp_Dir2d normL2(-dir2.Y(),dir2.X()); |
317 | |
318 | GccAna_CircLin2dBisec Bis(C1,L2); |
319 | if (Bis.IsDone()) { |
320 | Standard_Real Tol1 = Abs(Tolerance); |
321 | Standard_Real Tol2 = Tol1; |
322 | Geom2dInt_TheIntConicCurveOfGInter Intp; |
323 | Standard_Integer nbsolution = Bis.NbSolutions(); |
324 | Handle(Geom2dAdaptor_HCurve) HCu2 = new Geom2dAdaptor_HCurve(OnCurv); |
5201d3e6 |
325 | Adaptor2d_OffsetCurve C2(HCu2,0.); |
326 | firstparam = Max(C2.FirstParameter(),thefirst); |
327 | lastparam = Min(C2.LastParameter(),thelast); |
328 | IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol, |
329 | C2.Value(lastparam), lastparam, Tol); |
578ce4be |
330 | for (Standard_Integer i = 1 ; i <= nbsolution; i++) { |
331 | Handle(GccInt_Bisec) Sol = Bis.ThisSolution(i); |
332 | GccInt_IType type = Sol->ArcType(); |
333 | switch (type) { |
334 | case GccInt_Lin: |
335 | { |
336 | gp_Lin2d Line(Sol->Line()); |
337 | IntRes2d_Domain D1; |
338 | Intp.Perform(Line,D1,C2,D2,Tol1,Tol2); |
339 | } |
340 | break; |
341 | case GccInt_Par: |
342 | { |
343 | gp_Parab2d Parab(Sol->Parabola()); |
344 | IntRes2d_Domain D1(ElCLib::Value(-40,Parab),-40,Tol1, |
345 | ElCLib::Value(40,Parab),40,Tol1); |
346 | Intp.Perform(Parab,D1,C2,D2,Tol1,Tol2); |
347 | } |
348 | break; |
349 | default: |
350 | { |
9775fa61 |
351 | throw Standard_ConstructionError(); |
578ce4be |
352 | } |
353 | } |
354 | if (Intp.IsDone()) { |
355 | if (!Intp.IsEmpty()) { |
356 | for (Standard_Integer j = 1 ; j <= Intp.NbPoints() ; j++) { |
357 | gp_Pnt2d Center(Intp.Point(j).Value()); |
358 | Standard_Real dist1 = Center.Distance(center1); |
359 | // Standard_Integer nbsol = 1; |
360 | Standard_Boolean ok = Standard_False; |
361 | if (Qualified1.IsEnclosed()) { |
362 | if (dist1-R1 < Tol) { ok = Standard_True; } |
363 | } |
364 | else if (Qualified1.IsOutside()) { |
365 | if (R1-dist1 < Tol) { ok = Standard_True; } |
366 | } |
367 | else if (Qualified1.IsEnclosing() || Qualified1.IsUnqualified()) { |
368 | ok = Standard_True; |
369 | } |
370 | Radius = L2.Distance(Center); |
371 | if (Qualified2.IsEnclosed() && ok) { |
372 | ok = Standard_False; |
373 | if ((((origin2.X()-Center.X())*(-dir2.Y()))+ |
374 | ((origin2.Y()-Center.Y())*(dir2.X())))<=0){ |
375 | ok = Standard_True; |
376 | } |
377 | } |
378 | else if (Qualified2.IsOutside() && ok) { |
379 | ok = Standard_False; |
380 | if ((((origin2.X()-Center.X())*(-dir2.Y()))+ |
381 | ((origin2.Y()-Center.Y())*(dir2.X())))>=0){ |
382 | ok = Standard_True; |
383 | } |
384 | } |
385 | if (Qualified1.IsEnclosing()&&dist1>Radius) { ok=Standard_False; } |
386 | if (ok) { |
387 | NbrSol++; |
388 | cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Center,dirx),Radius); |
389 | // ======================================================= |
0797d9d3 |
390 | #ifdef OCCT_DEBUG |
51740958 |
391 | gp_Dir2d aDC1(center1.XY()-Center.XY()); |
578ce4be |
392 | #endif |
393 | gp_Dir2d dc2(origin2.XY()-Center.XY()); |
394 | Standard_Real distcc1 = Center.Distance(center1); |
395 | if (!Qualified1.IsUnqualified()) { |
396 | qualifier1(NbrSol) = Qualified1.Qualifier(); |
397 | } |
398 | else if (Abs(distcc1+Radius-R1) < Tol) { |
399 | qualifier1(NbrSol) = GccEnt_enclosed; |
400 | } |
401 | else if (Abs(distcc1-R1-Radius) < Tol) { |
402 | qualifier1(NbrSol) = GccEnt_outside; |
403 | } |
404 | else { qualifier1(NbrSol) = GccEnt_enclosing; } |
405 | if (!Qualified2.IsUnqualified()) { |
406 | qualifier2(NbrSol) = Qualified2.Qualifier(); |
407 | } |
408 | else if (dc2.Dot(normL2) > 0.0) { |
409 | qualifier2(NbrSol) = GccEnt_outside; |
410 | } |
411 | else { qualifier2(NbrSol) = GccEnt_enclosed; } |
412 | if (dist1 <= Tol && Abs(Radius-C1.Radius()) <= Tol) { |
413 | TheSame1(NbrSol) = 1; |
414 | } |
415 | else { |
416 | TheSame1(NbrSol) = 0; |
417 | gp_Dir2d dc1(center1.XY()-Center.XY()); |
418 | pnttg1sol(NbrSol)=gp_Pnt2d(Center.XY()+Radius*dc1.XY()); |
419 | par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
420 | pnttg1sol(NbrSol)); |
421 | pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol)); |
422 | } |
423 | TheSame2(NbrSol) = 0; |
424 | Standard_Real sign = dc2.Dot(gp_Dir2d(-dir2.Y(),dir2.X())); |
425 | dc2 = gp_Dir2d(sign*gp_XY(-dir2.Y(),dir2.X())); |
426 | pnttg2sol(NbrSol) = gp_Pnt2d(Center.XY()+Radius*dc2.XY()); |
427 | par2sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
428 | pnttg2sol(NbrSol)); |
429 | pararg2(NbrSol)=ElCLib::Parameter(L2,pnttg2sol(NbrSol)); |
430 | pntcen(NbrSol) = Center; |
431 | parcen3(NbrSol) = Intp.Point(j).ParamOnSecond(); |
432 | } |
433 | } |
434 | } |
435 | WellDone = Standard_True; |
436 | } |
437 | } |
438 | } |
439 | } |
440 | |
441 | //========================================================================= |
442 | // Creation d un cercle tant a deux Droites L1 et L2. + |
443 | // centre sur une courbe OnCurv. + |
444 | // Nous calculons les bissectrices a L1 et L2 qui nous donnent + |
445 | // l ensemble des lieux possibles des centres de tous les cercles + |
446 | // tants a L1 et L2. + |
447 | // Nous intersectons ces bissectrices avec la courbe OnCurv ce qui nous + |
448 | // donne les points parmis lesquels nous allons choisir les solutions. + |
449 | // Les choix s effectuent a partir des Qualifieurs qualifiant L1 et L2. + |
450 | //========================================================================= |
451 | |
452 | Geom2dGcc_Circ2d2TanOnGeo:: |
453 | Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedLin& Qualified1 , |
454 | const GccEnt_QualifiedLin& Qualified2 , |
455 | const Geom2dAdaptor_Curve& OnCurv , |
456 | const Standard_Real Tolerance ): |
457 | cirsol(1,8) , |
458 | qualifier1(1,8), |
459 | qualifier2(1,8), |
460 | TheSame1(1,8) , |
461 | TheSame2(1,8) , |
462 | pnttg1sol(1,8) , |
463 | pnttg2sol(1,8) , |
464 | pntcen(1,8) , |
465 | par1sol(1,8) , |
466 | par2sol(1,8) , |
467 | pararg1(1,8) , |
468 | pararg2(1,8) , |
469 | parcen3(1,8) |
470 | { |
471 | |
472 | WellDone = Standard_False; |
473 | Standard_Real thefirst = -100000.; |
474 | Standard_Real thelast = 100000.; |
475 | Standard_Real firstparam; |
476 | Standard_Real lastparam; |
477 | NbrSol = 0; |
478 | if (!(Qualified1.IsEnclosed() || |
479 | Qualified1.IsOutside() || Qualified1.IsUnqualified()) || |
480 | !(Qualified2.IsEnclosed() || |
481 | Qualified2.IsOutside() || Qualified2.IsUnqualified())) { |
9775fa61 |
482 | throw GccEnt_BadQualifier(); |
578ce4be |
483 | return; |
484 | } |
485 | Standard_Real Tol = Abs(Tolerance); |
486 | Standard_Real Radius=0; |
487 | gp_Dir2d dirx(1.,0.); |
488 | gp_Lin2d L1 = Qualified1.Qualified(); |
489 | gp_Lin2d L2 = Qualified2.Qualified(); |
490 | gp_Dir2d dir1(L1.Direction()); |
491 | gp_Dir2d dir2(L2.Direction()); |
492 | gp_Dir2d Dnor1(-dir1.Y(),dir1.X()); |
493 | gp_Dir2d Dnor2(-dir2.Y(),dir2.X()); |
494 | gp_Pnt2d origin1(L1.Location()); |
495 | gp_Pnt2d origin2(L2.Location()); |
496 | GccAna_Lin2dBisec Bis(L1,L2); |
497 | if (Bis.IsDone()) { |
498 | Standard_Real Tol1 = Abs(Tolerance); |
499 | Standard_Real Tol2 = Tol1; |
500 | Geom2dInt_TheIntConicCurveOfGInter Intp; |
501 | Standard_Integer nbsolution = Bis.NbSolutions(); |
502 | Handle(Geom2dAdaptor_HCurve) HCu2 = new Geom2dAdaptor_HCurve(OnCurv); |
5201d3e6 |
503 | Adaptor2d_OffsetCurve C2(HCu2,0.); |
504 | firstparam = Max(C2.FirstParameter(),thefirst); |
505 | lastparam = Min(C2.LastParameter(),thelast); |
506 | IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol, |
507 | C2.Value(lastparam), lastparam, Tol); |
578ce4be |
508 | IntRes2d_Domain D1; |
509 | for (Standard_Integer i = 1 ; i <= nbsolution; i++) { |
510 | Intp.Perform(Bis.ThisSolution(i),D1,C2,D2,Tol1,Tol2); |
511 | if (Intp.IsDone()) { |
512 | if ((!Intp.IsEmpty())) { |
513 | for (Standard_Integer j = 1 ; j <= Intp.NbPoints() ; j++) { |
514 | gp_Pnt2d Center(Intp.Point(j).Value()); |
515 | Standard_Real dist1 = L1.Distance(Center); |
516 | Standard_Real dist2 = L2.Distance(Center); |
517 | // Standard_Integer nbsol = 1; |
518 | Standard_Boolean ok = Standard_False; |
519 | if (Qualified1.IsEnclosed()) { |
520 | if ((((origin1.X()-Center.X())*(-dir1.Y()))+ |
521 | ((origin1.Y()-Center.Y())*(dir1.X())))<=0){ |
522 | ok = Standard_True; |
523 | } |
524 | } |
525 | else if (Qualified1.IsOutside()) { |
526 | if ((((origin1.X()-Center.X())*(-dir1.Y()))+ |
527 | ((origin1.Y()-Center.Y())*(dir1.X())))>=0){ |
528 | ok = Standard_True; |
529 | } |
530 | } |
531 | else if (Qualified1.IsUnqualified()) { ok = Standard_True; } |
532 | if (Qualified2.IsEnclosed() && ok) { |
533 | ok = Standard_False; |
534 | if ((((origin2.X()-Center.X())*(-dir2.Y()))+ |
535 | ((origin2.Y()-Center.Y())*(dir2.X())))<=0){ |
536 | ok = Standard_True; |
537 | Radius = (dist1+dist2)/2.; |
538 | } |
539 | } |
540 | else if (Qualified2.IsOutside() && ok) { |
541 | ok = Standard_False; |
542 | if ((((origin2.X()-Center.X())*(-dir2.Y()))+ |
543 | ((origin2.Y()-Center.Y())*(dir2.X())))>=0){ |
544 | ok = Standard_True; |
545 | Radius = (dist1+dist2)/2.; |
546 | } |
547 | } |
548 | else if (Qualified2.IsUnqualified() && ok) { |
549 | Radius = (dist1+dist2)/2.; |
550 | } |
551 | if (ok) { |
552 | NbrSol++; |
553 | cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Center,dirx),Radius); |
554 | // ======================================================= |
555 | gp_Dir2d dc1(origin1.XY()-Center.XY()); |
556 | gp_Dir2d dc2(origin2.XY()-Center.XY()); |
557 | if (!Qualified1.IsUnqualified()) { |
558 | qualifier1(NbrSol) = Qualified1.Qualifier(); |
559 | } |
560 | else if (dc1.Dot(Dnor1) > 0.0) { |
561 | qualifier1(NbrSol) = GccEnt_outside; |
562 | } |
563 | else { qualifier1(NbrSol) = GccEnt_enclosed; } |
564 | if (!Qualified2.IsUnqualified()) { |
565 | qualifier2(NbrSol) = Qualified2.Qualifier(); |
566 | } |
567 | else if (dc2.Dot(Dnor2) > 0.0) { |
568 | qualifier2(NbrSol) = GccEnt_outside; |
569 | } |
570 | else { qualifier2(NbrSol) = GccEnt_enclosed; } |
571 | TheSame1(NbrSol) = 0; |
572 | TheSame2(NbrSol) = 0; |
573 | Standard_Real sign = dc1.Dot(Dnor1); |
574 | dc1 = gp_Dir2d(sign*gp_XY(-dir1.Y(),dir1.X())); |
575 | pnttg1sol(NbrSol) = gp_Pnt2d(Center.XY()+Radius*dc1.XY()); |
576 | par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
577 | pnttg1sol(NbrSol)); |
578 | pararg1(NbrSol)=ElCLib::Parameter(L1,pnttg1sol(NbrSol)); |
579 | sign = dc2.Dot(gp_Dir2d(-dir2.Y(),dir2.X())); |
580 | dc2 = gp_Dir2d(sign*gp_XY(-dir2.Y(),dir2.X())); |
581 | pnttg2sol(NbrSol) = gp_Pnt2d(Center.XY()+Radius*dc2.XY()); |
582 | par2sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
583 | pnttg2sol(NbrSol)); |
584 | pararg2(NbrSol)=ElCLib::Parameter(L2,pnttg2sol(NbrSol)); |
585 | pntcen(NbrSol) = Center; |
586 | parcen3(NbrSol) = Intp.Point(j).ParamOnSecond(); |
587 | } |
588 | } |
589 | } |
590 | WellDone = Standard_True; |
591 | } |
592 | } |
593 | } |
594 | } |
595 | |
596 | //========================================================================= |
597 | // Creation d un cercle tant a un Cercle C1, passant par un point P2 + |
598 | // centre sur une courbe OnCurv. + |
599 | // Nous calculons les bissectrices a C1 et Point2 qui nous donnent + |
600 | // l ensemble des lieux possibles des centres de tous les cercles + |
601 | // tants a C1 et Point2. + |
602 | // Nous intersectons ces bissectrices avec la courbe OnCurv ce qui nous + |
603 | // donne les points parmis lesquels nous allons choisir les solutions. + |
604 | // Les choix s effectuent a partir des Qualifieurs qualifiant C1. + |
605 | //========================================================================= |
606 | |
607 | Geom2dGcc_Circ2d2TanOnGeo:: |
608 | Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedCirc& Qualified1 , |
609 | const gp_Pnt2d& Point2 , |
610 | const Geom2dAdaptor_Curve& OnCurv , |
611 | const Standard_Real Tolerance ): |
612 | cirsol(1,8) , |
613 | qualifier1(1,8), |
614 | qualifier2(1,8), |
615 | TheSame1(1,8) , |
616 | TheSame2(1,8) , |
617 | pnttg1sol(1,8) , |
618 | pnttg2sol(1,8) , |
619 | pntcen(1,8) , |
620 | par1sol(1,8) , |
621 | par2sol(1,8) , |
622 | pararg1(1,8) , |
623 | pararg2(1,8) , |
624 | parcen3(1,8) |
625 | { |
626 | |
627 | WellDone = Standard_False; |
628 | Standard_Real thefirst = -100000.; |
629 | Standard_Real thelast = 100000.; |
630 | Standard_Real firstparam; |
631 | Standard_Real lastparam; |
632 | NbrSol = 0; |
633 | if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || |
634 | Qualified1.IsOutside() || Qualified1.IsUnqualified())) { |
9775fa61 |
635 | throw GccEnt_BadQualifier(); |
578ce4be |
636 | return; |
637 | } |
638 | Standard_Real Tol = Abs(Tolerance); |
639 | Standard_Real Radius; |
640 | gp_Dir2d dirx(1.,0.); |
641 | gp_Circ2d C1 = Qualified1.Qualified(); |
642 | Standard_Real R1 = C1.Radius(); |
643 | gp_Pnt2d center1(C1.Location()); |
644 | GccAna_CircPnt2dBisec Bis(C1,Point2); |
645 | if (Bis.IsDone()) { |
646 | Standard_Real Tol1 = Abs(Tolerance); |
647 | Standard_Real Tol2 = Tol1; |
648 | Geom2dInt_TheIntConicCurveOfGInter Intp; |
649 | Standard_Integer nbsolution = Bis.NbSolutions(); |
650 | Handle(Geom2dAdaptor_HCurve) HCu2 = new Geom2dAdaptor_HCurve(OnCurv); |
5201d3e6 |
651 | Adaptor2d_OffsetCurve C2(HCu2,0.); |
652 | firstparam = Max(C2.FirstParameter(),thefirst); |
653 | lastparam = Min(C2.LastParameter(),thelast); |
654 | IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol, |
655 | C2.Value(lastparam), lastparam, Tol); |
578ce4be |
656 | for (Standard_Integer i = 1 ; i <= nbsolution; i++) { |
657 | Handle(GccInt_Bisec) Sol = Bis.ThisSolution(i); |
658 | GccInt_IType type = Sol->ArcType(); |
659 | switch (type) { |
660 | case GccInt_Cir: |
661 | { |
662 | gp_Circ2d Circ(Sol->Circle()); |
663 | IntRes2d_Domain D1(ElCLib::Value(0.,Circ), 0.,Tol1, |
664 | ElCLib::Value(2.*M_PI,Circ),2.*M_PI,Tol2); |
665 | D1.SetEquivalentParameters(0.,2.*M_PI); |
666 | Intp.Perform(Circ,D1,C2,D2,Tol1,Tol2); |
667 | } |
668 | break; |
669 | case GccInt_Lin: |
670 | { |
671 | gp_Lin2d Line(Sol->Line()); |
672 | IntRes2d_Domain D1; |
673 | Intp.Perform(Line,D1,C2,D2,Tol1,Tol2); |
674 | } |
675 | break; |
676 | case GccInt_Ell: |
677 | { |
678 | gp_Elips2d Elips(Sol->Ellipse()); |
679 | IntRes2d_Domain D1(ElCLib::Value(0.,Elips), 0.,Tol1, |
680 | ElCLib::Value(2.*M_PI,Elips),2.*M_PI,Tol2); |
681 | D1.SetEquivalentParameters(0.,2.*M_PI); |
682 | Intp.Perform(Elips,D1,C2,D2,Tol1,Tol2); |
683 | } |
684 | break; |
685 | case GccInt_Hpr: |
686 | { |
687 | gp_Hypr2d Hypr(Sol->Hyperbola()); |
688 | IntRes2d_Domain D1(ElCLib::Value(-4.,Hypr),-4.,Tol1, |
689 | ElCLib::Value(4.,Hypr),4.,Tol2); |
690 | Intp.Perform(Hypr,D1,C2,D2,Tol1,Tol2); |
691 | } |
692 | break; |
693 | default: |
694 | { |
9775fa61 |
695 | throw Standard_ConstructionError(); |
578ce4be |
696 | } |
697 | } |
698 | if (Intp.IsDone()) { |
699 | if ((!Intp.IsEmpty())) { |
700 | for (Standard_Integer j = 1 ; j <= Intp.NbPoints() ; j++) { |
701 | gp_Pnt2d Center(Intp.Point(j).Value()); |
702 | Radius = Center.Distance(Point2); |
703 | Standard_Real dist1 = center1.Distance(Center); |
704 | // Standard_Integer nbsol = 1; |
705 | Standard_Boolean ok = Standard_False; |
706 | if (Qualified1.IsEnclosed()) { |
707 | if (dist1-R1 <= Tol) { ok = Standard_True; } |
708 | } |
709 | else if (Qualified1.IsOutside()) { |
710 | if (R1-dist1 <= Tol) { ok = Standard_True; } |
711 | } |
712 | else if (Qualified1.IsEnclosing()) { ok = Standard_True; } |
713 | else if (Qualified1.IsUnqualified()) { ok = Standard_True; } |
714 | if (ok) { |
715 | NbrSol++; |
716 | cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Center,dirx),Radius); |
717 | // ======================================================= |
718 | Standard_Real distcc1 = Center.Distance(center1); |
719 | if (!Qualified1.IsUnqualified()) { |
720 | qualifier1(NbrSol) = Qualified1.Qualifier(); |
721 | } |
722 | else if (Abs(distcc1+Radius-R1) < Tol) { |
723 | qualifier1(NbrSol) = GccEnt_enclosed; |
724 | } |
725 | else if (Abs(distcc1-R1-Radius) < Tol) { |
726 | qualifier1(NbrSol) = GccEnt_outside; |
727 | } |
728 | else { qualifier1(NbrSol) = GccEnt_enclosing; } |
729 | qualifier2(NbrSol) = GccEnt_noqualifier; |
730 | if (dist1 <= Tol && Abs(Radius-R1) <= Tol) { |
731 | TheSame1(NbrSol) = 1; |
732 | } |
733 | else { |
734 | TheSame1(NbrSol) = 0; |
735 | gp_Dir2d dc1(center1.XY()-Center.XY()); |
736 | pnttg1sol(NbrSol)=gp_Pnt2d(Center.XY()+Radius*dc1.XY()); |
737 | par1sol(NbrSol) = 0.; |
738 | par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
739 | pnttg1sol(NbrSol)); |
740 | pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol)); |
741 | } |
742 | TheSame2(NbrSol) = 0; |
743 | pnttg2sol(NbrSol) = Point2; |
744 | pntcen(NbrSol) = Center; |
745 | parcen3(NbrSol) = Intp.Point(j).ParamOnSecond(); |
746 | pararg2(NbrSol) = 0.; |
747 | par2sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
748 | pnttg2sol(NbrSol)); |
749 | } |
750 | } |
751 | } |
752 | WellDone = Standard_True; |
753 | } |
754 | } |
755 | } |
756 | } |
757 | |
758 | //========================================================================= |
759 | // Creation d un cercle tant a une ligne L1, passant par un point P2 + |
760 | // centre sur une courbe OnCurv. + |
761 | // Nous calculons les bissectrices a L1 et Point2 qui nous donnent + |
762 | // l ensemble des lieux possibles des centres de tous les cercles + |
763 | // tants a L1 et passant par Point2. + |
764 | // Nous intersectons ces bissectrices avec la courbe OnCurv ce qui nous + |
765 | // donne les points parmis lesquels nous allons choisir les solutions. + |
766 | // Les choix s effectuent a partir des Qualifieurs qualifiant L1. + |
767 | //========================================================================= |
768 | |
769 | Geom2dGcc_Circ2d2TanOnGeo:: |
770 | Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedLin& Qualified1 , |
771 | const gp_Pnt2d& Point2 , |
772 | const Geom2dAdaptor_Curve& OnCurv , |
773 | const Standard_Real Tolerance ): |
774 | cirsol(1,8) , |
775 | qualifier1(1,8), |
776 | qualifier2(1,8), |
777 | TheSame1(1,8) , |
778 | TheSame2(1,8) , |
779 | pnttg1sol(1,8) , |
780 | pnttg2sol(1,8) , |
781 | pntcen(1,8) , |
782 | par1sol(1,8) , |
783 | par2sol(1,8) , |
784 | pararg1(1,8) , |
785 | pararg2(1,8) , |
786 | parcen3(1,8) |
787 | { |
788 | |
789 | WellDone = Standard_False; |
790 | Standard_Real thefirst = -100000.; |
791 | Standard_Real thelast = 100000.; |
792 | Standard_Real firstparam; |
793 | Standard_Real lastparam; |
794 | Standard_Real Tol = Abs(Tolerance); |
795 | NbrSol = 0; |
796 | if (!(Qualified1.IsEnclosed() || |
797 | Qualified1.IsOutside() || Qualified1.IsUnqualified())) { |
9775fa61 |
798 | throw GccEnt_BadQualifier(); |
578ce4be |
799 | return; |
800 | } |
801 | gp_Dir2d dirx(1.,0.); |
802 | gp_Lin2d L1 = Qualified1.Qualified(); |
803 | gp_Pnt2d origin1(L1.Location()); |
804 | gp_Dir2d dir1(L1.Direction()); |
805 | gp_Dir2d normal(-dir1.Y(),dir1.X()); |
806 | GccAna_LinPnt2dBisec Bis(L1,Point2); |
807 | if (Bis.IsDone()) { |
808 | Standard_Real Tol1 = Abs(Tolerance); |
809 | Standard_Real Tol2 = Tol1; |
810 | Geom2dInt_TheIntConicCurveOfGInter Intp; |
811 | Handle(Geom2dAdaptor_HCurve) HCu2 = new Geom2dAdaptor_HCurve(OnCurv); |
5201d3e6 |
812 | Adaptor2d_OffsetCurve C2(HCu2,0.); |
813 | firstparam = Max(C2.FirstParameter(),thefirst); |
814 | lastparam = Min(C2.LastParameter(),thelast); |
815 | IntRes2d_Domain D2(C2.Value(firstparam), firstparam, Tol, |
816 | C2.Value(lastparam), lastparam, Tol); |
578ce4be |
817 | Handle(GccInt_Bisec) Sol = Bis.ThisSolution(); |
818 | GccInt_IType type = Sol->ArcType(); |
819 | switch (type) { |
820 | case GccInt_Lin: |
821 | { |
822 | gp_Lin2d Line(Sol->Line()); |
823 | IntRes2d_Domain D1; |
824 | Intp.Perform(Line,D1,C2,D2,Tol1,Tol2); |
825 | } |
826 | break; |
827 | case GccInt_Par: |
828 | { |
829 | gp_Parab2d Parab(Sol->Parabola()); |
830 | IntRes2d_Domain D1(ElCLib::Value(-40,Parab),-40,Tol1, |
831 | ElCLib::Value(40,Parab),40,Tol1); |
832 | Intp.Perform(Parab,D1,C2,D2,Tol1,Tol2); |
833 | } |
834 | break; |
835 | default: |
836 | { |
9775fa61 |
837 | throw Standard_ConstructionError(); |
578ce4be |
838 | } |
839 | } |
840 | if (Intp.IsDone()) { |
841 | if ((!Intp.IsEmpty())) { |
842 | for (Standard_Integer j = 1 ; j <= Intp.NbPoints() ; j++) { |
843 | gp_Pnt2d Center(Intp.Point(j).Value()); |
844 | Standard_Real Radius = L1.Distance(Center); |
845 | // Standard_Integer nbsol = 1; |
846 | Standard_Boolean ok = Standard_False; |
847 | if (Qualified1.IsEnclosed()) { |
848 | if ((((origin1.X()-Center.X())*(-dir1.Y()))+ |
849 | ((origin1.Y()-Center.Y())*(dir1.X())))<=0){ |
850 | ok = Standard_True; |
851 | } |
852 | } |
853 | else if (Qualified1.IsOutside()) { |
854 | if ((((origin1.X()-Center.X())*(-dir1.Y()))+ |
855 | ((origin1.Y()-Center.Y())*(dir1.X())))>=0){ |
856 | ok = Standard_True; |
857 | } |
858 | } |
859 | else if (Qualified1.IsUnqualified()) { ok = Standard_True; } |
860 | if (ok) { |
861 | NbrSol++; |
862 | cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Center,dirx),Radius); |
863 | // ======================================================= |
864 | qualifier2(NbrSol) = GccEnt_noqualifier; |
865 | gp_Dir2d dc2(origin1.XY()-Center.XY()); |
866 | if (!Qualified1.IsUnqualified()) { |
867 | qualifier1(NbrSol) = Qualified1.Qualifier(); |
868 | } |
869 | else if (dc2.Dot(normal) > 0.0) { |
870 | qualifier1(NbrSol) = GccEnt_outside; |
871 | } |
872 | else { qualifier1(NbrSol) = GccEnt_enclosed; } |
873 | TheSame1(NbrSol) = 0; |
874 | TheSame2(NbrSol) = 0; |
875 | gp_Dir2d dc1(origin1.XY()-Center.XY()); |
876 | Standard_Real sign = dc1.Dot(gp_Dir2d(-dir1.Y(),dir1.X())); |
877 | dc1=gp_Dir2d(sign*gp_XY(-dir1.Y(),dir1.X())); |
878 | pnttg1sol(NbrSol) = gp_Pnt2d(Center.XY()+Radius*dc1.XY()); |
879 | par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
880 | pnttg1sol(NbrSol)); |
881 | pararg1(NbrSol)=ElCLib::Parameter(L1,pnttg1sol(NbrSol)); |
882 | pnttg2sol(NbrSol) = Point2; |
883 | par2sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
884 | pnttg2sol(NbrSol)); |
885 | pararg2(NbrSol) = 0.; |
886 | pntcen(NbrSol) = Center; |
887 | parcen3(NbrSol) = Intp.Point(j).ParamOnSecond(); |
888 | } |
889 | } |
890 | } |
891 | WellDone = Standard_True; |
892 | } |
893 | } |
894 | } |
895 | |
896 | //========================================================================= |
897 | // Creation d un cercle passant par deux point Point1 et Point2 + |
898 | // centre sur une courbe OnCurv. + |
899 | // Nous calculons les bissectrices a Point1 et Point2 qui nous donnent + |
900 | // l ensemble des lieux possibles des centres de tous les cercles + |
901 | // passant par Point1 et Point2. + |
902 | // Nous intersectons ces bissectrices avec la courbe OnCurv ce qui nous + |
903 | // donne les points parmis lesquels nous allons choisir les solutions. + |
904 | //========================================================================= |
905 | |
906 | Geom2dGcc_Circ2d2TanOnGeo:: |
907 | Geom2dGcc_Circ2d2TanOnGeo (const gp_Pnt2d& Point1 , |
908 | const gp_Pnt2d& Point2 , |
909 | const Geom2dAdaptor_Curve& OnCurv , |
910 | const Standard_Real Tolerance ): |
911 | cirsol(1,8) , |
912 | qualifier1(1,8), |
913 | qualifier2(1,8), |
914 | TheSame1(1,8) , |
915 | TheSame2(1,8) , |
916 | pnttg1sol(1,8) , |
917 | pnttg2sol(1,8) , |
918 | pntcen(1,8) , |
919 | par1sol(1,8) , |
920 | par2sol(1,8) , |
921 | pararg1(1,8) , |
922 | pararg2(1,8) , |
923 | parcen3(1,8) |
924 | { |
925 | |
926 | WellDone = Standard_False; |
927 | Standard_Real thefirst = -100000.; |
928 | Standard_Real thelast = 100000.; |
929 | Standard_Real firstparam; |
930 | Standard_Real lastparam; |
931 | Standard_Real Tol = Abs(Tolerance); |
932 | NbrSol = 0; |
933 | gp_Dir2d dirx(1.,0.); |
934 | GccAna_Pnt2dBisec Bis(Point1,Point2); |
935 | if (Bis.IsDone()) { |
936 | Standard_Real Tol1 = Abs(Tolerance); |
937 | Standard_Real Tol2 = Tol1; |
938 | Geom2dInt_TheIntConicCurveOfGInter Intp; |
939 | Handle(Geom2dAdaptor_HCurve) HCu2 = new Geom2dAdaptor_HCurve(OnCurv); |
5201d3e6 |
940 | Adaptor2d_OffsetCurve Cu2(HCu2,0.); |
941 | firstparam = Max(Cu2.FirstParameter(),thefirst); |
942 | lastparam = Min(Cu2.LastParameter(),thelast); |
943 | IntRes2d_Domain D2(Cu2.Value(firstparam), firstparam, Tol, |
944 | Cu2.Value(lastparam), lastparam, Tol); |
578ce4be |
945 | IntRes2d_Domain D1; |
946 | if (Bis.HasSolution()) { |
947 | Intp.Perform(Bis.ThisSolution(),D1,Cu2,D2,Tol1,Tol2); |
948 | if (Intp.IsDone()) { |
949 | if ((!Intp.IsEmpty())) { |
950 | for (Standard_Integer j = 1 ; j <= Intp.NbPoints() ; j++) { |
951 | gp_Pnt2d Center(Intp.Point(j).Value()); |
952 | Standard_Real Radius = Point2.Distance(Center); |
953 | NbrSol++; |
954 | cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Center,dirx),Radius); |
955 | // ======================================================= |
956 | qualifier1(NbrSol) = GccEnt_noqualifier; |
957 | qualifier2(NbrSol) = GccEnt_noqualifier; |
958 | TheSame1(NbrSol) = 0; |
959 | TheSame2(NbrSol) = 0; |
960 | pntcen(NbrSol) = Center; |
961 | pnttg1sol(NbrSol) = Point1; |
962 | pnttg2sol(NbrSol) = Point2; |
963 | pararg1(NbrSol) = 0.; |
964 | pararg2(NbrSol) = 0.; |
965 | par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
966 | pnttg1sol(NbrSol)); |
967 | par2sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol), |
968 | pnttg2sol(NbrSol)); |
969 | parcen3(NbrSol) = Intp.Point(j).ParamOnSecond(); |
970 | } |
971 | } |
972 | WellDone = Standard_True; |
973 | } |
974 | } |
975 | } |
976 | } |
977 | |
978 | Standard_Boolean Geom2dGcc_Circ2d2TanOnGeo:: |
979 | IsDone () const { return WellDone; } |
980 | |
981 | Standard_Integer Geom2dGcc_Circ2d2TanOnGeo:: |
982 | NbSolutions () const{ return NbrSol; } |
983 | |
984 | gp_Circ2d Geom2dGcc_Circ2d2TanOnGeo:: |
985 | ThisSolution (const Standard_Integer Index) const |
986 | { |
9775fa61 |
987 | if (!WellDone) { throw StdFail_NotDone(); } |
988 | if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); } |
578ce4be |
989 | |
990 | return cirsol(Index); |
991 | } |
992 | |
993 | void Geom2dGcc_Circ2d2TanOnGeo:: |
994 | WhichQualifier(const Standard_Integer Index , |
995 | GccEnt_Position& Qualif1 , |
996 | GccEnt_Position& Qualif2 ) const |
997 | { |
9775fa61 |
998 | if (!WellDone) { throw StdFail_NotDone(); } |
999 | else if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); } |
578ce4be |
1000 | else { |
1001 | Qualif1 = qualifier1(Index); |
1002 | Qualif2 = qualifier2(Index); |
1003 | } |
1004 | } |
1005 | |
1006 | void Geom2dGcc_Circ2d2TanOnGeo:: |
1007 | Tangency1 (const Standard_Integer Index , |
1008 | Standard_Real& ParSol , |
1009 | Standard_Real& ParArg , |
1010 | gp_Pnt2d& PntSol ) const{ |
9775fa61 |
1011 | if (!WellDone) { throw StdFail_NotDone(); } |
1012 | else if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); } |
578ce4be |
1013 | else { |
1014 | if (TheSame1(Index) == 0) { |
1015 | ParSol = par1sol(Index); |
1016 | ParArg = pararg1(Index); |
1017 | PntSol = gp_Pnt2d(pnttg1sol(Index)); |
1018 | } |
9775fa61 |
1019 | else { throw StdFail_NotDone(); } |
578ce4be |
1020 | } |
1021 | } |
1022 | |
1023 | void Geom2dGcc_Circ2d2TanOnGeo:: |
1024 | Tangency2 (const Standard_Integer Index , |
1025 | Standard_Real& ParSol , |
1026 | Standard_Real& ParArg , |
1027 | gp_Pnt2d& PntSol ) const{ |
9775fa61 |
1028 | if (!WellDone) { throw StdFail_NotDone(); } |
1029 | else if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); } |
578ce4be |
1030 | else { |
1031 | if (TheSame2(Index) == 0) { |
1032 | ParSol = par2sol(Index); |
1033 | ParArg = pararg2(Index); |
1034 | PntSol = gp_Pnt2d(pnttg2sol(Index)); |
1035 | } |
9775fa61 |
1036 | else { throw StdFail_NotDone(); } |
578ce4be |
1037 | } |
1038 | } |
1039 | |
1040 | void Geom2dGcc_Circ2d2TanOnGeo:: |
1041 | CenterOn3 (const Standard_Integer Index , |
1042 | Standard_Real& ParArg , |
1043 | gp_Pnt2d& PntSol ) const{ |
9775fa61 |
1044 | if (!WellDone) { throw StdFail_NotDone(); } |
1045 | else if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); } |
578ce4be |
1046 | else { |
1047 | ParArg = parcen3(Index); |
1048 | PntSol = gp_Pnt2d(pntcen(Index)); |
1049 | } |
1050 | } |
1051 | |
1052 | Standard_Boolean Geom2dGcc_Circ2d2TanOnGeo:: |
1053 | IsTheSame1 (const Standard_Integer Index) const |
1054 | { |
9775fa61 |
1055 | if (!WellDone) throw StdFail_NotDone(); |
1056 | if (Index <= 0 ||Index > NbrSol) throw Standard_OutOfRange(); |
578ce4be |
1057 | |
1058 | if (TheSame1(Index) == 0) |
1059 | return Standard_False; |
1060 | |
1061 | return Standard_True; |
1062 | } |
1063 | |
1064 | |
1065 | Standard_Boolean Geom2dGcc_Circ2d2TanOnGeo:: |
1066 | IsTheSame2 (const Standard_Integer Index) const |
1067 | { |
9775fa61 |
1068 | if (!WellDone) throw StdFail_NotDone(); |
1069 | if (Index <= 0 ||Index > NbrSol) throw Standard_OutOfRange(); |
578ce4be |
1070 | |
1071 | if (TheSame2(Index) == 0) |
1072 | return Standard_False; |
1073 | |
1074 | return Standard_True; |
1075 | } |