OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-09 13:22:24 +03:00
Code Activity

0024683: Convertation of the generic classes to the non-generic. Part 1

Browse Source 
Generic classes from "BRepApprox" package:
    "BRepApprox_ApproxLineGen" and "BRepApprox_SurfaceToolGen" converted to the non-generic classes "BRepApprox_ApproxLine" and "BRepApprox_SurfaceTool".
Generic classes from "BRepBlend" package:
    "BRepBlend_HCurve3dToolGen" and "BRepBlend_HCurve2dToolGen" converted to the non-generic classes "BRepBlend_HCurve3dTool" and "BRepBlend_HCurve2dTool".
Generic classes from "Blend" package:
    "Blend_Extremity", "Blend_Line" and "Blend_PointOnRst" moved to the corresponding non-generic classes "BRepBlend_Extremity", "BRepBlend_Line" and "BRepBlend_PointOnRst" to "BRepBlend" package.

And some other minor changes were done.
Field "myPntOn2S" was deleted from "BRepApprox_ApproxLine" class. Therefore BRepApprox_ApproxLine::Point(...) method was a little changed.
This commit is contained in:
dln
2014-03-27 16:24:53 +04:00
committed by apn
parent 0a58bfe2c3
commit 04f7bd75e3
25 changed files with 364 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/BRepApprox/BRepApprox.cdl
View File

@@ -36,16 +36,9 @@ uses
is
generic class ApproxLineGen;
class ApproxLine instantiates ApproxLineGen from BRepApprox
(BSplineCurve from Geom,
BSplineCurve from Geom2d);
generic class SurfaceToolGen;
class SurfaceTool instantiates SurfaceToolGen from BRepApprox
(Surface from BRepAdaptor);
class ApproxLine;
class SurfaceTool;
class Approx instantiates Approx from ApproxInt
(Surface from BRepAdaptor,

34
src/BRepApprox/BRepApprox_ApproxLineGen.cdl → src/BRepApprox/BRepApprox_ApproxLine.cdl
View File

@@ -14,42 +14,40 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class ApproxLineGen from BRepApprox
(TheCurve as any;
TheCurve2d as any)
inherits TShared from MMgt
class ApproxLine from BRepApprox inherits TShared from MMgt
uses
PntOn2S from IntSurf,
LineOn2S from IntSurf
LineOn2S from IntSurf,
BSplineCurve from Geom,
BSplineCurve from Geom2d
is
Create(CurveXYZ: TheCurve;
CurveUV1: TheCurve2d;
CurveUV2: TheCurve2d)
returns mutable ApproxLineGen from BRepApprox;
Create(CurveXYZ: BSplineCurve from Geom;
CurveUV1: BSplineCurve from Geom2d;
CurveUV2: BSplineCurve from Geom2d)
returns mutable ApproxLine from BRepApprox;
Create(lin: LineOn2S from IntSurf; Tang: Boolean from Standard)
returns mutable ApproxLineGen from BRepApprox;
returns mutable ApproxLine from BRepApprox;
NbPnts(me)
returns Integer from Standard
is static;
Point(me: mutable; Index: Integer from Standard)
returns PntOn2S from IntSurf
is static;
fields
curvxyz : TheCurve;
curvuv1 : TheCurve2d;
curvuv2 : TheCurve2d;
pnton2s : PntOn2S from IntSurf;
linon2s : LineOn2S from IntSurf;
myCurveXYZ : BSplineCurve from Geom;
myCurveUV1 : BSplineCurve from Geom2d;
myCurveUV2 : BSplineCurve from Geom2d;
myLineOn2S : LineOn2S from IntSurf;
end ApproxLineGen from BRepApprox;
end ApproxLine from BRepApprox;

71
src/BRepApprox/BRepApprox_ApproxLineGen.gxx → src/BRepApprox/BRepApprox_ApproxLine.cxx
View File

@@ -14,33 +14,35 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepApprox_ApproxLine.ixx>
#include <gp_Pnt2d.hxx>
//=======================================================================
//function : BRepApprox_ApproxLineGen
//function : BRepApprox_ApproxLine
//purpose :
//=======================================================================
BRepApprox_ApproxLineGen::BRepApprox_ApproxLineGen
(const TheCurve& CurveXYZ,
const TheCurve2d& CurveUV1,
const TheCurve2d& CurveUV2)
BRepApprox_ApproxLine::BRepApprox_ApproxLine
(const Handle(Geom_BSplineCurve)& CurveXYZ,
const Handle(Geom2d_BSplineCurve)& CurveUV1,
const Handle(Geom2d_BSplineCurve)& CurveUV2)
{
curvxyz = CurveXYZ;
curvuv1 = CurveUV1;
curvuv2 = CurveUV2;
myCurveXYZ = CurveXYZ;
myCurveUV1 = CurveUV1;
myCurveUV2 = CurveUV2;
}
//=======================================================================
//function : BRepApprox_ApproxLineGen
//function : BRepApprox_ApproxLine
//purpose :
//=======================================================================
BRepApprox_ApproxLineGen::BRepApprox_ApproxLineGen
BRepApprox_ApproxLine::BRepApprox_ApproxLine
(const Handle(IntSurf_LineOn2S)& lin,
const Standard_Boolean )
:linon2s(lin)
:myLineOn2S(lin)
{
}
@@ -49,15 +51,15 @@ BRepApprox_ApproxLineGen::BRepApprox_ApproxLineGen
//purpose :
//=======================================================================
Standard_Integer BRepApprox_ApproxLineGen::NbPnts() const
Standard_Integer BRepApprox_ApproxLine::NbPnts() const
{
if(!curvxyz.IsNull())
return(curvxyz->NbPoles());
if(!curvuv1.IsNull())
return(curvuv1->NbPoles());
if(!curvuv2.IsNull())
return(curvuv2->NbPoles());
return(linon2s->NbPoints());
if(!myCurveXYZ.IsNull())
return(myCurveXYZ->NbPoles());
if(!myCurveUV1.IsNull())
return(myCurveUV1->NbPoles());
if(!myCurveUV2.IsNull())
return(myCurveUV2->NbPoles());
return(myLineOn2S->NbPoints());
}
//=======================================================================
@@ -65,27 +67,24 @@ Standard_Integer BRepApprox_ApproxLineGen::NbPnts() const
//purpose :
//=======================================================================
IntSurf_PntOn2S BRepApprox_ApproxLineGen::Point
(const Standard_Integer Index)
IntSurf_PntOn2S BRepApprox_ApproxLine::Point(const Standard_Integer Index)
{
if(!linon2s.IsNull()) {
if(linon2s->NbPoints()) {
return(linon2s->Value(Index));
if(!myLineOn2S.IsNull()) {
if(myLineOn2S->NbPoints()) {
return(myLineOn2S->Value(Index));
}
}
gp_Pnt2d P1,P2;
gp_Pnt P;
if(!curvxyz.IsNull())
P = curvxyz->Pole(Index);
if(!curvuv1.IsNull())
P1 = curvuv1->Pole(Index);
if(!curvuv2.IsNull())
P2 = curvuv2->Pole(Index);
if(!myCurveXYZ.IsNull())
P = myCurveXYZ->Pole(Index);
if(!myCurveUV1.IsNull())
P1 = myCurveUV1->Pole(Index);
if(!myCurveUV2.IsNull())
P2 = myCurveUV2->Pole(Index);
pnton2s.SetValue(P,
P1.X(),
P1.Y(),
P2.X(),
P2.Y());
return(pnton2s);
IntSurf_PntOn2S aPntOn2S;
aPntOn2S.SetValue(P, P1.X(), P1.Y(), P2.X(), P2.Y());
return aPntOn2S;
}

89
src/BRepApprox/BRepApprox_SurfaceToolGen.cdl → src/BRepApprox/BRepApprox_SurfaceTool.cdl
View File

@@ -14,9 +14,7 @@
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
generic class SurfaceToolGen from BRepApprox
(TheSurface as any)
class SurfaceTool from BRepApprox
uses
@@ -35,57 +33,58 @@ uses
HSurface from Adaptor3d,
HCurve from Adaptor3d,
Ax1 from gp,
Dir from gp
Dir from gp,
Surface from BRepAdaptor
raises
NoSuchObject from Standard,
OutOfRange from Standard
is
is
FirstUParameter(myclass; S: TheSurface)
FirstUParameter(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Real from Standard;
FirstVParameter(myclass; S: TheSurface)
FirstVParameter(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Real from Standard;
LastUParameter(myclass; S: TheSurface)
LastUParameter(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Real from Standard;
LastVParameter(myclass; S: TheSurface)
LastVParameter(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Real from Standard;
NbUIntervals(myclass; S: TheSurface;
NbUIntervals(myclass; S: Surface from BRepAdaptor;
Sh : Shape from GeomAbs)
---C++: inline
returns Integer from Standard;
NbVIntervals(myclass; S: TheSurface;
NbVIntervals(myclass; S: Surface from BRepAdaptor;
Sh : Shape from GeomAbs)
---C++: inline
returns Integer from Standard;
UIntervals(myclass; S : TheSurface;
UIntervals(myclass; S : Surface from BRepAdaptor;
T : in out Array1OfReal from TColStd;
Sh : Shape from GeomAbs);
---C++: inline
VIntervals(myclass; S : TheSurface;
VIntervals(myclass; S : Surface from BRepAdaptor;
T : in out Array1OfReal from TColStd;
Sh : Shape from GeomAbs) ;
---C++: inline
UTrim(myclass; S : TheSurface;
UTrim(myclass; S : Surface from BRepAdaptor;
First, Last, Tol : Real)
---C++: inline
returns HSurface from Adaptor3d
@@ -93,7 +92,7 @@ is
OutOfRange from Standard;
---Purpose: If <First> >= <Last>
VTrim(myclass; S : TheSurface;
VTrim(myclass; S : Surface from BRepAdaptor;
First, Last, Tol : Real)
---C++: inline
returns HSurface from Adaptor3d
@@ -102,62 +101,62 @@ is
---Purpose: If <First> >= <Last>
IsUClosed(myclass; S: TheSurface)
IsUClosed(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Boolean from Standard;
IsVClosed(myclass; S: TheSurface)
IsVClosed(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Boolean from Standard;
IsUPeriodic(myclass; S: TheSurface)
IsUPeriodic(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Boolean from Standard;
UPeriod(myclass; S: TheSurface)
UPeriod(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Real from Standard;
IsVPeriodic(myclass; S: TheSurface)
IsVPeriodic(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Boolean from Standard;
VPeriod(myclass; S: TheSurface)
VPeriod(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Real from Standard;
Value(myclass; S : TheSurface;
Value(myclass; S : Surface from BRepAdaptor;
u,v : Real from Standard)
---C++: inline
returns Pnt from gp;
D0(myclass; S : TheSurface;
D0(myclass; S : Surface from BRepAdaptor;
u,v : Real from Standard;
P : out Pnt from gp);
---C++: inline
D1(myclass; S : TheSurface;
D1(myclass; S : Surface from BRepAdaptor;
u,v : Real from Standard;
P : out Pnt from gp;
D1u,D1v: out Vec from gp);
---C++: inline
D2(myclass; S : TheSurface;
D2(myclass; S : Surface from BRepAdaptor;
u,v : Real from Standard;
P : out Pnt from gp;
D1U,D1V,D2U,D2V,D2UV: out Vec from gp);
---C++: inline
D3(myclass; S : TheSurface;
D3(myclass; S : Surface from BRepAdaptor;
u,v : Real from Standard;
P : out Pnt from gp;
D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV: out Vec from gp);
---C++: inline
DN(myclass; S : TheSurface;
DN(myclass; S : Surface from BRepAdaptor;
u,v : Real from Standard;
Nu,Nv : Integer from Standard)
---C++: inline
@@ -165,58 +164,58 @@ is
UResolution(myclass; S:TheSurface; R3d: Real from Standard)
UResolution(myclass; S:Surface from BRepAdaptor; R3d: Real from Standard)
---C++: inline
returns Real from Standard;
VResolution(myclass; S:TheSurface; R3d: Real from Standard)
VResolution(myclass; S:Surface from BRepAdaptor; R3d: Real from Standard)
---C++: inline
returns Real from Standard;
GetType(myclass; S: TheSurface)
GetType(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns SurfaceType from GeomAbs;
Plane(myclass; S: TheSurface)
Plane(myclass; S: Surface from BRepAdaptor)
---C++: inline
returns Pln from gp;
Cylinder(myclass; S : TheSurface) returns Cylinder from gp
Cylinder(myclass; S : Surface from BRepAdaptor) returns Cylinder from gp
raises NoSuchObject from Standard;
---C++: inline
Cone(myclass; S : TheSurface) returns Cone from gp
Cone(myclass; S : Surface from BRepAdaptor) returns Cone from gp
raises NoSuchObject from Standard;
---C++: inline
Torus(myclass; S : TheSurface) returns Torus from gp
Torus(myclass; S : Surface from BRepAdaptor) returns Torus from gp
raises NoSuchObject from Standard;
---C++: inline
Sphere(myclass; S : TheSurface) returns Sphere from gp
Sphere(myclass; S : Surface from BRepAdaptor) returns Sphere from gp
raises NoSuchObject from Standard;
---C++: inline
Bezier(myclass; S : TheSurface) returns BezierSurface from Geom
Bezier(myclass; S : Surface from BRepAdaptor) returns BezierSurface from Geom
raises NoSuchObject from Standard;
---C++: inline
BSpline(myclass; S : TheSurface) returns BSplineSurface from Geom
BSpline(myclass; S : Surface from BRepAdaptor) returns BSplineSurface from Geom
raises NoSuchObject from Standard;
---C++: inline
AxeOfRevolution(myclass; S: TheSurface) returns Ax1 from gp
AxeOfRevolution(myclass; S: Surface from BRepAdaptor) returns Ax1 from gp
raises NoSuchObject from Standard;
---C++: inline
Direction(myclass; S: TheSurface) returns Dir from gp
Direction(myclass; S: Surface from BRepAdaptor) returns Dir from gp
raises NoSuchObject from Standard;
---C++: inline
BasisCurve(myclass; S:TheSurface) returns HCurve from Adaptor3d
BasisCurve(myclass; S:Surface from BRepAdaptor) returns HCurve from Adaptor3d
raises NoSuchObject from Standard;
---C++: inline
@@ -224,17 +223,17 @@ is
--------------------------------------------------------------------------------
NbSamplesU(myclass; S : TheSurface) returns Integer from Standard;
NbSamplesU(myclass; S : Surface from BRepAdaptor) returns Integer from Standard;
NbSamplesV(myclass; S : TheSurface) returns Integer from Standard;
NbSamplesV(myclass; S : Surface from BRepAdaptor) returns Integer from Standard;
NbSamplesU(myclass; S : TheSurface; u1,u2: Real from Standard) returns Integer from Standard;
NbSamplesU(myclass; S : Surface from BRepAdaptor; u1,u2: Real from Standard) returns Integer from Standard;
NbSamplesV(myclass; S : TheSurface; v1,v2: Real from Standard) returns Integer from Standard;
NbSamplesV(myclass; S : Surface from BRepAdaptor; v1,v2: Real from Standard) returns Integer from Standard;
end SurfaceToolGen from BRepApprox ;
end SurfaceTool from BRepApprox ;

11
src/BRepApprox/BRepApprox_SurfaceToolGen.gxx → src/BRepApprox/BRepApprox_SurfaceTool.cxx
View File

@@ -14,27 +14,26 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include TheSurface_hxx
#include "BRepApprox_SurfaceTool.ixx"
Standard_Integer BRepApprox_SurfaceToolGen::NbSamplesU (const TheSurface&)
Standard_Integer BRepApprox_SurfaceTool::NbSamplesU (const BRepAdaptor_Surface&)
{
return(10);
}
Standard_Integer BRepApprox_SurfaceToolGen::NbSamplesV (const TheSurface&)
Standard_Integer BRepApprox_SurfaceTool::NbSamplesV (const BRepAdaptor_Surface&)
{
return(10);
}
Standard_Integer BRepApprox_SurfaceToolGen::NbSamplesU (const TheSurface&,
Standard_Integer BRepApprox_SurfaceTool::NbSamplesU (const BRepAdaptor_Surface&,
const Standard_Real,
const Standard_Real)
{
return(10);
}
Standard_Integer BRepApprox_SurfaceToolGen::NbSamplesV (const TheSurface&,
Standard_Integer BRepApprox_SurfaceTool::NbSamplesV (const BRepAdaptor_Surface&,
const Standard_Real,
const Standard_Real)
{

73
src/BRepApprox/BRepApprox_SurfaceToolGen.lxx → src/BRepApprox/BRepApprox_SurfaceTool.lxx
View File

@@ -14,7 +14,6 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include TheSurface_hxx
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <gp_Pln.hxx>
@@ -29,44 +28,42 @@
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HCurve.hxx>
inline Standard_Real BRepApprox_SurfaceTool::FirstUParameter(const BRepAdaptor_Surface& Surf){ return Surf.FirstUParameter(); }
inline Standard_Real BRepApprox_SurfaceTool::FirstVParameter(const BRepAdaptor_Surface& Surf){ return Surf.FirstVParameter();}
inline Standard_Real BRepApprox_SurfaceTool::LastUParameter(const BRepAdaptor_Surface& Surf){ return Surf.LastUParameter();}
inline Standard_Real BRepApprox_SurfaceTool::LastVParameter(const BRepAdaptor_Surface& Surf){ return Surf.LastVParameter();}
inline Standard_Real BRepApprox_SurfaceToolGen::FirstUParameter(const TheSurface& Surf){ return Surf.FirstUParameter(); }
inline Standard_Real BRepApprox_SurfaceToolGen::FirstVParameter(const TheSurface& Surf){ return Surf.FirstVParameter();}
inline Standard_Real BRepApprox_SurfaceToolGen::LastUParameter(const TheSurface& Surf){ return Surf.LastUParameter();}
inline Standard_Real BRepApprox_SurfaceToolGen::LastVParameter(const TheSurface& Surf){ return Surf.LastVParameter();}
inline Standard_Integer BRepApprox_SurfaceToolGen::NbUIntervals(const TheSurface& Surf,
inline Standard_Integer BRepApprox_SurfaceTool::NbUIntervals(const BRepAdaptor_Surface& Surf,
const GeomAbs_Shape S){
return Surf.NbUIntervals(S);
}
inline Standard_Integer BRepApprox_SurfaceToolGen::NbVIntervals(const TheSurface& Surf,
inline Standard_Integer BRepApprox_SurfaceTool::NbVIntervals(const BRepAdaptor_Surface& Surf,
const GeomAbs_Shape S){
return Surf.NbVIntervals(S);
}
inline void BRepApprox_SurfaceToolGen::UIntervals(const TheSurface& Surf,
inline void BRepApprox_SurfaceTool::UIntervals(const BRepAdaptor_Surface& Surf,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape S){
Surf.UIntervals(Tab,S);
}
inline void BRepApprox_SurfaceToolGen::VIntervals(const TheSurface& Surf,
inline void BRepApprox_SurfaceTool::VIntervals(const BRepAdaptor_Surface& Surf,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape S){
Surf.VIntervals(Tab,S);
}
inline Handle_Adaptor3d_HSurface BRepApprox_SurfaceToolGen::UTrim(const TheSurface& Surf,
inline Handle_Adaptor3d_HSurface BRepApprox_SurfaceTool::UTrim(const BRepAdaptor_Surface& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol) {
return Surf.UTrim(F,L,Tol);
}
inline Handle_Adaptor3d_HSurface BRepApprox_SurfaceToolGen::VTrim(const TheSurface& Surf,
inline Handle_Adaptor3d_HSurface BRepApprox_SurfaceTool::VTrim(const BRepAdaptor_Surface& Surf,
const Standard_Real F,
const Standard_Real L,
const Standard_Real Tol) {
@@ -76,44 +73,44 @@ inline Handle_Adaptor3d_HSurface BRepApprox_SurfaceToolGen::VTrim(const TheSurfa
inline Standard_Boolean BRepApprox_SurfaceToolGen::IsUClosed(const TheSurface& S)
inline Standard_Boolean BRepApprox_SurfaceTool::IsUClosed(const BRepAdaptor_Surface& S)
{
return S.IsUClosed();
}
inline Standard_Boolean BRepApprox_SurfaceToolGen::IsVClosed(const TheSurface& S)
inline Standard_Boolean BRepApprox_SurfaceTool::IsVClosed(const BRepAdaptor_Surface& S)
{
return S.IsVClosed();
}
inline Standard_Boolean BRepApprox_SurfaceToolGen::IsUPeriodic(const TheSurface& S)
inline Standard_Boolean BRepApprox_SurfaceTool::IsUPeriodic(const BRepAdaptor_Surface& S)
{
return S.IsUPeriodic();
}
inline Standard_Real BRepApprox_SurfaceToolGen::UPeriod(const TheSurface& S)
inline Standard_Real BRepApprox_SurfaceTool::UPeriod(const BRepAdaptor_Surface& S)
{
return S.UPeriod();
}
inline Standard_Boolean BRepApprox_SurfaceToolGen::IsVPeriodic(const TheSurface& S)
inline Standard_Boolean BRepApprox_SurfaceTool::IsVPeriodic(const BRepAdaptor_Surface& S)
{
return S.IsVPeriodic();
}
inline Standard_Real BRepApprox_SurfaceToolGen::VPeriod(const TheSurface& S)
inline Standard_Real BRepApprox_SurfaceTool::VPeriod(const BRepAdaptor_Surface& S)
{
return S.VPeriod();
}
inline gp_Pnt BRepApprox_SurfaceToolGen::Value(const TheSurface& S,
inline gp_Pnt BRepApprox_SurfaceTool::Value(const BRepAdaptor_Surface& S,
const Standard_Real U,
const Standard_Real V )
{
return S.Value(U,V);
}
inline void BRepApprox_SurfaceToolGen::D0(const TheSurface& S,
inline void BRepApprox_SurfaceTool::D0(const BRepAdaptor_Surface& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P)
@@ -121,7 +118,7 @@ inline void BRepApprox_SurfaceToolGen::D0(const TheSurface& S,
S.D0(U,V,P);
}
inline void BRepApprox_SurfaceToolGen::D1(const TheSurface& S,
inline void BRepApprox_SurfaceTool::D1(const BRepAdaptor_Surface& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
@@ -131,7 +128,7 @@ inline void BRepApprox_SurfaceToolGen::D1(const TheSurface& S,
S.D1(U,V,P,D1U,D1V);
}
inline void BRepApprox_SurfaceToolGen::D2(const TheSurface& S,
inline void BRepApprox_SurfaceTool::D2(const BRepAdaptor_Surface& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
@@ -144,7 +141,7 @@ inline void BRepApprox_SurfaceToolGen::D2(const TheSurface& S,
S.D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
}
inline void BRepApprox_SurfaceToolGen::D3(const TheSurface& S,
inline void BRepApprox_SurfaceTool::D3(const BRepAdaptor_Surface& S,
const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
@@ -161,7 +158,7 @@ inline void BRepApprox_SurfaceToolGen::D3(const TheSurface& S,
S.D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
}
inline gp_Vec BRepApprox_SurfaceToolGen::DN(const TheSurface& S,
inline gp_Vec BRepApprox_SurfaceTool::DN(const BRepAdaptor_Surface& S,
const Standard_Real U,
const Standard_Real V,
const Standard_Integer Nu,
@@ -170,66 +167,66 @@ inline gp_Vec BRepApprox_SurfaceToolGen::DN(const TheSurface& S,
return S.DN(U,V,Nu,Nv);
}
inline Standard_Real BRepApprox_SurfaceToolGen::UResolution(const TheSurface& S,
inline Standard_Real BRepApprox_SurfaceTool::UResolution(const BRepAdaptor_Surface& S,
const Standard_Real R3d)
{
return S.UResolution(R3d);
}
inline Standard_Real BRepApprox_SurfaceToolGen::VResolution(const TheSurface& S,
inline Standard_Real BRepApprox_SurfaceTool::VResolution(const BRepAdaptor_Surface& S,
const Standard_Real R3d)
{
return S.VResolution(R3d);
}
inline GeomAbs_SurfaceType BRepApprox_SurfaceToolGen::GetType(const TheSurface& S )
inline GeomAbs_SurfaceType BRepApprox_SurfaceTool::GetType(const BRepAdaptor_Surface& S )
{
return S.GetType();
}
inline gp_Pln BRepApprox_SurfaceToolGen::Plane(const TheSurface& S)
inline gp_Pln BRepApprox_SurfaceTool::Plane(const BRepAdaptor_Surface& S)
{
return S.Plane();
}
inline gp_Cylinder BRepApprox_SurfaceToolGen::Cylinder(const TheSurface& S)
inline gp_Cylinder BRepApprox_SurfaceTool::Cylinder(const BRepAdaptor_Surface& S)
{
return S.Cylinder();
}
inline gp_Cone BRepApprox_SurfaceToolGen::Cone(const TheSurface& S)
inline gp_Cone BRepApprox_SurfaceTool::Cone(const BRepAdaptor_Surface& S)
{
return S.Cone();
}
inline gp_Sphere BRepApprox_SurfaceToolGen::Sphere(const TheSurface& S)
inline gp_Sphere BRepApprox_SurfaceTool::Sphere(const BRepAdaptor_Surface& S)
{
return S.Sphere();
}
inline gp_Torus BRepApprox_SurfaceToolGen::Torus(const TheSurface& S)
inline gp_Torus BRepApprox_SurfaceTool::Torus(const BRepAdaptor_Surface& S)
{
return S.Torus();
}
inline Handle(Geom_BezierSurface) BRepApprox_SurfaceToolGen::Bezier(const TheSurface& S) {
inline Handle(Geom_BezierSurface) BRepApprox_SurfaceTool::Bezier(const BRepAdaptor_Surface& S) {
return(S.Bezier());
}
inline Handle(Geom_BSplineSurface) BRepApprox_SurfaceToolGen::BSpline(const TheSurface& S) {
inline Handle(Geom_BSplineSurface) BRepApprox_SurfaceTool::BSpline(const BRepAdaptor_Surface& S) {
return(S.BSpline());
}
inline gp_Ax1 BRepApprox_SurfaceToolGen::AxeOfRevolution(const TheSurface& S) {
inline gp_Ax1 BRepApprox_SurfaceTool::AxeOfRevolution(const BRepAdaptor_Surface& S) {
return(S.AxeOfRevolution());
}
inline gp_Dir BRepApprox_SurfaceToolGen::Direction(const TheSurface& S) {
inline gp_Dir BRepApprox_SurfaceTool::Direction(const BRepAdaptor_Surface& S) {
return(S.Direction());
}
inline Handle(Adaptor3d_HCurve) BRepApprox_SurfaceToolGen::BasisCurve(const TheSurface& S) {
inline Handle(Adaptor3d_HCurve) BRepApprox_SurfaceTool::BasisCurve(const BRepAdaptor_Surface& S) {
return(S.BasisCurve());
}