7fd59977 |
1 | //File Convert_TorusToBSplineSurface.cxx |
2 | //JCV 16/10/91 |
3 | |
4 | #include <Convert_TorusToBSplineSurface.ixx> |
5 | |
6 | #include <gp.hxx> |
7 | #include <gp_Trsf.hxx> |
8 | |
9 | static const Standard_Integer TheUDegree = 2; |
10 | static const Standard_Integer TheVDegree = 2; |
11 | static const Standard_Integer MaxNbUKnots = 4; |
12 | static const Standard_Integer MaxNbVKnots = 4; |
13 | static const Standard_Integer MaxNbUPoles = 7; |
14 | static const Standard_Integer MaxNbVPoles = 7; |
15 | |
16 | |
17 | static void ComputePoles ( const Standard_Real R, |
18 | const Standard_Real r, |
19 | const Standard_Real U1, |
20 | const Standard_Real U2, |
21 | const Standard_Real V1, |
22 | const Standard_Real V2, |
23 | TColgp_Array2OfPnt& Poles) |
24 | { |
25 | Standard_Real deltaU = U2 - U1; |
26 | Standard_Real deltaV = V2 - V1; |
27 | |
28 | Standard_Integer i, j; |
29 | |
30 | // Nombre de spans : ouverture maximale = 150 degres ( = PI / 1.2 rds) |
31 | Standard_Integer |
32 | nbUSpans = (Standard_Integer)IntegerPart( 1.2 * deltaU / PI) + 1; |
33 | Standard_Integer |
34 | nbVSpans = (Standard_Integer)IntegerPart( 1.2 * deltaV / PI) + 1; |
35 | Standard_Real AlfaU = deltaU / ( nbUSpans * 2); |
36 | Standard_Real AlfaV = deltaV / ( nbVSpans * 2); |
37 | |
38 | Standard_Integer nbVP = 2 * nbVSpans + 1; |
39 | |
40 | Standard_Real x[MaxNbVPoles]; |
41 | Standard_Real z[MaxNbVPoles]; |
42 | |
43 | x[0] = R + r * Cos( V1); |
44 | z[0] = r * Sin( V1); |
45 | |
46 | Standard_Real VStart = V1; |
47 | for ( i = 1; i <= nbVSpans; i++) { |
48 | x[2*i-1] = R + r * Cos( VStart + AlfaV) / Cos( AlfaV); |
49 | z[2*i-1] = r * Sin( VStart + AlfaV) / Cos( AlfaV); |
50 | x[2*i] = R + r * Cos( VStart + 2 * AlfaV); |
51 | z[2*i] = r * Sin( VStart + 2 * AlfaV); |
52 | VStart += 2*AlfaV; |
53 | } |
54 | |
55 | Standard_Real UStart = U1; |
56 | for ( j = 0; j <= nbVP-1; j++) { |
57 | Poles( 1, j+1) = gp_Pnt(x[j]*Cos(UStart),x[j]*Sin(UStart),z[j]); |
58 | } |
59 | |
60 | for ( i = 1; i <= nbUSpans; i++) { |
61 | for ( j = 0; j<= nbVP-1; j++) { |
62 | Poles( 2*i, j+1) = gp_Pnt( x[j] * Cos(UStart+AlfaU) / Cos(AlfaU), |
63 | x[j] * Sin(UStart+AlfaU) / Cos(AlfaU), |
64 | z[j] ); |
65 | Poles(2*i+1,j+1) = gp_Pnt( x[j] * Cos(UStart+2*AlfaU), |
66 | x[j] * Sin(UStart+2*AlfaU), |
67 | z[j] ); |
68 | } |
69 | UStart += 2*AlfaU; |
70 | } |
71 | } |
72 | |
73 | |
74 | //======================================================================= |
75 | //function : Convert_TorusToBSplineSurface |
76 | //purpose : |
77 | //======================================================================= |
78 | |
79 | Convert_TorusToBSplineSurface::Convert_TorusToBSplineSurface |
80 | (const gp_Torus& T, |
81 | const Standard_Real U1, |
82 | const Standard_Real U2, |
83 | const Standard_Real V1, |
84 | const Standard_Real V2) |
85 | : Convert_ElementarySurfaceToBSplineSurface (MaxNbUPoles, MaxNbVPoles, |
86 | MaxNbUKnots, MaxNbVKnots, |
87 | TheUDegree , TheVDegree) |
88 | { |
89 | Standard_Real deltaU = U2 - U1; |
90 | Standard_Real deltaV = V2 - V1; |
91 | Standard_DomainError_Raise_if( (deltaU>2*PI) || (deltaU<0.) || |
92 | (deltaV>2*PI) || (deltaV<0.), |
93 | "Convert_TorusToBSplineSurface"); |
94 | |
95 | isuperiodic = Standard_False; |
96 | isvperiodic = Standard_False; |
97 | |
98 | Standard_Integer i,j; |
99 | // construction du tore dans le repere de reference xOy. |
100 | |
101 | // Nombre de spans : ouverture maximale = 150 degres ( = PI / 1.2 rds) |
102 | Standard_Integer |
103 | nbUSpans = (Standard_Integer)IntegerPart( 1.2 * deltaU / PI) + 1; |
104 | Standard_Integer |
105 | nbVSpans = (Standard_Integer)IntegerPart( 1.2 * deltaV / PI) + 1; |
106 | Standard_Real AlfaU = deltaU / ( nbUSpans * 2); |
107 | Standard_Real AlfaV = deltaV / ( nbVSpans * 2); |
108 | |
109 | nbUPoles = 2 * nbUSpans + 1; |
110 | nbVPoles = 2 * nbVSpans + 1; |
111 | nbUKnots = nbUSpans + 1; |
112 | nbVKnots = nbVSpans + 1; |
113 | |
114 | Standard_Real R = T.MajorRadius(); |
115 | Standard_Real r = T.MinorRadius(); |
116 | |
117 | ComputePoles( R, r, U1, U2, V1, V2, poles); |
118 | |
119 | for ( i = 1; i<= nbUKnots; i++) { |
120 | uknots(i) = U1 + (i-1) * 2 * AlfaU; |
121 | umults(i) = 2; |
122 | } |
123 | umults(1)++; umults(nbUKnots)++; |
124 | for ( i = 1; i<= nbVKnots; i++) { |
125 | vknots(i) = V1 + (i-1) * 2 * AlfaV; |
126 | vmults(i) = 2; |
127 | } |
128 | vmults(1)++; vmults(nbVKnots)++; |
129 | |
130 | |
131 | // On replace la bspline dans le repere du tore. |
132 | // et on calcule les poids de la bspline. |
133 | Standard_Real W1, W2; |
134 | gp_Trsf Trsf; |
135 | Trsf.SetTransformation( T.Position(), gp::XOY()); |
136 | |
137 | for ( i = 1; i <= nbUPoles; i++) { |
138 | if ( i % 2 == 0) W1 = Cos(AlfaU); |
139 | else W1 = 1.; |
140 | |
141 | for ( j = 1; j <= nbVPoles; j++) { |
142 | if ( j % 2 == 0) W2 = Cos(AlfaV); |
143 | else W2 = 1.; |
144 | |
145 | weights( i, j) = W1 * W2; |
146 | poles( i, j).Transform( Trsf); |
147 | } |
148 | } |
149 | } |
150 | |
151 | |
152 | //======================================================================= |
153 | //function : Convert_TorusToBSplineSurface |
154 | //purpose : |
155 | //======================================================================= |
156 | |
157 | Convert_TorusToBSplineSurface::Convert_TorusToBSplineSurface |
158 | (const gp_Torus& T, |
159 | const Standard_Real Param1, |
160 | const Standard_Real Param2, |
161 | const Standard_Boolean UTrim ) |
162 | : Convert_ElementarySurfaceToBSplineSurface (MaxNbUPoles, MaxNbVPoles, |
163 | MaxNbUKnots, MaxNbVKnots, |
164 | TheUDegree , TheVDegree) |
165 | { |
166 | #ifndef No_Exception |
167 | Standard_Real delta = Param2 - Param1; |
168 | #endif |
169 | Standard_DomainError_Raise_if( (delta>2*PI) || (delta<0.), |
170 | "Convert_TorusToBSplineSurface"); |
171 | |
172 | Standard_Integer i, j; |
173 | Standard_Real deltaU, deltaV; |
174 | |
175 | isuperiodic = !UTrim; |
176 | isvperiodic = UTrim; |
177 | |
178 | Standard_Real R = T.MajorRadius(); |
179 | Standard_Real r = T.MinorRadius(); |
180 | |
181 | Standard_Real W1, W2, CosU, CosV; |
182 | |
183 | if ( isuperiodic) { |
184 | ComputePoles(R, r, 0, 2.*PI, Param1, Param2, poles); |
185 | |
186 | nbUPoles = 6; |
187 | nbUKnots = 4; |
188 | |
189 | deltaV = Param2 - Param1; |
190 | Standard_Integer |
191 | nbVSpans = (Standard_Integer)IntegerPart( 1.2 * deltaV / PI) + 1; |
192 | Standard_Real AlfaV = deltaV / ( nbVSpans * 2); |
193 | nbVPoles = 2 * nbVSpans + 1; |
194 | nbVKnots = nbVSpans + 1; |
195 | |
196 | for ( i = 1; i <= nbUKnots; i++) { |
197 | uknots(i) = ( i-1) * 2. * PI /3.; |
198 | umults(i) = 2; |
199 | } |
200 | for ( i = 1; i <= nbVKnots; i++) { |
201 | vknots(i) = Param1 + (i-1) * 2 * AlfaV; |
202 | vmults(i) = 2; |
203 | } |
204 | vmults(1)++; vmults(nbVKnots)++; |
205 | |
206 | CosU = 0.5; // = Cos(pi /3) |
207 | CosV = Cos(AlfaV); |
208 | } |
209 | else { |
210 | ComputePoles(R, r, Param1, Param2, 0., 2.*PI, poles); |
211 | |
212 | nbVPoles = 6; |
213 | nbVKnots = 4; |
214 | |
215 | deltaU = Param2 - Param1; |
216 | Standard_Integer |
217 | nbUSpans = (Standard_Integer)IntegerPart( 1.2 * deltaU / PI) + 1; |
218 | Standard_Real AlfaU = deltaU / ( nbUSpans * 2); |
219 | nbUPoles = 2 * nbUSpans + 1; |
220 | nbUKnots = nbUSpans + 1; |
221 | |
222 | for ( i = 1; i <= nbVKnots; i++) { |
223 | vknots(i) = ( i-1) * 2. * PI /3.; |
224 | vmults(i) = 2; |
225 | } |
226 | for ( i = 1; i <= nbUKnots; i++) { |
227 | uknots(i) = Param1 + (i-1) * 2 * AlfaU; |
228 | umults(i) = 2; |
229 | } |
230 | umults(1)++; umults(nbUKnots)++; |
231 | |
232 | CosV = 0.5; // = Cos(pi /3) |
233 | CosU = Cos(AlfaU); |
234 | } |
235 | |
236 | // On replace la bspline dans le repere du tore. |
237 | // et on calcule les poids de la bspline. |
238 | gp_Trsf Trsf; |
239 | Trsf.SetTransformation( T.Position(), gp::XOY()); |
240 | |
241 | for ( i = 1; i <= nbUPoles; i++) { |
242 | if ( i % 2 == 0) W1 = CosU; |
243 | else W1 = 1.; |
244 | |
245 | for ( j = 1; j <= nbVPoles; j++) { |
246 | if ( j % 2 == 0) W2 = CosV; |
247 | else W2 = 1.; |
248 | |
249 | weights( i, j) = W1 * W2; |
250 | poles( i, j).Transform( Trsf); |
251 | } |
252 | } |
253 | } |
254 | |
255 | |
256 | |
257 | //======================================================================= |
258 | //function : Convert_TorusToBSplineSurface |
259 | //purpose : |
260 | //======================================================================= |
261 | |
262 | Convert_TorusToBSplineSurface::Convert_TorusToBSplineSurface |
263 | (const gp_Torus& T ) |
264 | : Convert_ElementarySurfaceToBSplineSurface (MaxNbUPoles, MaxNbVPoles, |
265 | MaxNbUKnots, MaxNbVKnots, |
266 | TheUDegree , TheVDegree ) |
267 | { |
268 | isuperiodic = Standard_True; |
269 | isvperiodic = Standard_True; |
270 | |
271 | Standard_Real W1, W2; |
272 | Standard_Integer i, j; |
273 | |
274 | nbUPoles = 6; |
275 | nbVPoles = 6; |
276 | nbUKnots = 4; |
277 | nbVKnots = 4; |
278 | |
279 | // Construction du Tore dans le repere reference xOy. |
280 | |
281 | Standard_Real R = T.MajorRadius(); |
282 | Standard_Real r = T.MinorRadius(); |
283 | |
284 | ComputePoles( R, r, 0., 2.*PI, 0., 2.*PI, poles); |
285 | |
286 | uknots( 1) = vknots( 1) = 0.; |
287 | uknots( 2) = vknots( 2) = 2. * PI / 3.; |
288 | uknots( 3) = vknots( 3) = 4. * PI / 3.; |
289 | uknots( 4) = vknots( 4) = 2. * PI; |
290 | for ( i = 1; i <= 4; i++) { |
291 | umults( i) = vmults( i) = 2; |
292 | } |
293 | |
294 | // On replace la bspline dans le repere du tore. |
295 | // et on calcule les poids de la bspline. |
296 | gp_Trsf Trsf; |
297 | Trsf.SetTransformation( T.Position(), gp::XOY()); |
298 | |
299 | for ( i = 1; i <= nbUPoles; i++) { |
300 | if ( i % 2 == 0) W1 = 0.5; |
301 | else W1 = 1.; |
302 | |
303 | for ( j = 1; j <= nbVPoles; j++) { |
304 | if ( j % 2 == 0) W2 = 0.5; |
305 | else W2 = 1.; |
306 | |
307 | weights( i, j) = W1 * W2; |
308 | poles( i, j).Transform( Trsf); |
309 | } |
310 | } |
311 | } |