1 // Created on: 1993-05-14
2 // Created by: Joelle CHAUVET
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
6 // This file is part of Open CASCADE Technology software library.
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
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.
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
17 // Modified: Thu Nov 26 16:37:18 1998
18 // correction in NbUIntervals for SurfaceOfLinearExtrusion
21 #define No_Standard_RangeError
22 #define No_Standard_OutOfRange
24 #include <Adaptor3d_HCurve.hxx>
25 #include <Adaptor3d_HSurface.hxx>
26 #include <BSplCLib.hxx>
27 #include <BSplSLib_Cache.hxx>
28 #include <Geom_BezierSurface.hxx>
29 #include <Geom_BSplineSurface.hxx>
30 #include <Geom_Circle.hxx>
31 #include <Geom_ConicalSurface.hxx>
32 #include <Geom_Curve.hxx>
33 #include <Geom_CylindricalSurface.hxx>
34 #include <Geom_OffsetSurface.hxx>
35 #include <Geom_Plane.hxx>
36 #include <Geom_RectangularTrimmedSurface.hxx>
37 #include <Geom_SphericalSurface.hxx>
38 #include <Geom_Surface.hxx>
39 #include <Geom_SurfaceOfLinearExtrusion.hxx>
40 #include <Geom_SurfaceOfRevolution.hxx>
41 #include <Geom_ToroidalSurface.hxx>
42 #include <GeomAdaptor_Curve.hxx>
43 #include <GeomAdaptor_HCurve.hxx>
44 #include <GeomAdaptor_HSurface.hxx>
45 #include <GeomAdaptor_Surface.hxx>
46 #include <GeomEvaluator_OffsetSurface.hxx>
47 #include <GeomEvaluator_SurfaceOfExtrusion.hxx>
48 #include <GeomEvaluator_SurfaceOfRevolution.hxx>
50 #include <gp_Circ.hxx>
51 #include <gp_Cone.hxx>
52 #include <gp_Cylinder.hxx>
57 #include <gp_Sphere.hxx>
58 #include <gp_Torus.hxx>
59 #include <gp_Trsf.hxx>
61 #include <Precision.hxx>
62 #include <Standard_ConstructionError.hxx>
63 #include <Standard_DomainError.hxx>
64 #include <Standard_NoSuchObject.hxx>
65 #include <Standard_NullObject.hxx>
66 #include <Standard_OutOfRange.hxx>
67 #include <TColStd_Array1OfInteger.hxx>
68 #include <TColStd_Array1OfReal.hxx>
69 #include <TColStd_HArray1OfInteger.hxx>
71 static const Standard_Real PosTol = Precision::PConfusion()*0.5;
73 //=======================================================================
74 //function : LocalContinuity
76 //=======================================================================
78 GeomAbs_Shape LocalContinuity(Standard_Integer Degree,
80 TColStd_Array1OfReal& TK,
81 TColStd_Array1OfInteger& TM,
84 Standard_Boolean IsPeriodic)
86 Standard_DomainError_Raise_if( (TK.Length()!=Nb || TM.Length()!=Nb )," ");
87 Standard_Integer Index1 = 0;
88 Standard_Integer Index2 = 0;
89 Standard_Real newFirst, newLast;
90 BSplCLib::LocateParameter(Degree,TK,TM,PFirst,IsPeriodic,1,Nb,Index1,newFirst);
91 BSplCLib::LocateParameter(Degree,TK,TM,PLast, IsPeriodic,1,Nb,Index2,newLast );
92 const Standard_Real EpsKnot = Precision::PConfusion();
93 if (Abs(newFirst-TK(Index1+1))< EpsKnot) Index1++;
94 if (Abs(newLast -TK(Index2 ))< EpsKnot) Index2--;
95 // attention aux courbes peridiques.
96 if ( (IsPeriodic) && (Index1 == Nb) )
101 Standard_Integer i, Multmax = TM(Index1+1);
102 for (i = Index1+1; i<=Index2; i++) {
103 if (TM(i)>Multmax) Multmax=TM(i);
105 Multmax = Degree - Multmax;
106 if (Multmax <= 0) return GeomAbs_C0;
108 case 1: return GeomAbs_C1;
109 case 2: return GeomAbs_C2;
110 case 3: return GeomAbs_C3;
116 //=======================================================================
119 //=======================================================================
121 void GeomAdaptor_Surface::load(const Handle(Geom_Surface)& S,
122 const Standard_Real UFirst,
123 const Standard_Real ULast,
124 const Standard_Real VFirst,
125 const Standard_Real VLast,
126 const Standard_Real TolU,
127 const Standard_Real TolV)
135 mySurfaceCache.Nullify();
137 if ( mySurface != S) {
139 myNestedEvaluator.Nullify();
140 myBSplineSurface.Nullify();
142 const Handle(Standard_Type)& TheType = S->DynamicType();
143 if (TheType == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
144 Load(Handle(Geom_RectangularTrimmedSurface)::DownCast (S)->BasisSurface(),
145 UFirst,ULast,VFirst,VLast);
147 else if ( TheType == STANDARD_TYPE(Geom_Plane))
148 mySurfaceType = GeomAbs_Plane;
149 else if ( TheType == STANDARD_TYPE(Geom_CylindricalSurface))
150 mySurfaceType = GeomAbs_Cylinder;
151 else if ( TheType == STANDARD_TYPE(Geom_ConicalSurface))
152 mySurfaceType = GeomAbs_Cone;
153 else if ( TheType == STANDARD_TYPE(Geom_SphericalSurface))
154 mySurfaceType = GeomAbs_Sphere;
155 else if ( TheType == STANDARD_TYPE(Geom_ToroidalSurface))
156 mySurfaceType = GeomAbs_Torus;
157 else if ( TheType == STANDARD_TYPE(Geom_SurfaceOfRevolution))
159 mySurfaceType = GeomAbs_SurfaceOfRevolution;
160 Handle(Geom_SurfaceOfRevolution) myRevSurf =
161 Handle(Geom_SurfaceOfRevolution)::DownCast(mySurface);
162 // Create nested adaptor for base curve
163 Handle(Geom_Curve) aBaseCurve = myRevSurf->BasisCurve();
164 Handle(Adaptor3d_HCurve) aBaseAdaptor = new GeomAdaptor_HCurve(aBaseCurve);
165 // Create corresponding evaluator
167 new GeomEvaluator_SurfaceOfRevolution (aBaseAdaptor, myRevSurf->Direction(), myRevSurf->Location());
169 else if ( TheType == STANDARD_TYPE(Geom_SurfaceOfLinearExtrusion))
171 mySurfaceType = GeomAbs_SurfaceOfExtrusion;
172 Handle(Geom_SurfaceOfLinearExtrusion) myExtSurf =
173 Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(mySurface);
174 // Create nested adaptor for base curve
175 Handle(Geom_Curve) aBaseCurve = myExtSurf->BasisCurve();
176 Handle(Adaptor3d_HCurve) aBaseAdaptor = new GeomAdaptor_HCurve(aBaseCurve);
177 // Create corresponding evaluator
179 new GeomEvaluator_SurfaceOfExtrusion (aBaseAdaptor, myExtSurf->Direction());
181 else if (TheType == STANDARD_TYPE(Geom_BezierSurface))
183 mySurfaceType = GeomAbs_BezierSurface;
185 else if (TheType == STANDARD_TYPE(Geom_BSplineSurface)) {
186 mySurfaceType = GeomAbs_BSplineSurface;
187 myBSplineSurface = Handle(Geom_BSplineSurface)::DownCast(mySurface);
189 else if ( TheType == STANDARD_TYPE(Geom_OffsetSurface))
191 mySurfaceType = GeomAbs_OffsetSurface;
192 Handle(Geom_OffsetSurface) myOffSurf = Handle(Geom_OffsetSurface)::DownCast(mySurface);
193 // Create nested adaptor for base surface
194 Handle(Geom_Surface) aBaseSurf = myOffSurf->BasisSurface();
195 Handle(GeomAdaptor_HSurface) aBaseAdaptor =
196 new GeomAdaptor_HSurface(aBaseSurf, myUFirst, myULast, myVFirst, myVLast, myTolU, myTolV);
197 myNestedEvaluator = new GeomEvaluator_OffsetSurface(
198 aBaseAdaptor, myOffSurf->Offset(), myOffSurf->OsculatingSurface());
201 mySurfaceType = GeomAbs_OtherSurface;
206 // -- Global methods - Apply to the whole Surface.
210 //=======================================================================
211 //function : UContinuity
213 //=======================================================================
215 GeomAbs_Shape GeomAdaptor_Surface::UContinuity() const
217 switch (mySurfaceType)
219 case GeomAbs_BSplineSurface:
221 const Standard_Integer N = myBSplineSurface->NbUKnots();
222 TColStd_Array1OfReal TK(1,N);
223 TColStd_Array1OfInteger TM(1,N);
224 myBSplineSurface->UKnots(TK);
225 myBSplineSurface->UMultiplicities(TM);
226 return LocalContinuity(myBSplineSurface->UDegree(), myBSplineSurface->NbUKnots(), TK, TM,
227 myUFirst, myULast, IsUPeriodic());
229 case GeomAbs_OffsetSurface:
231 switch(BasisSurface()->UContinuity())
234 case GeomAbs_C3 : return GeomAbs_CN;
236 case GeomAbs_C2 : return GeomAbs_C1;
239 case GeomAbs_C0 : return GeomAbs_C0;
241 throw Standard_NoSuchObject("GeomAdaptor_Surface::UContinuity");
244 case GeomAbs_SurfaceOfExtrusion:
246 Handle(Geom_SurfaceOfLinearExtrusion) myExtSurf =
247 Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(mySurface);
248 GeomAdaptor_Curve GC(myExtSurf->BasisCurve(), myUFirst, myULast);
249 return GC.Continuity();
251 case GeomAbs_OtherSurface:
252 throw Standard_NoSuchObject("GeomAdaptor_Surface::UContinuity");
254 case GeomAbs_Cylinder:
258 case GeomAbs_BezierSurface:
259 case GeomAbs_SurfaceOfRevolution: break;
264 //=======================================================================
265 //function : VContinuity
267 //=======================================================================
269 GeomAbs_Shape GeomAdaptor_Surface::VContinuity() const
271 switch (mySurfaceType)
273 case GeomAbs_BSplineSurface:
275 const Standard_Integer N = myBSplineSurface->NbVKnots();
276 TColStd_Array1OfReal TK(1,N);
277 TColStd_Array1OfInteger TM(1,N);
278 myBSplineSurface->VKnots(TK);
279 myBSplineSurface->VMultiplicities(TM);
280 return LocalContinuity(myBSplineSurface->VDegree(), myBSplineSurface->NbVKnots(), TK, TM,
281 myVFirst, myVLast, IsVPeriodic());
283 case GeomAbs_OffsetSurface:
285 switch(BasisSurface()->VContinuity())
288 case GeomAbs_C3 : return GeomAbs_CN;
290 case GeomAbs_C2 : return GeomAbs_C1;
293 case GeomAbs_C0 : return GeomAbs_C0;
295 throw Standard_NoSuchObject("GeomAdaptor_Surface::VContinuity");
298 case GeomAbs_SurfaceOfRevolution:
300 Handle(Geom_SurfaceOfRevolution) myRevSurf =
301 Handle(Geom_SurfaceOfRevolution)::DownCast(mySurface);
302 GeomAdaptor_Curve GC(myRevSurf->BasisCurve(), myVFirst, myVLast);
303 return GC.Continuity();
305 case GeomAbs_OtherSurface:
306 throw Standard_NoSuchObject("GeomAdaptor_Surface::VContinuity");
308 case GeomAbs_Cylinder:
312 case GeomAbs_BezierSurface:
313 case GeomAbs_SurfaceOfExtrusion: break;
318 //=======================================================================
319 //function : NbUIntervals
321 //=======================================================================
323 Standard_Integer GeomAdaptor_Surface::NbUIntervals(const GeomAbs_Shape S) const
325 switch (mySurfaceType)
327 case GeomAbs_BSplineSurface:
329 GeomAdaptor_Curve myBasisCurve
330 (myBSplineSurface->VIso(myBSplineSurface->VKnot(myBSplineSurface->FirstVKnotIndex())),myUFirst,myULast);
331 return myBasisCurve.NbIntervals(S);
333 case GeomAbs_SurfaceOfExtrusion:
335 Handle(Geom_SurfaceOfLinearExtrusion) myExtSurf =
336 Handle(Geom_SurfaceOfLinearExtrusion)::DownCast(mySurface);
337 GeomAdaptor_Curve myBasisCurve(myExtSurf->BasisCurve(), myUFirst, myULast);
338 if (myBasisCurve.GetType() == GeomAbs_BSplineCurve)
339 return myBasisCurve.NbIntervals(S);
342 case GeomAbs_OffsetSurface:
344 GeomAbs_Shape BaseS = GeomAbs_CN;
348 case GeomAbs_G2: throw Standard_DomainError("GeomAdaptor_Curve::NbUIntervals");
349 case GeomAbs_C0: BaseS = GeomAbs_C1; break;
350 case GeomAbs_C1: BaseS = GeomAbs_C2; break;
351 case GeomAbs_C2: BaseS = GeomAbs_C3; break;
353 case GeomAbs_CN: break;
355 Handle(Geom_OffsetSurface) myOffSurf = Handle(Geom_OffsetSurface)::DownCast(mySurface);
356 GeomAdaptor_Surface Sur(myOffSurf->BasisSurface(), myUFirst, myULast, myVFirst, myVLast);
357 return Sur.NbUIntervals(BaseS);
360 case GeomAbs_Cylinder:
364 case GeomAbs_BezierSurface:
365 case GeomAbs_OtherSurface:
366 case GeomAbs_SurfaceOfRevolution: break;
371 //=======================================================================
372 //function : NbVIntervals
374 //=======================================================================
376 Standard_Integer GeomAdaptor_Surface::NbVIntervals(const GeomAbs_Shape S) const
378 switch (mySurfaceType)
380 case GeomAbs_BSplineSurface:
382 GeomAdaptor_Curve myBasisCurve
383 (myBSplineSurface->UIso(myBSplineSurface->UKnot(myBSplineSurface->FirstUKnotIndex())),myVFirst,myVLast);
384 return myBasisCurve.NbIntervals(S);
386 case GeomAbs_SurfaceOfRevolution:
388 Handle(Geom_SurfaceOfRevolution) myRevSurf =
389 Handle(Geom_SurfaceOfRevolution)::DownCast(mySurface);
390 GeomAdaptor_Curve myBasisCurve(myRevSurf->BasisCurve(), myVFirst, myVLast);
391 if (myBasisCurve.GetType() == GeomAbs_BSplineCurve)
392 return myBasisCurve.NbIntervals(S);
395 case GeomAbs_OffsetSurface:
397 GeomAbs_Shape BaseS = GeomAbs_CN;
401 case GeomAbs_G2: throw Standard_DomainError("GeomAdaptor_Curve::NbVIntervals");
402 case GeomAbs_C0: BaseS = GeomAbs_C1; break;
403 case GeomAbs_C1: BaseS = GeomAbs_C2; break;
404 case GeomAbs_C2: BaseS = GeomAbs_C3; break;
406 case GeomAbs_CN: break;
408 Handle(Geom_OffsetSurface) myOffSurf = Handle(Geom_OffsetSurface)::DownCast(mySurface);
409 GeomAdaptor_Surface Sur(myOffSurf->BasisSurface(), myUFirst, myULast, myVFirst, myVLast);
410 return Sur.NbVIntervals(BaseS);
413 case GeomAbs_Cylinder:
417 case GeomAbs_BezierSurface:
418 case GeomAbs_OtherSurface:
419 case GeomAbs_SurfaceOfExtrusion: break;
424 //=======================================================================
425 //function : UIntervals
427 //=======================================================================
429 void GeomAdaptor_Surface::UIntervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const
431 Standard_Integer myNbUIntervals = 1;
433 switch (mySurfaceType)
435 case GeomAbs_BSplineSurface:
437 GeomAdaptor_Curve myBasisCurve
438 (myBSplineSurface->VIso(myBSplineSurface->VKnot(myBSplineSurface->FirstVKnotIndex())),myUFirst,myULast);
439 myNbUIntervals = myBasisCurve.NbIntervals(S);
440 myBasisCurve.Intervals(T,S);
443 case GeomAbs_SurfaceOfExtrusion:
445 GeomAdaptor_Curve myBasisCurve
446 (Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (mySurface)->BasisCurve(),myUFirst,myULast);
447 if (myBasisCurve.GetType() == GeomAbs_BSplineCurve)
449 myNbUIntervals = myBasisCurve.NbIntervals(S);
450 myBasisCurve.Intervals(T,S);
455 case GeomAbs_OffsetSurface:
457 GeomAbs_Shape BaseS = GeomAbs_CN;
461 case GeomAbs_G2: throw Standard_DomainError("GeomAdaptor_Curve::UIntervals");
462 case GeomAbs_C0: BaseS = GeomAbs_C1; break;
463 case GeomAbs_C1: BaseS = GeomAbs_C2; break;
464 case GeomAbs_C2: BaseS = GeomAbs_C3; break;
466 case GeomAbs_CN: break;
468 Handle(Geom_OffsetSurface) myOffSurf = Handle(Geom_OffsetSurface)::DownCast(mySurface);
469 GeomAdaptor_Surface Sur(myOffSurf->BasisSurface(), myUFirst, myULast, myVFirst, myVLast);
470 myNbUIntervals = Sur.NbUIntervals(BaseS);
471 Sur.UIntervals(T, BaseS);
475 case GeomAbs_Cylinder:
479 case GeomAbs_BezierSurface:
480 case GeomAbs_OtherSurface:
481 case GeomAbs_SurfaceOfRevolution: break;
484 T(T.Lower()) = myUFirst;
485 T(T.Lower() + myNbUIntervals) = myULast;
488 //=======================================================================
489 //function : VIntervals
491 //=======================================================================
493 void GeomAdaptor_Surface::VIntervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const
495 Standard_Integer myNbVIntervals = 1;
497 switch (mySurfaceType)
499 case GeomAbs_BSplineSurface:
501 GeomAdaptor_Curve myBasisCurve
502 (myBSplineSurface->UIso(myBSplineSurface->UKnot(myBSplineSurface->FirstUKnotIndex())),myVFirst,myVLast);
503 myNbVIntervals = myBasisCurve.NbIntervals(S);
504 myBasisCurve.Intervals(T,S);
507 case GeomAbs_SurfaceOfRevolution:
509 Handle(Geom_SurfaceOfRevolution) myRevSurf =
510 Handle(Geom_SurfaceOfRevolution)::DownCast(mySurface);
511 GeomAdaptor_Curve myBasisCurve(myRevSurf->BasisCurve(), myVFirst, myVLast);
512 if (myBasisCurve.GetType() == GeomAbs_BSplineCurve)
514 myNbVIntervals = myBasisCurve.NbIntervals(S);
515 myBasisCurve.Intervals(T,S);
520 case GeomAbs_OffsetSurface:
522 GeomAbs_Shape BaseS = GeomAbs_CN;
526 case GeomAbs_G2: throw Standard_DomainError("GeomAdaptor_Curve::VIntervals");
527 case GeomAbs_C0: BaseS = GeomAbs_C1; break;
528 case GeomAbs_C1: BaseS = GeomAbs_C2; break;
529 case GeomAbs_C2: BaseS = GeomAbs_C3; break;
531 case GeomAbs_CN: break;
533 Handle(Geom_OffsetSurface) myOffSurf = Handle(Geom_OffsetSurface)::DownCast(mySurface);
534 GeomAdaptor_Surface Sur(myOffSurf->BasisSurface(), myUFirst, myULast, myVFirst, myVLast);
535 myNbVIntervals = Sur.NbVIntervals(BaseS);
536 Sur.VIntervals(T, BaseS);
540 case GeomAbs_Cylinder:
544 case GeomAbs_BezierSurface:
545 case GeomAbs_OtherSurface:
546 case GeomAbs_SurfaceOfExtrusion: break;
549 T(T.Lower()) = myVFirst;
550 T(T.Lower() + myNbVIntervals) = myVLast;
553 //=======================================================================
556 //=======================================================================
558 Handle(Adaptor3d_HSurface) GeomAdaptor_Surface::UTrim(const Standard_Real First,
559 const Standard_Real Last ,
560 const Standard_Real Tol ) const
562 return Handle(GeomAdaptor_HSurface)
563 (new GeomAdaptor_HSurface(mySurface,First,Last,myVFirst,myVLast,Tol,myTolV));
566 //=======================================================================
569 //=======================================================================
571 Handle(Adaptor3d_HSurface) GeomAdaptor_Surface::VTrim(const Standard_Real First,
572 const Standard_Real Last ,
573 const Standard_Real Tol ) const
575 return Handle(GeomAdaptor_HSurface)
576 (new GeomAdaptor_HSurface(mySurface,myUFirst,myULast,First,Last,myTolU,Tol));
579 //=======================================================================
580 //function : IsUClosed
582 //=======================================================================
584 Standard_Boolean GeomAdaptor_Surface::IsUClosed() const
586 if (!mySurface->IsUClosed())
587 return Standard_False;
589 Standard_Real U1,U2,V1,V2;
590 mySurface->Bounds(U1,U2,V1,V2);
591 if (mySurface->IsUPeriodic())
592 return (Abs(Abs(U1-U2)-Abs(myUFirst-myULast))<Precision::PConfusion());
594 return ( Abs(U1-myUFirst)<Precision::PConfusion()
595 && Abs(U2-myULast )<Precision::PConfusion() );
598 //=======================================================================
599 //function : IsVClosed
601 //=======================================================================
603 Standard_Boolean GeomAdaptor_Surface::IsVClosed() const
605 if (!mySurface->IsVClosed())
606 return Standard_False;
608 Standard_Real U1,U2,V1,V2;
609 mySurface->Bounds(U1,U2,V1,V2);
610 if (mySurface->IsVPeriodic())
611 return (Abs(Abs(V1-V2)-Abs(myVFirst-myVLast))<Precision::PConfusion());
613 return ( Abs(V1-myVFirst)<Precision::PConfusion()
614 && Abs(V2-myVLast )<Precision::PConfusion() );
617 //=======================================================================
618 //function : IsUPeriodic
620 //=======================================================================
622 Standard_Boolean GeomAdaptor_Surface::IsUPeriodic() const
624 return (mySurface->IsUPeriodic());
627 //=======================================================================
630 //=======================================================================
632 Standard_Real GeomAdaptor_Surface::UPeriod() const
634 Standard_NoSuchObject_Raise_if(!IsUPeriodic()," ");
635 return mySurface->UPeriod();
638 //=======================================================================
639 //function : IsVPeriodic
641 //=======================================================================
643 Standard_Boolean GeomAdaptor_Surface::IsVPeriodic() const
645 return (mySurface->IsVPeriodic());
648 //=======================================================================
651 //=======================================================================
653 Standard_Real GeomAdaptor_Surface::VPeriod() const
655 Standard_NoSuchObject_Raise_if(!IsVPeriodic()," ");
656 return mySurface->VPeriod();
659 //=======================================================================
660 //function : RebuildCache
662 //=======================================================================
663 void GeomAdaptor_Surface::RebuildCache(const Standard_Real theU,
664 const Standard_Real theV) const
666 if (mySurfaceType == GeomAbs_BezierSurface)
668 // Create cache for Bezier
669 Handle(Geom_BezierSurface) aBezier = Handle(Geom_BezierSurface)::DownCast(mySurface);
670 Standard_Integer aDegU = aBezier->UDegree();
671 Standard_Integer aDegV = aBezier->VDegree();
672 TColStd_Array1OfReal aFlatKnotsU(BSplCLib::FlatBezierKnots(aDegU), 1, 2 * (aDegU + 1));
673 TColStd_Array1OfReal aFlatKnotsV(BSplCLib::FlatBezierKnots(aDegV), 1, 2 * (aDegV + 1));
674 if (mySurfaceCache.IsNull())
675 mySurfaceCache = new BSplSLib_Cache(
676 aDegU, aBezier->IsUPeriodic(), aFlatKnotsU,
677 aDegV, aBezier->IsVPeriodic(), aFlatKnotsV, aBezier->Weights());
678 mySurfaceCache->BuildCache (theU, theV, aFlatKnotsU, aFlatKnotsV,
679 aBezier->Poles(), aBezier->Weights());
681 else if (mySurfaceType == GeomAbs_BSplineSurface)
683 // Create cache for B-spline
684 if (mySurfaceCache.IsNull())
685 mySurfaceCache = new BSplSLib_Cache(
686 myBSplineSurface->UDegree(), myBSplineSurface->IsUPeriodic(), myBSplineSurface->UKnotSequence(),
687 myBSplineSurface->VDegree(), myBSplineSurface->IsVPeriodic(), myBSplineSurface->VKnotSequence(),
688 myBSplineSurface->Weights());
689 mySurfaceCache->BuildCache (theU, theV, myBSplineSurface->UKnotSequence(), myBSplineSurface->VKnotSequence(),
690 myBSplineSurface->Poles(), myBSplineSurface->Weights());
694 //=======================================================================
697 //=======================================================================
699 gp_Pnt GeomAdaptor_Surface::Value(const Standard_Real U,
700 const Standard_Real V) const
707 //=======================================================================
710 //=======================================================================
712 void GeomAdaptor_Surface::D0(const Standard_Real U,
713 const Standard_Real V, gp_Pnt& P) const
715 switch (mySurfaceType)
717 case GeomAbs_BezierSurface:
718 case GeomAbs_BSplineSurface:
719 if (mySurfaceCache.IsNull() || !mySurfaceCache->IsCacheValid(U, V))
721 mySurfaceCache->D0(U, V, P);
724 case GeomAbs_OffsetSurface:
725 case GeomAbs_SurfaceOfExtrusion:
726 case GeomAbs_SurfaceOfRevolution:
727 Standard_NoSuchObject_Raise_if(myNestedEvaluator.IsNull(),
728 "GeomAdaptor_Surface::D0: evaluator is not initialized");
729 myNestedEvaluator->D0(U, V, P);
733 mySurface->D0(U, V, P);
738 //=======================================================================
741 //=======================================================================
743 void GeomAdaptor_Surface::D1(const Standard_Real U,
744 const Standard_Real V,
749 Standard_Integer Ideb, Ifin, IVdeb, IVfin, USide=0, VSide=0;
750 Standard_Real u = U, v = V;
751 if (Abs(U-myUFirst) <= myTolU) {USide= 1; u = myUFirst;}
752 else if (Abs(U-myULast) <= myTolU) {USide= -1; u = myULast;}
753 if (Abs(V-myVFirst) <= myTolV) {VSide= 1; v = myVFirst;}
754 else if (Abs(V-myVLast) <= myTolV) {VSide= -1; v = myVLast;}
756 switch(mySurfaceType) {
757 case GeomAbs_BezierSurface:
758 case GeomAbs_BSplineSurface: {
759 if (!myBSplineSurface.IsNull() &&
760 (USide != 0 || VSide != 0) &&
761 IfUVBound(u, v, Ideb, Ifin, IVdeb, IVfin, USide, VSide))
762 myBSplineSurface->LocalD1(u, v, Ideb, Ifin, IVdeb, IVfin, P, D1U, D1V);
765 if (mySurfaceCache.IsNull() || !mySurfaceCache->IsCacheValid(U, V))
767 mySurfaceCache->D1(U, V, P, D1U, D1V);
772 case GeomAbs_SurfaceOfExtrusion:
773 case GeomAbs_SurfaceOfRevolution:
774 case GeomAbs_OffsetSurface:
775 Standard_NoSuchObject_Raise_if(myNestedEvaluator.IsNull(),
776 "GeomAdaptor_Surface::D1: evaluator is not initialized");
777 myNestedEvaluator->D1(u, v, P, D1U, D1V);
781 mySurface->D1(u, v, P, D1U, D1V);
785 //=======================================================================
788 //=======================================================================
790 void GeomAdaptor_Surface::D2(const Standard_Real U,
791 const Standard_Real V,
799 Standard_Integer Ideb, Ifin, IVdeb, IVfin, USide=0, VSide=0;
800 Standard_Real u = U, v = V;
801 if (Abs(U-myUFirst) <= myTolU) {USide= 1; u = myUFirst;}
802 else if (Abs(U-myULast) <= myTolU) {USide= -1; u = myULast;}
803 if (Abs(V-myVFirst) <= myTolV) {VSide= 1; v = myVFirst;}
804 else if (Abs(V-myVLast) <= myTolV) {VSide= -1; v = myVLast;}
806 switch(mySurfaceType) {
807 case GeomAbs_BezierSurface:
808 case GeomAbs_BSplineSurface: {
809 if (!myBSplineSurface.IsNull() &&
810 (USide != 0 || VSide != 0) &&
811 IfUVBound(u, v, Ideb, Ifin, IVdeb, IVfin, USide, VSide))
812 myBSplineSurface->LocalD2(u, v, Ideb, Ifin, IVdeb, IVfin, P, D1U, D1V, D2U, D2V, D2UV);
815 if (mySurfaceCache.IsNull() || !mySurfaceCache->IsCacheValid(U, V))
817 mySurfaceCache->D2(U, V, P, D1U, D1V, D2U, D2V, D2UV);
822 case GeomAbs_SurfaceOfExtrusion :
823 case GeomAbs_SurfaceOfRevolution :
824 case GeomAbs_OffsetSurface :
825 Standard_NoSuchObject_Raise_if(myNestedEvaluator.IsNull(),
826 "GeomAdaptor_Surface::D2: evaluator is not initialized");
827 myNestedEvaluator->D2(u, v, P, D1U, D1V, D2U, D2V, D2UV);
830 default: { mySurface->D2(u, v, P, D1U, D1V, D2U, D2V, D2UV);
836 //=======================================================================
839 //=======================================================================
841 void GeomAdaptor_Surface::D3(const Standard_Real U, const Standard_Real V,
842 gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V,
843 gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV,
844 gp_Vec& D3U, gp_Vec& D3V, gp_Vec& D3UUV,
847 Standard_Integer Ideb,Ifin,IVdeb,IVfin,USide=0,VSide=0;
848 Standard_Real u = U, v = V;
849 if (Abs(U-myUFirst) <= myTolU) {USide= 1; u = myUFirst;}
850 else if (Abs(U-myULast) <= myTolU) {USide= -1; u = myULast;}
851 if (Abs(V-myVFirst) <= myTolV) {VSide= 1; v = myVFirst;}
852 else if (Abs(V-myVLast) <= myTolV) {VSide= -1; v = myVLast;}
854 switch(mySurfaceType) {
855 case GeomAbs_BSplineSurface: {
856 if ((USide == 0) && (VSide == 0))
857 myBSplineSurface->D3(u, v, P, D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV);
859 if (IfUVBound(u, v, Ideb, Ifin, IVdeb, IVfin, USide, VSide))
860 myBSplineSurface->LocalD3(u, v, Ideb, Ifin, IVdeb, IVfin,
861 P, D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV);
863 myBSplineSurface->D3(u, v, P, D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV);
868 case GeomAbs_SurfaceOfExtrusion :
869 case GeomAbs_SurfaceOfRevolution :
870 case GeomAbs_OffsetSurface:
871 Standard_NoSuchObject_Raise_if(myNestedEvaluator.IsNull(),
872 "GeomAdaptor_Surface::D3: evaluator is not initialized");
873 myNestedEvaluator->D3(u, v, P, D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV);
876 default : { mySurface->D3(u,v,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
881 //=======================================================================
884 //=======================================================================
886 gp_Vec GeomAdaptor_Surface::DN(const Standard_Real U,
887 const Standard_Real V,
888 const Standard_Integer Nu,
889 const Standard_Integer Nv) const
891 Standard_Integer Ideb,Ifin,IVdeb,IVfin,USide=0,VSide=0;
892 Standard_Real u = U, v = V;
893 if (Abs(U-myUFirst) <= myTolU) {USide= 1; u = myUFirst;}
894 else if (Abs(U-myULast) <= myTolU) {USide= -1; u = myULast;}
895 if (Abs(V-myVFirst) <= myTolV) {VSide= 1; v = myVFirst;}
896 else if (Abs(V-myVLast) <= myTolV) {VSide= -1; v = myVLast;}
898 switch(mySurfaceType)
900 case GeomAbs_BSplineSurface: {
901 if ((USide == 0) && (VSide == 0))
902 return myBSplineSurface->DN(u, v, Nu, Nv);
904 if (IfUVBound(u, v, Ideb, Ifin, IVdeb, IVfin, USide, VSide))
905 return myBSplineSurface->LocalDN(u, v, Ideb, Ifin, IVdeb, IVfin, Nu, Nv);
907 return myBSplineSurface->DN(u, v, Nu, Nv);
911 case GeomAbs_SurfaceOfExtrusion:
912 case GeomAbs_SurfaceOfRevolution:
913 case GeomAbs_OffsetSurface:
914 Standard_NoSuchObject_Raise_if(myNestedEvaluator.IsNull(),
915 "GeomAdaptor_Surface::DN: evaluator is not initialized");
916 return myNestedEvaluator->DN(u, v, Nu, Nv);
919 case GeomAbs_Cylinder:
923 case GeomAbs_BezierSurface:
924 case GeomAbs_OtherSurface:
929 return mySurface->DN(u,v, Nu, Nv);
933 //=======================================================================
934 //function : UResolution
936 //=======================================================================
938 Standard_Real GeomAdaptor_Surface::UResolution(const Standard_Real R3d) const
940 Standard_Real Res = 0.;
942 switch (mySurfaceType)
944 case GeomAbs_SurfaceOfExtrusion:
946 GeomAdaptor_Curve myBasisCurve
947 (Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (mySurface)->BasisCurve(),myUFirst,myULast);
948 return myBasisCurve.Resolution(R3d);
952 Handle(Geom_ToroidalSurface) S (Handle(Geom_ToroidalSurface)::DownCast (mySurface));
953 const Standard_Real R = S->MajorRadius() + S->MinorRadius();
954 if(R>Precision::Confusion())
960 Handle(Geom_SphericalSurface) S (Handle(Geom_SphericalSurface)::DownCast (mySurface));
961 const Standard_Real R = S->Radius();
962 if(R>Precision::Confusion())
966 case GeomAbs_Cylinder:
968 Handle(Geom_CylindricalSurface) S (Handle(Geom_CylindricalSurface)::DownCast (mySurface));
969 const Standard_Real R = S->Radius();
970 if(R>Precision::Confusion())
976 if (myVLast - myVFirst > 1.e10) {
977 // Pas vraiment borne => resolution inconnue
978 return Precision::Parametric(R3d);
980 Handle(Geom_ConicalSurface) S (Handle(Geom_ConicalSurface)::DownCast (mySurface));
981 Handle(Geom_Curve) C = S->VIso(myVLast);
982 const Standard_Real Rayon1 = Handle(Geom_Circle)::DownCast (C)->Radius();
983 C = S->VIso(myVFirst);
984 const Standard_Real Rayon2 = Handle(Geom_Circle)::DownCast (C)->Radius();
985 const Standard_Real R = (Rayon1 > Rayon2)? Rayon1 : Rayon2;
986 return (R>Precision::Confusion()? (R3d / R) : 0.);
992 case GeomAbs_BezierSurface:
994 Standard_Real Ures,Vres;
995 Handle(Geom_BezierSurface)::DownCast (mySurface)->Resolution(R3d,Ures,Vres);
998 case GeomAbs_BSplineSurface:
1000 Standard_Real Ures,Vres;
1001 myBSplineSurface->Resolution(R3d,Ures,Vres);
1004 case GeomAbs_OffsetSurface:
1006 Handle(Geom_Surface) base = Handle(Geom_OffsetSurface)::DownCast (mySurface)->BasisSurface();
1007 GeomAdaptor_Surface gabase(base,myUFirst,myULast,myVFirst,myVLast);
1008 return gabase.UResolution(R3d);
1010 default: return Precision::Parametric(R3d);
1014 return 2.*ASin(Res);
1019 //=======================================================================
1020 //function : VResolution
1022 //=======================================================================
1024 Standard_Real GeomAdaptor_Surface::VResolution(const Standard_Real R3d) const
1026 Standard_Real Res = 0.;
1028 switch (mySurfaceType)
1030 case GeomAbs_SurfaceOfRevolution:
1032 GeomAdaptor_Curve myBasisCurve
1033 (Handle(Geom_SurfaceOfRevolution)::DownCast (mySurface)->BasisCurve(),myUFirst,myULast);
1034 return myBasisCurve.Resolution(R3d);
1038 Handle(Geom_ToroidalSurface) S (Handle(Geom_ToroidalSurface)::DownCast (mySurface));
1039 const Standard_Real R = S->MinorRadius();
1040 if(R>Precision::Confusion())
1044 case GeomAbs_Sphere:
1046 Handle(Geom_SphericalSurface) S (Handle(Geom_SphericalSurface)::DownCast (mySurface));
1047 const Standard_Real R = S->Radius();
1048 if(R>Precision::Confusion())
1052 case GeomAbs_SurfaceOfExtrusion:
1053 case GeomAbs_Cylinder:
1059 case GeomAbs_BezierSurface:
1061 Standard_Real Ures,Vres;
1062 Handle(Geom_BezierSurface)::DownCast (mySurface)->Resolution(R3d,Ures,Vres);
1065 case GeomAbs_BSplineSurface:
1067 Standard_Real Ures,Vres;
1068 myBSplineSurface->Resolution(R3d,Ures,Vres);
1071 case GeomAbs_OffsetSurface:
1073 Handle(Geom_Surface) base = Handle(Geom_OffsetSurface)::DownCast (mySurface)->BasisSurface();
1074 GeomAdaptor_Surface gabase(base,myUFirst,myULast,myVFirst,myVLast);
1075 return gabase.VResolution(R3d);
1077 default: return Precision::Parametric(R3d);
1081 return 2.*ASin(Res);
1086 //=======================================================================
1089 //=======================================================================
1091 gp_Pln GeomAdaptor_Surface::Plane() const
1093 if (mySurfaceType != GeomAbs_Plane)
1094 throw Standard_NoSuchObject("GeomAdaptor_Surface::Plane");
1095 return Handle(Geom_Plane)::DownCast (mySurface)->Pln();
1098 //=======================================================================
1099 //function : Cylinder
1101 //=======================================================================
1103 gp_Cylinder GeomAdaptor_Surface::Cylinder() const
1105 if (mySurfaceType != GeomAbs_Cylinder)
1106 throw Standard_NoSuchObject("GeomAdaptor_Surface::Cylinder");
1107 return Handle(Geom_CylindricalSurface)::DownCast (mySurface)->Cylinder();
1110 //=======================================================================
1113 //=======================================================================
1115 gp_Cone GeomAdaptor_Surface::Cone() const
1117 if (mySurfaceType != GeomAbs_Cone)
1118 throw Standard_NoSuchObject("GeomAdaptor_Surface::Cone");
1119 return Handle(Geom_ConicalSurface)::DownCast (mySurface)->Cone();
1122 //=======================================================================
1125 //=======================================================================
1127 gp_Sphere GeomAdaptor_Surface::Sphere() const
1129 if (mySurfaceType != GeomAbs_Sphere)
1130 throw Standard_NoSuchObject("GeomAdaptor_Surface::Sphere");
1131 return Handle(Geom_SphericalSurface)::DownCast (mySurface)->Sphere();
1134 //=======================================================================
1137 //=======================================================================
1139 gp_Torus GeomAdaptor_Surface::Torus() const
1141 if (mySurfaceType != GeomAbs_Torus)
1142 throw Standard_NoSuchObject("GeomAdaptor_Surface::Torus");
1143 return Handle(Geom_ToroidalSurface)::DownCast (mySurface)->Torus();
1146 //=======================================================================
1147 //function : UDegree
1149 //=======================================================================
1151 Standard_Integer GeomAdaptor_Surface::UDegree() const
1153 if (mySurfaceType == GeomAbs_BSplineSurface)
1154 return myBSplineSurface->UDegree();
1155 if ( mySurfaceType == GeomAbs_BezierSurface)
1156 return Handle(Geom_BezierSurface)::DownCast (mySurface)->UDegree();
1157 if ( mySurfaceType == GeomAbs_SurfaceOfExtrusion)
1159 GeomAdaptor_Curve myBasisCurve
1160 (Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (mySurface)->BasisCurve(),myUFirst,myULast);
1161 return myBasisCurve.Degree();
1163 throw Standard_NoSuchObject("GeomAdaptor_Surface::UDegree");
1166 //=======================================================================
1167 //function : NbUPoles
1169 //=======================================================================
1171 Standard_Integer GeomAdaptor_Surface::NbUPoles() const
1173 if (mySurfaceType == GeomAbs_BSplineSurface)
1174 return myBSplineSurface->NbUPoles();
1175 if ( mySurfaceType == GeomAbs_BezierSurface)
1176 return Handle(Geom_BezierSurface)::DownCast (mySurface)->NbUPoles();
1177 if ( mySurfaceType == GeomAbs_SurfaceOfExtrusion)
1179 GeomAdaptor_Curve myBasisCurve
1180 (Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (mySurface)->BasisCurve(),myUFirst,myULast);
1181 return myBasisCurve.NbPoles();
1183 throw Standard_NoSuchObject("GeomAdaptor_Surface::NbUPoles");
1186 //=======================================================================
1187 //function : VDegree
1189 //=======================================================================
1191 Standard_Integer GeomAdaptor_Surface::VDegree() const
1193 if (mySurfaceType == GeomAbs_BSplineSurface)
1194 return myBSplineSurface->VDegree();
1195 if ( mySurfaceType == GeomAbs_BezierSurface)
1196 return Handle(Geom_BezierSurface)::DownCast (mySurface)->VDegree();
1197 if ( mySurfaceType == GeomAbs_SurfaceOfRevolution)
1199 GeomAdaptor_Curve myBasisCurve
1200 (Handle(Geom_SurfaceOfRevolution)::DownCast (mySurface)->BasisCurve(),myUFirst,myULast);
1201 return myBasisCurve.Degree();
1203 throw Standard_NoSuchObject("GeomAdaptor_Surface::VDegree");
1206 //=======================================================================
1207 //function : NbVPoles
1209 //=======================================================================
1211 Standard_Integer GeomAdaptor_Surface::NbVPoles() const
1213 if (mySurfaceType == GeomAbs_BSplineSurface)
1214 return myBSplineSurface->NbVPoles();
1215 if ( mySurfaceType == GeomAbs_BezierSurface)
1216 return Handle(Geom_BezierSurface)::DownCast (mySurface)->NbVPoles();
1217 if ( mySurfaceType == GeomAbs_SurfaceOfRevolution)
1219 GeomAdaptor_Curve myBasisCurve
1220 (Handle(Geom_SurfaceOfRevolution)::DownCast (mySurface)->BasisCurve(),myUFirst,myULast);
1221 return myBasisCurve.NbPoles();
1223 throw Standard_NoSuchObject("GeomAdaptor_Surface::NbVPoles");
1226 //=======================================================================
1227 //function : NbUKnots
1229 //=======================================================================
1231 Standard_Integer GeomAdaptor_Surface::NbUKnots() const
1233 if (mySurfaceType == GeomAbs_BSplineSurface)
1234 return myBSplineSurface->NbUKnots();
1235 if ( mySurfaceType == GeomAbs_SurfaceOfExtrusion)
1237 GeomAdaptor_Curve myBasisCurve
1238 (Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (mySurface)->BasisCurve(),myUFirst,myULast);
1239 return myBasisCurve.NbKnots();
1241 throw Standard_NoSuchObject("GeomAdaptor_Surface::NbUKnots");
1244 //=======================================================================
1245 //function : NbVKnots
1247 //=======================================================================
1249 Standard_Integer GeomAdaptor_Surface::NbVKnots() const
1251 if (mySurfaceType == GeomAbs_BSplineSurface)
1252 return myBSplineSurface->NbVKnots();
1253 throw Standard_NoSuchObject("GeomAdaptor_Surface::NbVKnots");
1255 //=======================================================================
1256 //function : IsURational
1258 //=======================================================================
1260 Standard_Boolean GeomAdaptor_Surface::IsURational() const
1262 if (mySurfaceType == GeomAbs_BSplineSurface)
1263 return myBSplineSurface->IsURational();
1264 if (mySurfaceType == GeomAbs_BezierSurface)
1265 return Handle(Geom_BezierSurface)::DownCast (mySurface)->IsURational();
1266 return Standard_False;
1269 //=======================================================================
1270 //function : IsVRational
1272 //=======================================================================
1274 Standard_Boolean GeomAdaptor_Surface::IsVRational() const
1276 if (mySurfaceType == GeomAbs_BSplineSurface)
1277 return myBSplineSurface->IsVRational();
1278 if (mySurfaceType == GeomAbs_BezierSurface)
1279 return Handle(Geom_BezierSurface)::DownCast (mySurface)->IsVRational();
1280 return Standard_False;
1283 //=======================================================================
1286 //=======================================================================
1288 Handle(Geom_BezierSurface) GeomAdaptor_Surface::Bezier() const
1290 if (mySurfaceType != GeomAbs_BezierSurface)
1291 throw Standard_NoSuchObject("GeomAdaptor_Surface::Bezier");
1292 return Handle(Geom_BezierSurface)::DownCast (mySurface);
1295 //=======================================================================
1296 //function : BSpline
1298 //=======================================================================
1300 Handle(Geom_BSplineSurface) GeomAdaptor_Surface::BSpline() const
1302 if (mySurfaceType != GeomAbs_BSplineSurface)
1303 throw Standard_NoSuchObject("GeomAdaptor_Surface::BSpline");
1304 return myBSplineSurface;
1307 //=======================================================================
1308 //function : AxeOfRevolution
1310 //=======================================================================
1312 gp_Ax1 GeomAdaptor_Surface::AxeOfRevolution() const
1314 if (mySurfaceType != GeomAbs_SurfaceOfRevolution)
1315 throw Standard_NoSuchObject("GeomAdaptor_Surface::AxeOfRevolution");
1316 return Handle(Geom_SurfaceOfRevolution)::DownCast (mySurface)->Axis();
1319 //=======================================================================
1320 //function : Direction
1322 //=======================================================================
1324 gp_Dir GeomAdaptor_Surface::Direction() const
1326 if (mySurfaceType != GeomAbs_SurfaceOfExtrusion)
1327 throw Standard_NoSuchObject("GeomAdaptor_Surface::Direction");
1328 return Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (mySurface)->Direction();
1331 //=======================================================================
1332 //function : BasisCurve
1334 //=======================================================================
1336 Handle(Adaptor3d_HCurve) GeomAdaptor_Surface::BasisCurve() const
1338 Handle(Geom_Curve) C;
1339 if (mySurfaceType == GeomAbs_SurfaceOfExtrusion)
1340 C = Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (mySurface)->BasisCurve();
1341 else if (mySurfaceType == GeomAbs_SurfaceOfRevolution)
1342 C = Handle(Geom_SurfaceOfRevolution)::DownCast (mySurface)->BasisCurve();
1344 throw Standard_NoSuchObject("GeomAdaptor_Surface::BasisCurve");
1345 return Handle(GeomAdaptor_HCurve)(new GeomAdaptor_HCurve(C));
1348 //=======================================================================
1349 //function : BasisSurface
1351 //=======================================================================
1353 Handle(Adaptor3d_HSurface) GeomAdaptor_Surface::BasisSurface() const
1355 if (mySurfaceType != GeomAbs_OffsetSurface)
1356 throw Standard_NoSuchObject("GeomAdaptor_Surface::BasisSurface");
1357 return new GeomAdaptor_HSurface
1358 (Handle(Geom_OffsetSurface)::DownCast (mySurface)->BasisSurface(),
1359 myUFirst,myULast,myVFirst,myVLast);
1362 //=======================================================================
1363 //function : OffsetValue
1365 //=======================================================================
1367 Standard_Real GeomAdaptor_Surface::OffsetValue() const
1369 if (mySurfaceType != GeomAbs_OffsetSurface)
1370 throw Standard_NoSuchObject("GeomAdaptor_Surface::BasisSurface");
1371 return Handle(Geom_OffsetSurface)::DownCast (mySurface)->Offset();
1374 //=======================================================================
1375 //function : IfUVBound <private>
1376 //purpose : locates U,V parameters if U,V =First, Last,
1377 // processes the finding span and returns the
1378 // parameters for LocalDi
1379 //=======================================================================
1381 Standard_Boolean GeomAdaptor_Surface::IfUVBound(const Standard_Real U,
1382 const Standard_Real V,
1383 Standard_Integer& IOutDeb,
1384 Standard_Integer& IOutFin,
1385 Standard_Integer& IOutVDeb,
1386 Standard_Integer& IOutVFin,
1387 const Standard_Integer USide,
1388 const Standard_Integer VSide) const
1390 Standard_Integer Ideb,Ifin;
1391 Standard_Integer anUFKIndx = myBSplineSurface->FirstUKnotIndex(),
1392 anULKIndx = myBSplineSurface->LastUKnotIndex(),
1393 aVFKIndx = myBSplineSurface->FirstVKnotIndex(), aVLKIndx = myBSplineSurface->LastVKnotIndex();
1394 myBSplineSurface->LocateU(U, PosTol, Ideb, Ifin, Standard_False);
1395 Standard_Boolean Local = (Ideb == Ifin);
1396 Span(USide,Ideb,Ifin,Ideb,Ifin,anUFKIndx,anULKIndx);
1397 Standard_Integer IVdeb,IVfin;
1398 myBSplineSurface->LocateV(V, PosTol, IVdeb, IVfin, Standard_False);
1399 if(IVdeb == IVfin) Local = Standard_True;
1400 Span(VSide,IVdeb,IVfin,IVdeb,IVfin,aVFKIndx,aVLKIndx);
1402 IOutDeb=Ideb; IOutFin=Ifin;
1403 IOutVDeb=IVdeb; IOutVFin=IVfin;
1407 //=======================================================================
1408 //function : Span <private>
1409 //purpose : locates U,V parameters if U=UFirst or U=ULast,
1410 // processes the finding span and returns the
1411 // parameters for LocalDi
1412 //=======================================================================
1414 void GeomAdaptor_Surface::Span(const Standard_Integer Side,
1415 const Standard_Integer Ideb,
1416 const Standard_Integer Ifin,
1417 Standard_Integer& OutIdeb,
1418 Standard_Integer& OutIfin,
1419 const Standard_Integer theFKIndx,
1420 const Standard_Integer theLKIndx) const
1422 if(Ideb!=Ifin)//not a knot
1424 if(Ideb<theFKIndx) { OutIdeb=theFKIndx; OutIfin=theFKIndx+1; }
1425 else if(Ifin>theLKIndx) { OutIdeb=theLKIndx-1; OutIfin=theLKIndx; }
1426 else if(Ideb>=(theLKIndx-1)) { OutIdeb=theLKIndx-1; OutIfin=theLKIndx; }
1427 else if(Ifin<=theFKIndx+1) { OutIdeb=theFKIndx; OutIfin=theFKIndx+1; }
1428 else if(Ideb>Ifin) { OutIdeb=Ifin-1; OutIfin=Ifin; }
1429 else { OutIdeb=Ideb; OutIfin=Ifin; }
1433 if(Ideb<=theFKIndx){ OutIdeb=theFKIndx; OutIfin=theFKIndx+1;}//first knot
1434 else if(Ifin>=theLKIndx) { OutIdeb=theLKIndx-1;OutIfin=theLKIndx;}//last knot
1437 if(Side==-1){OutIdeb=Ideb-1; OutIfin=Ifin;}
1438 else {OutIdeb=Ideb; OutIfin=Ifin+1;}