0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / IntAna2d / IntAna2d_Outils.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 //======================================================= IntAna2d_Outils.cxx
17 //============================================================================
18 #include <IntAna2d_Outils.hxx>
19 #include <math_DirectPolynomialRoots.hxx>
20
21 MyDirectPolynomialRoots::MyDirectPolynomialRoots(const Standard_Real A4,
22                                                  const Standard_Real A3,
23                                                  const Standard_Real A2,
24                                                  const Standard_Real A1,
25                                                  const Standard_Real A0) { 
26   //-- std::cout<<" IntAna2d : A4..A0 "<<A4<<" "<<A3<<" "<<A2<<" "<<A1<<" "<<A0<<" "<<std::endl;
27   nbsol = 0;
28   same = Standard_False;
29 //  Modified by Sergey KHROMOV - Thu Oct 24 13:10:14 2002 Begin
30   Standard_Real anAA[5];
31
32   anAA[0] = Abs(A0);
33   anAA[1] = Abs(A1);
34   anAA[2] = Abs(A2);
35   anAA[3] = Abs(A3);
36   anAA[4] = Abs(A4);
37
38 //   if((Abs(A4)+Abs(A3)+Abs(A2)+Abs(A1)+Abs(A0))<Epsilon(10000.0))  { 
39   if((anAA[0]+anAA[1]+anAA[2]+anAA[3]+anAA[4])<Epsilon(10000.0))  { 
40 //  Modified by Sergey KHROMOV - Thu Oct 24 13:10:15 2002 End
41     same = Standard_True;
42     return;
43   }
44   Standard_Integer i,j,nbp;
45   for (size_t anIdx = 0; anIdx < sizeof (val) / sizeof (val[0]); anIdx++)
46   {
47     val[anIdx] = RealLast();
48     sol[anIdx] = RealLast();
49   }
50   
51   Standard_Real tol = Epsilon(100.0);
52   math_DirectPolynomialRoots MATH_A43210(A4,A3,A2,A1,A0);
53   Standard_Boolean PbPossible = Standard_False;
54   Standard_Integer NbsolPolyComplet = 0;
55   if(MATH_A43210.IsDone()) { 
56     nbp = MATH_A43210.NbSolutions();
57     NbsolPolyComplet = nbp;
58     for(i=1;i<=nbp;i++) { 
59       Standard_Real x = MATH_A43210.Value(i);
60       //-- std::cout<<" IntAna2d : x Pol Complet :"<<x<<std::endl;
61       val[nbsol] = A0 + x*(A1+x*(A2+x*(A3+x*A4)));
62       sol[nbsol] = x;
63       if(val[nbsol]> tol  ||  val[nbsol]<-tol) {
64         PbPossible = Standard_True;
65       }
66       nbsol++;
67     }
68     if(nbp & 1) 
69       PbPossible = Standard_True;
70   }
71   else { 
72     PbPossible = Standard_True;
73   }
74   //-- On recherche le plus petit coeff entre A4 et A0 
75   if(PbPossible) { 
76 //  Modified by Sergey KHROMOV - Thu Oct 24 12:45:35 2002 Begin
77     Standard_Real anAMin = RealLast();
78     Standard_Real anAMax = -1;
79     Standard_Real anEps  = RealEpsilon();
80
81     for (i = 0; i < 5; i++) {
82       anAMin = Min(anAMin, Max(anAA[i], anEps));
83       anAMax = Max(anAMax, Max(anAA[i], anEps));
84     }
85
86     anEps = Min(1.e-4, Epsilon(1000.*anAMax/anAMin));
87 //  Modified by Sergey KHROMOV - Thu Oct 24 15:46:24 2002 End
88     math_DirectPolynomialRoots MATH_A4321(A4,A3,A2,A1);
89     if(MATH_A4321.IsDone()) { 
90       nbp = MATH_A4321.NbSolutions();
91       //-- On Ajoute les valeurs au tableau 
92       for(i=1;i<=nbp;i++) { 
93         Standard_Real x = MATH_A4321.Value(i);
94         Standard_Boolean Add = Standard_True;
95         for(j=0;j<nbsol;j++) { 
96           Standard_Real t = sol[j]-x;
97 //  Modified by Sergey KHROMOV - Thu Oct 24 12:04:26 2002 Begin
98 //        if(Abs(t)<tol) { 
99           if(Abs(t) < anEps) { 
100 //  Modified by Sergey KHROMOV - Thu Oct 24 12:04:47 2002 End
101             Add = Standard_False;
102           }
103         }
104         if(Add) {
105           val[nbsol] =  A0 + x*(A1+x*(A2+x*(A3+x*A4)));
106           sol[nbsol] = x;
107           nbsol++;
108         }
109       }
110     }
111     math_DirectPolynomialRoots MATH_A3210(A3,A2,A1,A0);
112     if(MATH_A3210.IsDone()) { 
113       nbp = MATH_A3210.NbSolutions();
114       //-- On Ajoute les valeurs au tableau 
115       for(i=1;i<=nbp;i++) { 
116         Standard_Real x = MATH_A3210.Value(i);
117         Standard_Boolean Add = Standard_True;
118         for(j=0;j<nbsol;j++) { 
119           Standard_Real t = sol[j]-x;
120 //  Modified by Sergey KHROMOV - Thu Oct 24 12:06:01 2002 Begin
121 //        if(Abs(t)<tol) { 
122           if(Abs(t) < anEps) { 
123 //  Modified by Sergey KHROMOV - Thu Oct 24 12:06:04 2002 End
124             Add = Standard_False;
125           }
126         }
127         if(Add) { 
128           val[nbsol] =  A0 + x*(A1+x*(A2+x*(A3+x*A4)));
129           sol[nbsol] = x;
130           nbsol++;
131         }
132       }
133     }
134     math_DirectPolynomialRoots MATH_A210(A3,A2,A1);
135     if(MATH_A210.IsDone()) { 
136       nbp = MATH_A210.NbSolutions();
137       //-- On Ajoute les valeurs au tableau 
138       for(i=1;i<=nbp;i++) { 
139         Standard_Real x = MATH_A210.Value(i);
140         Standard_Boolean Add = Standard_True;
141         for(j=0;j<nbsol;j++) { 
142           Standard_Real t = sol[j]-x;
143 //  Modified by Sergey KHROMOV - Thu Oct 24 12:07:04 2002 Begin
144 //        if(Abs(t)<tol) { 
145           if(Abs(t) < anEps) { 
146 //  Modified by Sergey KHROMOV - Thu Oct 24 12:07:06 2002 End
147             Add = Standard_False;
148           }
149         }
150         if(Add) {
151           val[nbsol] =  A0 + x*(A1+x*(A2+x*(A3+x*A4)));
152           sol[nbsol] = x;
153           nbsol++;
154         }
155       }
156     }
157     //------------------------------------------------------------
158     //-- On trie les valeurs par ordre decroissant de val
159     //-- for(i=0;i<nbsol;i++) { 
160     //--  std::cout<<" IntAna2d Sol,Val"<<sol[i]<<"  "<<val[i]<<std::endl;
161     //-- }
162     Standard_Boolean TriOK = Standard_False;
163     do {
164       TriOK = Standard_True;
165       for(i=1; i<nbsol;i++) { 
166         if(Abs(val[i])<Abs(val[i-1])) { 
167           Standard_Real t;
168           t        = val[i];
169           val[i]   = val[i-1];
170           val[i-1] = t;
171           t        = sol[i];
172           sol[i]   = sol[i-1];
173           sol[i-1] = t;
174           TriOK = Standard_False;
175         }
176       }
177     }
178     while(!TriOK);
179     //-----------------------------------------------------------
180     //-- On garde les premieres valeurs
181     //-- Au moins autant que le polynome Complet 
182     //-- 
183     for(nbsol=0; nbsol<NbsolPolyComplet || Abs(val[nbsol])<Epsilon(10000.0); nbsol++) ;
184     //-- std::cout<<" IntAna2d : nbsol:"<<nbsol<<std::endl;
185   }
186   if(nbsol==0) { 
187     nbsol=-1;
188   }
189   if(nbsol>4) { 
190     same=1;
191     nbsol=0;
192   }
193 }
194
195
196 MyDirectPolynomialRoots::MyDirectPolynomialRoots(const Standard_Real A2,
197                                                  const Standard_Real A1,
198                                                  const Standard_Real A0) { 
199   //-- std::cout<<" IntAna2d : A2..A0 "<<A2<<" "<<A1<<" "<<A0<<" "<<std::endl;
200   for (size_t anIdx = 0; anIdx < sizeof (val) / sizeof (val[0]); anIdx++)
201   {
202     val[anIdx] = RealLast();
203     sol[anIdx] = RealLast();
204   }
205   nbsol=0;
206   if((Abs(A2)+Abs(A1)+Abs(A0))<Epsilon(10000.0))  { 
207     same = Standard_True;
208     return;
209   }  
210   math_DirectPolynomialRoots MATH_A210(A2,A1,A0);
211   same = Standard_False;
212   if(MATH_A210.IsDone()) { 
213     for(Standard_Integer i=1;i<=MATH_A210.NbSolutions(); i++) { 
214       Standard_Real x = MATH_A210.Value(i);
215       val[nbsol] = A0 + x*(A1+x*A2);
216       sol[nbsol] = x;
217       //-- std::cout<<" IntAna2d : x Pol Complet :"<<x<<"  Val:"<<val[nbsol]<<std::endl;
218       nbsol++;
219     }
220   }
221   else { 
222     nbsol = -1;
223   }
224 }
225
226 Standard_Boolean Points_Confondus(const Standard_Real x1,const Standard_Real y1
227                                   ,const Standard_Real x2,const Standard_Real y2) {
228   if(Abs(x1-x2)<Epsilon(x1)) {
229     if(Abs(y1-y2)<Epsilon(y1)) {
230       return(Standard_True);
231     }
232   }
233   return(Standard_False);
234 }
235
236 //-----------------------------------------------------------------------------
237 //--- Les points confondus sont supprimes
238 //--- Le nombre de points est mis a jour
239
240 void Traitement_Points_Confondus(Standard_Integer& nb_pts,
241                                  IntAna2d_IntPoint* pts) {
242   Standard_Integer i,j;
243   for(i=nb_pts;i>1;i--) {  
244     Standard_Boolean Non_Egalite=Standard_True;
245     for(j=i-1;(j>0) && Non_Egalite;j--) { 
246       //                                        <--- Deja Teste --->
247       //             | 1  |2  |  | J |  |I-1| I |I+1|          |NPTS|
248       //             | 1  |2  |  | J |  |I-1|XXX|I+1|          |NPTS|
249       //             | 1  |2  |  | J |  |I-1|I+1|I+2|     |NPTS|
250       if(Points_Confondus(pts[i-1].Value().X(),
251                           pts[i-1].Value().Y(),
252                           pts[j-1].Value().X(),
253                           pts[j-1].Value().Y())) {
254         Standard_Integer k;
255         Non_Egalite=Standard_False;
256         for(k=i;k<nb_pts;k++) {
257           Standard_Real Xk,Yk,Uk;
258           Xk=pts[k].Value().X();
259           Yk=pts[k].Value().Y();
260           Uk=pts[k].ParamOnFirst();
261           pts[k-1].SetValue(Xk,Yk,Uk);
262         }
263         nb_pts--;
264       }
265     }
266   }
267 }
268
269 //-----------------------------------------------------------------------------
270 void Coord_Ancien_Repere(Standard_Real& x1,Standard_Real& y1,const gp_Ax2d Dir1) {
271   Standard_Real t11,t12,t21,t22,t13,t23;
272   Standard_Real x0,y0;  
273
274   // x1 et y1 Sont les Coordonnees dans le repere lie a Dir1
275   // On Renvoie ces Coordonnees dans le repere "absolu"
276
277   Dir1.Direction().Coord(t11,t21);
278   Dir1.Location().Coord(t13,t23);
279
280   t22=t11;
281   t12=-t21;
282
283   x0= t11*x1 + t12*y1 + t13;
284   y0= t21*x1 + t22*y1 + t23;
285
286   x1=x0;
287   y1=y0;
288 }
289
290
291
292 #if 0      
293
294 //-- A Placer dans les ressources de la classe Conic   ??
295 //-----------------------------------------------------------------------------
296 //--- Calcul des Coefficients A,..F dans le repere lie a  Dir1
297 //--- A Partir des Coefficients dans le repere "Absolu"
298
299 void Coeff_Nouveau_Repere(Standard_Real& A,Standard_Real& B,Standard_Real& C
300                           ,Standard_Real& D,Standard_Real& E,Standard_Real& F
301                           ,const gp_Ax2d Dir1)  {
302   Standard_Real t11,t12,t13;                  // x = t11 X + t12 Y + t13
303   Standard_Real t21,t22,t23;                  // y = t21 X + t22 Y + t23
304   Standard_Real A1,B1,C1,D1,E1,F1;            
305
306   // On a P0(x,y)=A x x + B y y + ... + F =0    (x et y ds le repere "Absolu")
307   // et on cherche P1(X(x,y),Y(x,y))=P0(x,y)
308   // Avec P1(X,Y)= A1 X X + B1 Y Y + 2 C1 X Y + 2 D1 X + 2 E1 Y + F1
309   //             = A  x x + B  y y + 2 C  x y + 2 D  x + 2 E  y + f
310
311   Dir1.Direction().Coord(t11,t21);
312   Dir1.Location().Coord(t13,t23);
313
314   t22=t11;
315   t12=-t21;
316
317   A1=(t11*(A*t11 + 2*C*t21) + B*t21*t21);
318   B1=(t12*(A*t12 + 2*C*t22) + B*t22*t22);
319   C1=(t12*(A*t11 + C*t21) + t22*(C*t11 + B*t21));
320   D1=(t11*(D + A*t13) + t21*(E + C*t13) + t23*(C*t11 + B*t21));
321   E1=(t12*(D + A*t13) + t22*(E + C*t13) + t23*(C*t12 + B*t22));
322   F1=F + t13*(2.0*D + A*t13) + t23*(2.0*E + 2.0*C*t13 + B*t23);
323   
324   A=A1; B=B1; C=C1; D=D1; E=E1; F=F1;
325 }
326 #endif
327
328
329
330
331
332
333
334
335
336