0024002: Overall code and build procedure refactoring -- automatic
[occt.git] / src / BRepGProp / BRepGProp_Face.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
16 #include <Bnd_Box2d.hxx>
17 #include <BndLib_Add2dCurve.hxx>
18 #include <BRepGProp_Face.hxx>
19 #include <Geom2d_BezierCurve.hxx>
20 #include <Geom2d_BSplineCurve.hxx>
21 #include <Geom2d_Line.hxx>
22 #include <Geom_BezierSurface.hxx>
23 #include <Geom_BSplineCurve.hxx>
24 #include <Geom_BSplineSurface.hxx>
25 #include <Geom_SurfaceOfLinearExtrusion.hxx>
26 #include <GeomAdaptor_Curve.hxx>
27 #include <gp_Pnt.hxx>
28 #include <gp_Pnt2d.hxx>
29 #include <gp_Vec.hxx>
30 #include <gp_Vec2d.hxx>
31 #include <math.hxx>
32 #include <Precision.hxx>
33 #include <TopoDS.hxx>
34 #include <TopoDS_Edge.hxx>
35 #include <TopoDS_Face.hxx>
36
37 //=======================================================================
38 //function : UIntegrationOrder
39 //purpose  : 
40 //=======================================================================
41 Standard_Integer BRepGProp_Face::UIntegrationOrder() const {
42
43   Standard_Integer Nu;
44   switch (mySurface.GetType())
45   {
46
47   case GeomAbs_Plane :
48     Nu =4;
49     break;
50
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   }
69  return Max(8,2*Nu);
70 }
71
72 //=======================================================================
73 //function : VIntegrationOrder
74 //purpose  : 
75 //=======================================================================
76
77 Standard_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
113 Standard_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
160 void 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
176 void 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
195 void 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
208 void 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.
223 static Standard_Real AS = -0.15, AL = -0.50, B = 1.0, C = 0.75, D = 0.25;
224 static inline Standard_Real SCoeff(const Standard_Real Eps){
225   return Eps < 0.1? AS*(B+Log10(Eps)) + C: C;
226 }
227 static 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
236 Standard_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
269 Standard_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
298 Standard_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
328 void 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:
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;
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
354 void 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: 
363     Knots(1) = -M_PI/2.0;  Knots(2) = 0.0;  Knots(3) = +M_PI/2.0;
364     break;
365   case GeomAbs_Torus:
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;
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
382 Standard_Integer BRepGProp_Face::LIntOrder(const Standard_Real Eps) const
383 {
384   Bnd_Box2d aBox;
385
386   BndLib_Add2dCurve::Add(myCurve, 1.e-7, aBox);
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
436 Standard_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
462 void 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:
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;
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
490 void 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
536 static 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
578 static 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 //=======================================================================
603 //function : GetUKnots
604 //purpose  : 
605 //=======================================================================
606
607 void 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
621       aCurve.Load(Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (aSurf)->BasisCurve());
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
647       aCurve.Load(Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (aSurf)->BasisCurve());
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
669 void 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 }