projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0029915: Porting to VC 2017 : Regressions in Modeling Algorithms on VC 2017
[occt.git] / src / Geom2dGcc / Geom2dGcc_Circ2d2TanOnGeo.cxx
CommitLineData
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
49Geom2dGcc_Circ2d2TanOnGeo::
50Geom2dGcc_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
274Geom2dGcc_Circ2d2TanOnGeo::
275Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedCirc& Qualified1 ,
276 const GccEnt_QualifiedLin& Qualified2 ,
277 const Geom2dAdaptor_Curve& OnCurv ,
278 const Standard_Real Tolerance ):
279cirsol(1,8) ,
280qualifier1(1,8),
281qualifier2(1,8),
282TheSame1(1,8) ,
283TheSame2(1,8) ,
284pnttg1sol(1,8) ,
285pnttg2sol(1,8) ,
286pntcen(1,8) ,
287par1sol(1,8) ,
288par2sol(1,8) ,
289pararg1(1,8) ,
290pararg2(1,8) ,
291parcen3(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
452Geom2dGcc_Circ2d2TanOnGeo::
453Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedLin& Qualified1 ,
454 const GccEnt_QualifiedLin& Qualified2 ,
455 const Geom2dAdaptor_Curve& OnCurv ,
456 const Standard_Real Tolerance ):
457cirsol(1,8) ,
458qualifier1(1,8),
459qualifier2(1,8),
460TheSame1(1,8) ,
461TheSame2(1,8) ,
462pnttg1sol(1,8) ,
463pnttg2sol(1,8) ,
464pntcen(1,8) ,
465par1sol(1,8) ,
466par2sol(1,8) ,
467pararg1(1,8) ,
468pararg2(1,8) ,
469parcen3(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
607Geom2dGcc_Circ2d2TanOnGeo::
608Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedCirc& Qualified1 ,
609 const gp_Pnt2d& Point2 ,
610 const Geom2dAdaptor_Curve& OnCurv ,
611 const Standard_Real Tolerance ):
612cirsol(1,8) ,
613qualifier1(1,8),
614qualifier2(1,8),
615TheSame1(1,8) ,
616TheSame2(1,8) ,
617pnttg1sol(1,8) ,
618pnttg2sol(1,8) ,
619pntcen(1,8) ,
620par1sol(1,8) ,
621par2sol(1,8) ,
622pararg1(1,8) ,
623pararg2(1,8) ,
624parcen3(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
769Geom2dGcc_Circ2d2TanOnGeo::
770Geom2dGcc_Circ2d2TanOnGeo (const GccEnt_QualifiedLin& Qualified1 ,
771 const gp_Pnt2d& Point2 ,
772 const Geom2dAdaptor_Curve& OnCurv ,
773 const Standard_Real Tolerance ):
774cirsol(1,8) ,
775qualifier1(1,8),
776qualifier2(1,8),
777TheSame1(1,8) ,
778TheSame2(1,8) ,
779pnttg1sol(1,8) ,
780pnttg2sol(1,8) ,
781pntcen(1,8) ,
782par1sol(1,8) ,
783par2sol(1,8) ,
784pararg1(1,8) ,
785pararg2(1,8) ,
786parcen3(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
906Geom2dGcc_Circ2d2TanOnGeo::
907Geom2dGcc_Circ2d2TanOnGeo (const gp_Pnt2d& Point1 ,
908 const gp_Pnt2d& Point2 ,
909 const Geom2dAdaptor_Curve& OnCurv ,
910 const Standard_Real Tolerance ):
911cirsol(1,8) ,
912qualifier1(1,8),
913qualifier2(1,8),
914TheSame1(1,8) ,
915TheSame2(1,8) ,
916pnttg1sol(1,8) ,
917pnttg2sol(1,8) ,
918pntcen(1,8) ,
919par1sol(1,8) ,
920par2sol(1,8) ,
921pararg1(1,8) ,
922pararg2(1,8) ,
923parcen3(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
978Standard_Boolean Geom2dGcc_Circ2d2TanOnGeo::
979IsDone () const { return WellDone; }
980
981Standard_Integer Geom2dGcc_Circ2d2TanOnGeo::
982NbSolutions () const{ return NbrSol; }
983
984gp_Circ2d Geom2dGcc_Circ2d2TanOnGeo::
985ThisSolution (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
993void Geom2dGcc_Circ2d2TanOnGeo::
994WhichQualifier(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
1006void Geom2dGcc_Circ2d2TanOnGeo::
1007Tangency1 (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
1023void Geom2dGcc_Circ2d2TanOnGeo::
1024Tangency2 (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
1040void Geom2dGcc_Circ2d2TanOnGeo::
1041CenterOn3 (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
1052Standard_Boolean Geom2dGcc_Circ2d2TanOnGeo::
1053IsTheSame1 (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
1065Standard_Boolean Geom2dGcc_Circ2d2TanOnGeo::
1066IsTheSame2 (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}
Open CASCADE Technology repository