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