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