0024750: Replace instantiations of TCollection generic classes by NCollection templat...
[occt.git] / src / GProp / GProp_SelGProps.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 #include <GProp_SelGProps.ixx>
16 #include <Standard_NotImplemented.hxx>
17 #include <math_Matrix.hxx>
18 #include <math_Vector.hxx>
19 #include <math_Jacobi.hxx>
20 #include <GProp.hxx>
21
22 GProp_SelGProps::GProp_SelGProps(){};
23
24 void GProp_SelGProps::SetLocation(const gp_Pnt& SLocation )
25 {
26   loc = SLocation;
27 }
28
29
30 void GProp_SelGProps::Perform(const gp_Cylinder& S, 
31                               const Standard_Real         Alpha1,
32                               const Standard_Real         Alpha2, 
33                               const Standard_Real         Z1,
34                               const Standard_Real         Z2)
35  {
36   Standard_Real X0,Y0,Z0,Xa1,Ya1,Za1,Xa2,Ya2,Za2,Xa3,Ya3,Za3;
37   S.Location().Coord(X0,Y0,Z0);
38   Standard_Real R = S.Radius();
39   S.Position().XDirection().Coord(Xa1,Ya1,Za1);
40   S.Position().YDirection().Coord(Xa2,Ya2,Za2);
41   S.Position().Direction().Coord(Xa3,Ya3,Za3);
42   dim = R*(Z2-Z1)*(Alpha2-Alpha1);
43   Standard_Real SA2 = Sin(Alpha2);
44   Standard_Real SA1 = Sin(Alpha1);
45   Standard_Real CA2 = Cos(Alpha2);
46   Standard_Real CA1 = Cos(Alpha1);
47   Standard_Real Ix = R*(SA2-SA1)/(Alpha2-Alpha1);
48   Standard_Real Iy = R*(CA1-CA2)/(Alpha2-Alpha1);
49   g.SetCoord( X0 + Ix*Xa1+Iy*Xa2 + Xa3*(Z2+Z1)/2.,
50               Y0 + Ix*Ya1+Iy*Ya2 + Ya3*(Z2+Z1)/2.,
51               Z0 + Ix*Za1+Iy*Za2 + Za3*(Z2+Z1)/2.);
52   Standard_Real ICn2 =R*R*( Alpha2-Alpha1 + SA2*CA2 - SA1*CA1 )/2.;  
53   Standard_Real ISn2 =R*R*( Alpha2-Alpha1 - SA2*CA2 + SA1*CA1 )/2.;  
54   Standard_Real IZ2 = (Alpha2-Alpha1)*(Z2*Z2+Z2*Z1+Z1*Z1)/3.;
55   Standard_Real ICnSn= R*R*( SA2*SA2-SA1*SA1)/2.;
56   Standard_Real ICnz = (Z2+Z1)*(SA2-SA1)/2.;
57   Standard_Real ISnz = (Z2+Z1)*(CA1-CA2)/2.;
58
59   math_Matrix Dm(1,3,1,3);
60
61   Dm(1,1) = ISn2 + IZ2;
62   Dm(2,2) = ICn2 + IZ2;
63   Dm(3,3) = Alpha2-Alpha1;
64   Dm(1,2) = Dm(2,1) = -ICnSn;
65   Dm(1,3) = Dm(3,1) = -ICnz;
66   Dm(3,2) = Dm(2,3) = -ISnz;
67
68   math_Matrix Passage (1,3,1,3);
69   Passage(1,1) = Xa1; Passage(1,2) = Xa2 ;Passage(1,3) = Xa3;
70   Passage(2,1) = Ya1; Passage(2,2) = Ya2 ;Passage(2,3) = Ya3;
71   Passage(3,1) = Za1; Passage(3,2) = Za2 ;Passage(3,3) = Za3;
72
73   math_Jacobi J(Dm);
74   R = R*(Z2-Z1);
75   math_Vector V1(1,3), V2(1,3), V3(1,3);
76   J.Vector(1,V1);
77   V1.Multiply(Passage,V1);
78   V1.Multiply(R*J.Value(1));
79   J.Vector(2,V2);
80   V2.Multiply(Passage,V2);
81   V2.Multiply(R*J.Value(2));
82   J.Vector(3,V3);
83   V3.Multiply(Passage,V3);
84   V3.Multiply(R*J.Value(3));
85
86   inertia = gp_Mat (gp_XYZ(V1(1),V2(1),V3(1)),
87                     gp_XYZ(V1(2),V2(2),V3(2)),
88                     gp_XYZ(V1(3),V2(3),V3(3)));
89   gp_Mat Hop;
90   GProp::HOperator(g,loc,dim,Hop);
91   inertia = inertia+Hop;
92 }
93
94 void GProp_SelGProps::Perform (const gp_Cone& S, 
95                                const Standard_Real     Alpha1,
96                                const Standard_Real     Alpha2,
97                                const Standard_Real     Z1,
98                                const Standard_Real     Z2)
99
100 {
101   Standard_Real X0,Y0,Z0,Xa1,Ya1,Za1,Xa2,Ya2,Za2,Xa3,Ya3,Za3;
102   S.Location().Coord(X0,Y0,Z0);
103   S.Position().XDirection().Coord(Xa1,Ya1,Za1);
104   S.Position().YDirection().Coord(Xa2,Ya2,Za2);
105   S.Position().Direction().Coord(Xa3,Ya3,Za3);
106   Standard_Real t =S.SemiAngle();
107   Standard_Real Cnt = Cos(t);
108   Standard_Real Snt = Sin(t); 
109   Standard_Real R = S.RefRadius();
110   Standard_Real Sn2 = Sin(Alpha2);
111   Standard_Real Sn1 = Sin(Alpha1);
112   Standard_Real Cn2 = Cos(Alpha2);
113   Standard_Real Cn1 = Cos(Alpha1);
114
115   Standard_Real Auxi1 = R + (Z2+Z1)*Snt/2.;
116   Standard_Real Auxi2 = (Z2*Z2+Z1*Z2+Z1*Z1)/3.;
117   dim = (Alpha2-Alpha1)*Cnt*(Z2-Z1)*Auxi1; 
118
119   Standard_Real Ix  =
120     (R*R+R*(Z2+Z1)*Snt + Snt*Auxi2)/Auxi1;
121   Standard_Real Iy = Ix*(Cn1-Cn2)/(Alpha2-Alpha1);
122   Ix = Ix*(Sn2-Sn1)/(Alpha2-Alpha1);
123   Standard_Real Iz = Cnt*(R*(Z2+Z1)/2.+Snt*Auxi2)/Auxi1;
124
125   g.SetCoord(X0 + Xa1*Ix+ Xa2*Iy+ Xa3*Iz,
126              Y0 + Ya1*Ix+ Ya2*Iy+ Ya3*Iz,
127              Z0 + Za1*Ix+ Za2*Iy+ Za3*Iz);
128  
129  Standard_Real R1 = R+Z1*Snt;
130  Standard_Real R2 = R+Z2*Snt;
131  Standard_Real ZZ = (Z2-Z1)*Cnt;
132  Standard_Real IR2 = ZZ*Snt*(R1*R1*R1+R1*R1*R2+R1*R2*R2+R2*R2*R2)/4.;
133  Standard_Real ICn2  = IR2*(Alpha2-Alpha1+Cn2*Sn2-Cn1*Sn1)/2.;
134  Standard_Real ISn2 = IR2*(Alpha2-Alpha1+Cn2*Sn2-Cn1*Sn1)/2.;
135  Standard_Real IZ2 = ZZ*Cnt*Cnt*(Z2-Z1)*(Alpha2-Alpha1)*
136    (R*Auxi2 +Snt*(Z2*Z2*Z2+Z2*Z2*Z1+Z2*Z1*Z1+Z1*Z1*Z1))/4.;
137  Standard_Real ICnSn = IR2*(Cn2*Cn2-Cn1*Cn1);
138  Standard_Real ICnz = Cnt*Snt*ZZ*(R*(Z1+Z2)/2.+Auxi2)*(Sn2-Sn1);
139  Standard_Real ISnz = Cnt*Snt*ZZ*(R*(Z1+Z2)/2.+Auxi2)*(Cn1-Cn2);    
140
141   math_Matrix Dm(1,3,1,3);
142   Dm(1,1) = ISn2 + IZ2;
143   Dm(2,2) = ICn2 + IZ2;
144   Dm(3,3) = IR2*(Alpha2-Alpha1);
145   Dm(1,2) = Dm(2,1) = -ICnSn;
146   Dm(1,3) = Dm(3,1) = -ICnz;
147   Dm(3,2) = Dm(2,3) = -ISnz;
148
149   math_Matrix Passage (1,3,1,3);
150   Passage(1,1) = Xa1; Passage(1,2) = Xa2 ;Passage(1,3) = Xa3;
151   Passage(2,1) = Ya1; Passage(2,2) = Ya2 ;Passage(2,3) = Ya3;
152   Passage(3,1) = Za1; Passage(3,2) = Za2 ;Passage(3,3) = Za3;
153
154   math_Jacobi J(Dm);
155   math_Vector V1(1,3),V2(1,3),V3(1,3);
156   J.Vector(1,V1);
157   V1.Multiply(Passage,V1);
158   V1.Multiply(J.Value(1));
159   J.Vector(2,V2);
160   V2.Multiply(Passage,V2);
161   V2.Multiply(J.Value(2));
162   J.Vector(3,V3);
163   V3.Multiply(Passage,V3);
164   V3.Multiply(J.Value(3));
165
166   inertia = gp_Mat (gp_XYZ(V1(1),V2(1),V3(1)),
167                     gp_XYZ(V1(2),V2(2),V3(2)),
168                     gp_XYZ(V1(3),V2(3),V3(3)));
169   gp_Mat Hop;
170   GProp::HOperator(g,loc,dim,Hop);
171   inertia = inertia+Hop;
172 }
173
174
175 void GProp_SelGProps::Perform(const gp_Sphere& S,
176                               const Standard_Real       Teta1,
177                               const Standard_Real       Teta2,
178                               const Standard_Real       Alpha1,
179                               const Standard_Real       Alpha2)
180 {
181   Standard_Real X0,Y0,Z0,Xa1,Ya1,Za1,Xa2,Ya2,Za2,Xa3,Ya3,Za3;
182   S.Location().Coord(X0,Y0,Z0);
183   S.Position().XDirection().Coord(Xa1,Ya1,Za1);
184   S.Position().YDirection().Coord(Xa2,Ya2,Za2);
185   S.Position().Direction().Coord(Xa3,Ya3,Za3);
186   Standard_Real R = S.Radius();
187   Standard_Real Cnt1 = Cos(Teta1);
188   Standard_Real Snt1 = Sin(Teta1);
189   Standard_Real Cnt2 = Cos(Teta2);
190   Standard_Real Snt2 = Sin(Teta2);
191   Standard_Real Cnf1 = Cos(Alpha1);
192   Standard_Real Snf1 = Sin(Alpha1);
193   Standard_Real Cnf2 = Cos(Alpha2);
194   Standard_Real Snf2 = Sin(Alpha2);
195   dim = R*R*(Teta2-Teta1)*(Snf2-Snf1);
196   Standard_Real Ix = 
197     R*(Snt2-Snt1)/(Teta2-Teta1)*
198     (Alpha2-Alpha1+Snf2*Cnf2-Snf1*Cnf1)/(Snf2-Snf1)/2.;
199   Standard_Real Iy = 
200     R*(Cnt1-Cnt2)/(Teta2-Teta1)*
201     (Alpha2-Alpha1+Snf2*Cnf2-Snf1*Cnf1)/(Snf2-Snf1)/2.;
202   Standard_Real Iz = R*(Snf2+Snf1)/2.;
203   g.SetCoord(
204    X0 + Ix*Xa1 + Iy*Xa2 + Iz*Xa3,
205    Y0 + Ix*Ya1 + Iy*Ya2 + Iz*Ya3,
206    Z0 + Ix*Za1 + Iy*Za2 + Iz*Za3);
207
208   Standard_Real IR2 = ( Cnf2*Snf2*(Cnf2+1.)- Cnf1*Snf1*(Cnf1+1.) +
209                        Alpha2-Alpha1 )/3.;
210   Standard_Real ICn2 = (Teta2-Teta1+ Cnt2*Snt2-Cnt1*Snt1)*IR2/2.;
211   Standard_Real ISn2 = (Teta2-Teta1-Cnt2*Snt2+Cnt1*Snt1)*IR2/2.;
212   Standard_Real ICnSn = ( Snt2*Snt2-Snt1*Snt1)*IR2/2.;
213   Standard_Real IZ2 = (Teta2-Teta1)*(Snf2*Snf2*Snf2-Snf1*Snf1*Snf1)/3.;
214   Standard_Real ICnz =(Snt2-Snt1)*(Cnf1*Cnf1*Cnf1-Cnf2*Cnf2*Cnf2)/3.;
215   Standard_Real ISnz =(Cnt1-Cnt2)*(Cnf1*Cnf1*Cnf1-Cnf2*Cnf2*Cnf2)/3.;
216
217   math_Matrix Dm(1,3,1,3);
218   Dm(1,1) = ISn2 +IZ2; 
219   Dm(2,2) = ICn2 +IZ2;
220   Dm(3,3) = IR2*(Teta2-Teta1);
221   Dm(1,2) = Dm(2,1) = -ICnSn;
222   Dm(1,3) = Dm(3,1) = -ICnz;
223   Dm(3,2) = Dm(2,3) = -ISnz;
224
225   math_Matrix Passage (1,3,1,3);
226   Passage(1,1) = Xa1; Passage(1,2) = Xa2 ;Passage(1,3) = Xa3;
227   Passage(2,1) = Ya1; Passage(2,2) = Ya2 ;Passage(2,3) = Ya3;
228   Passage(3,1) = Za1; Passage(3,2) = Za2 ;Passage(3,3) = Za3;
229
230   math_Jacobi J(Dm);
231   R = R*R*R*R;
232   math_Vector V1(1,3), V2(1,3), V3(1,3);
233   J.Vector(1,V1);
234   V1.Multiply(Passage,V1);
235   V1.Multiply(R*J.Value(1));
236   J.Vector(2,V2);
237   V2.Multiply(Passage,V2);
238   V2.Multiply(R*J.Value(2));
239   J.Vector(3,V3);
240   V3.Multiply(Passage,V3);
241   V3.Multiply(R*J.Value(3));
242
243   inertia = gp_Mat (gp_XYZ(V1(1),V2(1),V3(1)),
244                     gp_XYZ(V1(2),V2(2),V3(2)),
245                     gp_XYZ(V1(3),V2(3),V3(3)));
246   gp_Mat Hop;
247   GProp::HOperator(g,loc,dim,Hop);
248   inertia = inertia+Hop;
249
250  
251 }
252
253
254 void GProp_SelGProps::Perform (const gp_Torus& S, 
255                                const Standard_Real      Teta1,
256                                const Standard_Real      Teta2,
257                                const Standard_Real      Alpha1,
258                                const Standard_Real      Alpha2)
259 {
260   Standard_Real X0,Y0,Z0,Xa1,Ya1,Za1,Xa2,Ya2,Za2,Xa3,Ya3,Za3;
261   S.Location().Coord(X0,Y0,Z0);
262   S.XAxis().Direction().Coord(Xa1,Ya1,Za1);
263   S.YAxis().Direction().Coord(Xa2,Ya2,Za2);
264   S.Axis().Direction().Coord(Xa3,Ya3,Za3);
265   Standard_Real RMax = S.MajorRadius();
266   Standard_Real Rmin = S.MinorRadius();
267   Standard_Real Cnt1 = Cos(Teta1);
268   Standard_Real Snt1 = Sin(Teta1);
269   Standard_Real Cnt2 = Cos(Teta2);
270   Standard_Real Snt2 = Sin(Teta2);
271   Standard_Real Cnf1 = Cos(Alpha1);
272   Standard_Real Snf1 = Sin(Alpha1);
273   Standard_Real Cnf2 = Cos(Alpha2);
274   Standard_Real Snf2 = Sin(Alpha2);
275
276
277   dim = RMax*Rmin*(Teta2-Teta1)*(Alpha2-Alpha1);
278   Standard_Real Ix = 
279     (Snt2-Snt1)/(Teta2-Teta1)*(Rmin*(Snf2-Snf1)/(Alpha2-Alpha1) + RMax);
280   Standard_Real Iy = 
281     (Cnt1-Cnt2)/(Teta2-Teta1)*(Rmin*(Snf2-Snf1)/(Alpha2-Alpha1) + RMax);
282    Standard_Real Iz = Rmin*(Cnf1-Cnf2)/(Alpha2-Alpha1);
283   
284    g.SetCoord(
285              X0+Ix*Xa1+Iy*Xa2+Iz*Xa3,
286              Y0+Ix*Ya1+Iy*Ya2+Iz*Ya3,
287              Z0+Ix*Za1+Iy*Za2+Iz*Za3);
288
289   Standard_Real IR2 = RMax*RMax + 2.*RMax*Rmin*(Snf2-Snf1) +
290                       Rmin*Rmin/2.*(Snf2*Cnf2-Snf1*Cnf1);
291   Standard_Real ICn2 = IR2*(Teta2-Teta1 +Snt2*Cnt2-Snt1*Cnt1)/2.;
292   Standard_Real ISn2 = IR2*(Teta2-Teta1 -Snt2*Cnt2+Snt1*Cnt1)/2.;
293   Standard_Real ICnSn = IR2*(Snt2*Snt2-Snt1*Snt1)/2.;
294   Standard_Real IZ2 = 
295      (Teta2-Teta1)*Rmin*Rmin*(Alpha2-Alpha1-Snf2*Cnf2+Snf1*Cnf1)/2.;
296   Standard_Real ICnz = Rmin*(Snt2-Snt1)*(Cnf1-Cnf2)*(RMax+Rmin*(Cnf1+Cnf2)/2.);
297   Standard_Real ISnz = Rmin*(Cnt2-Cnt1)*(Cnf1-Cnf2)*(RMax+Rmin*(Cnf1+Cnf2)/2.);
298
299   math_Matrix Dm(1,3,1,3);
300   Dm(1,1) = ISn2 + IZ2; 
301   Dm(2,2) = ICn2 + IZ2;
302   Dm(3,3) = IR2*(Teta2-Teta1);
303   Dm(1,2) = Dm(2,1) = -ICnSn;
304   Dm(1,3) = Dm(3,1) = -ICnz;
305   Dm(3,2) = Dm(2,3) = -ISnz;
306
307   math_Matrix Passage (1,3,1,3);
308   Passage(1,1) = Xa1; Passage(1,2) = Xa2 ;Passage(1,3) = Xa3;
309   Passage(2,1) = Ya1; Passage(2,2) = Ya2 ;Passage(2,3) = Ya3;
310   Passage(3,1) = Za1; Passage(3,2) = Za2 ;Passage(3,3) = Za3;
311
312   math_Jacobi J(Dm);
313   RMax = RMax*Rmin;
314   math_Vector V1(1,3), V2(1,3), V3(1,3);
315   J.Vector(1,V1);
316   V1.Multiply(Passage,V1);
317   V1.Multiply(RMax*J.Value(1));
318   J.Vector(2,V2);
319   V2.Multiply(Passage,V2);
320   V2.Multiply(RMax*J.Value(2));
321   J.Vector(3,V3);
322   V3.Multiply(Passage,V3);
323   V3.Multiply(RMax*J.Value(3));
324
325   inertia = gp_Mat (gp_XYZ(V1(1),V2(1),V3(1)),
326                     gp_XYZ(V1(2),V2(2),V3(2)),
327                     gp_XYZ(V1(3),V2(3),V3(3)));
328   gp_Mat Hop;
329   GProp::HOperator(g,loc,dim,Hop);
330   inertia = inertia+Hop;
331
332
333 }
334
335    
336
337 GProp_SelGProps::GProp_SelGProps (const gp_Cone& S, 
338                                   const Standard_Real     Alpha1,
339                                   const Standard_Real     Alpha2,
340                                   const Standard_Real     Z1,
341                                   const Standard_Real     Z2,
342                                   const gp_Pnt& SLocation )
343 {
344   SetLocation(SLocation);
345   Perform(S,Alpha1,Alpha2,Z1,Z2);
346 }
347
348
349 GProp_SelGProps::GProp_SelGProps (const gp_Cylinder& S, 
350                                   const Standard_Real         Alpha1,
351                                   const Standard_Real         Alpha2, 
352                                   const Standard_Real         Z1,
353                                   const Standard_Real         Z2,
354                                   const gp_Pnt& SLocation)
355  {
356   SetLocation(SLocation);
357   Perform(S,Alpha1,Alpha2,Z1,Z2);
358 }
359
360
361 GProp_SelGProps::GProp_SelGProps (const gp_Sphere& S,
362                                   const Standard_Real       Teta1,
363                                   const Standard_Real       Teta2,
364                                   const Standard_Real       Alpha1,
365                                   const Standard_Real       Alpha2,
366                                   const gp_Pnt& SLocation)
367  {
368   SetLocation(SLocation);
369   Perform(S,Teta1,Teta2,Alpha1,Alpha2);
370 }
371
372
373 GProp_SelGProps::GProp_SelGProps (const gp_Torus& S, 
374                                   const Standard_Real      Teta1,
375                                   const Standard_Real      Teta2,
376                                   const Standard_Real      Alpha1,
377                                   const Standard_Real      Alpha2,
378                                   const gp_Pnt& SLocation)
379  {
380   SetLocation(SLocation);
381   Perform(S,Teta1,Teta2,Alpha1,Alpha2);
382 }
383
384    
385