0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / Contap / Contap_SurfFunction.cxx
1 // Created on: 1993-06-03
2 // Created by: Jacques GOUSSARD
3 // Copyright (c) 1993-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 // jag 940616 Tolpetit = 1.e-16
18
19 #include <Adaptor3d_HSurface.hxx>
20 #include <Adaptor3d_HSurfaceTool.hxx>
21 #include <Contap_HContTool.hxx>
22 #include <Contap_SurfFunction.hxx>
23 #include <Contap_SurfProps.hxx>
24 #include <gp_Dir.hxx>
25 #include <gp_Dir2d.hxx>
26 #include <gp_Pnt.hxx>
27 #include <gp_Vec.hxx>
28 #include <math_Matrix.hxx>
29 #include <StdFail_UndefinedDerivative.hxx>
30
31 Contap_SurfFunction::Contap_SurfFunction ():
32   myMean(1.),
33   myType(Contap_ContourStd),
34   myDir(0.,0.,1.),
35   myAng(0.0),
36   myCosAng(0.), // PI/2 - Angle de depouille
37   tol(1.e-6),
38   valf(0.0),
39   Usol(0.0),
40   Vsol(0.0),
41   Fpu(0.0),
42   Fpv(0.0),
43   tangent(Standard_False),
44   computed(Standard_False),
45   derived(Standard_False)
46 {
47 }
48
49 void Contap_SurfFunction::Set(const Handle(Adaptor3d_HSurface)& S)
50 {
51   mySurf = S;
52   Standard_Integer i;
53   Standard_Integer nbs = Contap_HContTool::NbSamplePoints(S);
54   Standard_Real U,V;
55   gp_Vec norm;
56   if (nbs > 0) {
57     myMean = 0.;
58     for (i = 1; i <= nbs; i++) {
59       Contap_HContTool::SamplePoint(S,i,U,V);
60       //      Adaptor3d_HSurfaceTool::D1(S,U,V,solpt,d1u,d1v);
61       //      myMean = myMean + d1u.Crossed(d1v).Magnitude();
62       Contap_SurfProps::Normale(S,U,V,solpt,norm);
63       myMean = myMean + norm.Magnitude();
64     }
65     myMean = myMean / ((Standard_Real)nbs);
66   }
67   computed = Standard_False;
68   derived = Standard_False;
69 }
70
71
72 Standard_Integer Contap_SurfFunction::NbVariables () const
73 {
74   return 2;
75 }
76
77 Standard_Integer Contap_SurfFunction::NbEquations () const
78 {
79   return 1;
80 }
81
82
83 Standard_Boolean Contap_SurfFunction::Value(const math_Vector& X,
84                                             math_Vector& F)
85 {
86   Usol = X(1); Vsol = X(2);
87   //  Adaptor3d_HSurfaceTool::D1(mySurf,Usol,Vsol,solpt,d1u,d1v);
88   //  gp_Vec norm(d1u.Crossed(d1v));
89   gp_Vec norm;
90   Contap_SurfProps::Normale(mySurf,Usol,Vsol,solpt,norm);
91   switch (myType) {
92   case Contap_ContourStd:
93     {
94       F(1) = valf = (norm.Dot(myDir))/myMean;
95     }
96     break;
97   case Contap_ContourPrs:
98     {
99       F(1) = valf = (norm.Dot(gp_Vec(myEye,solpt)))/myMean;
100     }
101     break;
102   case Contap_DraftStd:
103     {
104       F(1) = valf = (norm.Dot(myDir)-myCosAng*norm.Magnitude())/myMean;
105     }
106     break;
107   default:
108     {
109     }
110   }
111   computed = Standard_False;
112   derived = Standard_False;
113   return Standard_True;
114 }
115
116
117 Standard_Boolean Contap_SurfFunction::Derivatives(const math_Vector& X,
118                                                   math_Matrix& Grad)
119 {
120   //  gp_Vec d2u,d2v,d2uv;
121   Usol = X(1); Vsol = X(2);
122   //  Adaptor3d_HSurfaceTool::D2(mySurf,Usol,Vsol,solpt,d1u,d1v,d2u,d2v,d2uv);
123
124   gp_Vec norm,dnu,dnv;
125   Contap_SurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv);
126
127   switch (myType) {
128   case Contap_ContourStd:
129     {
130       //      Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
131       //      Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
132       Grad(1,1) = (dnu.Dot(myDir))/myMean;
133       Grad(1,2) = (dnv.Dot(myDir))/myMean;
134     }
135     break;
136   case Contap_ContourPrs:
137     {
138       gp_Vec Ep(myEye,solpt);
139       Grad(1,1) = (dnu.Dot(Ep))/myMean;
140       Grad(1,2) = (dnv.Dot(Ep))/myMean;
141     }
142     break;
143   case Contap_DraftStd:
144     {
145       //      gp_Vec norm(d1u.Crossed(d1v).Normalized());
146       //      gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
147       //      Grad(1,1) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
148       //      dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
149       //      Grad(1,2) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
150       norm.Normalize();
151       Grad(1,1) = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
152       Grad(1,2) = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
153     }
154     break;
155   case Contap_DraftPrs:
156   default:
157     {
158     }
159   }
160   Fpu = Grad(1,1); Fpv = Grad(1,2);
161   computed = Standard_False;
162   derived = Standard_True;
163   return Standard_True;
164 }
165
166
167 Standard_Boolean Contap_SurfFunction::Values (const math_Vector& X,
168                                               math_Vector& F,
169                                               math_Matrix& Grad)
170 {
171   //  gp_Vec d2u,d2v,d2uv;
172
173   Usol = X(1); Vsol = X(2);
174   //  Adaptor3d_HSurfaceTool::D2(mySurf,Usol,Vsol,solpt,d1u,d1v,d2u,d2v,d2uv);
175   //  gp_Vec norm(d1u.Crossed(d1v));
176   gp_Vec norm,dnu,dnv;
177   Contap_SurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv);
178
179   switch (myType) {
180
181   case Contap_ContourStd:
182     {
183       F(1)      = (norm.Dot(myDir))/myMean;
184       //      Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
185       //      Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
186       Grad(1,1) = (dnu.Dot(myDir))/myMean;
187       Grad(1,2) = (dnv.Dot(myDir))/myMean;
188     }
189     break;
190   case Contap_ContourPrs:
191     {
192       gp_Vec Ep(myEye,solpt);
193       F(1)      = (norm.Dot(Ep))/myMean;
194       //      Grad(1,1) = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean;
195       //      Grad(1,2) = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean;
196       Grad(1,1) = (dnu.Dot(Ep))/myMean;
197       Grad(1,2) = (dnv.Dot(Ep))/myMean;
198     }
199     break;
200   case Contap_DraftStd:
201     {
202       F(1) = (norm.Dot(myDir)-myCosAng*norm.Magnitude())/myMean;
203       norm.Normalize();
204       /*
205       gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
206       Grad(1,1) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
207       dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
208       Grad(1,2) = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
209       */
210       Grad(1,1) = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
211       Grad(1,2) = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
212     }
213     break;
214   case Contap_DraftPrs:
215   default:
216     {
217     }
218   }
219   valf = F(1);
220   Fpu = Grad(1,1); Fpv = Grad(1,2);
221   computed = Standard_False;
222   derived = Standard_True;
223   return Standard_True;
224 }
225
226
227 Standard_Boolean Contap_SurfFunction::IsTangent ()
228 {
229   if (!computed) {
230     computed = Standard_True;
231     if(!derived) {
232       //      gp_Vec d2u,d2v,d2uv;
233       //      Adaptor3d_HSurfaceTool::D2(mySurf, Usol, Vsol, solpt, d1u, d1v, d2u, d2v, d2uv);
234       gp_Vec norm,dnu,dnv;
235       Contap_SurfProps::NormAndDn(mySurf,Usol,Vsol,solpt,norm,dnu,dnv);
236
237       switch (myType) {
238       case Contap_ContourStd:
239         {
240           //      Fpu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(myDir))/myMean;
241           //      Fpv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(myDir))/myMean;
242           Fpu = (dnu.Dot(myDir))/myMean;
243           Fpv = (dnv.Dot(myDir))/myMean;
244         }
245         break;
246       case Contap_ContourPrs:
247         {
248           gp_Vec Ep(myEye,solpt);
249           //      Fpu = ((d2u.Crossed(d1v) + d1u.Crossed(d2uv)).Dot(Ep))/myMean;
250           //      Fpv = ((d2uv.Crossed(d1v) + d1u.Crossed(d2v)).Dot(Ep))/myMean;
251           Fpu = (dnu.Dot(Ep))/myMean;
252           Fpv = (dnv.Dot(Ep))/myMean;
253         }
254         break;
255       case Contap_DraftStd:
256         {
257           /*
258           gp_Vec norm(d1u.Crossed(d1v).Normalized());
259           gp_Vec dnorm(d2u.Crossed(d1v) + d1u.Crossed(d2uv));
260           Fpu = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
261           dnorm = d2uv.Crossed(d1v) + d1u.Crossed(d2v);
262           Fpv = (dnorm.Dot(myDir)-myCosAng*dnorm.Dot(norm))/myMean;
263           */
264           norm.Normalize();
265           Fpu = (dnu.Dot(myDir)-myCosAng*dnu.Dot(norm))/myMean;
266           Fpv = (dnv.Dot(myDir)-myCosAng*dnv.Dot(norm))/myMean;
267         }
268         break;
269       case Contap_DraftPrs:
270       default:
271         {
272         }
273       }
274       derived = Standard_True;
275     }
276     tangent = Standard_False;
277     Standard_Real D = Sqrt (Fpu * Fpu + Fpv * Fpv);
278
279     if (D <= gp::Resolution()) {
280       tangent = Standard_True;
281     }
282     else {
283       d2d = gp_Dir2d(-Fpv,Fpu);
284       gp_Vec d1u,d1v;
285       Adaptor3d_HSurfaceTool::D1(mySurf, Usol, Vsol, solpt, d1u, d1v); // ajout jag 02.95
286
287       gp_XYZ d3dxyz(-Fpv*d1u.XYZ());
288       d3dxyz.Add(Fpu*d1v.XYZ());
289       d3d.SetXYZ(d3dxyz);
290
291       //jag 940616    if (d3d.Magnitude() <= Tolpetit) {
292       if (d3d.Magnitude() <= tol) {
293         tangent = Standard_True;
294       }
295     }
296   }
297   return tangent;
298 }