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

0028966: Coding Rules - remove Adaptor2d_HCurve2d, Adaptor3d_HCurve and Adaptor3d_HSurface classes

Browse Source 
Adaptor2d_Curve2d, Adaptor3d_Curve and Adaptor3d_Surface now inherit Standard_Transient.
Interfaces Adaptor2d_HCurve2d, Adaptor3d_HCurve, Adaptor3d_HSurface and their subclasses
are now aliases to Adaptor2d_Curve2d, Adaptor3d_Curve and Adaptor3d_Surface.
Removed numerous unsafe reinterpret casts.

Generic classes Adaptor3d_GenHCurve, Adaptor3d_GenHSurface, Adaptor2d_GenHCurve2d have been removed.
Several redundant .lxx files have been merged into .hxx.

Removed obsolete adaptor classes with H suffix.
This commit is contained in:
kgv
2020-12-03 17:36:19 +03:00
committed by bugmaster
parent 266877a7c3
commit c22b52d60e
710 changed files with 6144 additions and 14175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/BRepAdaptor/BRepAdaptor_CompCurve.cxx
View File

@@ -14,13 +14,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_CompCurve.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_HCompCurve.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools_WireExplorer.hxx>
#include <ElCLib.hxx>
#include <GCPnts_AbscissaPoint.hxx>
@@ -42,6 +38,8 @@
#include <TopoDS_Edge.hxx>
#include <TopoDS_Wire.hxx>
IMPLEMENT_STANDARD_RTTIEXT(BRepAdaptor_CompCurve, Adaptor3d_Curve)
BRepAdaptor_CompCurve::BRepAdaptor_CompCurve()
: TFirst (0.0),
TLast (0.0),
@@ -152,7 +150,7 @@ BRepAdaptor_CompCurve::BRepAdaptor_CompCurve(const TopoDS_Wire& theWire,
PTol = Tol;
// Trim the extremal curves.
Handle (BRepAdaptor_HCurve) HC;
Handle (BRepAdaptor_Curve) HC;
Standard_Integer i1, i2;
Standard_Real f=TFirst, l=TLast, d;
i1 = i2 = CurIndex;
@@ -161,10 +159,10 @@ BRepAdaptor_CompCurve::BRepAdaptor_CompCurve(const TopoDS_Wire& theWire,
CurIndex = (i1+i2)/2; // Small optimization
if (i1==i2) {
if (l > f)
HC = Handle(BRepAdaptor_HCurve)::DownCast(myCurves->Value(i1).Trim(f, l, PTol));
HC = Handle(BRepAdaptor_Curve)::DownCast(myCurves->Value(i1).Trim(f, l, PTol));
else
HC = Handle(BRepAdaptor_HCurve)::DownCast(myCurves->Value(i1).Trim(l, f, PTol));
myCurves->SetValue(i1, HC->ChangeCurve());
HC = Handle(BRepAdaptor_Curve)::DownCast(myCurves->Value(i1).Trim(l, f, PTol));
myCurves->SetValue(i1, *HC);
}
else {
const BRepAdaptor_Curve& c1 = myCurves->Value(i1);
@@ -173,17 +171,17 @@ BRepAdaptor_CompCurve::BRepAdaptor_CompCurve(const TopoDS_Wire& theWire,
k = c1.LastParameter();
if (k>f)
HC = Handle(BRepAdaptor_HCurve)::DownCast(c1.Trim(f, k, PTol));
HC = Handle(BRepAdaptor_Curve)::DownCast(c1.Trim(f, k, PTol));
else
HC = Handle(BRepAdaptor_HCurve)::DownCast(c1.Trim(k, f, PTol));
myCurves->SetValue(i1, HC->ChangeCurve());
HC = Handle(BRepAdaptor_Curve)::DownCast(c1.Trim(k, f, PTol));
myCurves->SetValue(i1, *HC);
k = c2.FirstParameter();
if (k<=l)
HC = Handle(BRepAdaptor_HCurve)::DownCast(c2.Trim(k, l, PTol));
HC = Handle(BRepAdaptor_Curve)::DownCast(c2.Trim(k, l, PTol));
else
HC = Handle(BRepAdaptor_HCurve)::DownCast(c2.Trim(l, k, PTol));
myCurves->SetValue(i2, HC->ChangeCurve());
HC = Handle(BRepAdaptor_Curve)::DownCast(c2.Trim(l, k, PTol));
myCurves->SetValue(i2, *HC);
}
}
@@ -269,13 +267,13 @@ const TopoDS_Wire& BRepAdaptor_CompCurve::Wire() const
}
}
Handle(Adaptor3d_HCurve) BRepAdaptor_CompCurve::Trim(const Standard_Real First,
Handle(Adaptor3d_Curve) BRepAdaptor_CompCurve::Trim(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const
{
BRepAdaptor_CompCurve C(myWire, IsbyAC, First, Last, Tol);
Handle(BRepAdaptor_HCompCurve) HC =
new (BRepAdaptor_HCompCurve) (C);
Handle(BRepAdaptor_CompCurve) HC =
new (BRepAdaptor_CompCurve) (C);
return HC;
}

9
src/BRepAdaptor/BRepAdaptor_CompCurve.hxx
View File

@@ -31,13 +31,13 @@
#include <GeomAbs_Shape.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_CurveType.hxx>
class Standard_NullObject;
class Standard_DomainError;
class Standard_OutOfRange;
class Standard_NoSuchObject;
class TopoDS_Wire;
class TopoDS_Edge;
class Adaptor3d_HCurve;
class gp_Pnt;
class gp_Vec;
class gp_Lin;
@@ -48,6 +48,7 @@ class gp_Parab;
class Geom_BezierCurve;
class Geom_BSplineCurve;
DEFINE_STANDARD_HANDLE(BRepAdaptor_CompCurve, Adaptor3d_Curve)
//! The Curve from BRepAdaptor allows to use a Wire
//! of the BRep topology like a 3D curve.
@@ -61,11 +62,9 @@ class Geom_BSplineCurve;
//! connected to each other to make a chain.
class BRepAdaptor_CompCurve : public Adaptor3d_Curve
{
DEFINE_STANDARD_RTTIEXT(BRepAdaptor_CompCurve, Adaptor3d_Curve)
public:
DEFINE_STANDARD_ALLOC
//! Creates an undefined Curve with no Wire loaded.
Standard_EXPORT BRepAdaptor_CompCurve();
@@ -109,7 +108,7 @@ public:
//! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_HCurve) Trim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
Standard_EXPORT Handle(Adaptor3d_Curve) Trim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsClosed() const Standard_OVERRIDE;

58
src/BRepAdaptor/BRepAdaptor_Curve.cxx
View File

@@ -14,21 +14,18 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepAdaptor_Curve.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HCurveOnSurface.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <BRepAdaptor_HCurve.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2dAdaptor_HCurve.hxx>
#include <Geom2dAdaptor_Curve.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_OffsetCurve.hxx>
#include <Geom_Surface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <gp_Circ.hxx>
#include <gp_Elips.hxx>
#include <gp_Hypr.hxx>
@@ -44,7 +41,9 @@
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <Geom_OffsetCurve.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_Curve.hxx>
IMPLEMENT_STANDARD_RTTIEXT(BRepAdaptor_Curve, Adaptor3d_Curve)
//=======================================================================
//function : BRepAdaptor_Curve
@@ -108,12 +107,12 @@ void BRepAdaptor_Curve::Initialize(const TopoDS_Edge& E)
Handle(Geom_Surface) S;
BRep_Tool::CurveOnSurface(E,PC,S,L,pf,pl);
if (!PC.IsNull()) {
Handle(GeomAdaptor_HSurface) HS = new GeomAdaptor_HSurface();
HS->ChangeSurface().Load(S);
Handle(Geom2dAdaptor_HCurve) HC = new Geom2dAdaptor_HCurve();
HC->ChangeCurve2d().Load(PC,pf,pl);
myConSurf = new Adaptor3d_HCurveOnSurface();
myConSurf->ChangeCurve().Load(HC, HS);
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load(S);
Handle(Geom2dAdaptor_Curve) HC = new Geom2dAdaptor_Curve();
HC->Load(PC,pf,pl);
myConSurf = new Adaptor3d_CurveOnSurface();
myConSurf->Load(HC, HS);
}
else {
throw Standard_NullObject("BRepAdaptor_Curve::No geometry");
@@ -138,12 +137,12 @@ void BRepAdaptor_Curve::Initialize(const TopoDS_Edge& E,
Handle(Geom_Surface) S = BRep_Tool::Surface(F,L);
Handle(Geom2d_Curve) PC = BRep_Tool::CurveOnSurface(E,F,pf,pl);
Handle(GeomAdaptor_HSurface) HS = new GeomAdaptor_HSurface();
HS->ChangeSurface().Load(S);
Handle(Geom2dAdaptor_HCurve) HC = new Geom2dAdaptor_HCurve();
HC->ChangeCurve2d().Load(PC,pf,pl);
myConSurf = new Adaptor3d_HCurveOnSurface();
myConSurf->ChangeCurve().Load(HC, HS);
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load(S);
Handle(Geom2dAdaptor_Curve) HC = new Geom2dAdaptor_Curve();
HC->Load(PC,pf,pl);
myConSurf = new Adaptor3d_CurveOnSurface();
myConSurf->Load(HC, HS);
myTrsf = L.Transformation();
}
@@ -195,7 +194,7 @@ const GeomAdaptor_Curve& BRepAdaptor_Curve::Curve() const
const Adaptor3d_CurveOnSurface& BRepAdaptor_Curve::CurveOnSurface() const
{
return *((Adaptor3d_CurveOnSurface*)&(myConSurf->Curve()));
return *myConSurf;
}
//=======================================================================
@@ -300,25 +299,24 @@ void BRepAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
//purpose :
//=======================================================================
Handle(Adaptor3d_HCurve) BRepAdaptor_Curve::Trim(const Standard_Real First,
Handle(Adaptor3d_Curve) BRepAdaptor_Curve::Trim(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const
{
// On fait une copie de this pour garder la trsf.
Handle(BRepAdaptor_HCurve) res = new BRepAdaptor_HCurve();
Handle(BRepAdaptor_Curve) res;
if (myConSurf.IsNull()){
Standard_Real pf = FirstParameter(), pl = LastParameter();
Handle(Geom_Curve) C = myCurve.Curve();
((GeomAdaptor_Curve*) (void*) &myCurve)->Load(C,First,Last);
res->ChangeCurve() = *this;
((GeomAdaptor_Curve*) (void*) &myCurve)->Load(C,pf,pl);
const_cast<GeomAdaptor_Curve*>(&myCurve)->Load(C,First,Last);
res = new BRepAdaptor_Curve (*this);
const_cast<GeomAdaptor_Curve*>(&myCurve)->Load(C,pf,pl);
}
else {
Handle(Adaptor3d_HCurveOnSurface) sav = myConSurf;
*((Handle(Adaptor3d_HCurveOnSurface)*) (void*) &myConSurf) =
Handle(Adaptor3d_HCurveOnSurface)::DownCast(myConSurf->Trim(First,Last,Tol));
res->ChangeCurve() = *this;
*((Handle(Adaptor3d_HCurveOnSurface)*) (void*) &myConSurf) = sav;
Handle(Adaptor3d_CurveOnSurface) sav = myConSurf;
const_cast<Handle(Adaptor3d_CurveOnSurface)&>(myConSurf) = Handle(Adaptor3d_CurveOnSurface)::DownCast(myConSurf->Trim(First,Last,Tol));
res = new BRepAdaptor_Curve (*this);
const_cast<Handle(Adaptor3d_CurveOnSurface)&>(myConSurf) = sav;
}
return res;
}

34
src/BRepAdaptor/BRepAdaptor_Curve.hxx
View File

@@ -17,10 +17,7 @@
#ifndef _BRepAdaptor_Curve_HeaderFile
#define _BRepAdaptor_Curve_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_CurveOnSurface.hxx>
#include <gp_Trsf.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <TopoDS_Edge.hxx>
@@ -31,7 +28,7 @@
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_CurveType.hxx>
class Adaptor3d_HCurveOnSurface;
class Standard_NullObject;
class Standard_DomainError;
class Standard_OutOfRange;
@@ -41,7 +38,6 @@ class TopoDS_Face;
class gp_Trsf;
class GeomAdaptor_Curve;
class Adaptor3d_CurveOnSurface;
class Adaptor3d_HCurve;
class gp_Pnt;
class gp_Vec;
class gp_Lin;
@@ -53,6 +49,7 @@ class Geom_BezierCurve;
class Geom_BSplineCurve;
class Geom_OffsetCurve;
DEFINE_STANDARD_HANDLE(BRepAdaptor_Curve, Adaptor3d_Curve)
//! The Curve from BRepAdaptor allows to use an Edge
//! of the BRep topology like a 3D curve.
@@ -68,11 +65,9 @@ class Geom_OffsetCurve;
//! an Edge and a Face.
class BRepAdaptor_Curve : public Adaptor3d_Curve
{
DEFINE_STANDARD_RTTIEXT(BRepAdaptor_Curve, Adaptor3d_Curve)
public:
DEFINE_STANDARD_ALLOC
//! Creates an undefined Curve with no Edge loaded.
Standard_EXPORT BRepAdaptor_Curve();
@@ -145,7 +140,7 @@ public:
//! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_HCurve) Trim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
Standard_EXPORT Handle(Adaptor3d_Curve) Trim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsClosed() const Standard_OVERRIDE;
@@ -226,30 +221,13 @@ public:
Standard_EXPORT Handle(Geom_OffsetCurve) OffsetCurve() const Standard_OVERRIDE;
protected:
private:
gp_Trsf myTrsf;
GeomAdaptor_Curve myCurve;
Handle(Adaptor3d_HCurveOnSurface) myConSurf;
Handle(Adaptor3d_CurveOnSurface) myConSurf;
TopoDS_Edge myEdge;
};
#endif // _BRepAdaptor_Curve_HeaderFile

2
src/BRepAdaptor/BRepAdaptor_Curve2d.cxx
View File

@@ -21,6 +21,8 @@
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
IMPLEMENT_STANDARD_RTTIEXT(BRepAdaptor_Curve2d, Geom2dAdaptor_Curve)
//=======================================================================
//function : BRepAdaptor_Curve2d
//purpose :

22
src/BRepAdaptor/BRepAdaptor_Curve2d.hxx
View File

@@ -41,10 +41,8 @@ class TopoDS_Face;
//! Geom2dAdaptor.
class BRepAdaptor_Curve2d : public Geom2dAdaptor_Curve
{
DEFINE_STANDARD_RTTIEXT(BRepAdaptor_Curve2d, Geom2dAdaptor_Curve)
public:
DEFINE_STANDARD_ALLOC
//! Creates an uninitialized curve2d.
Standard_EXPORT BRepAdaptor_Curve2d();
@@ -61,29 +59,13 @@ public:
//! Returns the Face.
Standard_EXPORT const TopoDS_Face& Face() const;
protected:
private:
TopoDS_Edge myEdge;
TopoDS_Face myFace;
};
DEFINE_STANDARD_HANDLE(BRepAdaptor_Curve2d, Geom2dAdaptor_Curve)
#endif // _BRepAdaptor_Curve2d_HeaderFile

97
src/BRepAdaptor/BRepAdaptor_HCompCurve.hxx
View File

@@ -1,97 +0,0 @@
// Created on: 1993-02-19
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepAdaptor_HCompCurve_HeaderFile
#define _BRepAdaptor_HCompCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <BRepAdaptor_CompCurve.hxx>
#include <Adaptor3d_HCurve.hxx>
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_DomainError;
class BRepAdaptor_CompCurve;
class Adaptor3d_Curve;
class BRepAdaptor_HCompCurve;
DEFINE_STANDARD_HANDLE(BRepAdaptor_HCompCurve, Adaptor3d_HCurve)
class BRepAdaptor_HCompCurve : public Adaptor3d_HCurve
{
public:
//! Creates an empty GenHCurve.
Standard_EXPORT BRepAdaptor_HCompCurve();
//! Creates a GenHCurve from a Curve
Standard_EXPORT BRepAdaptor_HCompCurve(const BRepAdaptor_CompCurve& C);
//! Sets the field of the GenHCurve.
Standard_EXPORT void Set (const BRepAdaptor_CompCurve& C);
//! Returns the curve used to create the GenHCurve.
//! This is redefined from HCurve, cannot be inline.
Standard_EXPORT const Adaptor3d_Curve& Curve() const Standard_OVERRIDE;
//! Returns the curve used to create the GenHCurve.
//! This is redefined from HCurve, cannot be inline.
Standard_EXPORT Adaptor3d_Curve& GetCurve() Standard_OVERRIDE;
//! Returns the curve used to create the GenHCurve.
BRepAdaptor_CompCurve& ChangeCurve();
DEFINE_STANDARD_RTTI_INLINE(BRepAdaptor_HCompCurve,Adaptor3d_HCurve)
protected:
BRepAdaptor_CompCurve myCurve;
private:
};
#define TheCurve BRepAdaptor_CompCurve
#define TheCurve_hxx <BRepAdaptor_CompCurve.hxx>
#define Adaptor3d_GenHCurve BRepAdaptor_HCompCurve
#define Adaptor3d_GenHCurve_hxx <BRepAdaptor_HCompCurve.hxx>
#define Handle_Adaptor3d_GenHCurve Handle(BRepAdaptor_HCompCurve)
#include <Adaptor3d_GenHCurve.lxx>
#undef TheCurve
#undef TheCurve_hxx
#undef Adaptor3d_GenHCurve
#undef Adaptor3d_GenHCurve_hxx
#undef Handle_Adaptor3d_GenHCurve
#endif // _BRepAdaptor_HCompCurve_HeaderFile

42
src/BRepAdaptor/BRepAdaptor_HCompCurve_0.cxx
View File

@@ -1,42 +0,0 @@
// Created on: 1993-02-19
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepAdaptor_HCompCurve.hxx>
#include <Standard_Type.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_DomainError.hxx>
#include <BRepAdaptor_CompCurve.hxx>
#include <Adaptor3d_Curve.hxx>
#define TheCurve BRepAdaptor_CompCurve
#define TheCurve_hxx <BRepAdaptor_CompCurve.hxx>
#define Adaptor3d_GenHCurve BRepAdaptor_HCompCurve
#define Adaptor3d_GenHCurve_hxx <BRepAdaptor_HCompCurve.hxx>
#define Handle_Adaptor3d_GenHCurve Handle(BRepAdaptor_HCompCurve)
#include <Adaptor3d_GenHCurve.gxx>

97
src/BRepAdaptor/BRepAdaptor_HCurve.hxx
View File

@@ -1,97 +0,0 @@
// Created on: 1993-02-19
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepAdaptor_HCurve_HeaderFile
#define _BRepAdaptor_HCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <Adaptor3d_HCurve.hxx>
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_DomainError;
class BRepAdaptor_Curve;
class Adaptor3d_Curve;
class BRepAdaptor_HCurve;
DEFINE_STANDARD_HANDLE(BRepAdaptor_HCurve, Adaptor3d_HCurve)
class BRepAdaptor_HCurve : public Adaptor3d_HCurve
{
public:
//! Creates an empty GenHCurve.
Standard_EXPORT BRepAdaptor_HCurve();
//! Creates a GenHCurve from a Curve
Standard_EXPORT BRepAdaptor_HCurve(const BRepAdaptor_Curve& C);
//! Sets the field of the GenHCurve.
Standard_EXPORT void Set (const BRepAdaptor_Curve& C);
//! Returns the curve used to create the GenHCurve.
//! This is redefined from HCurve, cannot be inline.
Standard_EXPORT const Adaptor3d_Curve& Curve() const Standard_OVERRIDE;
//! Returns the curve used to create the GenHCurve.
//! This is redefined from HCurve, cannot be inline.
Standard_EXPORT Adaptor3d_Curve& GetCurve() Standard_OVERRIDE;
//! Returns the curve used to create the GenHCurve.
BRepAdaptor_Curve& ChangeCurve();
DEFINE_STANDARD_RTTI_INLINE(BRepAdaptor_HCurve,Adaptor3d_HCurve)
protected:
BRepAdaptor_Curve myCurve;
private:
};
#define TheCurve BRepAdaptor_Curve
#define TheCurve_hxx <BRepAdaptor_Curve.hxx>
#define Adaptor3d_GenHCurve BRepAdaptor_HCurve
#define Adaptor3d_GenHCurve_hxx <BRepAdaptor_HCurve.hxx>
#define Handle_Adaptor3d_GenHCurve Handle(BRepAdaptor_HCurve)
#include <Adaptor3d_GenHCurve.lxx>
#undef TheCurve
#undef TheCurve_hxx
#undef Adaptor3d_GenHCurve
#undef Adaptor3d_GenHCurve_hxx
#undef Handle_Adaptor3d_GenHCurve
#endif // _BRepAdaptor_HCurve_HeaderFile

93
src/BRepAdaptor/BRepAdaptor_HCurve2d.hxx
View File

@@ -1,93 +0,0 @@
// Created on: 1993-02-19
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepAdaptor_HCurve2d_HeaderFile
#define _BRepAdaptor_HCurve2d_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <Adaptor2d_HCurve2d.hxx>
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_DomainError;
class BRepAdaptor_Curve2d;
class Adaptor2d_Curve2d;
class BRepAdaptor_HCurve2d;
DEFINE_STANDARD_HANDLE(BRepAdaptor_HCurve2d, Adaptor2d_HCurve2d)
class BRepAdaptor_HCurve2d : public Adaptor2d_HCurve2d
{
public:
//! Creates an empty GenHCurve2d.
Standard_EXPORT BRepAdaptor_HCurve2d();
//! Creates a GenHCurve2d from a Curve
Standard_EXPORT BRepAdaptor_HCurve2d(const BRepAdaptor_Curve2d& C);
//! Sets the field of the GenHCurve2d.
Standard_EXPORT void Set (const BRepAdaptor_Curve2d& C);
//! Returns the curve used to create the GenHCurve2d.
//! This is redefined from HCurve2d, cannot be inline.
Standard_EXPORT const Adaptor2d_Curve2d& Curve2d() const Standard_OVERRIDE;
//! Returns the curve used to create the GenHCurve.
BRepAdaptor_Curve2d& ChangeCurve2d();
DEFINE_STANDARD_RTTI_INLINE(BRepAdaptor_HCurve2d,Adaptor2d_HCurve2d)
protected:
BRepAdaptor_Curve2d myCurve;
private:
};
#define TheCurve BRepAdaptor_Curve2d
#define TheCurve_hxx <BRepAdaptor_Curve2d.hxx>
#define Adaptor2d_GenHCurve2d BRepAdaptor_HCurve2d
#define Adaptor2d_GenHCurve2d_hxx <BRepAdaptor_HCurve2d.hxx>
#define Handle_Adaptor2d_GenHCurve2d Handle(BRepAdaptor_HCurve2d)
#include <Adaptor2d_GenHCurve2d.lxx>
#undef TheCurve
#undef TheCurve_hxx
#undef Adaptor2d_GenHCurve2d
#undef Adaptor2d_GenHCurve2d_hxx
#undef Handle_Adaptor2d_GenHCurve2d
#endif // _BRepAdaptor_HCurve2d_HeaderFile

42
src/BRepAdaptor/BRepAdaptor_HCurve2d_0.cxx
View File

@@ -1,42 +0,0 @@
// Created on: 1993-02-19
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepAdaptor_HCurve2d.hxx>
#include <Standard_Type.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_DomainError.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#define TheCurve BRepAdaptor_Curve2d
#define TheCurve_hxx <BRepAdaptor_Curve2d.hxx>
#define Adaptor2d_GenHCurve2d BRepAdaptor_HCurve2d
#define Adaptor2d_GenHCurve2d_hxx <BRepAdaptor_HCurve2d.hxx>
#define Handle_Adaptor2d_GenHCurve2d Handle(BRepAdaptor_HCurve2d)
#include <Adaptor2d_GenHCurve2d.gxx>

42
src/BRepAdaptor/BRepAdaptor_HCurve_0.cxx
View File

@@ -1,42 +0,0 @@
// Created on: 1993-02-19
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepAdaptor_HCurve.hxx>
#include <Standard_Type.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_DomainError.hxx>
#include <BRepAdaptor_Curve.hxx>
#include <Adaptor3d_Curve.hxx>
#define TheCurve BRepAdaptor_Curve
#define TheCurve_hxx <BRepAdaptor_Curve.hxx>
#define Adaptor3d_GenHCurve BRepAdaptor_HCurve
#define Adaptor3d_GenHCurve_hxx <BRepAdaptor_HCurve.hxx>
#define Handle_Adaptor3d_GenHCurve Handle(BRepAdaptor_HCurve)
#include <Adaptor3d_GenHCurve.gxx>

93
src/BRepAdaptor/BRepAdaptor_HSurface.hxx
View File

@@ -1,93 +0,0 @@
// Created on: 1993-02-19
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepAdaptor_HSurface_HeaderFile
#define _BRepAdaptor_HSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <Adaptor3d_HSurface.hxx>
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_DomainError;
class BRepAdaptor_Surface;
class Adaptor3d_Surface;
class BRepAdaptor_HSurface;
DEFINE_STANDARD_HANDLE(BRepAdaptor_HSurface, Adaptor3d_HSurface)
class BRepAdaptor_HSurface : public Adaptor3d_HSurface
{
public:
//! Creates an empty GenHSurface.
Standard_EXPORT BRepAdaptor_HSurface();
//! Creates a GenHSurface from a Surface.
Standard_EXPORT BRepAdaptor_HSurface(const BRepAdaptor_Surface& S);
//! Sets the field of the GenHSurface.
Standard_EXPORT void Set (const BRepAdaptor_Surface& S);
//! Returns a reference to the Surface inside the HSurface.
//! This is redefined from HSurface, cannot be inline.
Standard_EXPORT const Adaptor3d_Surface& Surface() const Standard_OVERRIDE;
//! Returns the surface used to create the GenHSurface.
BRepAdaptor_Surface& ChangeSurface();
DEFINE_STANDARD_RTTI_INLINE(BRepAdaptor_HSurface,Adaptor3d_HSurface)
protected:
BRepAdaptor_Surface mySurf;
private:
};
#define TheSurface BRepAdaptor_Surface
#define TheSurface_hxx <BRepAdaptor_Surface.hxx>
#define Adaptor3d_GenHSurface BRepAdaptor_HSurface
#define Adaptor3d_GenHSurface_hxx <BRepAdaptor_HSurface.hxx>
#define Handle_Adaptor3d_GenHSurface Handle(BRepAdaptor_HSurface)
#include <Adaptor3d_GenHSurface.lxx>
#undef TheSurface
#undef TheSurface_hxx
#undef Adaptor3d_GenHSurface
#undef Adaptor3d_GenHSurface_hxx
#undef Handle_Adaptor3d_GenHSurface
#endif // _BRepAdaptor_HSurface_HeaderFile

42
src/BRepAdaptor/BRepAdaptor_HSurface_0.cxx
View File

@@ -1,42 +0,0 @@
// Created on: 1993-02-19
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepAdaptor_HSurface.hxx>
#include <Standard_Type.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_DomainError.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <Adaptor3d_Surface.hxx>
#define TheSurface BRepAdaptor_Surface
#define TheSurface_hxx <BRepAdaptor_Surface.hxx>
#define Adaptor3d_GenHSurface BRepAdaptor_HSurface
#define Adaptor3d_GenHSurface_hxx <BRepAdaptor_HSurface.hxx>
#define Handle_Adaptor3d_GenHSurface Handle(BRepAdaptor_HSurface)
#include <Adaptor3d_GenHSurface.gxx>

41
src/BRepAdaptor/BRepAdaptor_Surface.cxx
View File

@@ -14,17 +14,16 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BRep_Tool.hxx>
#include <BRepTools.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_Surface.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <gp_Ax1.hxx>
#include <gp_Cone.hxx>
@@ -41,6 +40,8 @@
#include <Standard_OutOfRange.hxx>
#include <TopoDS_Face.hxx>
IMPLEMENT_STANDARD_RTTIEXT(BRepAdaptor_Surface, Adaptor3d_Surface)
//=======================================================================
//function : BRepAdaptor_Surface
//purpose :
@@ -170,14 +171,13 @@ void BRepAdaptor_Surface::VIntervals(TColStd_Array1OfReal& T,
//purpose :
//=======================================================================
Handle(Adaptor3d_HSurface) BRepAdaptor_Surface::UTrim
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::UTrim
(const Standard_Real First,
const Standard_Real Last ,
const Standard_Real Tol ) const
{
Handle(GeomAdaptor_HSurface) HS = new GeomAdaptor_HSurface();
HS->ChangeSurface().Load
(Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
return HS->UTrim(First,Last,Tol);
}
@@ -187,14 +187,13 @@ Handle(Adaptor3d_HSurface) BRepAdaptor_Surface::UTrim
//purpose :
//=======================================================================
Handle(Adaptor3d_HSurface) BRepAdaptor_Surface::VTrim
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::VTrim
(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const
{
Handle(GeomAdaptor_HSurface) HS = new GeomAdaptor_HSurface();
HS->ChangeSurface().Load
(Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
return HS->VTrim(First,Last,Tol);
}
@@ -408,11 +407,10 @@ gp_Dir BRepAdaptor_Surface::Direction() const
//purpose :
//=======================================================================
Handle(Adaptor3d_HCurve) BRepAdaptor_Surface::BasisCurve() const
Handle(Adaptor3d_Curve) BRepAdaptor_Surface::BasisCurve() const
{
Handle(GeomAdaptor_HSurface) HS = new GeomAdaptor_HSurface();
HS->ChangeSurface().Load
(Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
return HS->BasisCurve();
}
@@ -423,11 +421,10 @@ Handle(Adaptor3d_HCurve) BRepAdaptor_Surface::BasisCurve() const
//purpose :
//=======================================================================
Handle(Adaptor3d_HSurface) BRepAdaptor_Surface::BasisSurface() const
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::BasisSurface() const
{
Handle(GeomAdaptor_HSurface) HS = new GeomAdaptor_HSurface();
HS->ChangeSurface().Load
(Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
return HS->BasisSurface();
}

153
src/BRepAdaptor/BRepAdaptor_Surface.hxx
View File

@@ -17,27 +17,18 @@
#ifndef _BRepAdaptor_Surface_HeaderFile
#define _BRepAdaptor_Surface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <gp_Trsf.hxx>
#include <TopoDS_Face.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <gp_Trsf.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TopoDS_Face.hxx>
class Standard_OutOfRange;
class Standard_DomainError;
class Standard_NoSuchObject;
class TopoDS_Face;
class GeomAdaptor_Surface;
class gp_Trsf;
class Adaptor3d_HSurface;
class gp_Pnt;
class gp_Vec;
class gp_Pln;
@@ -49,8 +40,8 @@ class Geom_BezierSurface;
class Geom_BSplineSurface;
class gp_Ax1;
class gp_Dir;
class Adaptor3d_HCurve;
DEFINE_STANDARD_HANDLE(BRepAdaptor_Surface, Adaptor3d_Surface)
//! The Surface from BRepAdaptor allows to use a Face
//! of the BRep topology look like a 3D surface.
@@ -66,11 +57,9 @@ class Adaptor3d_HCurve;
//! set to false.
class BRepAdaptor_Surface : public Adaptor3d_Surface
{
DEFINE_STANDARD_RTTIEXT(BRepAdaptor_Surface, Adaptor3d_Surface)
public:
DEFINE_STANDARD_ALLOC
//! Creates an undefined surface with no face loaded.
Standard_EXPORT BRepAdaptor_Surface();
@@ -97,28 +86,28 @@ public:
//! Returns the face tolerance.
Standard_EXPORT Standard_Real Tolerance() const;
Standard_Real FirstUParameter() const Standard_OVERRIDE;
Standard_Real LastUParameter() const Standard_OVERRIDE;
Standard_Real FirstVParameter() const Standard_OVERRIDE;
Standard_Real LastVParameter() const Standard_OVERRIDE;
GeomAbs_Shape UContinuity() const Standard_OVERRIDE;
GeomAbs_Shape VContinuity() const Standard_OVERRIDE;
virtual Standard_Real FirstUParameter() const Standard_OVERRIDE { return mySurf.FirstUParameter(); }
virtual Standard_Real LastUParameter() const Standard_OVERRIDE { return mySurf.LastUParameter(); }
virtual Standard_Real FirstVParameter() const Standard_OVERRIDE { return mySurf.FirstVParameter(); }
virtual Standard_Real LastVParameter() const Standard_OVERRIDE { return mySurf.LastVParameter(); }
virtual GeomAbs_Shape UContinuity() const Standard_OVERRIDE { return mySurf.UContinuity(); }
virtual GeomAbs_Shape VContinuity() const Standard_OVERRIDE { return mySurf.VContinuity(); }
//! If necessary, breaks the surface in U intervals of
//! continuity <S>. And returns the number of
//! intervals.
Standard_Integer NbUIntervals (const GeomAbs_Shape S) const Standard_OVERRIDE;
virtual Standard_Integer NbUIntervals (const GeomAbs_Shape theSh) const Standard_OVERRIDE { return mySurf.NbUIntervals (theSh); }
//! If necessary, breaks the surface in V intervals of
//! continuity <S>. And returns the number of
//! intervals.
Standard_Integer NbVIntervals (const GeomAbs_Shape S) const Standard_OVERRIDE;
virtual Standard_Integer NbVIntervals (const GeomAbs_Shape theSh) const Standard_OVERRIDE { return mySurf.NbVIntervals (theSh); }
//! Returns the intervals with the requested continuity
//! in the U direction.
@@ -133,26 +122,26 @@ public:
//! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_HSurface) UTrim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
Standard_EXPORT Handle(Adaptor3d_Surface) UTrim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
//! Returns a surface trimmed in the V direction between
//! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_HSurface) VTrim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
Standard_Boolean IsUClosed() const Standard_OVERRIDE;
Standard_Boolean IsVClosed() const Standard_OVERRIDE;
Standard_Boolean IsUPeriodic() const Standard_OVERRIDE;
Standard_Real UPeriod() const Standard_OVERRIDE;
Standard_Boolean IsVPeriodic() const Standard_OVERRIDE;
Standard_Real VPeriod() const Standard_OVERRIDE;
Standard_EXPORT Handle(Adaptor3d_Surface) VTrim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) const Standard_OVERRIDE;
virtual Standard_Boolean IsUClosed() const Standard_OVERRIDE { return mySurf.IsUClosed(); }
virtual Standard_Boolean IsVClosed() const Standard_OVERRIDE { return mySurf.IsVClosed(); }
virtual Standard_Boolean IsUPeriodic() const Standard_OVERRIDE { return mySurf.IsUPeriodic(); }
virtual Standard_Real UPeriod() const Standard_OVERRIDE { return mySurf.UPeriod(); }
virtual Standard_Boolean IsVPeriodic() const Standard_OVERRIDE { return mySurf.IsVPeriodic(); }
virtual Standard_Real VPeriod() const Standard_OVERRIDE { return mySurf.VPeriod(); }
//! Computes the point of parameters U,V on the surface.
Standard_EXPORT gp_Pnt Value (const Standard_Real U, const Standard_Real V) const Standard_OVERRIDE;
@@ -186,17 +175,17 @@ public:
//! Returns the parametric U resolution corresponding
//! to the real space resolution <R3d>.
Standard_Real UResolution (const Standard_Real R3d) const Standard_OVERRIDE;
virtual Standard_Real UResolution (const Standard_Real theR3d) const Standard_OVERRIDE { return mySurf.UResolution (theR3d); }
//! Returns the parametric V resolution corresponding
//! to the real space resolution <R3d>.
Standard_Real VResolution (const Standard_Real R3d) const Standard_OVERRIDE;
virtual Standard_Real VResolution (const Standard_Real theR3d) const Standard_OVERRIDE { return mySurf.VResolution (theR3d); }
//! Returns the type of the surface : Plane, Cylinder,
//! Cone, Sphere, Torus, BezierSurface,
//! BSplineSurface, SurfaceOfRevolution,
//! SurfaceOfExtrusion, OtherSurface
GeomAbs_SurfaceType GetType() const Standard_OVERRIDE;
virtual GeomAbs_SurfaceType GetType() const Standard_OVERRIDE { return mySurf.GetType(); }
Standard_EXPORT gp_Pln Plane() const Standard_OVERRIDE;
@@ -208,29 +197,28 @@ public:
Standard_EXPORT gp_Torus Torus() const Standard_OVERRIDE;
Standard_Integer UDegree() const Standard_OVERRIDE;
Standard_Integer NbUPoles() const Standard_OVERRIDE;
Standard_Integer VDegree() const Standard_OVERRIDE;
Standard_Integer NbVPoles() const Standard_OVERRIDE;
Standard_Integer NbUKnots() const Standard_OVERRIDE;
Standard_Integer NbVKnots() const Standard_OVERRIDE;
Standard_Boolean IsURational() const Standard_OVERRIDE;
Standard_Boolean IsVRational() const Standard_OVERRIDE;
virtual Standard_Integer UDegree() const Standard_OVERRIDE { return mySurf.UDegree(); }
virtual Standard_Integer NbUPoles() const Standard_OVERRIDE { return mySurf.NbUPoles(); }
virtual Standard_Integer VDegree() const Standard_OVERRIDE { return mySurf.VDegree(); }
virtual Standard_Integer NbVPoles() const Standard_OVERRIDE { return mySurf.NbVPoles(); }
virtual Standard_Integer NbUKnots() const Standard_OVERRIDE { return mySurf.NbUKnots(); }
virtual Standard_Integer NbVKnots() const Standard_OVERRIDE { return mySurf.NbVKnots(); }
virtual Standard_Boolean IsURational() const Standard_OVERRIDE { return mySurf.IsURational(); }
virtual Standard_Boolean IsVRational() const Standard_OVERRIDE { return mySurf.IsVRational(); }
Standard_EXPORT Handle(Geom_BezierSurface) Bezier() const Standard_OVERRIDE;
//! Warning : this will make a copy of the
//! BSpline Surface since it applies
//! to it the myTsrf transformation
//! Be Carefull when using this method
//! Be Careful when using this method
Standard_EXPORT Handle(Geom_BSplineSurface) BSpline() const Standard_OVERRIDE;
Standard_EXPORT gp_Ax1 AxeOfRevolution() const Standard_OVERRIDE;
@@ -240,38 +228,19 @@ public:
//! only for SurfaceOfExtrusion and SurfaceOfRevolution
//! Warning: this will make a copy of the underlying curve
//! since it applies to it the transformation
//! myTrsf. Be carefull when using this method.
Standard_EXPORT Handle(Adaptor3d_HCurve) BasisCurve() const Standard_OVERRIDE;
//! myTrsf. Be careful when using this method.
Standard_EXPORT Handle(Adaptor3d_Curve) BasisCurve() const Standard_OVERRIDE;
Standard_EXPORT Handle(Adaptor3d_HSurface) BasisSurface() const Standard_OVERRIDE;
Standard_EXPORT Handle(Adaptor3d_Surface) BasisSurface() const Standard_OVERRIDE;
Standard_EXPORT Standard_Real OffsetValue() const Standard_OVERRIDE;
protected:
private:
GeomAdaptor_Surface mySurf;
gp_Trsf myTrsf;
TopoDS_Face myFace;
};
#include <BRepAdaptor_Surface.lxx>
#endif // _BRepAdaptor_Surface_HeaderFile

272
src/BRepAdaptor/BRepAdaptor_Surface.lxx
View File

@@ -1,272 +0,0 @@
// Created on: 1993-02-19
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
//function : FirstUParameter
//purpose :
//=======================================================================
inline Standard_Real BRepAdaptor_Surface::FirstUParameter() const
{
return mySurf.FirstUParameter();
}
//=======================================================================
//function : LastUParameter
//purpose :
//=======================================================================
inline Standard_Real BRepAdaptor_Surface::LastUParameter() const
{
return mySurf.LastUParameter();
}
//=======================================================================
//function : FirstVParameter
//purpose :
//=======================================================================
inline Standard_Real BRepAdaptor_Surface::FirstVParameter() const
{
return mySurf.FirstVParameter();
}
//=======================================================================
//function : LastVParameter
//purpose :
//=======================================================================
inline Standard_Real BRepAdaptor_Surface::LastVParameter() const
{
return mySurf.LastVParameter();
}
//=======================================================================
//function : UContinuity
//purpose :
//=======================================================================
inline GeomAbs_Shape BRepAdaptor_Surface::UContinuity() const
{
return mySurf.UContinuity();
}
//=======================================================================
//function : VContinuity
//purpose :
//=======================================================================
inline GeomAbs_Shape BRepAdaptor_Surface::VContinuity() const
{
return mySurf.VContinuity();
}
//=======================================================================
//function : NbUIntervals
//purpose :
//=======================================================================
inline Standard_Integer BRepAdaptor_Surface::NbUIntervals
(const GeomAbs_Shape S) const
{
return mySurf.NbUIntervals(S);
}
//=======================================================================
//function : NbVIntervals
//purpose :
//=======================================================================
inline Standard_Integer BRepAdaptor_Surface::NbVIntervals
(const GeomAbs_Shape S) const
{
return mySurf.NbVIntervals(S);
}
//=======================================================================
//function : IsUClosed
//purpose :
//=======================================================================
inline Standard_Boolean BRepAdaptor_Surface::IsUClosed()const
{
return mySurf.IsUClosed();
}
//=======================================================================
//function : IsVClosed
//purpose :
//=======================================================================
inline Standard_Boolean BRepAdaptor_Surface::IsVClosed()const
{
return mySurf.IsVClosed();
}
//=======================================================================
//function : IsUPeriodic
//purpose :
//=======================================================================
inline Standard_Boolean BRepAdaptor_Surface::IsUPeriodic()const
{
return mySurf.IsUPeriodic();
}
//=======================================================================
//function : UPeriod
//purpose :
//=======================================================================
inline Standard_Real BRepAdaptor_Surface::UPeriod()const
{
return mySurf.UPeriod();
}
//=======================================================================
//function : IsVPeriodic
//purpose :
//=======================================================================
inline Standard_Boolean BRepAdaptor_Surface::IsVPeriodic()const
{
return mySurf.IsVPeriodic();
}
//=======================================================================
//function : VPeriod
//purpose :
//=======================================================================
inline Standard_Real BRepAdaptor_Surface::VPeriod()const
{
return mySurf.VPeriod();
}
//=======================================================================
//function : UResolution
//purpose :
//=======================================================================
inline Standard_Real BRepAdaptor_Surface::UResolution(const Standard_Real R3d)const
{
return mySurf.UResolution(R3d);
}
//=======================================================================
//function : VResolution
//purpose :
//=======================================================================
inline Standard_Real BRepAdaptor_Surface::VResolution(const Standard_Real R3d)const
{
return mySurf.VResolution(R3d);
}
//=======================================================================
//function : GetType
//purpose :
//=======================================================================
inline GeomAbs_SurfaceType BRepAdaptor_Surface::GetType()const
{
return mySurf.GetType();
}
//=======================================================================
//function : UDegree
//purpose :
//=======================================================================
inline Standard_Integer BRepAdaptor_Surface::UDegree()const
{
return mySurf.UDegree();
}
//=======================================================================
//function : NbUPoles
//purpose :
//=======================================================================
inline Standard_Integer BRepAdaptor_Surface::NbUPoles()const
{
return mySurf.NbUPoles();
}
//=======================================================================
//function : VDegree
//purpose :
//=======================================================================
inline Standard_Integer BRepAdaptor_Surface::VDegree()const
{
return mySurf.VDegree();
}
//=======================================================================
//function : NbVPoles
//purpose :
//=======================================================================
inline Standard_Integer BRepAdaptor_Surface::NbVPoles()const
{
return mySurf.NbVPoles();
}
//=======================================================================
//function : NbUKnots
//purpose :
//=======================================================================
inline Standard_Integer BRepAdaptor_Surface::NbUKnots()const
{
return mySurf.NbUKnots();
}
//=======================================================================
//function : NbVKnots
//purpose :
//=======================================================================
inline Standard_Integer BRepAdaptor_Surface::NbVKnots()const
{
return mySurf.NbVKnots();
}
//=======================================================================
//function : IsURational
//purpose :
//=======================================================================
inline Standard_Boolean BRepAdaptor_Surface::IsURational()const
{
return mySurf.IsURational();
}
//=======================================================================
//function : IsVRational
//purpose :
//=======================================================================
inline Standard_Boolean BRepAdaptor_Surface::IsVRational()const
{
return mySurf.IsVRational();
}

9
src/BRepAdaptor/FILES
View File

@@ -6,14 +6,5 @@ BRepAdaptor_Curve.hxx
BRepAdaptor_Curve2d.cxx
BRepAdaptor_Curve2d.hxx
BRepAdaptor_HArray1OfCurve.hxx
BRepAdaptor_HCompCurve.hxx
BRepAdaptor_HCompCurve_0.cxx
BRepAdaptor_HCurve.hxx
BRepAdaptor_HCurve2d.hxx
BRepAdaptor_HCurve2d_0.cxx
BRepAdaptor_HCurve_0.cxx
BRepAdaptor_HSurface.hxx
BRepAdaptor_HSurface_0.cxx
BRepAdaptor_Surface.cxx
BRepAdaptor_Surface.hxx
BRepAdaptor_Surface.lxx