1 // Created on: 1992-10-21
2 // Created by: Remi GILET
3 // Copyright (c) 1992-1999 Matra Datavision
4 // Copyright (c) 1999-2012 OPEN CASCADE SAS
6 // The content of this file is subject to the Open CASCADE Technology Public
7 // License Version 6.5 (the "License"). You may not use the content of this file
8 // except in compliance with the License. Please obtain a copy of the License
9 // at http://www.opencascade.org and read it completely before using this file.
11 // The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
12 // main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
14 // The Original Code and all software distributed under the License is
15 // distributed on an "AS IS" basis, without warranty of any kind, and the
16 // Initial Developer hereby disclaims all such warranties, including without
17 // limitation, any warranties of merchantability, fitness for a particular
18 // purpose or non-infringement. Please see the License for the specific terms
19 // and conditions governing the rights and limitations under the License.
22 #include <Geom2dGcc_Circ2d2TanRad.ixx>
23 #include <Geom2dAdaptor_Curve.hxx>
24 #include <GccAna_Circ2d2TanRad.hxx>
25 #include <Geom2dGcc_MyCirc2d2TanRad.hxx>
26 #include <Geom2dGcc_MyQCurve.hxx>
27 #include <GccEnt_BadQualifier.hxx>
28 #include <Geom2d_Circle.hxx>
29 #include <Geom2d_Line.hxx>
30 #include <gp_Circ2d.hxx>
31 #include <gp_Lin2d.hxx>
32 #include <GccEnt_QualifiedCirc.hxx>
33 #include <GccEnt_QualifiedLin.hxx>
34 #include <StdFail_NotDone.hxx>
35 #include <Standard_NegativeValue.hxx>
36 #include <Standard_OutOfRange.hxx>
39 // circulaire tangent a deux cercles et de rayon donne
40 //====================================================
41 //========================================================================
42 // On initialise WellDone a false. +
43 // On recupere le cercle C1 et le cercle C2. +
44 // On sort en erreur dans les cas ou la construction est impossible. +
45 // On distingue les cas limites pour les triater separement. +
46 // On fait la parallele a C1 dans le bon sens. +
47 // On fait la parallele a C2 dans le bon sens. +
48 // On intersecte les paralleles ==> point de centre de la solution. +
49 // On cree la solution qu on ajoute aux solutions deja trouvees. +
50 // On remplit les champs. +
51 //========================================================================
53 Geom2dGcc_Circ2d2TanRad::
54 Geom2dGcc_Circ2d2TanRad (const Geom2dGcc_QualifiedCurve& Qualified1 ,
55 const Geom2dGcc_QualifiedCurve& Qualified2 ,
56 const Standard_Real Radius ,
57 const Standard_Real Tolerance ):
70 if (Radius < 0.) { Standard_NegativeValue::Raise(); }
72 Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
73 Geom2dAdaptor_Curve C2 = Qualified2.Qualified();
74 Handle(Geom2d_Curve) CC1 = C1.Curve();
75 Handle(Geom2d_Curve) CC2 = C2.Curve();
76 GeomAbs_CurveType Type1 = C1.GetType();
77 GeomAbs_CurveType Type2 = C2.GetType();
79 //=============================================================================
81 //=============================================================================
83 Invert = Standard_False;
85 if ((Type1 == GeomAbs_Line || Type1 == GeomAbs_Circle) &&
86 (Type2 == GeomAbs_Line || Type2 == GeomAbs_Circle)) {
87 if (Type1 == GeomAbs_Circle) {
88 Handle(Geom2d_Circle) CCC1 = Handle(Geom2d_Circle)::DownCast(CC1);
89 gp_Circ2d c1(CCC1->Circ2d());
90 GccEnt_QualifiedCirc Qc1 = GccEnt_QualifiedCirc(c1,
91 Qualified1.Qualifier());
92 if (Type2 == GeomAbs_Circle) {
93 Handle(Geom2d_Circle) CCC2 = Handle(Geom2d_Circle)::DownCast(CC2);
94 gp_Circ2d c2(CCC2->Circ2d());
95 GccAna_Circ2d2TanRad CircAna(Qc1,
96 GccEnt_QualifiedCirc(c2,Qualified2.Qualifier()),
98 WellDone = CircAna.IsDone();
99 NbrSol = CircAna.NbSolutions();
100 for(Standard_Integer i=1; i<=NbrSol; i++) {
101 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
106 Handle(Geom2d_Line) LL2 = Handle(Geom2d_Line)::DownCast(CC2);
107 gp_Lin2d l2(LL2->Lin2d());
108 if (!Qualified2.IsEnclosing()) {
109 GccAna_Circ2d2TanRad CircAna(Qc1,
110 GccEnt_QualifiedLin(l2,Qualified2.Qualifier()),
112 WellDone = CircAna.IsDone();
113 NbrSol = CircAna.NbSolutions();
114 for(Standard_Integer i=1; i<=NbrSol; i++) {
115 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
120 WellDone = Standard_False;
121 GccEnt_BadQualifier::Raise();
126 Handle(Geom2d_Line) LL1 = Handle(Geom2d_Line)::DownCast(CC1);
127 gp_Lin2d l1(LL1->Lin2d());
128 if (Qualified1.IsEnclosing()) {
129 WellDone = Standard_False;
130 GccEnt_BadQualifier::Raise();
133 GccEnt_QualifiedLin Ql1 = GccEnt_QualifiedLin(l1,
134 Qualified1.Qualifier());
135 if (Type2 == GeomAbs_Circle) {
136 Handle(Geom2d_Circle) CCC2 = Handle(Geom2d_Circle)::DownCast(CC2);
137 gp_Circ2d c2(CCC2->Circ2d());
138 Invert = Standard_True;
139 GccAna_Circ2d2TanRad CircAna(GccEnt_QualifiedCirc(c2,
140 Qualified2.Qualifier()),
141 Ql1,Radius,Tolerance);
142 WellDone = CircAna.IsDone();
143 NbrSol = CircAna.NbSolutions();
144 for(Standard_Integer i=1; i<=NbrSol; i++) {
145 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
150 Handle(Geom2d_Line) LL2 = Handle(Geom2d_Line)::DownCast(CC2);
151 gp_Lin2d l2(LL2->Lin2d());
152 if (!Qualified2.IsEnclosing()) {
153 GccAna_Circ2d2TanRad CircAna(Ql1,
154 GccEnt_QualifiedLin(l2,Qualified2.Qualifier()),
156 WellDone = CircAna.IsDone();
157 NbrSol = CircAna.NbSolutions();
158 for(Standard_Integer i=1; i<=NbrSol; i++) {
159 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
164 WellDone = Standard_False;
165 GccEnt_BadQualifier::Raise();
171 //=============================================================================
173 //=============================================================================
175 if (Type1 == GeomAbs_Line) {
176 Handle(Geom2d_Line) LL1 = Handle(Geom2d_Line)::DownCast(CC1);
177 gp_Lin2d l1(LL1->Lin2d());
178 if (Qualified1.IsEnclosing()) {
179 WellDone = Standard_False;
180 GccEnt_BadQualifier::Raise();
183 GccEnt_QualifiedLin Ql1 = GccEnt_QualifiedLin(l1,
184 Qualified1.Qualifier());
185 Geom2dGcc_MyQCurve Qc2(C2,Qualified2.Qualifier());
186 Geom2dGcc_MyCirc2d2TanRad CircGeo(Ql1,Qc2,Radius,Tolerance);
187 WellDone = CircGeo.IsDone();
188 NbrSol = CircGeo.NbSolutions();
189 for(Standard_Integer i=1; i<=NbrSol; i++) {
190 CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
195 else if (Type1 == GeomAbs_Circle) {
196 Handle(Geom2d_Circle) CCC1 = Handle(Geom2d_Circle)::DownCast(CC1);
197 gp_Circ2d c1(CCC1->Circ2d());
198 GccEnt_QualifiedCirc Qc1 = GccEnt_QualifiedCirc(c1,
199 Qualified1.Qualifier());
200 Geom2dGcc_MyQCurve Qc2(C2,Qualified2.Qualifier());
201 Geom2dGcc_MyCirc2d2TanRad CircGeo(Qc1,Qc2,Radius,Tolerance);
202 WellDone = CircGeo.IsDone();
203 NbrSol = CircGeo.NbSolutions();
204 for(Standard_Integer i=1; i<=NbrSol; i++) {
205 CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
209 else if (Type2 == GeomAbs_Line) {
210 Invert = Standard_True;
211 Handle(Geom2d_Line) LL2 = Handle(Geom2d_Line)::DownCast(CC2);
212 gp_Lin2d l2(LL2->Lin2d());
213 if (Qualified2.IsEnclosing()) {
214 WellDone = Standard_False;
215 GccEnt_BadQualifier::Raise();
218 GccEnt_QualifiedLin Ql2 = GccEnt_QualifiedLin(l2,
219 Qualified2.Qualifier());
220 Geom2dGcc_MyQCurve Qc1(C1,Qualified1.Qualifier());
221 Geom2dGcc_MyCirc2d2TanRad CircGeo(Ql2,Qc1,Radius,Tolerance);
222 WellDone = CircGeo.IsDone();
223 NbrSol = CircGeo.NbSolutions();
224 for(Standard_Integer i=1; i<=NbrSol; i++) {
225 CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
230 else if (Type2 == GeomAbs_Circle) {
231 Invert = Standard_True;
232 Handle(Geom2d_Circle) CCC2 = Handle(Geom2d_Circle)::DownCast(CC2);
233 gp_Circ2d c2(CCC2->Circ2d());
234 GccEnt_QualifiedCirc Qc2 = GccEnt_QualifiedCirc(c2,
235 Qualified2.Qualifier());
236 Geom2dGcc_MyQCurve Qc1(C1,Qualified1.Qualifier());
237 Geom2dGcc_MyCirc2d2TanRad CircGeo(Qc2,Qc1,Radius,Tolerance);
238 WellDone = CircGeo.IsDone();
239 NbrSol = CircGeo.NbSolutions();
240 for(Standard_Integer i=1; i<=NbrSol; i++) {
241 CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
246 Geom2dGcc_MyQCurve Qc1(C1,Qualified1.Qualifier());
247 Geom2dGcc_MyQCurve Qc2(C2,Qualified2.Qualifier());
248 Geom2dGcc_MyCirc2d2TanRad CircGeo(Qc1,Qc2,Radius,Tolerance);
249 WellDone = CircGeo.IsDone();
250 NbrSol = CircGeo.NbSolutions();
251 for(Standard_Integer i=1; i<=NbrSol; i++) {
252 CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
260 Geom2dGcc_Circ2d2TanRad::
261 Geom2dGcc_Circ2d2TanRad (const Geom2dGcc_QualifiedCurve& Qualified1 ,
262 const Handle(Geom2d_Point)& Point ,
263 const Standard_Real Radius ,
264 const Standard_Real Tolerance ):
277 if (Radius < 0.) { Standard_NegativeValue::Raise(); }
279 Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
280 Handle(Geom2d_Curve) CC1 = C1.Curve();
281 GeomAbs_CurveType Type1 = C1.GetType();
283 //=============================================================================
285 //=============================================================================
287 Invert = Standard_False;
289 if (Type1 == GeomAbs_Line || Type1 == GeomAbs_Circle) {
290 if (Type1 == GeomAbs_Circle) {
291 Handle(Geom2d_Circle) CCC1 = Handle(Geom2d_Circle)::DownCast(CC1);
292 gp_Circ2d c1(CCC1->Circ2d());
293 GccEnt_QualifiedCirc Qc1(c1,Qualified1.Qualifier());
294 GccAna_Circ2d2TanRad CircAna(Qc1,Point->Pnt2d(),Radius,Tolerance);
295 WellDone = CircAna.IsDone();
296 NbrSol = CircAna.NbSolutions();
297 for(Standard_Integer i=1; i<=NbrSol; i++) {
298 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
303 Handle(Geom2d_Line) LLL1 = Handle(Geom2d_Line)::DownCast(CC1);
304 gp_Lin2d l1(LLL1->Lin2d());
305 GccEnt_QualifiedLin Ql1(l1,Qualified1.Qualifier());
306 GccAna_Circ2d2TanRad CircAna(Ql1,Point->Pnt2d(),Radius,Tolerance);
307 WellDone = CircAna.IsDone();
308 NbrSol = CircAna.NbSolutions();
309 for(Standard_Integer i=1; i<=NbrSol; i++) {
310 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
315 //=============================================================================
317 //=============================================================================
319 Geom2dGcc_MyQCurve Qc1(C1,Qualified1.Qualifier());
320 Geom2dGcc_MyCirc2d2TanRad CircGeo(Qc1,Point->Pnt2d(),Radius,Tolerance);
321 WellDone = CircGeo.IsDone();
322 NbrSol = CircGeo.NbSolutions();
323 for(Standard_Integer i=1; i<=NbrSol; i++) {
324 CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
331 Geom2dGcc_Circ2d2TanRad::
332 Geom2dGcc_Circ2d2TanRad (const Handle(Geom2d_Point)& Point1 ,
333 const Handle(Geom2d_Point)& Point2 ,
334 const Standard_Real Radius ,
335 const Standard_Real Tolerance ):
348 if (Radius < 0.) { Standard_NegativeValue::Raise(); }
351 //=============================================================================
353 //=============================================================================
355 Invert = Standard_False;
357 GccAna_Circ2d2TanRad CircAna(Point1->Pnt2d(),Point2->Pnt2d(),
359 WellDone = CircAna.IsDone();
360 NbrSol = CircAna.NbSolutions();
361 for(Standard_Integer i=1; i<=NbrSol; i++) {
362 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
368 void Geom2dGcc_Circ2d2TanRad::Results(const GccAna_Circ2d2TanRad& Circ)
370 for (Standard_Integer j = 1; j <= NbrSol; j++) {
371 cirsol(j) = Circ.ThisSolution(j);
372 if (Circ.IsTheSame1(j)) { TheSame1(j) = 1; }
373 else {TheSame1(j) = 0; }
374 if (Circ.IsTheSame2(j)) { TheSame2(j) = 1; }
375 else {TheSame2(j) = 0; }
376 Circ.Tangency1(j,par1sol(j),pararg1(j),pnttg1sol(j));
377 Circ.Tangency2(j,par2sol(j),pararg2(j),pnttg2sol(j));
381 void Geom2dGcc_Circ2d2TanRad::Results(const Geom2dGcc_MyCirc2d2TanRad& Circ)
383 for (Standard_Integer j = 1; j <= NbrSol; j++) {
384 cirsol(j) = Circ.ThisSolution(j);
385 if (Circ.IsTheSame1(j)) { TheSame1(j) = 1; }
386 else {TheSame1(j) = 0; }
387 if (Circ.IsTheSame2(j)) { TheSame2(j) = 1; }
388 else {TheSame2(j) = 0; }
389 Circ.Tangency1(j,par1sol(j),pararg1(j),pnttg1sol(j));
390 Circ.Tangency2(j,par2sol(j),pararg2(j),pnttg2sol(j));
394 Standard_Boolean Geom2dGcc_Circ2d2TanRad::
395 IsDone () const { return WellDone; }
397 Standard_Integer Geom2dGcc_Circ2d2TanRad::
403 gp_Circ2d Geom2dGcc_Circ2d2TanRad::
404 ThisSolution (const Standard_Integer Index) const
406 if (!WellDone) { StdFail_NotDone::Raise(); }
407 if (Index <= 0 ||Index > NbrSol) { Standard_OutOfRange::Raise(); }
408 return cirsol(Index);
411 void Geom2dGcc_Circ2d2TanRad::
412 WhichQualifier (const Standard_Integer Index ,
413 GccEnt_Position& Qualif1 ,
414 GccEnt_Position& Qualif2) const
416 if (!WellDone) { StdFail_NotDone::Raise(); }
417 else if (Index <= 0 ||Index > NbrSol) { Standard_OutOfRange::Raise(); }
420 Qualif1 = qualifier2(Index);
421 Qualif2 = qualifier1(Index);
424 Qualif1 = qualifier1(Index);
425 Qualif2 = qualifier2(Index);
430 void Geom2dGcc_Circ2d2TanRad::
431 Tangency1 (const Standard_Integer Index,
432 Standard_Real& ParSol,
433 Standard_Real& ParArg,
434 gp_Pnt2d& PntSol) const
436 if (!WellDone) { StdFail_NotDone::Raise(); }
437 else if (Index <= 0 ||Index > NbrSol) { Standard_OutOfRange::Raise(); }
440 if (TheSame2(Index) == 0) {
441 ParSol = par2sol(Index);
442 ParArg = pararg2(Index);
443 PntSol = pnttg2sol(Index);
445 else { StdFail_NotDone::Raise(); }
448 if (TheSame1(Index) == 0) {
449 ParSol = par1sol(Index);
450 ParArg = pararg1(Index);
451 PntSol = pnttg1sol(Index);
453 else { StdFail_NotDone::Raise(); }
458 void Geom2dGcc_Circ2d2TanRad::
459 Tangency2 (const Standard_Integer Index,
460 Standard_Real& ParSol,
461 Standard_Real& ParArg,
462 gp_Pnt2d& PntSol) const
464 if (!WellDone) { StdFail_NotDone::Raise(); }
465 else if (Index <= 0 ||Index > NbrSol) { Standard_OutOfRange::Raise(); }
468 if (TheSame2(Index) == 0) {
469 ParSol = par2sol(Index);
470 ParArg = pararg2(Index);
471 PntSol = pnttg2sol(Index);
473 else { StdFail_NotDone::Raise(); }
476 if (TheSame1(Index) == 0) {
477 ParSol = par1sol(Index);
478 ParArg = pararg1(Index);
479 PntSol = pnttg1sol(Index);
481 else { StdFail_NotDone::Raise(); }
486 Standard_Boolean Geom2dGcc_Circ2d2TanRad::
487 IsTheSame1 (const Standard_Integer Index) const
489 if (!WellDone) { StdFail_NotDone::Raise(); }
490 if (Index <= 0 ||Index > NbrSol) { Standard_OutOfRange::Raise(); }
492 if (TheSame2(Index) == 0) { return Standard_False; }
493 else { return Standard_True; }
496 if (TheSame1(Index) == 0) { return Standard_False; }
497 else { return Standard_True; }
501 Standard_Boolean Geom2dGcc_Circ2d2TanRad::
502 IsTheSame2 (const Standard_Integer Index) const
504 if (!WellDone) { StdFail_NotDone::Raise(); }
505 if (Index <= 0 ||Index > NbrSol) { Standard_OutOfRange::Raise(); }
507 if (TheSame2(Index) == 0) { return Standard_False; }
508 else { return Standard_True; }
511 if (TheSame1(Index) == 0) { return Standard_False; }
512 else { return Standard_True; }
514 // return Standard_True;