0024002: Overall code and build procedure refactoring -- automatic
[occt.git] / src / BRepGProp / BRepGProp_Face.cxx
CommitLineData
b311480e 1// Copyright (c) 1995-1999 Matra Datavision
973c2be1 2// Copyright (c) 1999-2014 OPEN CASCADE SAS
b311480e 3//
973c2be1 4// This file is part of Open CASCADE Technology software library.
b311480e 5//
d5f74e42 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
973c2be1 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.
b311480e 11//
973c2be1 12// Alternatively, this file may be used under the terms of Open CASCADE
13// commercial license or contractual agreement.
b311480e 14
424cd6bb 15
42cf5bc1 16#include <Bnd_Box2d.hxx>
17#include <BndLib_Add2dCurve.hxx>
18#include <BRepGProp_Face.hxx>
7fd59977 19#include <Geom2d_BezierCurve.hxx>
20#include <Geom2d_BSplineCurve.hxx>
42cf5bc1 21#include <Geom2d_Line.hxx>
424cd6bb 22#include <Geom_BezierSurface.hxx>
42cf5bc1 23#include <Geom_BSplineCurve.hxx>
424cd6bb 24#include <Geom_BSplineSurface.hxx>
25#include <Geom_SurfaceOfLinearExtrusion.hxx>
7fd59977 26#include <GeomAdaptor_Curve.hxx>
42cf5bc1 27#include <gp_Pnt.hxx>
28#include <gp_Pnt2d.hxx>
29#include <gp_Vec.hxx>
30#include <gp_Vec2d.hxx>
31#include <math.hxx>
7fd59977 32#include <Precision.hxx>
42cf5bc1 33#include <TopoDS.hxx>
34#include <TopoDS_Edge.hxx>
35#include <TopoDS_Face.hxx>
7fd59977 36
37//=======================================================================
38//function : UIntegrationOrder
39//purpose :
40//=======================================================================
7fd59977 41Standard_Integer BRepGProp_Face::UIntegrationOrder() const {
7fd59977 42
424cd6bb 43 Standard_Integer Nu;
44 switch (mySurface.GetType())
45 {
7fd59977 46
424cd6bb 47 case GeomAbs_Plane :
48 Nu =4;
49 break;
7fd59977 50
424cd6bb 51 case GeomAbs_BezierSurface :
52 {
53 Nu = (*((Handle(Geom_BezierSurface)*)&((mySurface.Surface()).Surface())))->UDegree()+1;
54 Nu = Max(4,Nu);
55 }
56 break;
57 case GeomAbs_BSplineSurface :
58 {
59 Standard_Integer a = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->UDegree()+1;
60 Standard_Integer b = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->NbUKnots()-1;
61 Nu = Max(4,a*b);
62 }
63 break;
64
65 default :
66 Nu = 9;
67 break;
68 }
7fd59977 69 return Max(8,2*Nu);
70}
71
72//=======================================================================
73//function : VIntegrationOrder
74//purpose :
75//=======================================================================
76
77Standard_Integer BRepGProp_Face::VIntegrationOrder() const
78{
79 Standard_Integer Nv;
80 switch (mySurface.GetType()) {
81
82 case GeomAbs_Plane :
83 Nv = 4;
84 break;
85
86 case GeomAbs_BezierSurface :
87 {
88 Nv = (*((Handle(Geom_BezierSurface)*)&((mySurface.Surface()).Surface())))->VDegree()+1;
89 Nv = Max(4,Nv);
90 }
91 break;
92
93 case GeomAbs_BSplineSurface :
94 {
95 Standard_Integer a = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->VDegree()+1;
96 Standard_Integer b = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->NbVKnots()-1;
97 Nv = Max(4,a*b);
98 }
99 break;
100
101 default :
102 Nv = 9;
103 break;
104 }
105 return Max(8,2*Nv);
106}
107
108//=======================================================================
109//function : IntegrationOrder
110//purpose :
111//=======================================================================
112
113Standard_Integer BRepGProp_Face::IntegrationOrder() const
114{
115 Standard_Integer N;
116
117 switch (myCurve.GetType()) {
118
119 case GeomAbs_Line :
120 N = 2;
121 break;
122
123 case GeomAbs_Circle :
124 case GeomAbs_Ellipse :
125 case GeomAbs_Hyperbola :
126 N = 9;
127 break;
128
129 case GeomAbs_Parabola :
130 N = 9;
131 break;
132
133 case GeomAbs_BezierCurve :
134 {
135 N = (*((Handle(Geom2d_BezierCurve)*)&(myCurve.Curve())))->Degree() + 1;
136 }
137 break;
138
139 case GeomAbs_BSplineCurve :
140 {
141 Standard_Integer a = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve.Curve())))->Degree() + 1;
142 Standard_Integer b = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve.Curve())))->NbKnots() - 1;
143 N = a * b;
144 }
145 break;
146
147 default :
148 N = 9;
149 break;
150 }
151
152 return Max(4,2*N);
153}
154
155//=======================================================================
156//function : Bounds
157//purpose :
158//=======================================================================
159
160void BRepGProp_Face::Bounds(Standard_Real& U1,
161 Standard_Real& U2,
162 Standard_Real& V1,
163 Standard_Real& V2)const
164{
165 U1 = mySurface.FirstUParameter();
166 U2 = mySurface.LastUParameter();
167 V1 = mySurface.FirstVParameter();
168 V2 = mySurface.LastVParameter();
169}
170
171//=======================================================================
172//function : Load
173//purpose :
174//=======================================================================
175
176void BRepGProp_Face::Load(const TopoDS_Edge& E)
177{
178 Standard_Real a,b;
179 Handle(Geom2d_Curve) C =
180 BRep_Tool::CurveOnSurface(E, mySurface.Face(), a,b);
181 if (E.Orientation() == TopAbs_REVERSED) {
182 Standard_Real x = a;
183 a = C->ReversedParameter(b);
184 b = C->ReversedParameter(x);
185 C = C->Reversed();
186 }
187 myCurve.Load(C,a,b);
188}
189
190//=======================================================================
191//function : Load
192//purpose :
193//=======================================================================
194
195void BRepGProp_Face::Load(const TopoDS_Face& F)
196{
197 TopoDS_Shape aLocalShape = F.Oriented(TopAbs_FORWARD);
198 mySurface.Initialize(TopoDS::Face(aLocalShape));
199// mySurface.Initialize(TopoDS::Face(F.Oriented(TopAbs_FORWARD)));
200 mySReverse = (F.Orientation() == TopAbs_REVERSED);
201}
202
203//=======================================================================
204//function : Normal
205//purpose :
206//=======================================================================
207
208void BRepGProp_Face::Normal (const Standard_Real U,
209 const Standard_Real V,
210 gp_Pnt &P,
211 gp_Vec &VNor) const
212{
213 gp_Vec D1U,D1V;
214 mySurface.D1(U,V,P,D1U,D1V);
215 VNor = D1U.Crossed(D1V);
216 if (mySReverse) VNor.Reverse();
217
218}
219
220// APO 17.04.2002 (OCC104)
221// This is functions that calculate coeff. to optimize "integration order".
222//They had been produced experementally for some hard example.
223static Standard_Real AS = -0.15, AL = -0.50, B = 1.0, C = 0.75, D = 0.25;
224static inline Standard_Real SCoeff(const Standard_Real Eps){
225 return Eps < 0.1? AS*(B+Log10(Eps)) + C: C;
226}
227static inline Standard_Real LCoeff(const Standard_Real Eps){
228 return Eps < 0.1? AL*(B+Log10(Eps)) + D: D;
229}
230
231//=======================================================================
232//function : SIntOrder
233//purpose :
234//=======================================================================
235
236Standard_Integer BRepGProp_Face::SIntOrder(const Standard_Real Eps) const
237{
238 Standard_Integer Nv, Nu;
239 switch (mySurface.GetType()) {
240 case GeomAbs_Plane:
241 Nu = 1; Nv = 1; break;
242 case GeomAbs_Cylinder:
243 Nu = 2; Nv = 1; break;
244 case GeomAbs_Cone:
245 Nu = 2; Nv = 1; break;
246 case GeomAbs_Sphere:
247 Nu = 2; Nv = 2; break;
248 case GeomAbs_Torus:
249 Nu = 2; Nv = 2; break;
250 case GeomAbs_BezierSurface:
251 Nv = (*((Handle(Geom_BezierSurface)*)&((mySurface.Surface()).Surface())))->VDegree();
252 Nu = (*((Handle(Geom_BezierSurface)*)&((mySurface.Surface()).Surface())))->UDegree();
253 break;
254 case GeomAbs_BSplineSurface:
255 Nv = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->VDegree();
256 Nu = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->UDegree();
257 break;
258 default:
259 Nu = 2; Nv = 2; break;
260 }
261 return Min(RealToInt(Ceiling(SCoeff(Eps)*Max((Nu+1),(Nv+1)))), math::GaussPointsMax());
262}
263
264//=======================================================================
265//function : SUIntSubs
266//purpose :
267//=======================================================================
268
269Standard_Integer BRepGProp_Face::SUIntSubs() const
270{
271 Standard_Integer N;
272 switch (mySurface.GetType()) {
273 case GeomAbs_Plane:
274 N = 2; break;
275 case GeomAbs_Cylinder:
276 N = 4; break;
277 case GeomAbs_Cone:
278 N = 4; break;
279 case GeomAbs_Sphere:
280 N = 4; break;
281 case GeomAbs_Torus:
282 N = 4; break;
283 case GeomAbs_BezierSurface:
284 N = 2; break;
285 case GeomAbs_BSplineSurface:
286 N = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->NbUKnots(); break;
287 default:
288 N = 2; break;
289 }
290 return N - 1;
291}
292
293//=======================================================================
294//function : SVIntSubs
295//purpose :
296//=======================================================================
297
298Standard_Integer BRepGProp_Face::SVIntSubs() const
299{
300 Standard_Integer N;
301 switch (mySurface.GetType()) {
302 case GeomAbs_Plane:
303 N = 2; break;
304 case GeomAbs_Cylinder:
305 N = 2; break;
306 case GeomAbs_Cone:
307 N = 2; break;
308 case GeomAbs_Sphere:
309 N = 3; break;
310 case GeomAbs_Torus:
311 N = 4; break;
312 case GeomAbs_BezierSurface:
313 N = 2; break;
314 case GeomAbs_BSplineSurface:
315 N = (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->NbVKnots();
316 break;
317 default:
318 N = 2; break;
319 }
320 return N - 1;
321}
322
323//=======================================================================
324//function : UKnots
325//purpose :
326//=======================================================================
327
328void BRepGProp_Face::UKnots(TColStd_Array1OfReal& Knots) const
329{
330 switch (mySurface.GetType()) {
331 case GeomAbs_Plane:
332 Knots(1) = mySurface.FirstUParameter(); Knots(2) = mySurface.LastUParameter();
333 break;
334 case GeomAbs_Cylinder:
335 case GeomAbs_Cone:
336 case GeomAbs_Sphere:
337 case GeomAbs_Torus:
c6541a0c 338 Knots(1) = 0.0; Knots(2) = M_PI*2.0/3.0; Knots(3) = M_PI*4.0/3.0; Knots(4) = M_PI*6.0/3.0;
7fd59977 339 break;
340 case GeomAbs_BSplineSurface:
341 (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->UKnots(Knots);
342 break;
343 default:
344 Knots(1) = mySurface.FirstUParameter(); Knots(2) = mySurface.LastUParameter();
345 break;
346 }
347}
348
349//=======================================================================
350//function : VKnots
351//purpose :
352//=======================================================================
353
354void BRepGProp_Face::VKnots(TColStd_Array1OfReal& Knots) const
355{
356 switch (mySurface.GetType()) {
357 case GeomAbs_Plane:
358 case GeomAbs_Cylinder:
359 case GeomAbs_Cone:
360 Knots(1) = mySurface.FirstUParameter(); Knots(2) = mySurface.LastUParameter();
361 break;
362 case GeomAbs_Sphere:
c6541a0c 363 Knots(1) = -M_PI/2.0; Knots(2) = 0.0; Knots(3) = +M_PI/2.0;
7fd59977 364 break;
365 case GeomAbs_Torus:
c6541a0c 366 Knots(1) = 0.0; Knots(2) = M_PI*2.0/3.0; Knots(3) = M_PI*4.0/3.0; Knots(4) = M_PI*6.0/3.0;
7fd59977 367 break;
368 case GeomAbs_BSplineSurface:
369 (*((Handle(Geom_BSplineSurface)*)&((mySurface.Surface()).Surface())))->VKnots(Knots);
370 break;
371 default:
372 Knots(1) = mySurface.FirstUParameter(); Knots(2) = mySurface.LastUParameter();
373 break;
374 }
375}
376
377//=======================================================================
378//function : LIntOrder
379//purpose :
380//=======================================================================
381
382Standard_Integer BRepGProp_Face::LIntOrder(const Standard_Real Eps) const
383{
384 Bnd_Box2d aBox;
6e6cd5d9 385
386 BndLib_Add2dCurve::Add(myCurve, 1.e-7, aBox);
7fd59977 387 Standard_Real aXmin, aXmax, aYmin, aYmax;
388 aBox.Get(aXmin, aYmin, aXmax, aYmax);
389 Standard_Real aVmin = mySurface.FirstVParameter();
390 Standard_Real aVmax = mySurface.LastVParameter();
391
392 Standard_Real anR = Min((aYmax-aYmin)/(aVmax-aVmin), 1.);
393
394// Standard_Integer anRInt = Max(RealToInt(Ceiling(SVIntSubs()*anR)), 2);
395 Standard_Integer anRInt = RealToInt(Ceiling(SVIntSubs()*anR));
396 Standard_Integer aLSubs = LIntSubs();
397
398
399// Standard_Real NL, NS = Max(SIntOrder(1.0)*anRInt/LIntSubs(), 1);
400 Standard_Real NL, NS = Max(SIntOrder(1.)*anRInt/aLSubs, 1);
401 switch (myCurve.GetType()) {
402 case GeomAbs_Line:
403 NL = 1; break;
404 case GeomAbs_Circle:
405 NL = 2 * 3; break; //correction for the spans of converted curve
406 case GeomAbs_Ellipse:
407 NL = 2 * 3; break; //
408 case GeomAbs_Parabola:
409 NL = 2 * 3; break;
410 case GeomAbs_Hyperbola:
411 NL = 3 * 3; break;
412 case GeomAbs_BezierCurve:
413 NL = (*((Handle(Geom2d_BezierCurve)*)&(myCurve.Curve())))->Degree();
414 break;
415 case GeomAbs_BSplineCurve:
416 NL = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve.Curve())))->Degree();
417 break;
418 default:
419 NL = 3 * 3; break;
420 }
421
422 NL = Max(NL, NS);
423
424 Standard_Integer nn =
425 RealToInt (aLSubs <= 4 ? Ceiling(LCoeff(Eps)*(NL+1)) : NL+1);
426
427 //return Min(RealToInt(Ceiling(LCoeff(Eps)*(NL+1)*NS)), math::GaussPointsMax());
428 return Min(nn, math::GaussPointsMax());
429}
430
431//=======================================================================
432//function : LIntSubs
433//purpose :
434//=======================================================================
435
436Standard_Integer BRepGProp_Face::LIntSubs() const
437{
438 Standard_Integer N;
439 switch (myCurve.GetType()) {
440 case GeomAbs_Line:
441 N = 2; break;
442 case GeomAbs_Circle:
443 case GeomAbs_Ellipse:
444 N = 4; break;
445 case GeomAbs_Parabola:
446 case GeomAbs_Hyperbola:
447 N = 2; break;
448 case GeomAbs_BSplineCurve:
449 N = (*((Handle(Geom2d_BSplineCurve)*)&(myCurve.Curve())))->NbKnots();
450 break;
451 default:
452 N = 2; break;
453 }
454 return N - 1;
455}
456
457//=======================================================================
458//function : LKnots
459//purpose :
460//=======================================================================
461
462void BRepGProp_Face::LKnots(TColStd_Array1OfReal& Knots) const
463{
464 switch (myCurve.GetType()) {
465 case GeomAbs_Line:
466 Knots(1) = myCurve.FirstParameter(); Knots(2) = myCurve.LastParameter();
467 break;
468 case GeomAbs_Circle:
469 case GeomAbs_Ellipse:
c6541a0c 470 Knots(1) = 0.0; Knots(2) = M_PI*2.0/3.0; Knots(3) = M_PI*4.0/3.0; Knots(2) = M_PI*6.0/3.0;
7fd59977 471 break;
472 case GeomAbs_Parabola:
473 case GeomAbs_Hyperbola:
474 Knots(1) = myCurve.FirstParameter(); Knots(2) = myCurve.LastParameter();
475 break;
476 case GeomAbs_BSplineCurve:
477 (*((Handle(Geom2d_BSplineCurve)*)&(myCurve.Curve())))->Knots(Knots);
478 break;
479 default:
480 Knots(1) = myCurve.FirstParameter(); Knots(2) = myCurve.LastParameter();
481 break;
482 }
483}
484
485//=======================================================================
486//function : Load
487//purpose :
488//=======================================================================
489
490void BRepGProp_Face::Load(const Standard_Boolean IsFirstParam,
491 const GeomAbs_IsoType theIsoType)
492{
493 Standard_Real aLen;
494 Standard_Real aU1;
495 Standard_Real aU2;
496 Standard_Real aV1;
497 Standard_Real aV2;
498 gp_Pnt2d aLoc;
499 gp_Dir2d aDir;
500
501 Bounds(aU1, aU2, aV1, aV2);
502
503 if (theIsoType == GeomAbs_IsoU) {
504 aLen = aV2 - aV1;
505
506 if (IsFirstParam) {
507 aLoc.SetCoord(aU1, aV2);
508 aDir.SetCoord(0., -1.);
509 } else {
510 aLoc.SetCoord(aU2, aV1);
511 aDir.SetCoord(0., 1.);
512 }
513 } else if (theIsoType == GeomAbs_IsoV) {
514 aLen = aU2 - aU1;
515
516 if (IsFirstParam) {
517 aLoc.SetCoord(aU1, aV1);
518 aDir.SetCoord(1., 0.);
519 } else {
520 aLoc.SetCoord(aU2, aV2);
521 aDir.SetCoord(-1., 0.);
522 }
523 } else
524 return;
525
526 Handle(Geom2d_Curve) aLin = new Geom2d_Line(aLoc, aDir);
527
528 myCurve.Load(aLin, 0., aLen);
529}
530
531//=======================================================================
532//function : GetRealKnots
533//purpose :
534//=======================================================================
535
536static void GetRealKnots(const Standard_Real theMin,
537 const Standard_Real theMax,
538 const Handle(TColStd_HArray1OfReal) &theKnots,
539 Handle(TColStd_HArray1OfReal) &theRealKnots)
540{
541 Standard_Integer i = theKnots->Lower() - 1;
542 Standard_Integer iU = theKnots->Upper();
543 Standard_Integer aStartI = 0;
544 Standard_Integer aEndI = 0;
545 Standard_Real aTol = Precision::Confusion();
546
547 while (++i < iU) {
548 if (aStartI == 0 && theKnots->Value(i) > theMin + aTol)
549 aStartI = i;
550
551 if (aEndI == 0 && theKnots->Value(i + 1) > theMax - aTol)
552 aEndI = i;
553
554 if (aStartI != 0 && aEndI != 0)
555 break;
556 }
557
558 if (aStartI == 0)
559 aStartI = iU;
560
561 Standard_Integer aNbNode = Max(0, aEndI - aStartI + 1) + 2;
562 Standard_Integer j;
563
564 theRealKnots = new TColStd_HArray1OfReal(1, aNbNode);
565 theRealKnots->SetValue(1, theMin);
566 theRealKnots->SetValue(aNbNode, theMax);
567
568
569 for (i = 2, j = aStartI; j <= aEndI; i++, j++)
570 theRealKnots->SetValue(i, theKnots->Value(j));
571}
572
573//=======================================================================
574//function : GetCurveKnots
575//purpose :
576//=======================================================================
577
578static void GetCurveKnots(const Standard_Real theMin,
579 const Standard_Real theMax,
580 const Geom2dAdaptor_Curve &theCurve,
581 Handle(TColStd_HArray1OfReal) &theKnots)
582{
583 Standard_Boolean isSBSpline = theCurve.GetType() == GeomAbs_BSplineCurve;
584
585 if (isSBSpline) {
586 Handle(Geom2d_BSplineCurve) aCrv;
587 Standard_Integer aNbKnots;
588 Handle(TColStd_HArray1OfReal) aCrvKnots;
589
590 aCrv = Handle(Geom2d_BSplineCurve)::DownCast(theCurve.Curve());
591 aNbKnots = aCrv->NbKnots();
592 aCrvKnots = new TColStd_HArray1OfReal(1, aNbKnots);
593 aCrv->Knots(aCrvKnots->ChangeArray1());
594 GetRealKnots(theMin, theMax, aCrvKnots, theKnots);
595 } else {
596 theKnots = new TColStd_HArray1OfReal(1, 2);
597 theKnots->SetValue(1, theMin);
598 theKnots->SetValue(2, theMax);
599 }
600}
601
602//=======================================================================
7fd59977 603//function : GetUKnots
604//purpose :
605//=======================================================================
606
607void BRepGProp_Face::GetUKnots
608 (const Standard_Real theUMin,
609 const Standard_Real theUMax,
610 Handle(TColStd_HArray1OfReal) &theUKnots) const
611{
612 Standard_Boolean isSBSpline = mySurface.GetType() == GeomAbs_BSplineSurface;
613 Standard_Boolean isCBSpline = Standard_False;
614
615 if (!isSBSpline) {
616 // Check the basis curve of the surface of linear extrusion.
617 if (mySurface.GetType() == GeomAbs_SurfaceOfExtrusion) {
618 GeomAdaptor_Curve aCurve;
619 Handle(Geom_Surface) aSurf = mySurface.Surface().Surface();
620
c5f3a425 621 aCurve.Load(Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (aSurf)->BasisCurve());
7fd59977 622 isCBSpline = aCurve.GetType() == GeomAbs_BSplineCurve;
623 }
624 }
625
626 if (myIsUseSpan && (isSBSpline || isCBSpline)) {
627 // Using span decomposition for BSpline.
628 Handle(TColStd_HArray1OfReal) aKnots;
629 Standard_Integer aNbKnots;
630
631 if (isSBSpline) {
632 // Get U knots of BSpline surface.
633 Handle(Geom_Surface) aSurf = mySurface.Surface().Surface();
634 Handle(Geom_BSplineSurface) aBSplSurf;
635
636 aBSplSurf = Handle(Geom_BSplineSurface)::DownCast(aSurf);
637 aNbKnots = aBSplSurf->NbUKnots();
638 aKnots = new TColStd_HArray1OfReal(1, aNbKnots);
639 aBSplSurf->UKnots(aKnots->ChangeArray1());
640 } else {
641 // Get U knots of BSpline curve - basis curve of
642 // the surface of linear extrusion.
643 GeomAdaptor_Curve aCurve;
644 Handle(Geom_Surface) aSurf = mySurface.Surface().Surface();
645 Handle(Geom_BSplineCurve) aBSplCurve;
646
c5f3a425 647 aCurve.Load(Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (aSurf)->BasisCurve());
7fd59977 648 aBSplCurve = aCurve.BSpline();
649 aNbKnots = aBSplCurve->NbKnots();
650 aKnots = new TColStd_HArray1OfReal(1, aNbKnots);
651 aBSplCurve->Knots(aKnots->ChangeArray1());
652 }
653
654 // Compute number of knots inside theUMin and theUMax.
655 GetRealKnots(theUMin, theUMax, aKnots, theUKnots);
656 } else {
657 // No span decomposition.
658 theUKnots = new TColStd_HArray1OfReal(1, 2);
659 theUKnots->SetValue(1, theUMin);
660 theUKnots->SetValue(2, theUMax);
661 }
662}
663
664//=======================================================================
665//function : GetTKnots
666//purpose :
667//=======================================================================
668
669void BRepGProp_Face::GetTKnots
670 (const Standard_Real theTMin,
671 const Standard_Real theTMax,
672 Handle(TColStd_HArray1OfReal) &theTKnots) const
673{
674 Standard_Boolean isBSpline = mySurface.GetType() == GeomAbs_BSplineSurface;
675
676 if (myIsUseSpan && isBSpline) {
677 // Using span decomposition for BSpline.
678 Handle(TColStd_HArray1OfReal) aSurfKnots;
679 Standard_Integer aNbKnots;
680
681 // Get V knots of BSpline surface.
682 Handle(Geom_Surface) aSurf = mySurface.Surface().Surface();
683 Handle(Geom_BSplineSurface) aBSplSurf;
684
685 aBSplSurf = Handle(Geom_BSplineSurface)::DownCast(aSurf);
686 aNbKnots = aBSplSurf->NbVKnots();
687 aSurfKnots = new TColStd_HArray1OfReal(1, aNbKnots);
688 aBSplSurf->VKnots(aSurfKnots->ChangeArray1());
689
690// Handle(TColStd_HArray1OfReal) aCurveKnots;
691
692// GetCurveKnots(theTMin, theTMax, myCurve, aCurveKnots);
693// GetRealCurveKnots(aCurveKnots, aSurfKnots, myCurve, theTKnots);
694 GetCurveKnots(theTMin, theTMax, myCurve, theTKnots);
695 } else {
696 theTKnots = new TColStd_HArray1OfReal(1, 2);
697 theTKnots->SetValue(1, theTMin);
698 theTKnots->SetValue(2, theTMax);
699 }
700}