b311480e |
1 | // Created on: 1993-10-06 |
2 | // Created by: Bruno DUMORTIER |
3 | // Copyright (c) 1993-1999 Matra Datavision |
973c2be1 |
4 | // Copyright (c) 1999-2014 OPEN CASCADE SAS |
b311480e |
5 | // |
973c2be1 |
6 | // This file is part of Open CASCADE Technology software library. |
b311480e |
7 | // |
d5f74e42 |
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 |
973c2be1 |
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. |
b311480e |
13 | // |
973c2be1 |
14 | // Alternatively, this file may be used under the terms of Open CASCADE |
15 | // commercial license or contractual agreement. |
7fd59977 |
16 | |
7fd59977 |
17 | |
42cf5bc1 |
18 | #include <BSplCLib.hxx> |
19 | #include <Geom_BSplineCurve.hxx> |
20 | #include <Geom_BSplineSurface.hxx> |
21 | #include <GeomFill_BSplineCurves.hxx> |
7fd59977 |
22 | #include <GeomFill_Coons.hxx> |
23 | #include <GeomFill_Curved.hxx> |
42cf5bc1 |
24 | #include <GeomFill_Filling.hxx> |
25 | #include <GeomFill_Stretch.hxx> |
26 | #include <Precision.hxx> |
27 | #include <Standard_ConstructionError.hxx> |
28 | #include <Standard_NotImplemented.hxx> |
7fd59977 |
29 | #include <TColgp_Array1OfPnt.hxx> |
30 | #include <TColgp_Array2OfPnt.hxx> |
42cf5bc1 |
31 | #include <TColStd_Array1OfInteger.hxx> |
32 | #include <TColStd_Array1OfReal.hxx> |
33 | #include <TColStd_Array2OfReal.hxx> |
7fd59977 |
34 | |
35 | //======================================================================= |
36 | //function : Arrange |
37 | //purpose : Internal Use Only |
38 | // This function is used to prepare the Filling: The Curves |
39 | // are arranged in this way: |
7fd59977 |
40 | // CC3 |
41 | // ----->----- |
42 | // | | |
43 | // | | |
44 | // | | |
45 | // CC4 ^ ^ CC2 |
46 | // | | |
47 | // | | |
48 | // ----->----- |
49 | // CC1 = C1 |
50 | //======================================================================= |
e83d440f |
51 | static Standard_Boolean Arrange(const Handle(Geom_BSplineCurve)& C1, |
7fd59977 |
52 | const Handle(Geom_BSplineCurve)& C2, |
53 | const Handle(Geom_BSplineCurve)& C3, |
54 | const Handle(Geom_BSplineCurve)& C4, |
55 | Handle(Geom_BSplineCurve)& CC1, |
56 | Handle(Geom_BSplineCurve)& CC2, |
57 | Handle(Geom_BSplineCurve)& CC3, |
58 | Handle(Geom_BSplineCurve)& CC4, |
59 | const Standard_Real Tol ) |
60 | { |
61 | Handle(Geom_BSplineCurve) GC[4]; |
62 | Handle(Geom_BSplineCurve) Dummy; |
63 | GC[0] = Handle(Geom_BSplineCurve)::DownCast(C1->Copy()); |
64 | GC[1] = Handle(Geom_BSplineCurve)::DownCast(C2->Copy()); |
65 | GC[2] = Handle(Geom_BSplineCurve)::DownCast(C3->Copy()); |
66 | GC[3] = Handle(Geom_BSplineCurve)::DownCast(C4->Copy()); |
67 | |
68 | Standard_Integer i,j; |
69 | Standard_Boolean Trouve; |
70 | |
71 | for (i=1; i<=3; i++) { |
72 | Trouve = Standard_False; |
73 | for ( j=i; j<=3 && !Trouve; j++) { |
74 | if (GC[j]->StartPoint().Distance( GC[i-1]->EndPoint()) < Tol) { |
75 | Dummy = GC[i]; |
76 | GC[i] = GC[j]; |
77 | GC[j] = Dummy; |
78 | Trouve = Standard_True; |
79 | } |
80 | else if (GC[j]->EndPoint().Distance( GC[i-1]->EndPoint()) < Tol) { |
81 | GC[j] = Handle(Geom_BSplineCurve)::DownCast(GC[j]->Reversed()); |
82 | Dummy = GC[i]; |
83 | GC[i] = GC[j]; |
84 | GC[j] = Dummy; |
85 | Trouve = Standard_True; |
86 | } |
87 | } |
88 | if (!Trouve) return Standard_False; |
89 | } |
90 | |
91 | CC1 = GC[0]; |
92 | CC2 = GC[1]; |
93 | CC3 = Handle(Geom_BSplineCurve)::DownCast( GC[2]->Reversed()); |
94 | CC4 = Handle(Geom_BSplineCurve)::DownCast( GC[3]->Reversed()); |
95 | |
96 | return Standard_True; |
97 | } |
98 | |
99 | |
100 | |
101 | //======================================================================= |
102 | //function : SetSameDistribution |
103 | //purpose : Internal Use Only |
104 | //======================================================================= |
105 | |
e83d440f |
106 | static Standard_Integer SetSameDistribution(Handle(Geom_BSplineCurve)& C1, |
7fd59977 |
107 | Handle(Geom_BSplineCurve)& C2 ) |
108 | { |
109 | Standard_Integer nbp1 = C1->NbPoles(); |
110 | Standard_Integer nbk1 = C1->NbKnots(); |
111 | TColgp_Array1OfPnt P1(1,nbp1); |
112 | TColStd_Array1OfReal W1(1,nbp1); |
113 | W1.Init(1.); |
114 | TColStd_Array1OfReal K1(1,nbk1); |
115 | TColStd_Array1OfInteger M1(1,nbk1); |
116 | |
117 | C1->Poles(P1); |
118 | if( C1->IsRational()) |
119 | C1->Weights(W1); |
120 | C1->Knots(K1); |
121 | C1->Multiplicities(M1); |
122 | |
123 | Standard_Integer nbp2 = C2->NbPoles(); |
124 | Standard_Integer nbk2 = C2->NbKnots(); |
125 | TColgp_Array1OfPnt P2(1,nbp2); |
126 | TColStd_Array1OfReal W2(1,nbp2); |
127 | W2.Init(1.); |
128 | TColStd_Array1OfReal K2(1,nbk2); |
129 | TColStd_Array1OfInteger M2(1,nbk2); |
130 | |
131 | C2->Poles(P2); |
132 | if( C2->IsRational()) |
133 | C2->Weights(W2); |
134 | C2->Knots(K2); |
135 | C2->Multiplicities(M2); |
136 | |
137 | Standard_Real K11 = K1( 1 ); |
138 | Standard_Real K12 = K1(nbk1); |
139 | Standard_Real K21 = K2( 1 ); |
140 | Standard_Real K22 = K2(nbk2); |
141 | |
142 | if ( (K12-K11) > (K22-K21)) { |
143 | BSplCLib::Reparametrize( K11, K12, K2); |
144 | C2->SetKnots(K2); |
145 | } |
146 | else if ( (K12-K11) < (K22-K21)) { |
147 | BSplCLib::Reparametrize( K21, K22, K1); |
148 | C1->SetKnots(K1); |
149 | } |
150 | else if(Abs(K12-K11) > Precision::PConfusion()) { |
151 | BSplCLib::Reparametrize( K11, K12, K2); |
152 | C2->SetKnots(K2); |
153 | } |
154 | |
155 | Standard_Integer NP,NK; |
156 | if ( BSplCLib::PrepareInsertKnots(C1->Degree(),Standard_False, |
0e14656b |
157 | K1,M1,K2,&M2,NP,NK,Precision::PConfusion(), |
7fd59977 |
158 | Standard_False)) { |
159 | TColgp_Array1OfPnt NewP(1, NP); |
160 | TColStd_Array1OfReal NewW(1, NP); |
161 | TColStd_Array1OfReal NewK(1, NK); |
162 | TColStd_Array1OfInteger NewM(1, NK); |
163 | BSplCLib::InsertKnots(C1->Degree(),Standard_False, |
0e14656b |
164 | P1,&W1,K1,M1,K2,&M2, |
165 | NewP,&NewW,NewK,NewM,Precision::PConfusion(), |
7fd59977 |
166 | Standard_False); |
167 | if ( C1->IsRational()) { |
168 | C1 = new Geom_BSplineCurve(NewP,NewW,NewK,NewM,C1->Degree()); |
169 | } |
170 | else { |
171 | C1 = new Geom_BSplineCurve(NewP,NewK,NewM,C1->Degree()); |
172 | } |
173 | BSplCLib::InsertKnots(C2->Degree(),Standard_False, |
0e14656b |
174 | P2,&W2,K2,M2,K1,&M1, |
175 | NewP,&NewW,NewK,NewM,Precision::PConfusion(), |
7fd59977 |
176 | Standard_False); |
177 | if ( C2->IsRational()) { |
178 | C2 = new Geom_BSplineCurve(NewP,NewW,NewK,NewM,C2->Degree()); |
179 | } |
180 | else { |
181 | C2 = new Geom_BSplineCurve(NewP,NewK,NewM,C2->Degree()); |
182 | } |
183 | } |
184 | else { |
9775fa61 |
185 | throw Standard_ConstructionError(" "); |
7fd59977 |
186 | } |
187 | |
188 | return C1->NbPoles(); |
189 | } |
190 | |
191 | |
192 | //======================================================================= |
193 | //function : GeomFill_BSplineCurves |
194 | //purpose : |
195 | //======================================================================= |
196 | |
197 | GeomFill_BSplineCurves::GeomFill_BSplineCurves() |
198 | { |
199 | } |
200 | |
201 | |
202 | //======================================================================= |
203 | //function : GeomFill_BSplineCurves |
204 | //purpose : |
205 | //======================================================================= |
206 | |
207 | GeomFill_BSplineCurves::GeomFill_BSplineCurves |
208 | (const Handle(Geom_BSplineCurve)& C1, |
209 | const Handle(Geom_BSplineCurve)& C2, |
210 | const Handle(Geom_BSplineCurve)& C3, |
211 | const Handle(Geom_BSplineCurve)& C4, |
212 | const GeomFill_FillingStyle Type ) |
213 | { |
214 | Init( C1, C2, C3, C4, Type); |
215 | } |
216 | |
217 | |
218 | //======================================================================= |
219 | //function : GeomFill_BSplineCurves |
220 | //purpose : |
221 | //======================================================================= |
222 | |
223 | GeomFill_BSplineCurves::GeomFill_BSplineCurves |
224 | (const Handle(Geom_BSplineCurve)& C1, |
225 | const Handle(Geom_BSplineCurve)& C2, |
226 | const Handle(Geom_BSplineCurve)& C3, |
227 | const GeomFill_FillingStyle Type ) |
228 | { |
229 | Init( C1, C2, C3, Type); |
230 | } |
231 | |
232 | |
233 | //======================================================================= |
234 | //function : GeomFill_BSplineCurves |
235 | //purpose : |
236 | //======================================================================= |
237 | |
238 | GeomFill_BSplineCurves::GeomFill_BSplineCurves |
239 | (const Handle(Geom_BSplineCurve)& C1, |
240 | const Handle(Geom_BSplineCurve)& C2, |
241 | const GeomFill_FillingStyle Type ) |
242 | { |
243 | Init( C1, C2, Type); |
244 | } |
245 | |
246 | |
247 | //======================================================================= |
248 | //function : Init |
249 | //purpose : |
250 | //======================================================================= |
251 | |
252 | void GeomFill_BSplineCurves::Init |
253 | (const Handle(Geom_BSplineCurve)& C1, |
254 | const Handle(Geom_BSplineCurve)& C2, |
255 | const Handle(Geom_BSplineCurve)& C3, |
256 | const Handle(Geom_BSplineCurve)& C4, |
257 | const GeomFill_FillingStyle Type ) |
258 | { |
259 | // On ordonne les courbes |
260 | Handle(Geom_BSplineCurve) CC1, CC2, CC3, CC4; |
261 | |
262 | Standard_Real Tol = Precision::Confusion(); |
263 | #ifndef No_Exception |
264 | Standard_Boolean IsOK = |
265 | #endif |
266 | Arrange( C1, C2, C3, C4, CC1, CC2, CC3, CC4, Tol); |
267 | |
268 | Standard_ConstructionError_Raise_if |
269 | (!IsOK, " GeomFill_BSplineCurves: Courbes non jointives"); |
270 | |
271 | // Mise en conformite des degres |
272 | Standard_Integer Deg1 = CC1->Degree(); |
273 | Standard_Integer Deg2 = CC2->Degree(); |
274 | Standard_Integer Deg3 = CC3->Degree(); |
275 | Standard_Integer Deg4 = CC4->Degree(); |
276 | Standard_Integer DegU = Max( Deg1, Deg3); |
277 | Standard_Integer DegV = Max( Deg2, Deg4); |
278 | if ( Deg1 < DegU) CC1->IncreaseDegree(DegU); |
279 | if ( Deg2 < DegV) CC2->IncreaseDegree(DegV); |
280 | if ( Deg3 < DegU) CC3->IncreaseDegree(DegU); |
281 | if ( Deg4 < DegV) CC4->IncreaseDegree(DegV); |
282 | |
283 | // Mise en conformite des distributions de noeuds |
284 | Standard_Integer NbUPoles = SetSameDistribution(CC1,CC3); |
285 | Standard_Integer NbVPoles = SetSameDistribution(CC2,CC4); |
286 | |
287 | if(Type == GeomFill_CoonsStyle) { |
5146b5ba |
288 | if(NbUPoles < 4 || NbVPoles < 4) |
9775fa61 |
289 | throw Standard_ConstructionError("GeomFill_BSplineCurves: invalid filling style"); |
7fd59977 |
290 | } |
7fd59977 |
291 | |
292 | TColgp_Array1OfPnt P1(1,NbUPoles); |
293 | TColgp_Array1OfPnt P2(1,NbVPoles); |
294 | TColgp_Array1OfPnt P3(1,NbUPoles); |
295 | TColgp_Array1OfPnt P4(1,NbVPoles); |
296 | CC1->Poles(P1); |
297 | CC2->Poles(P2); |
298 | CC3->Poles(P3); |
299 | CC4->Poles(P4); |
300 | |
301 | // Traitement des courbes rationelles |
302 | Standard_Boolean isRat = ( CC1->IsRational() || CC2->IsRational() || |
303 | CC3->IsRational() || CC4->IsRational() ); |
304 | |
305 | TColStd_Array1OfReal W1(1,NbUPoles); |
306 | TColStd_Array1OfReal W3(1,NbUPoles); |
307 | TColStd_Array1OfReal W2(1,NbVPoles); |
308 | TColStd_Array1OfReal W4(1,NbVPoles); |
309 | W1.Init(1.); |
310 | W2.Init(1.); |
311 | W3.Init(1.); |
312 | W4.Init(1.); |
313 | if ( isRat) { |
314 | if (CC1->IsRational()) { |
315 | CC1->Weights(W1); |
316 | } |
317 | if (CC2->IsRational()) { |
318 | CC2->Weights(W2); |
319 | } |
320 | if (CC3->IsRational()) { |
321 | CC3->Weights(W3); |
322 | } |
323 | if (CC4->IsRational()) { |
324 | CC4->Weights(W4); |
325 | } |
326 | } |
327 | |
328 | GeomFill_Filling Caro; |
329 | if (isRat) { |
330 | switch (Type) |
331 | { |
332 | case GeomFill_StretchStyle : |
333 | Caro = GeomFill_Stretch( P1, P2, P3, P4, W1, W2, W3, W4); |
334 | break; |
335 | case GeomFill_CoonsStyle : |
336 | Caro = GeomFill_Coons ( P1, P4, P3, P2, W1, W4, W3, W2); |
337 | break; |
338 | case GeomFill_CurvedStyle : |
339 | Caro = GeomFill_Curved ( P1, P2, P3, P4, W1, W2, W3, W4); |
340 | break; |
341 | } |
342 | } |
343 | else { |
344 | switch (Type) |
345 | { |
346 | case GeomFill_StretchStyle : |
347 | Caro = GeomFill_Stretch( P1, P2, P3, P4); |
348 | break; |
349 | case GeomFill_CoonsStyle : |
350 | Caro = GeomFill_Coons ( P1, P4, P3, P2); |
351 | break; |
352 | case GeomFill_CurvedStyle : |
353 | Caro = GeomFill_Curved ( P1, P2, P3, P4); |
354 | break; |
355 | } |
356 | } |
357 | |
358 | NbUPoles = Caro.NbUPoles(); |
359 | NbVPoles = Caro.NbVPoles(); |
360 | TColgp_Array2OfPnt Poles(1,NbUPoles,1,NbVPoles); |
361 | |
362 | |
363 | // Creation de la surface |
364 | Standard_Integer NbUKnot = CC1->NbKnots(); |
365 | TColStd_Array1OfReal UKnots(1,NbUKnot); |
366 | TColStd_Array1OfInteger UMults(1,NbUKnot); |
367 | CC1->Knots(UKnots); |
368 | CC1->Multiplicities(UMults); |
369 | |
370 | Standard_Integer NbVKnot = CC2->NbKnots(); |
371 | TColStd_Array1OfReal VKnots(1,NbVKnot); |
372 | TColStd_Array1OfInteger VMults(1,NbVKnot); |
373 | CC2->Knots(VKnots); |
374 | CC2->Multiplicities(VMults); |
375 | |
376 | Caro.Poles(Poles); |
377 | |
378 | if (Caro.isRational()) { |
379 | TColStd_Array2OfReal Weights(1,NbUPoles, 1,NbVPoles); |
380 | Caro.Weights(Weights); |
381 | mySurface = new Geom_BSplineSurface(Poles , Weights, |
382 | UKnots , VKnots, |
383 | UMults , VMults, |
384 | CC1->Degree(), CC2->Degree()); |
385 | } |
386 | else { |
387 | mySurface = new Geom_BSplineSurface(Poles , |
388 | UKnots , VKnots, |
389 | UMults , VMults, |
390 | CC1->Degree(), CC2->Degree()); |
391 | } |
392 | |
393 | } |
394 | |
395 | |
396 | //======================================================================= |
397 | //function : Init |
398 | //purpose : |
399 | //======================================================================= |
400 | |
401 | void GeomFill_BSplineCurves::Init |
402 | (const Handle(Geom_BSplineCurve)& C1, |
403 | const Handle(Geom_BSplineCurve)& C2, |
404 | const Handle(Geom_BSplineCurve)& C3, |
405 | const GeomFill_FillingStyle Type ) |
406 | { |
407 | Handle(Geom_BSplineCurve) C4; |
408 | TColgp_Array1OfPnt Poles(1,2); |
409 | TColStd_Array1OfReal Knots(1,2); |
410 | TColStd_Array1OfInteger Mults(1,2); |
411 | Standard_Real Tol = Precision::Confusion(); |
412 | Tol = Tol * Tol; |
413 | if(C1->StartPoint().SquareDistance(C2->StartPoint()) > Tol && |
414 | C1->StartPoint().SquareDistance(C2->EndPoint()) > Tol ) |
415 | Poles( 1) = C1->StartPoint(); |
416 | else |
417 | Poles( 1) = C1->EndPoint(); |
418 | |
419 | if(C3->StartPoint().SquareDistance(C2->StartPoint()) > Tol && |
420 | C3->StartPoint().SquareDistance(C2->EndPoint()) > Tol ) |
421 | Poles( 2) = C3->StartPoint(); |
422 | else |
423 | Poles( 2) = C3->EndPoint(); |
424 | |
425 | Knots( 1) = C2->Knot(C2->FirstUKnotIndex()); |
426 | Knots( 2) = C2->Knot(C2->LastUKnotIndex()); |
427 | Mults( 1) = Mults( 2) = 2; |
428 | C4 = new Geom_BSplineCurve( Poles, Knots, Mults, 1); |
429 | Init( C1, C2, C3, C4, Type); |
430 | } |
431 | |
432 | |
433 | //======================================================================= |
434 | //function : Init |
435 | //purpose : |
436 | //======================================================================= |
437 | |
438 | void GeomFill_BSplineCurves::Init |
439 | (const Handle(Geom_BSplineCurve)& C1, |
440 | const Handle(Geom_BSplineCurve)& C2, |
441 | const GeomFill_FillingStyle Type ) |
442 | { |
443 | Handle(Geom_BSplineCurve) |
444 | CC1 = Handle(Geom_BSplineCurve)::DownCast(C1->Copy()); |
445 | Handle(Geom_BSplineCurve) |
446 | CC2 = Handle(Geom_BSplineCurve)::DownCast(C2->Copy()); |
447 | |
448 | Standard_Integer Deg1 = CC1->Degree(); |
449 | Standard_Integer Deg2 = CC2->Degree(); |
450 | |
451 | Standard_Boolean isRat = ( CC1->IsRational() || CC2->IsRational()); |
452 | |
453 | if ( Type != GeomFill_CurvedStyle) { |
454 | Standard_Integer DegU = Max( Deg1, Deg2); |
455 | |
456 | if ( CC1->Degree() < DegU ) CC1->IncreaseDegree(DegU); |
457 | if ( CC2->Degree() < DegU ) CC2->IncreaseDegree(DegU); |
458 | |
459 | // Mise en conformite des distributions de noeuds |
460 | Standard_Integer NbPoles = SetSameDistribution(CC1,CC2); |
461 | TColgp_Array2OfPnt Poles(1,NbPoles, 1,2); |
462 | TColgp_Array1OfPnt P1( 1, NbPoles); |
463 | TColgp_Array1OfPnt P2( 1, NbPoles); |
464 | CC1->Poles(P1); |
465 | CC2->Poles(P2); |
466 | Standard_Integer i; |
467 | for (i=1; i<=NbPoles; i++) { |
468 | Poles(i, 1) = P1(i); |
469 | Poles(i, 2) = P2(i); |
470 | } |
471 | Standard_Integer NbUKnots = CC1->NbKnots(); |
472 | TColStd_Array1OfReal UKnots( 1, NbUKnots); |
473 | TColStd_Array1OfInteger UMults( 1, NbUKnots); |
474 | CC1->Knots(UKnots); |
475 | CC1->Multiplicities(UMults); |
476 | // Standard_Integer NbVKnots = 2; |
477 | TColStd_Array1OfReal VKnots( 1, 2); |
478 | TColStd_Array1OfInteger VMults( 1, 2); |
479 | VKnots( 1) = 0; |
480 | VKnots( 2) = 1; |
481 | VMults( 1) = 2; |
482 | VMults( 2) = 2; |
483 | |
484 | |
485 | // Traitement des courbes rationelles |
486 | if (isRat) { |
487 | TColStd_Array2OfReal Weights(1,NbPoles, 1,2); |
488 | TColStd_Array1OfReal W1(1,NbPoles); |
489 | TColStd_Array1OfReal W2(1,NbPoles); |
490 | W1.Init(1.); |
491 | W2.Init(1.); |
492 | |
493 | if ( isRat) { |
494 | if (CC1->IsRational()) { |
495 | CC1->Weights(W1); |
496 | } |
497 | if (CC2->IsRational()) { |
498 | CC2->Weights(W2); |
499 | } |
500 | for (i=1; i<=NbPoles; i++) { |
501 | Weights(i, 1) = W1( i); |
502 | Weights(i, 2) = W2( i); |
503 | } |
504 | } |
505 | mySurface = new Geom_BSplineSurface(Poles , Weights, |
506 | UKnots , VKnots, |
507 | UMults , VMults, |
508 | CC1->Degree(), 1, |
509 | CC1->IsPeriodic(), |
510 | Standard_False); |
511 | } |
512 | else { |
513 | mySurface = new Geom_BSplineSurface(Poles , |
514 | UKnots , VKnots, |
515 | UMults , VMults, |
516 | CC1->Degree(), 1); |
517 | } |
518 | } |
519 | else { |
520 | Standard_Real Eps = Precision::Confusion(); |
521 | Standard_Boolean IsOK = Standard_False; |
522 | if ( CC1->StartPoint().IsEqual(CC2->StartPoint(),Eps)) { |
523 | IsOK = Standard_True; |
524 | } |
525 | else if ( CC1->StartPoint().IsEqual(CC2->EndPoint(),Eps)) { |
526 | CC2->Reverse(); |
527 | IsOK = Standard_True; |
528 | } |
529 | else if ( CC1->EndPoint().IsEqual(CC2->StartPoint(),Eps)) { |
530 | C1->Reverse(); |
531 | IsOK = Standard_True; |
532 | } |
533 | else if ( CC1->EndPoint().IsEqual(CC2->EndPoint(),Eps)) { |
534 | CC1->Reverse(); |
535 | CC2->Reverse(); |
536 | IsOK = Standard_True; |
537 | } |
538 | |
bcf50875 |
539 | if(!IsOK) |
9775fa61 |
540 | throw Standard_OutOfRange("GeomFill_BSplineCurves: Courbes non jointives"); |
7fd59977 |
541 | |
542 | Standard_Integer NbUPoles = CC1->NbPoles(); |
543 | Standard_Integer NbVPoles = CC2->NbPoles(); |
544 | TColgp_Array1OfPnt P1(1,NbUPoles); |
545 | TColgp_Array1OfPnt P2(1,NbVPoles); |
546 | CC1->Poles(P1); |
547 | CC2->Poles(P2); |
548 | |
549 | Standard_Integer NbUKnots = CC1->NbKnots(); |
550 | Standard_Integer NbVKnots = CC2->NbKnots(); |
551 | TColStd_Array1OfReal UKnots(1,NbUKnots); |
552 | TColStd_Array1OfReal VKnots(1,NbVKnots); |
553 | TColStd_Array1OfInteger UMults(1,NbUKnots); |
554 | TColStd_Array1OfInteger VMults(1,NbVKnots); |
555 | CC1->Knots(UKnots); |
556 | CC1->Multiplicities(UMults); |
557 | CC2->Knots(VKnots); |
558 | CC2->Multiplicities(VMults); |
559 | |
560 | TColStd_Array1OfReal W1(1,NbUPoles); |
561 | TColStd_Array1OfReal W2(1,NbVPoles); |
562 | W1.Init(1.); |
563 | W2.Init(1.); |
564 | |
565 | GeomFill_Filling Caro; |
566 | if ( isRat) { |
567 | if (CC1->IsRational()) { |
568 | CC1->Weights(W1); |
569 | } |
570 | if (CC2->IsRational()) { |
571 | CC2->Weights(W2); |
572 | } |
573 | Caro = GeomFill_Curved( P1, P2, W1, W2); |
574 | } |
575 | else { |
576 | Caro = GeomFill_Curved( P1, P2); |
577 | } |
578 | |
579 | NbUPoles = Caro.NbUPoles(); |
580 | NbVPoles = Caro.NbVPoles(); |
581 | TColgp_Array2OfPnt Poles(1,NbUPoles,1,NbVPoles); |
582 | |
583 | Caro.Poles(Poles); |
584 | |
585 | if (Caro.isRational()) { |
586 | TColStd_Array2OfReal Weights(1,NbUPoles, 1,NbVPoles); |
587 | Caro.Weights(Weights); |
588 | mySurface = new Geom_BSplineSurface(Poles , Weights, |
589 | UKnots , VKnots, |
590 | UMults , VMults, |
591 | Deg1 , Deg2, |
592 | Standard_False, Standard_False); |
593 | } |
594 | else { |
595 | mySurface = new Geom_BSplineSurface(Poles , |
596 | UKnots , VKnots, |
597 | UMults , VMults, |
598 | Deg1 , Deg2, |
599 | Standard_False, Standard_False); |
600 | } |
601 | } |
602 | } |
603 | |
604 | |