0026937: Eliminate NO_CXX_EXCEPTION macro support
[occt.git] / src / GccAna / GccAna_Circ2dTanCen.cxx
1 // Copyright (c) 1995-1999 Matra Datavision
2 // Copyright (c) 1999-2014 OPEN CASCADE SAS
3 //
4 // This file is part of Open CASCADE Technology software library.
5 //
6 // This library is free software; you can redistribute it and/or modify it under
7 // the terms of the GNU Lesser General Public License version 2.1 as published
8 // by the Free Software Foundation, with special exception defined in the file
9 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
10 // distribution for complete text of the license and disclaimer of any warranty.
11 //
12 // Alternatively, this file may be used under the terms of Open CASCADE
13 // commercial license or contractual agreement.
14
15 //================================================================================
16 //    Creation of a circle tangent to an element and having center in a point    +
17 //================================================================================
18
19 #include <ElCLib.hxx>
20 #include <GccAna_Circ2dTanCen.hxx>
21 #include <GccEnt_BadQualifier.hxx>
22 #include <GccEnt_QualifiedCirc.hxx>
23 #include <gp.hxx>
24 #include <gp_Circ2d.hxx>
25 #include <gp_Dir2d.hxx>
26 #include <gp_Lin2d.hxx>
27 #include <gp_Pnt2d.hxx>
28 #include <Standard_NegativeValue.hxx>
29 #include <Standard_OutOfRange.hxx>
30 #include <StdFail_NotDone.hxx>
31
32 //========================================================================
33 //     Creation of a circle tangent to a circle with center in a point.      +
34 //   - Calculate the distance between the center of the circle and the point of  +
35 //     center : dist                                                     +
36 //   - Check that this distance is compatible with the qualifier of the circle.                                                        +
37 //       Si yes, the radius of the solution will be :                           +
38 //          C1.Radius()-dist if the qualifier is Enclosed.              +
39 //          C1.Radius()+dist if the qualifier is Enclosing.             +
40 //          dist-C1.Radius() if the qualifier is Outside.               +
41 //          a mix of these values if the qualifier is Unqualified.  +
42 //========================================================================
43 GccAna_Circ2dTanCen::
44    GccAna_Circ2dTanCen (const GccEnt_QualifiedCirc& Qualified1,
45                         const gp_Pnt2d&             Pcenter   ,
46                         const Standard_Real                  Tolerance ):
47
48 //========================================================================
49 //   Initialization of fields.                                          +
50 //========================================================================
51
52    cirsol(1,2)   ,
53    qualifier1(1,2) ,
54    TheSame1(1,2) ,
55    pnttg1sol(1,2),
56    par1sol(1,2),
57    pararg1(1,2)
58 {
59
60    NbrSol = 0;
61    Standard_Real Radius = 0.0;
62    WellDone = Standard_False;
63    if (!(Qualified1.IsEnclosed() || Qualified1.IsEnclosing() || 
64          Qualified1.IsOutside() || Qualified1.IsUnqualified())) {
65      throw GccEnt_BadQualifier();
66      return;
67    }
68    gp_Dir2d dirx(1.0,0.0);
69    Standard_Real Tol = Abs(Tolerance);
70    gp_Circ2d C1 = Qualified1.Qualified();
71    Standard_Real R1 = C1.Radius();
72    gp_Pnt2d center1(C1.Location());
73    Standard_Real dist;
74    Standard_Integer signe = 0;
75    Standard_Integer signe1 = 0;
76
77    if (!Qualified1.IsUnqualified()) {
78      dist = Pcenter.Distance(center1);
79      if (Qualified1.IsEnclosed()) {
80 //   ============================
81        if (dist-R1 <= Tol) {
82          Radius = Abs(R1-dist);
83          signe = 1;
84        }
85        else { WellDone = Standard_True; }
86      }
87      else if (Qualified1.IsEnclosing()) {
88 //   =================================
89        Radius = R1+dist;
90        signe = -1;
91      }
92      else if (Qualified1.IsOutside()) {
93 //   ===============================
94        if (dist < R1-Tol) { WellDone = Standard_True; }
95        else {
96          Radius = Abs(R1-dist);
97          signe = -1;
98        }
99      }
100      if (signe != 0) {
101        NbrSol++;
102        cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),Radius);
103 //     ========================================================
104        qualifier1(NbrSol) = Qualified1.Qualifier();
105        if (dist <= gp::Resolution()) { TheSame1(NbrSol) = 1; }
106        else {
107          TheSame1(NbrSol) = 0;
108          gp_Dir2d d(Pcenter.X()-center1.X(),Pcenter.Y()-center1.Y());
109          pnttg1sol(NbrSol) = gp_Pnt2d(Pcenter.XY()+signe*Radius*d.XY());
110          par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),pnttg1sol(NbrSol));
111          pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol));
112        }
113        WellDone = Standard_True;
114      }
115    }
116    else {
117 // ====
118      dist = Pcenter.Distance(center1);
119      if (dist >= gp::Resolution()) {
120        signe = 1;
121        for (Standard_Integer i = 1; i <= 2 ; i++) {
122          signe = -signe;
123          if (R1-dist <= 0.) {
124            signe1 = -1;
125          }
126          else {
127            signe1 = -signe;
128          }
129          Radius = Abs(R1+signe*dist);
130          NbrSol++;
131          cirsol(NbrSol) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),Radius);
132 //       ========================================================
133          Standard_Real distcc1 = Pcenter.Distance(center1);
134          if (!Qualified1.IsUnqualified()) { 
135            qualifier1(NbrSol) = Qualified1.Qualifier();
136          }
137          else if (Abs(distcc1+Radius-R1) < Tol) {
138            qualifier1(NbrSol) = GccEnt_enclosed;
139          }
140          else if (Abs(distcc1-R1-Radius) < Tol) {
141            qualifier1(NbrSol) = GccEnt_outside;
142          }
143          else { qualifier1(NbrSol) = GccEnt_enclosing; }
144          TheSame1(NbrSol) = 0;
145          WellDone = Standard_True;
146          gp_Dir2d d(Pcenter.X()-center1.X(),Pcenter.Y()-center1.Y());
147          pnttg1sol(NbrSol) = gp_Pnt2d(Pcenter.XY()+signe1*Radius*d.XY());
148          par1sol(NbrSol)=ElCLib::Parameter(cirsol(NbrSol),pnttg1sol(NbrSol));
149          pararg1(NbrSol)=ElCLib::Parameter(C1,pnttg1sol(NbrSol));
150        }
151      }
152      else {
153        NbrSol++;
154        cirsol(NbrSol) = gp_Circ2d(C1);
155 //     ==============================
156        qualifier1(1) = Qualified1.Qualifier();
157        TheSame1(NbrSol) = 1;
158        WellDone = Standard_True;
159      }
160    }
161  }
162
163 //=========================================================================
164 //   Circle tangent to line Linetan and center in a point Pcenter.    +
165 //   Calculate the distance from the point to the line ==> Radius.                +
166 //   Create the circle with center Pcenter of radius Radius.                  +
167 //=========================================================================
168
169 GccAna_Circ2dTanCen::
170    GccAna_Circ2dTanCen (const gp_Lin2d&            Linetan    ,
171                         const gp_Pnt2d&            Pcenter    ):
172
173 //=========================================================================
174 //   Initialisation of fields.                                           +
175 //=========================================================================
176
177    cirsol(1,1)   ,
178    qualifier1(1,1),
179    TheSame1(1,1) ,
180    pnttg1sol(1,1),
181    par1sol(1,1),
182    pararg1(1,1) 
183 {
184
185    gp_Dir2d dirx(1.0,0.0);
186    Standard_Real rayon = Linetan.Distance(Pcenter);
187    cirsol(1) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),rayon);
188 // ==================================================
189    qualifier1(1) = GccEnt_noqualifier;
190    TheSame1(1) = 0;
191    Standard_Real xloc = Linetan.Location().X();
192    Standard_Real yloc = Linetan.Location().Y();
193    Standard_Real xdir = Linetan.Direction().X();
194    Standard_Real ydir = Linetan.Direction().Y();
195
196    if (gp_Dir2d(xloc-Pcenter.X(),yloc-Pcenter.Y())
197                .Dot(gp_Dir2d(-ydir,xdir)) > 0.0) {
198      pnttg1sol(1) = gp_Pnt2d(Pcenter.XY()+rayon*gp_XY(-ydir,xdir));
199      par1sol(1)=ElCLib::Parameter(cirsol(1),pnttg1sol(1));
200      pararg1(1)=ElCLib::Parameter(Linetan,pnttg1sol(1));
201    }
202    else {
203      pnttg1sol(1) = gp_Pnt2d(Pcenter.XY()+rayon*gp_XY(ydir,-xdir));
204      par1sol(1)=ElCLib::Parameter(cirsol(1),pnttg1sol(1));
205      pararg1(1)=ElCLib::Parameter(Linetan,pnttg1sol(1));
206    }
207    NbrSol = 1;
208    WellDone = Standard_True;
209  }
210
211 //=========================================================================
212 //   Circle tangent to point Point1 and centered in a point Pcenter.      +
213 //   Calculate the distance from Pcenter to Point1 ==> Radius.                +
214 //   Create the circle with center Pcenter of radius Radius.                  +
215 //=========================================================================
216
217 GccAna_Circ2dTanCen::
218    GccAna_Circ2dTanCen (const gp_Pnt2d&            Point1     ,
219                         const gp_Pnt2d&            Pcenter    ):
220
221 //=========================================================================
222 //   Initialisation of fields.                                           +
223 //=========================================================================
224
225    cirsol(1,1)   ,
226    qualifier1(1,1),
227    TheSame1(1,1) ,
228    pnttg1sol(1,1),
229    par1sol(1,1)  ,
230    pararg1(1,1)  
231 {
232
233    gp_Dir2d dirx(1.0,0.0);
234    Standard_Real rayon = Point1.Distance(Pcenter);
235    cirsol(1) = gp_Circ2d(gp_Ax2d(Pcenter,dirx),rayon);
236 // =================================================
237    qualifier1(1) = GccEnt_noqualifier;
238    TheSame1(1) = 0;
239    pnttg1sol(1) = Point1;
240    par1sol(1)=ElCLib::Parameter(cirsol(1),pnttg1sol(1));
241    pararg1(1) = 0.0;
242    NbrSol = 1;
243    WellDone = Standard_True;
244  }
245
246 //=========================================================================
247
248 Standard_Boolean GccAna_Circ2dTanCen::
249    IsDone () const { return WellDone; }
250
251 Standard_Integer GccAna_Circ2dTanCen::
252    NbSolutions () const { return NbrSol; }
253
254 gp_Circ2d GccAna_Circ2dTanCen::
255    ThisSolution (const Standard_Integer Index) const 
256 {
257   if (Index > NbrSol || Index <= 0) { throw Standard_OutOfRange(); }
258   return cirsol(Index);
259 }
260
261 void GccAna_Circ2dTanCen::
262   WhichQualifier(const Standard_Integer Index   ,
263                        GccEnt_Position& Qualif1 ) const
264 {
265   if (!WellDone) { throw StdFail_NotDone(); }
266    else if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); }
267    else {
268      Qualif1 = qualifier1(Index);
269    }
270 }
271
272 void GccAna_Circ2dTanCen::
273    Tangency1 (const Standard_Integer Index,
274               Standard_Real& ParSol,
275               Standard_Real& ParArg,
276               gp_Pnt2d& PntSol) const{
277    if (!WellDone) { throw StdFail_NotDone(); }
278    else if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); }
279    else {
280      if (TheSame1(Index) == 0) {
281        PntSol = gp_Pnt2d(pnttg1sol(Index));
282        ParSol = par1sol(Index);
283        ParArg = pararg1(Index);
284      }
285      else { throw StdFail_NotDone(); }
286    }
287  }
288
289 Standard_Boolean GccAna_Circ2dTanCen::
290    IsTheSame1 (const Standard_Integer Index) const
291 {
292   if (!WellDone) 
293     throw StdFail_NotDone();
294   if (Index <= 0 ||Index > NbrSol) 
295     throw Standard_OutOfRange();
296  
297   if (TheSame1(Index) == 0) 
298     return Standard_False;
299
300   return Standard_True;
301 }