0031035: Coding - uninitialized class fields reported by Visual Studio Code Analysis
[occt.git] / src / Extrema / Extrema_GlobOptFuncCC.cxx
1 // Created on: 2014-01-20
2 // Created by: Alexaner Malyshev
3 // Copyright (c) 2014-2014 OPEN CASCADE SAS
4 //
5 // This file is part of Open CASCADE Technology software library.
6 //
7 // This library is free software; you can redistribute it and/or modify it under
8 // the terms of the GNU Lesser General Public License version 2.1 as published
9 // by the Free Software Foundation, with special exception defined in the file
10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
11 // distribution for complete text of the license and disclaimer of any warranty.
12 //
13 // Alternatively, this file may be used under the terms of Open CASCADE
14 // commercial license or contractual agreement
15
16 #include <Extrema_GlobOptFuncCC.hxx>
17
18 #include <gp_Pnt.hxx>
19 #include <gp_Pnt2d.hxx>
20 #include <gp_Vec.hxx>
21 #include <gp_Vec2d.hxx>
22 #include <math_Vector.hxx>
23 #include <Standard_Integer.hxx>
24 #include <Standard_OutOfRange.hxx>
25
26 static Standard_Integer _NbVariables()
27 {
28   return 2;
29 }
30
31 // 3d _Value
32 static Standard_Boolean _Value(const Adaptor3d_Curve& C1,
33                                const Adaptor3d_Curve& C2,
34                                const math_Vector& X,
35                                Standard_Real& F)
36 {
37   Standard_Real u = X(1);
38   Standard_Real v = X(2);
39
40   if (u < C1.FirstParameter() ||
41       u > C1.LastParameter()  ||
42       v < C2.FirstParameter() ||
43       v > C2.LastParameter())
44   {
45     return Standard_False;
46   }
47
48   F = C2.Value(v).Distance(C1.Value(u));
49   return Standard_True;
50 }
51
52 // 2d _Value
53 static Standard_Boolean _Value(const Adaptor2d_Curve2d& C1,
54                                const Adaptor2d_Curve2d& C2,
55                                const math_Vector& X,
56                                Standard_Real& F)
57 {
58   Standard_Real u = X(1);
59   Standard_Real v = X(2);
60
61   if (u < C1.FirstParameter() ||
62       u > C1.LastParameter()  ||
63       v < C2.FirstParameter() ||
64       v > C2.LastParameter())
65   {
66     return Standard_False;
67   }
68
69   F = C2.Value(v).Distance(C1.Value(u));
70   return Standard_True;
71 }
72
73 //! F = (x2(v) - x1(u))^2 + (y2(v) - y1(u))^2 + (z2(v) - z1(u))^2
74
75 // 3d _Gradient
76 static Standard_Boolean _Gradient(const Adaptor3d_Curve& C1,
77                                   const Adaptor3d_Curve& C2,
78                                   const math_Vector& X,
79                                   math_Vector& G)
80 {
81   gp_Pnt C1D0, C2D0;
82   gp_Vec C1D1, C2D1;
83
84   if(X(1) < C1.FirstParameter() ||
85      X(1) > C1.LastParameter()  ||
86      X(2) < C2.FirstParameter() ||
87      X(2) > C2.LastParameter())
88   {
89     return Standard_False;
90   }
91
92   C1.D1(X(1), C1D0, C1D1);
93   C2.D1(X(2), C2D0, C2D1);
94
95   G(1) = - (C2D0.X() - C1D0.X()) * C1D1.X() 
96          - (C2D0.Y() - C1D0.Y()) * C1D1.Y() 
97          - (C2D0.Z() - C1D0.Z()) * C1D1.Z();
98   G(2) =   (C2D0.X() - C1D0.X()) * C2D1.X() 
99          + (C2D0.Y() - C1D0.Y()) * C2D1.Y() 
100          + (C2D0.Z() - C1D0.Z()) * C2D1.Z();
101   return Standard_True;
102 }
103
104 // 2d _Graient
105 static Standard_Boolean _Gradient(const Adaptor2d_Curve2d& C1,
106                                   const Adaptor2d_Curve2d& C2,
107                                   const math_Vector& X,
108                                   math_Vector& G)
109 {
110   gp_Pnt2d C1D0, C2D0;
111   gp_Vec2d C1D1, C2D1;
112
113   if(X(1) < C1.FirstParameter() ||
114      X(1) > C1.LastParameter()  ||
115      X(2) < C2.FirstParameter() ||
116      X(2) > C2.LastParameter())
117   {
118     return Standard_False;
119   }
120
121   C1.D1(X(1), C1D0, C1D1);
122   C2.D1(X(2), C2D0, C2D1);
123
124   G(1) = - (C2D0.X() - C1D0.X()) * C1D1.X() 
125          - (C2D0.Y() - C1D0.Y()) * C1D1.Y();
126   G(2) =   (C2D0.X() - C1D0.X()) * C2D1.X() 
127          + (C2D0.Y() - C1D0.Y()) * C2D1.Y();
128   return Standard_True;
129 }
130
131 // 3d _Hessian
132 static Standard_Boolean _Hessian (const Adaptor3d_Curve& C1,
133                                   const Adaptor3d_Curve& C2,
134                                   const math_Vector& X,
135                                   math_Matrix & H)
136 {
137   gp_Pnt C1D0, C2D0;
138   gp_Vec C1D1, C2D1;
139   gp_Vec C1D2, C2D2;
140
141   if(X(1) < C1.FirstParameter() ||
142      X(1) > C1.LastParameter()  ||
143      X(2) < C2.FirstParameter() ||
144      X(2) > C2.LastParameter())
145   {
146     return Standard_False;
147   }
148
149   C1.D2(X(1), C1D0, C1D1, C1D2);
150   C2.D2(X(2), C2D0, C2D1, C2D2);
151
152   H(1, 1) =   C1D1.X() * C1D1.X() 
153             + C1D1.Y() * C1D1.Y() 
154             + C1D1.Z() * C1D1.Z() 
155             - (C2D0.X() - C1D0.X()) * C1D2.X() 
156             - (C2D0.Y() - C1D0.Y()) * C1D2.Y() 
157             - (C2D0.Z() - C1D0.Z()) * C1D2.Z();
158
159   H(1, 2) = - C2D1.X() * C1D1.X()
160             - C2D1.Y() * C1D1.Y()
161             - C2D1.Z() * C1D1.Z();
162
163   H(2,1) = H(1,2);
164
165   H(2,2) =   C2D1.X() * C2D1.X() 
166            + C2D1.Y() * C2D1.Y() 
167            + C2D1.Z() * C2D1.Z() 
168            + (C2D0.X() - C1D0.X()) * C2D2.X() 
169            + (C2D0.Y() - C1D0.Y()) * C2D2.Y() 
170            + (C2D0.Z() - C1D0.Z()) * C2D2.Z();
171   return Standard_True;
172 }
173
174 // 2d _Hessian
175 static Standard_Boolean _Hessian (const Adaptor2d_Curve2d& C1,
176                                   const Adaptor2d_Curve2d& C2,
177                                   const math_Vector& X,
178                                   math_Matrix & H)
179 {
180   gp_Pnt2d C1D0, C2D0;
181   gp_Vec2d C1D1, C2D1;
182   gp_Vec2d C1D2, C2D2;
183
184   if(X(1) < C1.FirstParameter() ||
185      X(1) > C1.LastParameter()  ||
186      X(2) < C2.FirstParameter() ||
187      X(2) > C2.LastParameter())
188   {
189     return Standard_False;
190   }
191
192   C1.D2(X(1), C1D0, C1D1, C1D2);
193   C2.D2(X(2), C2D0, C2D1, C2D2);
194
195   H(1, 1) =   C1D1.X() * C1D1.X() 
196             + C1D1.Y() * C1D1.Y() 
197             - (C2D0.X() - C1D0.X()) * C1D2.X() 
198             - (C2D0.Y() - C1D0.Y()) * C1D2.Y();
199
200   H(1, 2) = - C2D1.X() * C1D1.X()
201             - C2D1.Y() * C1D1.Y();
202
203   H(2,1) = H(1,2);
204
205   H(2,2) =   C2D1.X() * C2D1.X() 
206            + C2D1.Y() * C2D1.Y() 
207            + (C2D0.X() - C1D0.X()) * C2D2.X() 
208            + (C2D0.Y() - C1D0.Y()) * C2D2.Y();
209   return Standard_True;
210 }
211
212 // C0
213
214 //=======================================================================
215 //function : Extrema_GlobOptFuncCCC0
216 //purpose  : Constructor
217 //=======================================================================
218 Extrema_GlobOptFuncCCC0::Extrema_GlobOptFuncCCC0(const Adaptor3d_Curve& C1,
219                                                  const Adaptor3d_Curve& C2)
220 : myC1_3d(&C1),
221   myC2_3d(&C2),
222   myC1_2d(NULL),
223   myC2_2d(NULL)
224 {
225   myType = 1;
226 }
227
228 //=======================================================================
229 //function : Extrema_GlobOptFuncCCC0
230 //purpose  : Constructor
231 //=======================================================================
232 Extrema_GlobOptFuncCCC0::Extrema_GlobOptFuncCCC0(const Adaptor2d_Curve2d& C1,
233                                                  const Adaptor2d_Curve2d& C2)
234 : myC1_3d(NULL),
235   myC2_3d(NULL),
236   myC1_2d(&C1),
237   myC2_2d(&C2)
238 {
239   myType = 2;
240 }
241
242
243 //=======================================================================
244 //function : NbVariables
245 //purpose  :
246 //=======================================================================
247 Standard_Integer Extrema_GlobOptFuncCCC0::NbVariables() const
248 {
249   return _NbVariables();
250 }
251
252 //=======================================================================
253 //function : Value
254 //purpose  :
255 //=======================================================================
256 Standard_Boolean Extrema_GlobOptFuncCCC0::Value(const math_Vector& X,Standard_Real& F)
257 {
258   if (myType == 1)
259     return _Value(*myC1_3d, *myC2_3d, X, F);
260   else
261     return _Value(*myC1_2d, *myC2_2d, X, F);
262 }
263
264 // C1
265
266 //=======================================================================
267 //function : Extrema_GlobOptFuncCCC1
268 //purpose  : Constructor
269 //=======================================================================
270 Extrema_GlobOptFuncCCC1::Extrema_GlobOptFuncCCC1(const Adaptor3d_Curve& C1,
271                                                  const Adaptor3d_Curve& C2)
272 : myC1_3d(&C1),
273   myC2_3d(&C2),
274   myC1_2d(NULL),
275   myC2_2d(NULL)
276 {
277   myType = 1;
278 }
279
280 //=======================================================================
281 //function : Extrema_GlobOptFuncCCC1
282 //purpose  : Constructor
283 //=======================================================================
284 Extrema_GlobOptFuncCCC1::Extrema_GlobOptFuncCCC1(const Adaptor2d_Curve2d& C1,
285                                                  const Adaptor2d_Curve2d& C2)
286 : myC1_3d(NULL),
287   myC2_3d(NULL),
288   myC1_2d(&C1),
289   myC2_2d(&C2)
290 {
291   myType = 2;
292 }
293
294 //=======================================================================
295 //function : NbVariables
296 //purpose  :
297 //=======================================================================
298 Standard_Integer Extrema_GlobOptFuncCCC1::NbVariables() const
299 {
300   return _NbVariables();
301 }
302
303 //=======================================================================
304 //function : Value
305 //purpose  :
306 //=======================================================================
307 Standard_Boolean Extrema_GlobOptFuncCCC1::Value(const math_Vector& X,Standard_Real& F)
308 {
309   if (myType == 1)
310     return _Value(*myC1_3d, *myC2_3d, X, F);
311   else
312     return _Value(*myC1_2d, *myC2_2d, X, F);
313 }
314
315 //=======================================================================
316 //function : Gradient
317 //purpose  :
318 //=======================================================================
319 Standard_Boolean Extrema_GlobOptFuncCCC1::Gradient(const math_Vector& X,math_Vector& G)
320 {
321   if (myType == 1)
322     return _Gradient(*myC1_3d, *myC2_3d, X, G);
323   else
324     return _Gradient(*myC1_2d, *myC2_2d, X, G);
325 }
326
327 //=======================================================================
328 //function : Values
329 //purpose  :
330 //=======================================================================
331 Standard_Boolean Extrema_GlobOptFuncCCC1::Values(const math_Vector& X,Standard_Real& F,math_Vector& G)
332 {
333   return (Value(X, F) && Gradient(X, G));
334 }
335
336 // C2
337
338 //=======================================================================
339 //function : Extrema_GlobOptFuncCCC2
340 //purpose  : Constructor
341 //=======================================================================
342 Extrema_GlobOptFuncCCC2::Extrema_GlobOptFuncCCC2(const Adaptor3d_Curve& C1,
343                                                  const Adaptor3d_Curve& C2)
344 : myC1_3d(&C1),
345   myC2_3d(&C2),
346   myC1_2d(NULL),
347   myC2_2d(NULL)
348 {
349   myType = 1;
350 }
351
352 //=======================================================================
353 //function : Extrema_GlobOptFuncCCC2
354 //purpose  : Constructor
355 //=======================================================================
356 Extrema_GlobOptFuncCCC2::Extrema_GlobOptFuncCCC2(const Adaptor2d_Curve2d& C1,
357                                                  const Adaptor2d_Curve2d& C2)
358 : myC1_3d(NULL),
359   myC2_3d(NULL),
360   myC1_2d(&C1),
361   myC2_2d(&C2)
362 {
363   myType = 2;
364 }
365
366 //=======================================================================
367 //function : NbVariables
368 //purpose  :
369 //=======================================================================
370 Standard_Integer Extrema_GlobOptFuncCCC2::NbVariables() const
371 {
372   return _NbVariables();
373 }
374
375 //=======================================================================
376 //function : Value
377 //purpose  :
378 //=======================================================================
379 Standard_Boolean Extrema_GlobOptFuncCCC2::Value(const math_Vector& X,Standard_Real& F)
380 {
381   if (myType == 1)
382     return _Value(*myC1_3d, *myC2_3d, X, F);
383   else
384     return _Value(*myC1_2d, *myC2_2d, X, F);
385 }
386
387 //=======================================================================
388 //function : Gradient
389 //purpose  :
390 //=======================================================================
391 Standard_Boolean Extrema_GlobOptFuncCCC2::Gradient(const math_Vector& X,math_Vector& G)
392 {
393   if (myType == 1)
394     return _Gradient(*myC1_3d, *myC2_3d, X, G);
395   else
396     return _Gradient(*myC1_2d, *myC2_2d, X, G);
397 }
398
399 //=======================================================================
400 //function : Values
401 //purpose  :
402 //=======================================================================
403 Standard_Boolean Extrema_GlobOptFuncCCC2::Values(const math_Vector& X,Standard_Real& F,math_Vector& G)
404 {
405   return  (Value(X, F) && Gradient(X, G));
406 }
407
408 //=======================================================================
409 //function : Values
410 //purpose  :
411 //=======================================================================
412 Standard_Boolean Extrema_GlobOptFuncCCC2::Values(const math_Vector& X,Standard_Real& F,math_Vector& G,math_Matrix& H)
413 {
414   Standard_Boolean isHessianComputed = Standard_False;
415   if (myType == 1)
416     isHessianComputed = _Hessian(*myC1_3d, *myC2_3d, X, H);
417   else
418     isHessianComputed = _Hessian(*myC1_2d, *myC2_2d, X, H);
419
420
421   return (Value(X, F) && Gradient(X, G) && isHessianComputed);
422 }