0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / Geom2dGcc / Geom2dGcc_Lin2dTanObl.cxx
1 // Created on: 1992-10-21
2 // Created by: Remi GILET
3 // Copyright (c) 1992-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 #include <GccAna_Lin2dTanObl.hxx>
19 #include <GccEnt_BadQualifier.hxx>
20 #include <GccEnt_QualifiedCirc.hxx>
21 #include <Geom2d_Circle.hxx>
22 #include <Geom2dAdaptor_Curve.hxx>
23 #include <Geom2dGcc_CurveTool.hxx>
24 #include <Geom2dGcc_IsParallel.hxx>
25 #include <Geom2dGcc_Lin2dTanObl.hxx>
26 #include <Geom2dGcc_Lin2dTanOblIter.hxx>
27 #include <Geom2dGcc_QCurve.hxx>
28 #include <Geom2dGcc_QualifiedCurve.hxx>
29 #include <gp_Lin2d.hxx>
30 #include <gp_Pnt2d.hxx>
31 #include <Standard_NegativeValue.hxx>
32 #include <Standard_OutOfRange.hxx>
33 #include <StdFail_NotDone.hxx>
34
35 Geom2dGcc_Lin2dTanObl::
36    Geom2dGcc_Lin2dTanObl (const Geom2dGcc_QualifiedCurve& Qualified1 ,
37                           const gp_Lin2d&                 TheLine    ,
38                           const Standard_Real             TolAng     ,
39                           const Standard_Real             Angle      ):
40   Paral2(Standard_False),
41   linsol(1,2)    ,
42   qualifier1(1,2),
43   pnttg1sol(1,2) ,
44   pntint2sol(1,2),
45   par1sol(1,2)   ,
46   par2sol(1,2)   ,
47   pararg1(1,2)   ,
48   pararg2(1,2)
49 {
50   Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
51   Handle(Geom2d_Curve) CC1 = C1.Curve();
52   GeomAbs_CurveType Type1 = C1.GetType();
53
54 //=============================================================================
55 //                            Appel a GccAna.                                 +
56 //=============================================================================
57
58   WellDone = Standard_False;
59   NbrSol = 0;
60   if (Type1 == GeomAbs_Circle ) {
61     Handle(Geom2d_Circle) CCC1 = Handle(Geom2d_Circle)::DownCast(CC1);
62     gp_Circ2d c1(CCC1->Circ2d());
63     GccEnt_QualifiedCirc Qc1=GccEnt_QualifiedCirc(c1,Qualified1.Qualifier());
64     GccAna_Lin2dTanObl Lin(Qc1,TheLine,Angle);
65     WellDone = Lin.IsDone();
66     if(WellDone) { 
67       NbrSol = Lin.NbSolutions();
68       for (Standard_Integer i = 1 ; i <= NbrSol ; i++) {
69         linsol(i)    = Lin.ThisSolution(i);
70         Lin.Tangency1(i,par1sol(i),pararg1(i),pnttg1sol(i));
71         Lin.Intersection2(i,par2sol(i),pararg2(i),pntint2sol(i));
72         Lin.WhichQualifier(i,qualifier1(i));
73       }
74     }
75   }
76   else {
77     Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
78     Standard_Real      aFirstPar  = Geom2dGcc_CurveTool::FirstParameter(C1);
79     Standard_Real      aLastPar   = Geom2dGcc_CurveTool::LastParameter(C1);
80     Standard_Integer   aNbSamples = Geom2dGcc_CurveTool::NbSamples(C1);
81     Standard_Real      aStep      = (aLastPar - aFirstPar)/aNbSamples;
82     Standard_Real      Param1     = aFirstPar;
83     Standard_Integer   i;
84     
85     for (i = 0; i <= aNbSamples && NbrSol < 2; i++) {
86       Geom2dGcc_Lin2dTanOblIter Lin(Qc1,TheLine,Param1,TolAng,Angle);
87
88       if (Lin.IsDone()) {
89         if (Add(NbrSol + 1, Lin, TolAng, C1))
90           NbrSol++;
91       }
92
93       Param1 += aStep;
94     }
95
96     WellDone = (NbrSol > 0);
97   }
98 }
99
100 Geom2dGcc_Lin2dTanObl::
101    Geom2dGcc_Lin2dTanObl (const Geom2dGcc_QualifiedCurve& Qualified1 ,
102                           const gp_Lin2d&                 TheLine    ,
103                           const Standard_Real             TolAng     ,
104                           const Standard_Real             Param1     ,
105                           const Standard_Real             Angle      ):
106   Paral2(Standard_False),
107   linsol(1,2)    ,
108   qualifier1(1,2),
109   pnttg1sol(1,2) ,
110   pntint2sol(1,2),
111   par1sol(1,2)   ,
112   par2sol(1,2)   ,
113   pararg1(1,2)   ,
114   pararg2(1,2)
115 {
116   Geom2dAdaptor_Curve C1 = Qualified1.Qualified();
117   Handle(Geom2d_Curve) CC1 = C1.Curve();
118   GeomAbs_CurveType Type1 = C1.GetType();
119
120 //=============================================================================
121 //                            Appel a GccAna.                                 +
122 //=============================================================================
123
124   WellDone = Standard_False;
125   NbrSol = 0;
126   if (Type1 == GeomAbs_Circle ) {
127     Handle(Geom2d_Circle) CCC1 = Handle(Geom2d_Circle)::DownCast(CC1);
128     gp_Circ2d c1(CCC1->Circ2d());
129     GccEnt_QualifiedCirc Qc1=GccEnt_QualifiedCirc(c1,Qualified1.Qualifier());
130     GccAna_Lin2dTanObl Lin(Qc1,TheLine,Angle);
131     WellDone = Lin.IsDone();
132     if(WellDone) { 
133       NbrSol = Lin.NbSolutions();
134       for (Standard_Integer i = 1 ; i <= NbrSol ; i++) {
135         linsol(i)    = Lin.ThisSolution(i);
136         Lin.Tangency1(i,par1sol(i),pararg1(i),pnttg1sol(i));
137         Lin.Intersection2(i,par2sol(i),pararg2(i),pntint2sol(i));
138         Lin.WhichQualifier(i,qualifier1(i));
139       }
140     }
141   }
142   else {
143     Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
144     Geom2dGcc_Lin2dTanOblIter Lin(Qc1,TheLine,TolAng,Param1,Angle);
145     WellDone = Lin.IsDone();
146     if(WellDone) { 
147       linsol(1)    = Lin.ThisSolution();
148       Lin.Tangency1(par1sol(1),pararg1(1),pnttg1sol(1));
149       Lin.Intersection2(par2sol(1),pararg2(1),pntint2sol(1));
150       Lin.WhichQualifier(qualifier1(1));
151     }
152   }
153 }
154
155 Standard_Boolean Geom2dGcc_Lin2dTanObl::
156    IsDone () const { return WellDone; }
157
158 Standard_Integer Geom2dGcc_Lin2dTanObl::
159    NbSolutions () const { return NbrSol; }
160
161 gp_Lin2d Geom2dGcc_Lin2dTanObl::
162    ThisSolution (const Standard_Integer Index) const {
163
164    if (Index > NbrSol || Index <= 0) { throw Standard_OutOfRange(); }
165    return linsol(Index);
166  }
167
168 void Geom2dGcc_Lin2dTanObl::
169    WhichQualifier (const Standard_Integer Index,
170                          GccEnt_Position& Qualif1) const
171 {
172   if (!WellDone) { throw StdFail_NotDone(); }
173   else if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); }
174   else { Qualif1 = qualifier1(Index);   }
175 }
176
177 void Geom2dGcc_Lin2dTanObl::
178    Tangency1 (const Standard_Integer Index,
179               Standard_Real& ParSol,
180               Standard_Real& ParArg,
181               gp_Pnt2d& PntSol) const {
182    if (!WellDone) { throw StdFail_NotDone(); }
183    else if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); }
184    else {
185      ParSol = par1sol(Index);
186      ParArg = pararg1(Index);
187      PntSol = pnttg1sol(Index);
188    }
189  }
190
191 void Geom2dGcc_Lin2dTanObl::
192    Intersection2 (const Standard_Integer   Index  ,
193                     Standard_Real&     ParSol ,
194                     Standard_Real&     ParArg ,
195                     gp_Pnt2d& PntSol ) const {
196    if (!WellDone) { throw StdFail_NotDone(); }
197    else if (Index <= 0 ||Index > NbrSol) { throw Standard_OutOfRange(); }
198    else {
199      ParSol = par2sol(Index);
200      ParArg = pararg2(Index);
201      PntSol = pntint2sol(Index);
202    }
203  }
204
205 Standard_Boolean Geom2dGcc_Lin2dTanObl::Add
206                            (const Standard_Integer       theIndex,
207                             const Geom2dGcc_Lin2dTanOblIter &theLin,
208                             const Standard_Real          theTol,
209                             const Geom2dAdaptor_Curve   &theC1)
210 {
211   Standard_Integer i;
212   Standard_Real    aPar1sol;
213   Standard_Real    aPar2sol;
214   Standard_Real    aPar1arg;
215   Standard_Real    aPar2arg;
216   gp_Pnt2d         aPnt1Sol;
217   gp_Pnt2d         aPnt2Sol;
218   gp_Lin2d         aLin   = theLin.ThisSolution();
219
220   theLin.Tangency1(aPar1sol, aPar1arg, aPnt1Sol);
221   theLin.Intersection2(aPar2sol, aPar2arg, aPnt2Sol);
222
223   for(i = 1; i < theIndex; i++) {
224     if (Abs(aPar1arg - pararg1(i)) <= theTol &&
225         Abs(aPar2arg - pararg2(i)) <= theTol)
226       return Standard_False;
227   }
228
229   gp_Dir2d aLinDir = aLin.Direction();
230   gp_Vec2d aVTan;
231   gp_Pnt2d aPoint;
232
233   Geom2dGcc_CurveTool::D1(theC1, aPar1arg, aPoint, aVTan);
234
235   if (Abs(aLinDir.Crossed(gp_Dir2d(aVTan))) > theTol)
236     return Standard_False;
237
238   linsol(theIndex)     = aLin;
239   par1sol(theIndex)    = aPar1sol;
240   pararg1(theIndex)    = aPar1arg;
241   pnttg1sol(theIndex)  = aPnt1Sol;
242   par2sol(theIndex)    = aPar2sol;
243   pararg2(theIndex)    = aPar2arg;
244   pntint2sol(theIndex) = aPnt2Sol;
245
246   theLin.WhichQualifier(qualifier1(theIndex));
247
248   return Standard_True;
249 }