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