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

Coding - Apply .clang-format formatting #286

Browse Source 
Update empty method guards to new style with regex (see PR).
Used clang-format 18.1.8.
New actions to validate code formatting is added.
Update .clang-format with disabling of include sorting.
  It is temporary changes, then include will be sorted.
Apply formatting for /src and /tools folder.
The files with .hxx,.cxx,.lxx,.h,.pxx,.hpp,*.cpp extensions.
This commit is contained in:
dpasukhi
2025-01-25 20:15:22 +00:00
parent dbba6f1289
commit a5a7b3185b
14005 changed files with 1273539 additions and 1195567 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/BRepAdaptor/BRepAdaptor_Array1OfCurve.hxx
View File

@@ -22,5 +22,4 @@
typedef NCollection_Array1<BRepAdaptor_Curve> BRepAdaptor_Array1OfCurve;
#endif

431
src/BRepAdaptor/BRepAdaptor_CompCurve.cxx
View File

@@ -36,48 +36,45 @@
IMPLEMENT_STANDARD_RTTIEXT(BRepAdaptor_CompCurve, Adaptor3d_Curve)
BRepAdaptor_CompCurve::BRepAdaptor_CompCurve()
: TFirst (0.0),
TLast (0.0),
PTol (0.0),
CurIndex(-1),
Forward (Standard_False),
IsbyAC (Standard_False)
: TFirst(0.0),
TLast(0.0),
PTol(0.0),
CurIndex(-1),
Forward(Standard_False),
IsbyAC(Standard_False)
{
}
BRepAdaptor_CompCurve::BRepAdaptor_CompCurve(const TopoDS_Wire& theWire,
const Standard_Boolean theIsAC)
: myWire (theWire),
TFirst (0.0),
TLast (0.0),
PTol (0.0),
CurIndex(-1),
Forward (Standard_False),
IsbyAC (theIsAC)
: myWire(theWire),
TFirst(0.0),
TLast(0.0),
PTol(0.0),
CurIndex(-1),
Forward(Standard_False),
IsbyAC(theIsAC)
{
Initialize(theWire, theIsAC);
}
BRepAdaptor_CompCurve::BRepAdaptor_CompCurve(const TopoDS_Wire& theWire,
BRepAdaptor_CompCurve::BRepAdaptor_CompCurve(const TopoDS_Wire& theWire,
const Standard_Boolean theIsAC,
const Standard_Real theFirst,
const Standard_Real theLast,
const Standard_Real theTolerance)
: myWire (theWire),
TFirst (theFirst),
TLast (theLast),
PTol (theTolerance),
CurIndex(-1),
Forward (Standard_False),
IsbyAC (theIsAC)
const Standard_Real theFirst,
const Standard_Real theLast,
const Standard_Real theTolerance)
: myWire(theWire),
TFirst(theFirst),
TLast(theLast),
PTol(theTolerance),
CurIndex(-1),
Forward(Standard_False),
IsbyAC(theIsAC)
{
Initialize(theWire, theIsAC, theFirst, theLast, theTolerance);
}
//=======================================================================
//function : ShallowCopy
//purpose :
//=======================================================================
//=================================================================================================
Handle(Adaptor3d_Curve) BRepAdaptor_CompCurve::ShallowCopy() const
{
@@ -87,11 +84,11 @@ Handle(Adaptor3d_Curve) BRepAdaptor_CompCurve::ShallowCopy() const
aCopy->TFirst = TFirst;
aCopy->TLast = TLast;
aCopy->PTol = PTol;
aCopy->myCurves = new (BRepAdaptor_HArray1OfCurve) (1, myCurves->Size());
aCopy->myCurves = new (BRepAdaptor_HArray1OfCurve)(1, myCurves->Size());
for (Standard_Integer anI = 1; anI <= myCurves->Size(); ++anI)
{
const Handle(Adaptor3d_Curve) aCurve = myCurves->Value(anI).ShallowCopy();
const BRepAdaptor_Curve& aBrepCurve = *(Handle(BRepAdaptor_Curve)::DownCast(aCurve));
const Handle(Adaptor3d_Curve) aCurve = myCurves->Value(anI).ShallowCopy();
const BRepAdaptor_Curve& aBrepCurve = *(Handle(BRepAdaptor_Curve)::DownCast(aCurve));
aCopy->myCurves->SetValue(anI, aBrepCurve);
}
aCopy->myKnots = myKnots;
@@ -102,105 +99,110 @@ Handle(Adaptor3d_Curve) BRepAdaptor_CompCurve::ShallowCopy() const
return aCopy;
}
void BRepAdaptor_CompCurve::Initialize(const TopoDS_Wire& W,
const Standard_Boolean AC)
void BRepAdaptor_CompCurve::Initialize(const TopoDS_Wire& W, const Standard_Boolean AC)
{
Standard_Integer ii, NbEdge;
Standard_Integer ii, NbEdge;
BRepTools_WireExplorer wexp;
TopoDS_Edge E;
TopoDS_Edge E;
myWire = W;
PTol = 0.0;
PTol = 0.0;
IsbyAC = AC;
for (NbEdge=0, wexp.Init(myWire);
wexp.More(); wexp.Next())
if (! BRep_Tool::Degenerated(wexp.Current())) NbEdge++;
for (NbEdge = 0, wexp.Init(myWire); wexp.More(); wexp.Next())
if (!BRep_Tool::Degenerated(wexp.Current()))
NbEdge++;
if (NbEdge == 0) return;
if (NbEdge == 0)
return;
CurIndex = (NbEdge+1)/2;
myCurves = new (BRepAdaptor_HArray1OfCurve) (1,NbEdge);
myKnots = new (TColStd_HArray1OfReal) (1,NbEdge+1);
CurIndex = (NbEdge + 1) / 2;
myCurves = new (BRepAdaptor_HArray1OfCurve)(1, NbEdge);
myKnots = new (TColStd_HArray1OfReal)(1, NbEdge + 1);
myKnots->SetValue(1, 0.);
for (ii=0, wexp.Init(myWire);
wexp.More(); wexp.Next()) {
for (ii = 0, wexp.Init(myWire); wexp.More(); wexp.Next())
{
E = wexp.Current();
if (! BRep_Tool::Degenerated(E)) {
if (!BRep_Tool::Degenerated(E))
{
ii++;
myCurves->ChangeValue(ii).Initialize(E);
if (AC) {
myKnots->SetValue(ii+1, myKnots->Value(ii));
myKnots->ChangeValue(ii+1) +=
GCPnts_AbscissaPoint::Length(myCurves->ChangeValue(ii));
if (AC)
{
myKnots->SetValue(ii + 1, myKnots->Value(ii));
myKnots->ChangeValue(ii + 1) += GCPnts_AbscissaPoint::Length(myCurves->ChangeValue(ii));
}
else myKnots->SetValue(ii+1, (Standard_Real)ii);
else
myKnots->SetValue(ii + 1, (Standard_Real)ii);
}
}
Forward = Standard_True; // Default ; The Reverse Edges are parsed.
if((NbEdge > 2) || ((NbEdge==2) && (!myWire.Closed())) ) {
if ((NbEdge > 2) || ((NbEdge == 2) && (!myWire.Closed())))
{
TopAbs_Orientation Or = myCurves->Value(1).Edge().Orientation();
TopoDS_Vertex VI, VL;
TopExp::CommonVertex(myCurves->Value(1).Edge(),
myCurves->Value(2).Edge(),
VI);
TopoDS_Vertex VI, VL;
TopExp::CommonVertex(myCurves->Value(1).Edge(), myCurves->Value(2).Edge(), VI);
VL = TopExp::LastVertex(myCurves->Value(1).Edge());
if (VI.IsSame(VL)) { // The direction of parsing is always preserved
if (VI.IsSame(VL))
{ // The direction of parsing is always preserved
if (Or == TopAbs_REVERSED)
Forward = Standard_False;
Forward = Standard_False;
}
else {// The direction of parsing is always reversed
if (Or != TopAbs_REVERSED)
Forward = Standard_False;
else
{ // The direction of parsing is always reversed
if (Or != TopAbs_REVERSED)
Forward = Standard_False;
}
}
TFirst = 0;
TLast = myKnots->Value(myKnots->Length());
TLast = myKnots->Value(myKnots->Length());
}
void BRepAdaptor_CompCurve::Initialize(const TopoDS_Wire& W,
const Standard_Boolean AC,
const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol)
void BRepAdaptor_CompCurve::Initialize(const TopoDS_Wire& W,
const Standard_Boolean AC,
const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol)
{
Initialize(W, AC);
TFirst = First;
TLast = Last;
PTol = Tol;
TLast = Last;
PTol = Tol;
// Trim the extremal curves.
Handle (BRepAdaptor_Curve) HC;
Standard_Integer i1, i2;
Standard_Real f=TFirst, l=TLast, d;
Handle(BRepAdaptor_Curve) HC;
Standard_Integer i1, i2;
Standard_Real f = TFirst, l = TLast, d;
i1 = i2 = CurIndex;
Prepare(f, d, i1);
Prepare(l, d, i2);
CurIndex = (i1+i2)/2; // Small optimization
if (i1==i2) {
CurIndex = (i1 + i2) / 2; // Small optimization
if (i1 == i2)
{
if (l > f)
HC = Handle(BRepAdaptor_Curve)::DownCast(myCurves->Value(i1).Trim(f, l, PTol));
else
HC = Handle(BRepAdaptor_Curve)::DownCast(myCurves->Value(i1).Trim(l, f, PTol));
myCurves->SetValue(i1, *HC);
}
else {
else
{
const BRepAdaptor_Curve& c1 = myCurves->Value(i1);
const BRepAdaptor_Curve& c2 = myCurves->Value(i2);
Standard_Real k;
Standard_Real k;
k = c1.LastParameter();
if (k>f)
if (k > f)
HC = Handle(BRepAdaptor_Curve)::DownCast(c1.Trim(f, k, PTol));
else
HC = Handle(BRepAdaptor_Curve)::DownCast(c1.Trim(k, f, PTol));
myCurves->SetValue(i1, *HC);
k = c2.FirstParameter();
if (k<=l)
if (k <= l)
HC = Handle(BRepAdaptor_Curve)::DownCast(c2.Trim(k, l, PTol));
else
HC = Handle(BRepAdaptor_Curve)::DownCast(c2.Trim(l, k, PTol));
@@ -213,332 +215,345 @@ const TopoDS_Wire& BRepAdaptor_CompCurve::Wire() const
return myWire;
}
void BRepAdaptor_CompCurve::Edge(const Standard_Real U,
TopoDS_Edge& E,
Standard_Real& UonE) const
void BRepAdaptor_CompCurve::Edge(const Standard_Real U, TopoDS_Edge& E, Standard_Real& UonE) const
{
Standard_Real d;
Standard_Real d;
Standard_Integer index = CurIndex;
UonE = U;
UonE = U;
Prepare(UonE, d, index);
E = myCurves->Value(index).Edge();
}
Standard_Real BRepAdaptor_CompCurve::FirstParameter() const
Standard_Real BRepAdaptor_CompCurve::FirstParameter() const
{
return TFirst;
}
Standard_Real BRepAdaptor_CompCurve::LastParameter() const
Standard_Real BRepAdaptor_CompCurve::LastParameter() const
{
return TLast;
}
GeomAbs_Shape BRepAdaptor_CompCurve::Continuity() const
GeomAbs_Shape BRepAdaptor_CompCurve::Continuity() const
{
if ( myCurves->Length() > 1) return GeomAbs_C0;
if (myCurves->Length() > 1)
return GeomAbs_C0;
return myCurves->Value(1).Continuity();
}
Standard_Integer BRepAdaptor_CompCurve::NbIntervals(const GeomAbs_Shape S) const
Standard_Integer BRepAdaptor_CompCurve::NbIntervals(const GeomAbs_Shape S) const
{
Standard_Integer NbInt, ii;
for (ii=1, NbInt=0; ii<=myCurves->Length(); ii++)
for (ii = 1, NbInt = 0; ii <= myCurves->Length(); ii++)
NbInt += myCurves->ChangeValue(ii).NbIntervals(S);
return NbInt;
}
void BRepAdaptor_CompCurve::Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const
void BRepAdaptor_CompCurve::Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const
{
Standard_Integer ii, jj, kk, n;
Standard_Real f, F, delta;
Standard_Real f, F, delta;
// First curve (direction of parsing of the edge)
n = myCurves->ChangeValue(1).NbIntervals(S);
Handle(TColStd_HArray1OfReal) Ti = new (TColStd_HArray1OfReal) (1, n+1);
n = myCurves->ChangeValue(1).NbIntervals(S);
Handle(TColStd_HArray1OfReal) Ti = new (TColStd_HArray1OfReal)(1, n + 1);
myCurves->ChangeValue(1).Intervals(Ti->ChangeArray1(), S);
InvPrepare(1, f, delta);
F = myKnots->Value(1);
if (delta < 0) {
if (delta < 0)
{
// invert the direction of parsing
for (kk=1,jj=Ti->Length(); jj>0; kk++, jj--)
T(kk) = F + (Ti->Value(jj)-f)*delta;
for (kk = 1, jj = Ti->Length(); jj > 0; kk++, jj--)
T(kk) = F + (Ti->Value(jj) - f) * delta;
}
else {
for (kk=1; kk<=Ti->Length(); kk++)
T(kk) = F + (Ti->Value(kk)-f)*delta;
else
{
for (kk = 1; kk <= Ti->Length(); kk++)
T(kk) = F + (Ti->Value(kk) - f) * delta;
}
// and the next
for (ii=2; ii<=myCurves->Length(); ii++) {
for (ii = 2; ii <= myCurves->Length(); ii++)
{
n = myCurves->ChangeValue(ii).NbIntervals(S);
if (n != Ti->Length()-1) Ti = new (TColStd_HArray1OfReal) (1, n+1);
if (n != Ti->Length() - 1)
Ti = new (TColStd_HArray1OfReal)(1, n + 1);
myCurves->ChangeValue(ii).Intervals(Ti->ChangeArray1(), S);
InvPrepare(ii, f, delta);
F = myKnots->Value(ii);
if (delta < 0) {
if (delta < 0)
{
// invert the direction of parcing
for (jj=Ti->Length()-1; jj>0; kk++, jj--)
T(kk) = F + (Ti->Value(jj)-f)*delta;
for (jj = Ti->Length() - 1; jj > 0; kk++, jj--)
T(kk) = F + (Ti->Value(jj) - f) * delta;
}
else {
for (jj=2; jj<=Ti->Length(); kk++, jj++)
T(kk) = F + (Ti->Value(jj)-f)*delta;
else
{
for (jj = 2; jj <= Ti->Length(); kk++, jj++)
T(kk) = F + (Ti->Value(jj) - f) * delta;
}
}
}
Handle(Adaptor3d_Curve) BRepAdaptor_CompCurve::Trim(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const
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_CompCurve) HC =
new (BRepAdaptor_CompCurve) (C);
BRepAdaptor_CompCurve C(myWire, IsbyAC, First, Last, Tol);
Handle(BRepAdaptor_CompCurve) HC = new (BRepAdaptor_CompCurve)(C);
return HC;
}
Standard_Boolean BRepAdaptor_CompCurve::IsClosed() const
Standard_Boolean BRepAdaptor_CompCurve::IsClosed() const
{
return myWire.Closed();
}
Standard_Boolean BRepAdaptor_CompCurve::IsPeriodic() const
Standard_Boolean BRepAdaptor_CompCurve::IsPeriodic() const
{
return Standard_False;
}
Standard_Real BRepAdaptor_CompCurve::Period() const
Standard_Real BRepAdaptor_CompCurve::Period() const
{
return (TLast - TFirst);
}
gp_Pnt BRepAdaptor_CompCurve::Value(const Standard_Real U) const
gp_Pnt BRepAdaptor_CompCurve::Value(const Standard_Real U) const
{
Standard_Real u = U, d;
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
return myCurves->Value(index).Value(u);
}
void BRepAdaptor_CompCurve::D0(const Standard_Real U,
gp_Pnt& P) const
void BRepAdaptor_CompCurve::D0(const Standard_Real U, gp_Pnt& P) const
{
Standard_Real u = U, d;
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
myCurves->Value(index).D0(u, P);
}
void BRepAdaptor_CompCurve::D1(const Standard_Real U,
gp_Pnt& P,
gp_Vec& V) const
void BRepAdaptor_CompCurve::D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const
{
Standard_Real u = U, d;
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
myCurves->Value(index).D1(u, P, V);
V*=d;
V *= d;
}
void BRepAdaptor_CompCurve::D2(const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2) const
void BRepAdaptor_CompCurve::D2(const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const
{
Standard_Real u = U, d;
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
myCurves->Value(index).D2(u, P, V1, V2);
V1*=d;
V2 *= d*d;
V1 *= d;
V2 *= d * d;
}
void BRepAdaptor_CompCurve::D3(const Standard_Real U,
gp_Pnt& P,gp_Vec& V1,
gp_Vec& V2,
gp_Vec& V3) const
void BRepAdaptor_CompCurve::D3(const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2,
gp_Vec& V3) const
{
Standard_Real u = U, d;
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
myCurves->Value(index).D3(u, P, V1, V2, V3);
V1*=d;
V2 *= d*d;
V3 *= d*d*d;
V1 *= d;
V2 *= d * d;
V3 *= d * d * d;
}
gp_Vec BRepAdaptor_CompCurve::DN(const Standard_Real U,
const Standard_Integer N) const
gp_Vec BRepAdaptor_CompCurve::DN(const Standard_Real U, const Standard_Integer N) const
{
Standard_Real u = U, d;
Standard_Real u = U, d;
Standard_Integer index = CurIndex;
Prepare(u, d, index);
return (myCurves->Value(index).DN(u, N) * Pow(d, N));
}
Standard_Real BRepAdaptor_CompCurve::Resolution(const Standard_Real R3d) const
Standard_Real BRepAdaptor_CompCurve::Resolution(const Standard_Real R3d) const
{
Standard_Real Res = 1.e200, r;
Standard_Real Res = 1.e200, r;
Standard_Integer ii, L = myCurves->Length();
for (ii=1; ii<=L; ii++) {
for (ii = 1; ii <= L; ii++)
{
r = myCurves->Value(ii).Resolution(R3d);
if (r < Res) Res = r;
if (r < Res)
Res = r;
}
return Res;
}
GeomAbs_CurveType BRepAdaptor_CompCurve::GetType() const
GeomAbs_CurveType BRepAdaptor_CompCurve::GetType() const
{
return GeomAbs_OtherCurve; //temporary
// if ( myCurves->Length() > 1) return GeomAbs_OtherCurve;
// return myCurves->Value(1).GetType();
return GeomAbs_OtherCurve; // temporary
// if ( myCurves->Length() > 1) return GeomAbs_OtherCurve;
// return myCurves->Value(1).GetType();
}
gp_Lin BRepAdaptor_CompCurve::Line() const
gp_Lin BRepAdaptor_CompCurve::Line() const
{
return myCurves->Value(1).Line();
}
gp_Circ BRepAdaptor_CompCurve::Circle() const
gp_Circ BRepAdaptor_CompCurve::Circle() const
{
return myCurves->Value(1).Circle();
}
gp_Elips BRepAdaptor_CompCurve::Ellipse() const
gp_Elips BRepAdaptor_CompCurve::Ellipse() const
{
return myCurves->Value(1).Ellipse();
}
gp_Hypr BRepAdaptor_CompCurve::Hyperbola() const
gp_Hypr BRepAdaptor_CompCurve::Hyperbola() const
{
return myCurves->Value(1).Hyperbola();
}
gp_Parab BRepAdaptor_CompCurve::Parabola() const
gp_Parab BRepAdaptor_CompCurve::Parabola() const
{
return myCurves->Value(1).Parabola();
}
Standard_Integer BRepAdaptor_CompCurve::Degree() const
Standard_Integer BRepAdaptor_CompCurve::Degree() const
{
return myCurves->Value(1).Degree();
}
Standard_Boolean BRepAdaptor_CompCurve::IsRational() const
Standard_Boolean BRepAdaptor_CompCurve::IsRational() const
{
return myCurves->Value(1).IsRational();
}
Standard_Integer BRepAdaptor_CompCurve::NbPoles() const
Standard_Integer BRepAdaptor_CompCurve::NbPoles() const
{
return myCurves->Value(1).NbPoles();
}
Standard_Integer BRepAdaptor_CompCurve::NbKnots() const
Standard_Integer BRepAdaptor_CompCurve::NbKnots() const
{
return myCurves->Value(1).NbKnots();
}
Handle(Geom_BezierCurve) BRepAdaptor_CompCurve::Bezier() const
Handle(Geom_BezierCurve) BRepAdaptor_CompCurve::Bezier() const
{
return myCurves->Value(1).Bezier();
}
Handle(Geom_BSplineCurve) BRepAdaptor_CompCurve::BSpline() const
Handle(Geom_BSplineCurve) BRepAdaptor_CompCurve::BSpline() const
{
return myCurves->Value(1).BSpline();
}
//=======================================================================
//function : Prepare
//purpose :
// function : Prepare
// purpose :
// When the parameter is close to "node" the rule is determined
// depending on the sign of tol:
// - negative -> Rule preceding to the node.
// - positive -> Rule following after the node.
//=======================================================================
void BRepAdaptor_CompCurve::Prepare(Standard_Real& W,
Standard_Real& Delta,
Standard_Integer& theCurIndex) const
void BRepAdaptor_CompCurve::Prepare(Standard_Real& W,
Standard_Real& Delta,
Standard_Integer& theCurIndex) const
{
Standard_Real f,l, Wtest, Eps;
Standard_Real f, l, Wtest, Eps;
Standard_Integer ii;
if (W-TFirst < TLast-W) { Eps = PTol; }
else { Eps = -PTol;}
if (W - TFirst < TLast - W)
{
Eps = PTol;
}
else
{
Eps = -PTol;
}
Wtest = W+Eps; //Offset to discriminate the nodes
Wtest = W + Eps; // Offset to discriminate the nodes
// Find the index
Standard_Boolean Trouve = Standard_False;
if (myKnots->Value(theCurIndex) > Wtest) {
for (ii=theCurIndex-1; ii>0 && !Trouve; ii--)
if (myKnots->Value(ii)<= Wtest) {
theCurIndex = ii;
Trouve = Standard_True;
if (myKnots->Value(theCurIndex) > Wtest)
{
for (ii = theCurIndex - 1; ii > 0 && !Trouve; ii--)
if (myKnots->Value(ii) <= Wtest)
{
theCurIndex = ii;
Trouve = Standard_True;
}
if (!Trouve) theCurIndex = 1; // Out of limits...
if (!Trouve)
theCurIndex = 1; // Out of limits...
}
else if (myKnots->Value(theCurIndex+1) <= Wtest) {
for (ii=theCurIndex+1; ii<=myCurves->Length() && !Trouve; ii++)
if (myKnots->Value(ii+1)> Wtest) {
theCurIndex = ii;
Trouve = Standard_True;
else if (myKnots->Value(theCurIndex + 1) <= Wtest)
{
for (ii = theCurIndex + 1; ii <= myCurves->Length() && !Trouve; ii++)
if (myKnots->Value(ii + 1) > Wtest)
{
theCurIndex = ii;
Trouve = Standard_True;
}
if (!Trouve) theCurIndex = myCurves->Length(); // Out of limits...
if (!Trouve)
theCurIndex = myCurves->Length(); // Out of limits...
}
// Invert ?
const TopoDS_Edge& E = myCurves->Value(theCurIndex).Edge();
const TopoDS_Edge& E = myCurves->Value(theCurIndex).Edge();
TopAbs_Orientation Or = E.Orientation();
Standard_Boolean Reverse;
Reverse = (Forward && (Or == TopAbs_REVERSED)) ||
(!Forward && (Or != TopAbs_REVERSED));
Standard_Boolean Reverse;
Reverse = (Forward && (Or == TopAbs_REVERSED)) || (!Forward && (Or != TopAbs_REVERSED));
// Calculate the local parameter
BRep_Tool::Range(E, f, l);
Delta = myKnots->Value(theCurIndex+1) - myKnots->Value(theCurIndex);
if (Delta > PTol*1.e-9) Delta = (l-f)/Delta;
Delta = myKnots->Value(theCurIndex + 1) - myKnots->Value(theCurIndex);
if (Delta > PTol * 1.e-9)
Delta = (l - f) / Delta;
if (Reverse) {
if (Reverse)
{
Delta *= -1;
W = l + (W-myKnots->Value(theCurIndex)) * Delta;
W = l + (W - myKnots->Value(theCurIndex)) * Delta;
}
else {
W = f + (W-myKnots->Value(theCurIndex)) * Delta;
else
{
W = f + (W - myKnots->Value(theCurIndex)) * Delta;
}
}
void BRepAdaptor_CompCurve::InvPrepare(const Standard_Integer index,
Standard_Real& First,
Standard_Real& Delta) const
void BRepAdaptor_CompCurve::InvPrepare(const Standard_Integer index,
Standard_Real& First,
Standard_Real& Delta) const
{
// Invert?
const TopoDS_Edge& E = myCurves->Value(index).Edge();
const TopoDS_Edge& E = myCurves->Value(index).Edge();
TopAbs_Orientation Or = E.Orientation();
Standard_Boolean Reverse;
Reverse = (Forward && (Or == TopAbs_REVERSED)) ||
(!Forward && (Or != TopAbs_REVERSED));
Standard_Boolean Reverse;
Reverse = (Forward && (Or == TopAbs_REVERSED)) || (!Forward && (Or != TopAbs_REVERSED));
// Calculate the parameters of reparametrisation
// such as : T = Ti + (t-First)*Delta
Standard_Real f, l;
BRep_Tool::Range(E, f, l);
Delta = myKnots->Value(index+1) - myKnots->Value(index);
if (l-f > PTol*1.e-9) Delta /= (l-f);
Delta = myKnots->Value(index + 1) - myKnots->Value(index);
if (l - f > PTol * 1.e-9)
Delta /= (l - f);
if (Reverse) {
if (Reverse)
{
Delta *= -1;
First = l;
}
else {
else
{
First = f;
}
}

161
src/BRepAdaptor/BRepAdaptor_CompCurve.hxx
View File

@@ -50,163 +50,166 @@ DEFINE_STANDARD_HANDLE(BRepAdaptor_CompCurve, Adaptor3d_Curve)
//! Warning: With this class of curve, C0 and C1 continuities
//! are not assumed. So be careful with some algorithm!
//! Please note that BRepAdaptor_CompCurve cannot be
//! periodic curve at all (even if it contains single
//! periodic curve at all (even if it contains single
//! periodic edge).
//!
//! BRepAdaptor_CompCurve can only work on valid wires where all edges are
//! connected to each other to make a chain.
class BRepAdaptor_CompCurve : public Adaptor3d_Curve
class BRepAdaptor_CompCurve : public Adaptor3d_Curve
{
DEFINE_STANDARD_RTTIEXT(BRepAdaptor_CompCurve, Adaptor3d_Curve)
public:
//! Creates an undefined Curve with no Wire loaded.
Standard_EXPORT BRepAdaptor_CompCurve();
Standard_EXPORT BRepAdaptor_CompCurve(const TopoDS_Wire& W, const Standard_Boolean KnotByCurvilinearAbcissa = Standard_False);
Standard_EXPORT BRepAdaptor_CompCurve(
const TopoDS_Wire& W,
const Standard_Boolean KnotByCurvilinearAbcissa = Standard_False);
//! Creates a Curve to access the geometry of edge
//! <W>.
Standard_EXPORT BRepAdaptor_CompCurve(const TopoDS_Wire& W, const Standard_Boolean KnotByCurvilinearAbcissa, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
Standard_EXPORT BRepAdaptor_CompCurve(const TopoDS_Wire& W,
const Standard_Boolean KnotByCurvilinearAbcissa,
const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol);
//! Shallow copy of adaptor
Standard_EXPORT virtual Handle(Adaptor3d_Curve) ShallowCopy() const Standard_OVERRIDE;
//! Sets the wire <W>.
Standard_EXPORT void Initialize (const TopoDS_Wire& W, const Standard_Boolean KnotByCurvilinearAbcissa);
Standard_EXPORT void Initialize(const TopoDS_Wire& W,
const Standard_Boolean KnotByCurvilinearAbcissa);
//! Sets wire <W> and trimmed parameter.
Standard_EXPORT void Initialize (const TopoDS_Wire& W, const Standard_Boolean KnotByCurvilinearAbcissa, const Standard_Real First, const Standard_Real Last, const Standard_Real Tol);
Standard_EXPORT void Initialize(const TopoDS_Wire& W,
const Standard_Boolean KnotByCurvilinearAbcissa,
const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol);
//! Returns the wire.
Standard_EXPORT const TopoDS_Wire& Wire() const;
//! returns an edge and one parameter on them
//! corresponding to the parameter U.
Standard_EXPORT void Edge (const Standard_Real U, TopoDS_Edge& E, Standard_Real& UonE) const;
Standard_EXPORT void Edge(const Standard_Real U, TopoDS_Edge& E, Standard_Real& UonE) const;
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
//! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals (const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Returns a curve equivalent of <me> between
//! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Curve) 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;
Standard_EXPORT Standard_Boolean IsPeriodic() const Standard_OVERRIDE;
Standard_EXPORT Standard_Real Period() const Standard_OVERRIDE;
//! Computes the point of parameter U on the curve
Standard_EXPORT gp_Pnt Value (const Standard_Real U) const Standard_OVERRIDE;
Standard_EXPORT gp_Pnt Value(const Standard_Real U) const Standard_OVERRIDE;
//! Computes the point of parameter U.
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt& P) const Standard_OVERRIDE;
Standard_EXPORT void D0(const Standard_Real U, gp_Pnt& P) const Standard_OVERRIDE;
//! Computes the point of parameter U on the curve
//! with its first derivative.
//! Raised if the continuity of the current interval
//! is not C1.
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt& P, gp_Vec& V) const Standard_OVERRIDE;
Standard_EXPORT void D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first and second
//! derivatives V1 and V2.
//! Raised if the continuity of the current interval
//! is not C2.
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const Standard_OVERRIDE;
Standard_EXPORT void D2(const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first, the second
//! and the third derivative.
//! Raised if the continuity of the current interval
//! is not C3.
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3) const Standard_OVERRIDE;
Standard_EXPORT void D3(const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2,
gp_Vec& V3) const Standard_OVERRIDE;
//! The returned vector gives the value of the derivative for the
//! order of derivation N.
//! Raised if the continuity of the current interval
//! is not CN.
//! Raised if N < 1.
Standard_EXPORT gp_Vec DN (const Standard_Real U, const Standard_Integer N) const Standard_OVERRIDE;
Standard_EXPORT gp_Vec DN(const Standard_Real U,
const Standard_Integer N) const Standard_OVERRIDE;
//! returns the parametric resolution
Standard_EXPORT Standard_Real Resolution (const Standard_Real R3d) const Standard_OVERRIDE;
Standard_EXPORT Standard_Real Resolution(const Standard_Real R3d) const Standard_OVERRIDE;
Standard_EXPORT GeomAbs_CurveType GetType() const Standard_OVERRIDE;
Standard_EXPORT gp_Lin Line() const Standard_OVERRIDE;
Standard_EXPORT gp_Circ Circle() const Standard_OVERRIDE;
Standard_EXPORT gp_Elips Ellipse() const Standard_OVERRIDE;
Standard_EXPORT gp_Hypr Hyperbola() const Standard_OVERRIDE;
Standard_EXPORT gp_Parab Parabola() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer Degree() const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsRational() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer NbPoles() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer NbKnots() const Standard_OVERRIDE;
Standard_EXPORT Handle(Geom_BezierCurve) Bezier() const Standard_OVERRIDE;
Standard_EXPORT Handle(Geom_BSplineCurve) BSpline() const Standard_OVERRIDE;
protected:
private:
Standard_EXPORT void Prepare(Standard_Real& W, Standard_Real& D, Standard_Integer& ind) const;
Standard_EXPORT void Prepare (Standard_Real& W, Standard_Real& D, Standard_Integer& ind) const;
Standard_EXPORT void InvPrepare (const Standard_Integer ind, Standard_Real& F, Standard_Real& D) const;
Standard_EXPORT void InvPrepare(const Standard_Integer ind,
Standard_Real& F,
Standard_Real& D) const;
TopoDS_Wire myWire;
Standard_Real TFirst;
Standard_Real TLast;
Standard_Real PTol;
TopoDS_Wire myWire;
Standard_Real TFirst;
Standard_Real TLast;
Standard_Real PTol;
Handle(BRepAdaptor_HArray1OfCurve) myCurves;
Handle(TColStd_HArray1OfReal) myKnots;
Standard_Integer CurIndex;
Standard_Boolean Forward;
Standard_Boolean IsbyAC;
Handle(TColStd_HArray1OfReal) myKnots;
Standard_Integer CurIndex;
Standard_Boolean Forward;
Standard_Boolean IsbyAC;
};
#endif // _BRepAdaptor_CompCurve_HeaderFile

450
src/BRepAdaptor/BRepAdaptor_Curve.cxx
View File

@@ -41,62 +41,47 @@
IMPLEMENT_STANDARD_RTTIEXT(BRepAdaptor_Curve, Adaptor3d_Curve)
//=======================================================================
//function : BRepAdaptor_Curve
//purpose :
//=======================================================================
BRepAdaptor_Curve::BRepAdaptor_Curve()
{}
//=================================================================================================
//=======================================================================
//function : BRepAdaptor_Curve
//purpose :
//=======================================================================
BRepAdaptor_Curve::BRepAdaptor_Curve() {}
//=================================================================================================
BRepAdaptor_Curve::BRepAdaptor_Curve(const TopoDS_Edge& E)
{
Initialize(E);
}
//=======================================================================
//function : BRepAdaptor_Curve
//purpose :
//=======================================================================
//=================================================================================================
BRepAdaptor_Curve::BRepAdaptor_Curve(const TopoDS_Edge& E,
const TopoDS_Face& F)
BRepAdaptor_Curve::BRepAdaptor_Curve(const TopoDS_Edge& E, const TopoDS_Face& F)
{
Initialize(E,F);
Initialize(E, F);
}
//=======================================================================
//function : ShallowCopy
//purpose :
//=======================================================================
//=================================================================================================
Handle(Adaptor3d_Curve) BRepAdaptor_Curve::ShallowCopy() const
{
Handle(BRepAdaptor_Curve) aCopy = new BRepAdaptor_Curve();
aCopy->myTrsf = myTrsf;
aCopy->myTrsf = myTrsf;
const Handle(Adaptor3d_Curve) aCurve = myCurve.ShallowCopy();
const GeomAdaptor_Curve& aGeomCurve = *(Handle(GeomAdaptor_Curve)::DownCast(aCurve));
aCopy->myCurve = aGeomCurve;
const Handle(Adaptor3d_Curve) aCurve = myCurve.ShallowCopy();
const GeomAdaptor_Curve& aGeomCurve = *(Handle(GeomAdaptor_Curve)::DownCast(aCurve));
aCopy->myCurve = aGeomCurve;
if (!myConSurf.IsNull())
{
aCopy->myConSurf = Handle(Adaptor3d_CurveOnSurface)::DownCast(myConSurf->ShallowCopy());
}
aCopy->myEdge = myEdge;
aCopy->myEdge = myEdge;
return aCopy;
}
//=======================================================================
//function : Reset
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Curve::Reset()
{
myCurve.Reset();
@@ -105,292 +90,254 @@ void BRepAdaptor_Curve::Reset()
myTrsf = gp_Trsf();
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Curve::Initialize(const TopoDS_Edge& E)
{
myConSurf.Nullify();
myEdge = E;
Standard_Real pf,pl;
Standard_Real pf, pl;
TopLoc_Location L;
Handle(Geom_Curve) C = BRep_Tool::Curve(E,L,pf,pl);
TopLoc_Location L;
Handle(Geom_Curve) C = BRep_Tool::Curve(E, L, pf, pl);
if (!C.IsNull()) {
myCurve.Load(C,pf,pl);
if (!C.IsNull())
{
myCurve.Load(C, pf, pl);
}
else {
else
{
Handle(Geom2d_Curve) PC;
Handle(Geom_Surface) S;
BRep_Tool::CurveOnSurface(E,PC,S,L,pf,pl);
if (!PC.IsNull()) {
BRep_Tool::CurveOnSurface(E, PC, S, L, pf, pl);
if (!PC.IsNull())
{
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load(S);
Handle(Geom2dAdaptor_Curve) HC = new Geom2dAdaptor_Curve();
HC->Load(PC,pf,pl);
HC->Load(PC, pf, pl);
myConSurf = new Adaptor3d_CurveOnSurface();
myConSurf->Load(HC, HS);
}
else {
else
{
throw Standard_NullObject("BRepAdaptor_Curve::No geometry");
}
}
myTrsf = L.Transformation();
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Curve::Initialize(const TopoDS_Edge& E,
const TopoDS_Face& F)
void BRepAdaptor_Curve::Initialize(const TopoDS_Edge& E, const TopoDS_Face& F)
{
myConSurf.Nullify();
myEdge = E;
TopLoc_Location L;
Standard_Real pf,pl;
Handle(Geom_Surface) S = BRep_Tool::Surface(F,L);
Handle(Geom2d_Curve) PC = BRep_Tool::CurveOnSurface(E,F,pf,pl);
TopLoc_Location L;
Standard_Real pf, pl;
Handle(Geom_Surface) S = BRep_Tool::Surface(F, L);
Handle(Geom2d_Curve) PC = BRep_Tool::CurveOnSurface(E, F, pf, pl);
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load(S);
Handle(Geom2dAdaptor_Curve) HC = new Geom2dAdaptor_Curve();
HC->Load(PC,pf,pl);
HC->Load(PC, pf, pl);
myConSurf = new Adaptor3d_CurveOnSurface();
myConSurf->Load(HC, HS);
myTrsf = L.Transformation();
}
//=======================================================================
//function : Trsf
//purpose :
//=======================================================================
//=================================================================================================
const gp_Trsf& BRepAdaptor_Curve::Trsf() const
{
return myTrsf;
}
//=======================================================================
//function : Is3DCurve
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean BRepAdaptor_Curve::Is3DCurve() const
{
return myConSurf.IsNull();
}
//=======================================================================
//function : IsCurveOnSurface
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean BRepAdaptor_Curve::IsCurveOnSurface() const
{
return !myConSurf.IsNull();
}
//=======================================================================
//function : Curve
//purpose :
//=======================================================================
//=================================================================================================
const GeomAdaptor_Curve& BRepAdaptor_Curve::Curve() const
{
return myCurve;
}
//=======================================================================
//function : CurveOnSurface
//purpose :
//=======================================================================
//=================================================================================================
const Adaptor3d_CurveOnSurface& BRepAdaptor_Curve::CurveOnSurface() const
{
return *myConSurf;
}
//=======================================================================
//function : Edge
//purpose :
//=======================================================================
//=================================================================================================
const TopoDS_Edge& BRepAdaptor_Curve::Edge() const
{
return myEdge;
}
//=======================================================================
//function : Tolerance
//purpose :
//=======================================================================
//=================================================================================================
Standard_Real BRepAdaptor_Curve::Tolerance() const
{
return BRep_Tool::Tolerance(myEdge);
}
//=======================================================================
//function : FirstParameter
//purpose :
//=======================================================================
//=================================================================================================
Standard_Real BRepAdaptor_Curve::FirstParameter() const
Standard_Real BRepAdaptor_Curve::FirstParameter() const
{
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
return myCurve.FirstParameter();
}
else {
else
{
return myConSurf->FirstParameter();
}
}
//=======================================================================
//function : LastParameter
//purpose :
//=======================================================================
//=================================================================================================
Standard_Real BRepAdaptor_Curve::LastParameter() const
Standard_Real BRepAdaptor_Curve::LastParameter() const
{
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
return myCurve.LastParameter();
}
else {
else
{
return myConSurf->LastParameter();
}
}
//=======================================================================
//function : Continuity
//purpose :
//=======================================================================
//=================================================================================================
GeomAbs_Shape BRepAdaptor_Curve::Continuity() const
GeomAbs_Shape BRepAdaptor_Curve::Continuity() const
{
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
return myCurve.Continuity();
}
else {
else
{
return myConSurf->Continuity();
}
}
//=======================================================================
//function : NbIntervals
//purpose :
//=======================================================================
//=================================================================================================
Standard_Integer BRepAdaptor_Curve::NbIntervals(const GeomAbs_Shape S) const
{
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
return myCurve.NbIntervals(S);
}
else {
else
{
return myConSurf->NbIntervals(S);
}
}
//=======================================================================
//function : Intervals
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Curve::Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const
void BRepAdaptor_Curve::Intervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const
{
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
myCurve.Intervals(T, S);
}
else {
else
{
myConSurf->Intervals(T, S);
}
}
//=================================================================================================
//=======================================================================
//function : Trim
//purpose :
//=======================================================================
Handle(Adaptor3d_Curve) BRepAdaptor_Curve::Trim(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const
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_Curve) res;
if (myConSurf.IsNull()){
Standard_Real pf = FirstParameter(), pl = LastParameter();
if (myConSurf.IsNull())
{
Standard_Real pf = FirstParameter(), pl = LastParameter();
Handle(Geom_Curve) C = myCurve.Curve();
const_cast<GeomAdaptor_Curve*>(&myCurve)->Load(C,First,Last);
res = new BRepAdaptor_Curve (*this);
const_cast<GeomAdaptor_Curve*>(&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 {
else
{
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) =
Handle(Adaptor3d_CurveOnSurface)::DownCast(myConSurf->Trim(First, Last, Tol));
res = new BRepAdaptor_Curve(*this);
const_cast<Handle(Adaptor3d_CurveOnSurface)&>(myConSurf) = sav;
}
return res;
}
//=================================================================================================
//=======================================================================
//function : IsClosed
//purpose :
//=======================================================================
Standard_Boolean BRepAdaptor_Curve::IsClosed() const
Standard_Boolean BRepAdaptor_Curve::IsClosed() const
{
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
return myCurve.IsClosed();
}
else {
else
{
return myConSurf->IsClosed();
}
}
//=======================================================================
//function : IsPeriodic
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean BRepAdaptor_Curve::IsPeriodic() const
Standard_Boolean BRepAdaptor_Curve::IsPeriodic() const
{
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
return myCurve.IsPeriodic();
}
else {
else
{
return myConSurf->IsPeriodic();
}
}
//=======================================================================
//function : Period
//purpose :
//=======================================================================
//=================================================================================================
Standard_Real BRepAdaptor_Curve::Period() const
Standard_Real BRepAdaptor_Curve::Period() const
{
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
return myCurve.Period();
}
else {
else
{
return myConSurf->Period();
}
}
//=======================================================================
//function : Value
//purpose :
//=======================================================================
//=================================================================================================
gp_Pnt BRepAdaptor_Curve::Value(const Standard_Real U) const
{
@@ -403,123 +350,102 @@ gp_Pnt BRepAdaptor_Curve::Value(const Standard_Real U) const
return P;
}
//=======================================================================
//function : D0
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Curve::D0(const Standard_Real U, gp_Pnt& P) const
{
if (myConSurf.IsNull())
myCurve.D0(U,P);
myCurve.D0(U, P);
else
myConSurf->D0(U,P);
myConSurf->D0(U, P);
P.Transform(myTrsf);
}
//=======================================================================
//function : D1
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Curve::D1(const Standard_Real U,
gp_Pnt& P, gp_Vec& V) const
void BRepAdaptor_Curve::D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const
{
if (myConSurf.IsNull())
myCurve.D1(U,P,V);
myCurve.D1(U, P, V);
else
myConSurf->D1(U,P,V);
myConSurf->D1(U, P, V);
P.Transform(myTrsf);
V.Transform(myTrsf);
}
//=======================================================================
//function : D2
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Curve::D2(const Standard_Real U,
gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const
void BRepAdaptor_Curve::D2(const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const
{
if (myConSurf.IsNull())
myCurve.D2(U,P,V1,V2);
myCurve.D2(U, P, V1, V2);
else
myConSurf->D2(U,P,V1,V2);
myConSurf->D2(U, P, V1, V2);
P.Transform(myTrsf);
V1.Transform(myTrsf);
V2.Transform(myTrsf);
}
//=======================================================================
//function : D3
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Curve::D3(const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1, gp_Vec& V2, gp_Vec& V3) const
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2,
gp_Vec& V3) const
{
if (myConSurf.IsNull())
myCurve.D3(U,P,V1,V2,V3);
myCurve.D3(U, P, V1, V2, V3);
else
myConSurf->D3(U,P,V1,V2,V3);
myConSurf->D3(U, P, V1, V2, V3);
P.Transform(myTrsf);
V1.Transform(myTrsf);
V2.Transform(myTrsf);
V3.Transform(myTrsf);
}
//=======================================================================
//function : DN
//purpose :
//=======================================================================
//=================================================================================================
gp_Vec BRepAdaptor_Curve::DN(const Standard_Real U,
const Standard_Integer N) const
gp_Vec BRepAdaptor_Curve::DN(const Standard_Real U, const Standard_Integer N) const
{
gp_Vec V;
if (myConSurf.IsNull())
V = myCurve.DN(U,N);
V = myCurve.DN(U, N);
else
V = myConSurf->DN(U,N);
V = myConSurf->DN(U, N);
V.Transform(myTrsf);
return V;
}
//=======================================================================
//function : Resolution
//purpose :
//=======================================================================
//=================================================================================================
Standard_Real BRepAdaptor_Curve::Resolution(const Standard_Real R) const
Standard_Real BRepAdaptor_Curve::Resolution(const Standard_Real R) const
{
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
return myCurve.Resolution(R);
}
else {
else
{
return myConSurf->Resolution(R);
}
}
//=======================================================================
//function : GetTYpe
//purpose :
//=======================================================================
//=================================================================================================
GeomAbs_CurveType BRepAdaptor_Curve::GetType() const
GeomAbs_CurveType BRepAdaptor_Curve::GetType() const
{
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
return myCurve.GetType();
}
else {
else
{
return myConSurf->GetType();
}
}
//=======================================================================
//function : Line
//purpose :
//=======================================================================
//=================================================================================================
gp_Lin BRepAdaptor_Curve::Line() const
{
@@ -532,10 +458,7 @@ gp_Lin BRepAdaptor_Curve::Line() const
return L;
}
//=======================================================================
//function : Circle
//purpose :
//=======================================================================
//=================================================================================================
gp_Circ BRepAdaptor_Curve::Circle() const
{
@@ -548,10 +471,7 @@ gp_Circ BRepAdaptor_Curve::Circle() const
return C;
}
//=======================================================================
//function : Ellipse
//purpose :
//=======================================================================
//=================================================================================================
gp_Elips BRepAdaptor_Curve::Ellipse() const
{
@@ -564,10 +484,7 @@ gp_Elips BRepAdaptor_Curve::Ellipse() const
return E;
}
//=======================================================================
//function : Hyperbola
//purpose :
//=======================================================================
//=================================================================================================
gp_Hypr BRepAdaptor_Curve::Hyperbola() const
{
@@ -580,10 +497,7 @@ gp_Hypr BRepAdaptor_Curve::Hyperbola() const
return H;
}
//=======================================================================
//function : Parabola
//purpose :
//=======================================================================
//=================================================================================================
gp_Parab BRepAdaptor_Curve::Parabola() const
{
@@ -596,10 +510,7 @@ gp_Parab BRepAdaptor_Curve::Parabola() const
return P;
}
//=======================================================================
//function : Degree
//purpose :
//=======================================================================
//=================================================================================================
Standard_Integer BRepAdaptor_Curve::Degree() const
{
@@ -609,10 +520,7 @@ Standard_Integer BRepAdaptor_Curve::Degree() const
return myConSurf->Degree();
}
//=======================================================================
//function : IsRational
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean BRepAdaptor_Curve::IsRational() const
{
@@ -621,79 +529,71 @@ Standard_Boolean BRepAdaptor_Curve::IsRational() const
else
return myConSurf->IsRational();
}
//=======================================================================
//function : NbPoles
//purpose :
//=======================================================================
//=================================================================================================
Standard_Integer BRepAdaptor_Curve::NbPoles() const
{
if (myConSurf.IsNull())
if (myConSurf.IsNull())
return myCurve.NbPoles();
else
return myConSurf->NbPoles();
}
//=======================================================================
//function : NbKnots
//purpose :
//=======================================================================
//=================================================================================================
Standard_Integer BRepAdaptor_Curve::NbKnots() const
{
if (myConSurf.IsNull())
if (myConSurf.IsNull())
return myCurve.NbKnots();
else
return myConSurf->NbKnots();
}
//=======================================================================
//function : Bezier
//purpose :
//=======================================================================
//=================================================================================================
Handle(Geom_BezierCurve) BRepAdaptor_Curve::Bezier() const
Handle(Geom_BezierCurve) BRepAdaptor_Curve::Bezier() const
{
Handle(Geom_BezierCurve) BC;
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
BC = myCurve.Bezier();
}
else {
else
{
BC = myConSurf->Bezier();
}
return myTrsf.Form() == gp_Identity
? BC : Handle(Geom_BezierCurve)::DownCast(BC->Transformed(myTrsf));
return myTrsf.Form() == gp_Identity ? BC
: Handle(Geom_BezierCurve)::DownCast(BC->Transformed(myTrsf));
}
//=================================================================================================
//=======================================================================
//function : BSpline
//purpose :
//=======================================================================
Handle(Geom_BSplineCurve) BRepAdaptor_Curve::BSpline() const
Handle(Geom_BSplineCurve) BRepAdaptor_Curve::BSpline() const
{
Handle(Geom_BSplineCurve) BS;
if (myConSurf.IsNull()) {
if (myConSurf.IsNull())
{
BS = myCurve.BSpline();
}
else {
else
{
BS = myConSurf->BSpline();
}
return myTrsf.Form() == gp_Identity
? BS : Handle(Geom_BSplineCurve)::DownCast(BS->Transformed(myTrsf));
? BS
: Handle(Geom_BSplineCurve)::DownCast(BS->Transformed(myTrsf));
}
//=======================================================================
//function : BasisCurve
//purpose :
//=======================================================================
//=================================================================================================
Handle(Geom_OffsetCurve) BRepAdaptor_Curve::OffsetCurve() const
{
if ( !Is3DCurve() || myCurve.GetType() != GeomAbs_OffsetCurve)
if (!Is3DCurve() || myCurve.GetType() != GeomAbs_OffsetCurve)
throw Standard_NoSuchObject("BRepAdaptor_Curve::OffsetCurve");
Handle(Geom_OffsetCurve) anOffC = myCurve.OffsetCurve();
return myTrsf.Form() == gp_Identity
? anOffC : Handle(Geom_OffsetCurve)::DownCast(anOffC->Transformed(myTrsf));
? anOffC
: Handle(Geom_OffsetCurve)::DownCast(anOffC->Transformed(myTrsf));
}

117
src/BRepAdaptor/BRepAdaptor_Curve.hxx
View File

@@ -55,18 +55,17 @@ DEFINE_STANDARD_HANDLE(BRepAdaptor_Curve, Adaptor3d_Curve)
//! surface is used. It is possible to enforce using a
//! curve on surface by creating or initialising with
//! an Edge and a Face.
class BRepAdaptor_Curve : public Adaptor3d_Curve
class BRepAdaptor_Curve : public Adaptor3d_Curve
{
DEFINE_STANDARD_RTTIEXT(BRepAdaptor_Curve, Adaptor3d_Curve)
public:
//! Creates an undefined Curve with no Edge loaded.
Standard_EXPORT BRepAdaptor_Curve();
//! Creates a Curve to access the geometry of edge
//! <E>.
Standard_EXPORT BRepAdaptor_Curve(const TopoDS_Edge& E);
//! Creates a Curve to access the geometry of edge
//! <E>. The geometry will be computed using the
//! parametric curve of <E> on the face <F>. An Error
@@ -82,130 +81,136 @@ public:
//! Sets the Curve <me> to access the geometry of
//! edge <E>.
Standard_EXPORT void Initialize (const TopoDS_Edge& E);
Standard_EXPORT void Initialize(const TopoDS_Edge& E);
//! Sets the Curve <me> to access the geometry of
//! edge <E>. The geometry will be computed using the
//! parametric curve of <E> on the face <F>. An Error
//! is raised if the edge does not have a pcurve on
//! the face.
Standard_EXPORT void Initialize (const TopoDS_Edge& E, const TopoDS_Face& F);
Standard_EXPORT void Initialize(const TopoDS_Edge& E, const TopoDS_Face& F);
//! Returns the coordinate system of the curve.
Standard_EXPORT const gp_Trsf& Trsf() const;
//! Returns True if the edge geometry is computed from
//! a 3D curve.
Standard_EXPORT Standard_Boolean Is3DCurve() const;
//! Returns True if the edge geometry is computed from
//! a pcurve on a surface.
Standard_EXPORT Standard_Boolean IsCurveOnSurface() const;
//! Returns the Curve of the edge.
Standard_EXPORT const GeomAdaptor_Curve& Curve() const;
//! Returns the CurveOnSurface of the edge.
Standard_EXPORT const Adaptor3d_CurveOnSurface& CurveOnSurface() const;
//! Returns the edge.
Standard_EXPORT const TopoDS_Edge& Edge() const;
//! Returns the edge tolerance.
Standard_EXPORT Standard_Real Tolerance() const;
Standard_EXPORT Standard_Real FirstParameter() const Standard_OVERRIDE;
Standard_EXPORT Standard_Real LastParameter() const Standard_OVERRIDE;
Standard_EXPORT GeomAbs_Shape Continuity() const Standard_OVERRIDE;
//! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(me) >= <S>
Standard_EXPORT Standard_Integer NbIntervals (const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer NbIntervals(const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accommodate
//! for the parameters. i.e. T.Length() > NbIntervals()
Standard_EXPORT void Intervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_EXPORT void Intervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Returns a curve equivalent of <me> between
//! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Curve) 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;
Standard_EXPORT Standard_Boolean IsPeriodic() const Standard_OVERRIDE;
Standard_EXPORT Standard_Real Period() const Standard_OVERRIDE;
//! Computes the point of parameter U on the curve
Standard_EXPORT gp_Pnt Value (const Standard_Real U) const Standard_OVERRIDE;
Standard_EXPORT gp_Pnt Value(const Standard_Real U) const Standard_OVERRIDE;
//! Computes the point of parameter U.
Standard_EXPORT void D0 (const Standard_Real U, gp_Pnt& P) const Standard_OVERRIDE;
Standard_EXPORT void D0(const Standard_Real U, gp_Pnt& P) const Standard_OVERRIDE;
//! Computes the point of parameter U on the curve
//! with its first derivative.
//! Raised if the continuity of the current interval
//! is not C1.
Standard_EXPORT void D1 (const Standard_Real U, gp_Pnt& P, gp_Vec& V) const Standard_OVERRIDE;
Standard_EXPORT void D1(const Standard_Real U, gp_Pnt& P, gp_Vec& V) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first and second
//! derivatives V1 and V2.
//! Raised if the continuity of the current interval
//! is not C2.
Standard_EXPORT void D2 (const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2) const Standard_OVERRIDE;
Standard_EXPORT void D2(const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2) const Standard_OVERRIDE;
//! Returns the point P of parameter U, the first, the second
//! and the third derivative.
//! Raised if the continuity of the current interval
//! is not C3.
Standard_EXPORT void D3 (const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3) const Standard_OVERRIDE;
Standard_EXPORT void D3(const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
gp_Vec& V2,
gp_Vec& V3) const Standard_OVERRIDE;
//! The returned vector gives the value of the derivative for the
//! order of derivation N.
//! Raised if the continuity of the current interval
//! is not CN.
//! Raised if N < 1.
Standard_EXPORT gp_Vec DN (const Standard_Real U, const Standard_Integer N) const Standard_OVERRIDE;
Standard_EXPORT gp_Vec DN(const Standard_Real U,
const Standard_Integer N) const Standard_OVERRIDE;
//! returns the parametric resolution
Standard_EXPORT Standard_Real Resolution (const Standard_Real R3d) const Standard_OVERRIDE;
Standard_EXPORT Standard_Real Resolution(const Standard_Real R3d) const Standard_OVERRIDE;
Standard_EXPORT GeomAbs_CurveType GetType() const Standard_OVERRIDE;
Standard_EXPORT gp_Lin Line() const Standard_OVERRIDE;
Standard_EXPORT gp_Circ Circle() const Standard_OVERRIDE;
Standard_EXPORT gp_Elips Ellipse() const Standard_OVERRIDE;
Standard_EXPORT gp_Hypr Hyperbola() const Standard_OVERRIDE;
Standard_EXPORT gp_Parab Parabola() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer Degree() const Standard_OVERRIDE;
Standard_EXPORT Standard_Boolean IsRational() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer NbPoles() const Standard_OVERRIDE;
Standard_EXPORT Standard_Integer NbKnots() const Standard_OVERRIDE;
//! Warning:
//! This will make a copy of the Bezier Curve since it applies to it myTsrf.
//! Be careful when using this method.
Standard_EXPORT Handle(Geom_BezierCurve) Bezier() const Standard_OVERRIDE;
//! Warning:
//! This will make a copy of the BSpline Curve since it applies to it myTsrf.
@@ -215,12 +220,10 @@ public:
Standard_EXPORT Handle(Geom_OffsetCurve) OffsetCurve() const Standard_OVERRIDE;
private:
gp_Trsf myTrsf;
GeomAdaptor_Curve myCurve;
gp_Trsf myTrsf;
GeomAdaptor_Curve myCurve;
Handle(Adaptor3d_CurveOnSurface) myConSurf;
TopoDS_Edge myEdge;
TopoDS_Edge myEdge;
};
#endif // _BRepAdaptor_Curve_HeaderFile

65
src/BRepAdaptor/BRepAdaptor_Curve2d.cxx
View File

@@ -14,7 +14,6 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRep_Tool.hxx>
#include <BRepAdaptor_Curve2d.hxx>
#include <TopoDS_Edge.hxx>
@@ -22,39 +21,27 @@
IMPLEMENT_STANDARD_RTTIEXT(BRepAdaptor_Curve2d, Geom2dAdaptor_Curve)
//=======================================================================
//function : BRepAdaptor_Curve2d
//purpose :
//=======================================================================
BRepAdaptor_Curve2d::BRepAdaptor_Curve2d()
//=================================================================================================
BRepAdaptor_Curve2d::BRepAdaptor_Curve2d() {}
//=================================================================================================
BRepAdaptor_Curve2d::BRepAdaptor_Curve2d(const TopoDS_Edge& E, const TopoDS_Face& F)
{
Initialize(E, F);
}
//=======================================================================
//function : BRepAdaptor_Curve2d
//purpose :
//=======================================================================
BRepAdaptor_Curve2d::BRepAdaptor_Curve2d(const TopoDS_Edge& E,
const TopoDS_Face& F)
{
Initialize(E,F);
}
//=======================================================================
//function : ShallowCopy
//purpose :
//=======================================================================
//=================================================================================================
Handle(Adaptor2d_Curve2d) BRepAdaptor_Curve2d::ShallowCopy() const
{
Handle(BRepAdaptor_Curve2d) aCopy = new BRepAdaptor_Curve2d();
aCopy->myCurve = myCurve;
aCopy->myTypeCurve = myTypeCurve;
aCopy->myFirst = myFirst;
aCopy->myLast = myLast;
aCopy->myCurve = myCurve;
aCopy->myTypeCurve = myTypeCurve;
aCopy->myFirst = myFirst;
aCopy->myLast = myLast;
aCopy->myBSplineCurve = myBSplineCurve;
if (!myNestedEvaluator.IsNull())
{
@@ -64,39 +51,27 @@ Handle(Adaptor2d_Curve2d) BRepAdaptor_Curve2d::ShallowCopy() const
return aCopy;
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Curve2d::Initialize(const TopoDS_Edge& E,
const TopoDS_Face& F)
void BRepAdaptor_Curve2d::Initialize(const TopoDS_Edge& E, const TopoDS_Face& F)
{
myEdge = E;
myFace = F;
Standard_Real pf,pl;
const Handle(Geom2d_Curve) PC = BRep_Tool::CurveOnSurface(E,F,pf,pl);
Geom2dAdaptor_Curve::Load(PC,pf,pl);
Standard_Real pf, pl;
const Handle(Geom2d_Curve) PC = BRep_Tool::CurveOnSurface(E, F, pf, pl);
Geom2dAdaptor_Curve::Load(PC, pf, pl);
}
//=======================================================================
//function : Edge
//purpose :
//=======================================================================
//=================================================================================================
const TopoDS_Edge& BRepAdaptor_Curve2d::Edge() const
{
return myEdge;
}
//=======================================================================
//function : Face
//purpose :
//=======================================================================
//=================================================================================================
const TopoDS_Face& BRepAdaptor_Curve2d::Face() const
{
return myFace;
}

16
src/BRepAdaptor/BRepAdaptor_Curve2d.hxx
View File

@@ -25,7 +25,6 @@
#include <TopoDS_Face.hxx>
#include <Geom2dAdaptor_Curve.hxx>
//! The Curve2d from BRepAdaptor allows to use an Edge
//! on a Face like a 2d curve. (curve in the
//! parametric space).
@@ -36,34 +35,31 @@
//! It is created or initialized with a Face and an
//! Edge. The methods are inherited from Curve from
//! Geom2dAdaptor.
class BRepAdaptor_Curve2d : public Geom2dAdaptor_Curve
class BRepAdaptor_Curve2d : public Geom2dAdaptor_Curve
{
DEFINE_STANDARD_RTTIEXT(BRepAdaptor_Curve2d, Geom2dAdaptor_Curve)
public:
//! Creates an uninitialized curve2d.
Standard_EXPORT BRepAdaptor_Curve2d();
//! Creates with the pcurve of <E> on <F>.
Standard_EXPORT BRepAdaptor_Curve2d(const TopoDS_Edge& E, const TopoDS_Face& F);
//! Shallow copy of adaptor
Standard_EXPORT virtual Handle(Adaptor2d_Curve2d) ShallowCopy() const Standard_OVERRIDE;
//! Initialize with the pcurve of <E> on <F>.
Standard_EXPORT void Initialize (const TopoDS_Edge& E, const TopoDS_Face& F);
Standard_EXPORT void Initialize(const TopoDS_Edge& E, const TopoDS_Face& F);
//! Returns the Edge.
Standard_EXPORT const TopoDS_Edge& Edge() const;
//! Returns the Face.
Standard_EXPORT const TopoDS_Face& Face() const;
private:
TopoDS_Edge myEdge;
TopoDS_Face myFace;
};
DEFINE_STANDARD_HANDLE(BRepAdaptor_Curve2d, Geom2dAdaptor_Curve)

1
src/BRepAdaptor/BRepAdaptor_HArray1OfCurve.hxx
View File

@@ -22,5 +22,4 @@
DEFINE_HARRAY1(BRepAdaptor_HArray1OfCurve, BRepAdaptor_Array1OfCurve)
#endif

359
src/BRepAdaptor/BRepAdaptor_Surface.cxx
View File

@@ -39,236 +39,166 @@
IMPLEMENT_STANDARD_RTTIEXT(BRepAdaptor_Surface, Adaptor3d_Surface)
//=======================================================================
//function : BRepAdaptor_Surface
//purpose :
//=======================================================================
BRepAdaptor_Surface::BRepAdaptor_Surface()
//=================================================================================================
BRepAdaptor_Surface::BRepAdaptor_Surface() {}
//=================================================================================================
BRepAdaptor_Surface::BRepAdaptor_Surface(const TopoDS_Face& F, const Standard_Boolean R)
{
Initialize(F, R);
}
//=======================================================================
//function : BRepAdaptor_Surface
//purpose :
//=======================================================================
BRepAdaptor_Surface::BRepAdaptor_Surface(const TopoDS_Face& F,
const Standard_Boolean R)
{
Initialize(F,R);
}
//=======================================================================
//function : ShallowCopy
//purpose :
//=======================================================================
//=================================================================================================
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::ShallowCopy() const
{
Handle(BRepAdaptor_Surface) aCopy = new BRepAdaptor_Surface();
const Handle(Adaptor3d_Surface) aSurface = mySurf.ShallowCopy();
const GeomAdaptor_Surface& aGeomSurface = *(Handle(GeomAdaptor_Surface)::DownCast(aSurface));
aCopy->mySurf = aGeomSurface;
const Handle(Adaptor3d_Surface) aSurface = mySurf.ShallowCopy();
const GeomAdaptor_Surface& aGeomSurface = *(Handle(GeomAdaptor_Surface)::DownCast(aSurface));
aCopy->mySurf = aGeomSurface;
aCopy->myTrsf = myTrsf;
aCopy->myFace = myFace;
return aCopy;
}
//=======================================================================
//function : Initialize
//purpose :
//=======================================================================
void BRepAdaptor_Surface::Initialize(const TopoDS_Face& F,
const Standard_Boolean Restriction)
//=================================================================================================
void BRepAdaptor_Surface::Initialize(const TopoDS_Face& F, const Standard_Boolean Restriction)
{
myFace = F;
TopLoc_Location L;
TopLoc_Location L;
const Handle(Geom_Surface)& aSurface = BRep_Tool::Surface(F, L);
if (aSurface.IsNull())
return;
if (Restriction) {
Standard_Real umin,umax,vmin,vmax;
BRepTools::UVBounds(F,umin,umax,vmin,vmax);
mySurf.Load(aSurface,umin,umax,vmin,vmax);
if (Restriction)
{
Standard_Real umin, umax, vmin, vmax;
BRepTools::UVBounds(F, umin, umax, vmin, vmax);
mySurf.Load(aSurface, umin, umax, vmin, vmax);
}
else
else
mySurf.Load(aSurface);
myTrsf = L.Transformation();
}
//=================================================================================================
//=======================================================================
//function : Surface
//purpose :
//=======================================================================
const GeomAdaptor_Surface& BRepAdaptor_Surface::Surface() const
const GeomAdaptor_Surface& BRepAdaptor_Surface::Surface() const
{
return mySurf;
}
//=======================================================================
//function : ChangeSurface
//purpose :
//=======================================================================
//=================================================================================================
GeomAdaptor_Surface& BRepAdaptor_Surface::ChangeSurface()
{
return mySurf;
}
//=================================================================================================
//=======================================================================
//function : Trsf
//purpose :
//=======================================================================
const gp_Trsf& BRepAdaptor_Surface::Trsf() const
const gp_Trsf& BRepAdaptor_Surface::Trsf() const
{
return myTrsf;
}
//=======================================================================
//function : Face
//purpose :
//=======================================================================
//=================================================================================================
const TopoDS_Face& BRepAdaptor_Surface::Face() const
{
return myFace;
}
//=======================================================================
//function : Tolerance
//purpose :
//=======================================================================
//=================================================================================================
Standard_Real BRepAdaptor_Surface::Tolerance() const
{
return BRep_Tool::Tolerance(myFace);
}
//=================================================================================================
//=======================================================================
//function : UIntervals
//purpose :
//=======================================================================
void BRepAdaptor_Surface::UIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const
void BRepAdaptor_Surface::UIntervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const
{
mySurf.UIntervals(T,S);
mySurf.UIntervals(T, S);
}
//=================================================================================================
//=======================================================================
//function : VIntervals
//purpose :
//=======================================================================
void BRepAdaptor_Surface::VIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const
void BRepAdaptor_Surface::VIntervals(TColStd_Array1OfReal& T, const GeomAbs_Shape S) const
{
mySurf.VIntervals(T,S);
mySurf.VIntervals(T, S);
}
//=================================================================================================
//=======================================================================
//function : UTrim
//purpose :
//=======================================================================
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::UTrim
(const Standard_Real First,
const Standard_Real Last ,
const Standard_Real Tol ) const
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::UTrim(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const
{
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
return HS->UTrim(First,Last,Tol);
HS->Load(Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
return HS->UTrim(First, Last, Tol);
}
//=================================================================================================
//=======================================================================
//function : VTrim
//purpose :
//=======================================================================
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::VTrim
(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::VTrim(const Standard_Real First,
const Standard_Real Last,
const Standard_Real Tol) const
{
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
return HS->VTrim(First,Last,Tol);
HS->Load(Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
return HS->VTrim(First, Last, Tol);
}
//=================================================================================================
//=======================================================================
//function : Value
//purpose :
//=======================================================================
gp_Pnt BRepAdaptor_Surface::Value(const Standard_Real U,
const Standard_Real V) const
gp_Pnt BRepAdaptor_Surface::Value(const Standard_Real U, const Standard_Real V) const
{
return mySurf.Value(U,V).Transformed(myTrsf);
return mySurf.Value(U, V).Transformed(myTrsf);
}
//=======================================================================
//function : D0
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Surface::D0(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P) const
void BRepAdaptor_Surface::D0(const Standard_Real U, const Standard_Real V, gp_Pnt& P) const
{
mySurf.D0(U,V,P);
mySurf.D0(U, V, P);
P.Transform(myTrsf);
}
//=======================================================================
//function : D1
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Surface::D1(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V)const
void BRepAdaptor_Surface::D1(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V) const
{
mySurf.D1(U,V,P,D1U,D1V);
mySurf.D1(U, V, P, D1U, D1V);
P.Transform(myTrsf);
D1U.Transform(myTrsf);
D1V.Transform(myTrsf);
}
//=================================================================================================
//=======================================================================
//function : D2
//purpose :
//=======================================================================
void BRepAdaptor_Surface::D2(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P, gp_Vec& D1U,
gp_Vec& D1V,
gp_Vec& D2U,
gp_Vec& D2V,
gp_Vec& D2UV)const
void BRepAdaptor_Surface::D2(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V,
gp_Vec& D2U,
gp_Vec& D2V,
gp_Vec& D2UV) const
{
mySurf.D2(U,V,P,D1U,D1V,D2U,D2V,D2UV);
mySurf.D2(U, V, P, D1U, D1V, D2U, D2V, D2UV);
P.Transform(myTrsf);
D1U.Transform(myTrsf);
D1V.Transform(myTrsf);
@@ -277,21 +207,22 @@ void BRepAdaptor_Surface::D2(const Standard_Real U,
D2UV.Transform(myTrsf);
}
//=======================================================================
//function : D3
//purpose :
//=======================================================================
//=================================================================================================
void BRepAdaptor_Surface::D3(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U, gp_Vec& D1V,
gp_Vec& D2U, gp_Vec& D2V,
gp_Vec& D2UV,
gp_Vec& D3U, gp_Vec& D3V,
gp_Vec& D3UUV, gp_Vec& D3UVV)const
void BRepAdaptor_Surface::D3(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V,
gp_Vec& D2U,
gp_Vec& D2V,
gp_Vec& D2UV,
gp_Vec& D3U,
gp_Vec& D3V,
gp_Vec& D3UUV,
gp_Vec& D3UVV) const
{
mySurf.D3(U,V,P,D1U,D1V,D2U,D2V,D2UV,D3U,D3V,D3UUV,D3UVV);
mySurf.D3(U, V, P, D1U, D1V, D2U, D2V, D2UV, D3U, D3V, D3UUV, D3UVV);
P.Transform(myTrsf);
D1U.Transform(myTrsf);
D1V.Transform(myTrsf);
@@ -304,153 +235,101 @@ void BRepAdaptor_Surface::D3(const Standard_Real U,
D3UVV.Transform(myTrsf);
}
//=================================================================================================
//=======================================================================
//function : DN
//purpose :
//=======================================================================
gp_Vec BRepAdaptor_Surface::DN(const Standard_Real U,
const Standard_Real V,
const Standard_Integer Nu,
const Standard_Integer Nv) const
gp_Vec BRepAdaptor_Surface::DN(const Standard_Real U,
const Standard_Real V,
const Standard_Integer Nu,
const Standard_Integer Nv) const
{
return mySurf.DN(U,V,Nu,Nv).Transformed(myTrsf);
return mySurf.DN(U, V, Nu, Nv).Transformed(myTrsf);
}
//=======================================================================
//function : Plane
//purpose :
//=======================================================================
//=================================================================================================
gp_Pln BRepAdaptor_Surface::Plane()const
gp_Pln BRepAdaptor_Surface::Plane() const
{
return mySurf.Plane().Transformed(myTrsf);
}
//=================================================================================================
//=======================================================================
//function : Cylinder
//purpose :
//=======================================================================
gp_Cylinder BRepAdaptor_Surface::Cylinder()const
gp_Cylinder BRepAdaptor_Surface::Cylinder() const
{
return mySurf.Cylinder().Transformed(myTrsf);
}
//=================================================================================================
//=======================================================================
//function : Sphere
//purpose :
//=======================================================================
gp_Sphere BRepAdaptor_Surface::Sphere()const
gp_Sphere BRepAdaptor_Surface::Sphere() const
{
return mySurf.Sphere().Transformed(myTrsf);
}
//=================================================================================================
//=======================================================================
//function : Cone
//purpose :
//=======================================================================
gp_Cone BRepAdaptor_Surface::Cone()const
gp_Cone BRepAdaptor_Surface::Cone() const
{
return mySurf.Cone().Transformed(myTrsf);
}
//=======================================================================
//function : Torus
//purpose :
//=======================================================================
//=================================================================================================
gp_Torus BRepAdaptor_Surface::Torus()const
gp_Torus BRepAdaptor_Surface::Torus() const
{
return mySurf.Torus().Transformed(myTrsf);
}
//=======================================================================
//function : Bezier
//purpose :
//=======================================================================
//=================================================================================================
Handle(Geom_BezierSurface) BRepAdaptor_Surface::Bezier() const
Handle(Geom_BezierSurface) BRepAdaptor_Surface::Bezier() const
{
return Handle(Geom_BezierSurface)::DownCast
(mySurf.Bezier()->Transformed(myTrsf));
return Handle(Geom_BezierSurface)::DownCast(mySurf.Bezier()->Transformed(myTrsf));
}
//=================================================================================================
//=======================================================================
//function : BSpline
//purpose :
//=======================================================================
Handle(Geom_BSplineSurface) BRepAdaptor_Surface::BSpline() const
Handle(Geom_BSplineSurface) BRepAdaptor_Surface::BSpline() const
{
return Handle(Geom_BSplineSurface)::DownCast
(mySurf.BSpline()->Transformed(myTrsf));
return Handle(Geom_BSplineSurface)::DownCast(mySurf.BSpline()->Transformed(myTrsf));
}
//=================================================================================================
//=======================================================================
//function : AxeOfRevolution
//purpose :
//=======================================================================
gp_Ax1 BRepAdaptor_Surface::AxeOfRevolution() const
gp_Ax1 BRepAdaptor_Surface::AxeOfRevolution() const
{
return mySurf.AxeOfRevolution().Transformed(myTrsf);
}
//=================================================================================================
//=======================================================================
//function : Direction
//purpose :
//=======================================================================
gp_Dir BRepAdaptor_Surface::Direction() const
gp_Dir BRepAdaptor_Surface::Direction() const
{
return mySurf.Direction().Transformed(myTrsf);
}
//=================================================================================================
//=======================================================================
//function : BasisCurve
//purpose :
//=======================================================================
Handle(Adaptor3d_Curve) BRepAdaptor_Surface::BasisCurve() const
Handle(Adaptor3d_Curve) BRepAdaptor_Surface::BasisCurve() const
{
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
HS->Load(Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
return HS->BasisCurve();
}
//=================================================================================================
//=======================================================================
//function : BasisSurface
//purpose :
//=======================================================================
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::BasisSurface() const
{
Handle(Adaptor3d_Surface) BRepAdaptor_Surface::BasisSurface() const
{
Handle(GeomAdaptor_Surface) HS = new GeomAdaptor_Surface();
HS->Load (Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
HS->Load(Handle(Geom_Surface)::DownCast(mySurf.Surface()->Transformed(myTrsf)));
return HS->BasisSurface();
}
//=================================================================================================
//=======================================================================
//function : OffsetValue
//purpose :
//=======================================================================
Standard_Real BRepAdaptor_Surface::OffsetValue() const
Standard_Real BRepAdaptor_Surface::OffsetValue() const
{
return mySurf.OffsetValue();
}

153
src/BRepAdaptor/BRepAdaptor_Surface.hxx
View File

@@ -50,83 +50,102 @@ DEFINE_STANDARD_HANDLE(BRepAdaptor_Surface, Adaptor3d_Surface)
//! The u,v parameter range is the minmax value for
//! the restriction, unless the flag restriction is
//! set to false.
class BRepAdaptor_Surface : public Adaptor3d_Surface
class BRepAdaptor_Surface : public Adaptor3d_Surface
{
DEFINE_STANDARD_RTTIEXT(BRepAdaptor_Surface, Adaptor3d_Surface)
public:
//! Creates an undefined surface with no face loaded.
Standard_EXPORT BRepAdaptor_Surface();
//! Creates a surface to access the geometry of <F>.
//! If <Restriction> is true the parameter range is
//! the parameter range in the UV space of the
//! restriction.
Standard_EXPORT BRepAdaptor_Surface(const TopoDS_Face& F, const Standard_Boolean R = Standard_True);
Standard_EXPORT BRepAdaptor_Surface(const TopoDS_Face& F,
const Standard_Boolean R = Standard_True);
//! Shallow copy of adaptor
Standard_EXPORT virtual Handle(Adaptor3d_Surface) ShallowCopy() const Standard_OVERRIDE;
//! Sets the surface to the geometry of <F>.
Standard_EXPORT void Initialize (const TopoDS_Face& F, const Standard_Boolean Restriction = Standard_True);
Standard_EXPORT void Initialize(const TopoDS_Face& F,
const Standard_Boolean Restriction = Standard_True);
//! Returns the surface.
Standard_EXPORT const GeomAdaptor_Surface& Surface() const;
//! Returns the surface.
Standard_EXPORT GeomAdaptor_Surface& ChangeSurface();
//! Returns the surface coordinate system.
Standard_EXPORT const gp_Trsf& Trsf() const;
//! Returns the face.
Standard_EXPORT const TopoDS_Face& Face() const;
//! Returns the face tolerance.
Standard_EXPORT Standard_Real Tolerance() const;
virtual Standard_Real FirstUParameter() const Standard_OVERRIDE { return mySurf.FirstUParameter(); }
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 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.
virtual Standard_Integer NbUIntervals (const GeomAbs_Shape theSh) const Standard_OVERRIDE { return mySurf.NbUIntervals (theSh); }
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.
virtual Standard_Integer NbVIntervals (const GeomAbs_Shape theSh) const Standard_OVERRIDE { return mySurf.NbVIntervals (theSh); }
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.
Standard_EXPORT void UIntervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_EXPORT void UIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Returns the intervals with the requested continuity
//! in the V direction.
Standard_EXPORT void VIntervals (TColStd_Array1OfReal& T, const GeomAbs_Shape S) const Standard_OVERRIDE;
Standard_EXPORT void VIntervals(TColStd_Array1OfReal& T,
const GeomAbs_Shape S) const Standard_OVERRIDE;
//! Returns a surface trimmed in the U direction
//! equivalent of <me> between
//! parameters <First> and <Last>. <Tol> is used to
//! test for 3d points confusion.
//! If <First> >= <Last>
Standard_EXPORT Handle(Adaptor3d_Surface) 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_Surface) VTrim (const Standard_Real First, const Standard_Real Last, const Standard_Real Tol) 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(); }
@@ -142,60 +161,94 @@ public:
//! Computes the point of parameters U,V on the surface.
//! Tip: use GeomLib::NormEstim() to calculate surface normal at specified (U, V) point.
Standard_EXPORT gp_Pnt Value (const Standard_Real U, const Standard_Real V) const Standard_OVERRIDE;
Standard_EXPORT gp_Pnt Value(const Standard_Real U,
const Standard_Real V) const Standard_OVERRIDE;
//! Computes the point of parameters U,V on the surface.
Standard_EXPORT void D0 (const Standard_Real U, const Standard_Real V, gp_Pnt& P) const Standard_OVERRIDE;
Standard_EXPORT void D0(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P) const Standard_OVERRIDE;
//! Computes the point and the first derivatives on the surface.
//! Raised if the continuity of the current intervals is not C1.
//!
//! Tip: use GeomLib::NormEstim() to calculate surface normal at specified (U, V) point.
Standard_EXPORT void D1 (const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V) const Standard_OVERRIDE;
Standard_EXPORT void D1(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V) const Standard_OVERRIDE;
//! Computes the point, the first and second
//! derivatives on the surface.
//! Raised if the continuity of the current
//! intervals is not C2.
Standard_EXPORT void D2 (const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV) const Standard_OVERRIDE;
Standard_EXPORT void D2(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V,
gp_Vec& D2U,
gp_Vec& D2V,
gp_Vec& D2UV) const Standard_OVERRIDE;
//! Computes the point, the first, second and third
//! derivatives on the surface.
//! Raised if the continuity of the current
//! intervals is not C3.
Standard_EXPORT void D3 (const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& D1U, gp_Vec& D1V, gp_Vec& D2U, gp_Vec& D2V, gp_Vec& D2UV, gp_Vec& D3U, gp_Vec& D3V, gp_Vec& D3UUV, gp_Vec& D3UVV) const Standard_OVERRIDE;
Standard_EXPORT void D3(const Standard_Real U,
const Standard_Real V,
gp_Pnt& P,
gp_Vec& D1U,
gp_Vec& D1V,
gp_Vec& D2U,
gp_Vec& D2V,
gp_Vec& D2UV,
gp_Vec& D3U,
gp_Vec& D3V,
gp_Vec& D3UUV,
gp_Vec& D3UVV) const Standard_OVERRIDE;
//! Computes the derivative of order Nu in the direction
//! U and Nv in the direction V at the point P(U, V).
//! Raised if the current U interval is not not CNu
//! and the current V interval is not CNv.
//! Raised if Nu + Nv < 1 or Nu < 0 or Nv < 0.
Standard_EXPORT gp_Vec DN (const Standard_Real U, const Standard_Real V, const Standard_Integer Nu, const Standard_Integer Nv) const Standard_OVERRIDE;
Standard_EXPORT gp_Vec DN(const Standard_Real U,
const Standard_Real V,
const Standard_Integer Nu,
const Standard_Integer Nv) const Standard_OVERRIDE;
//! Returns the parametric U resolution corresponding
//! to the real space resolution <R3d>.
virtual Standard_Real UResolution (const Standard_Real theR3d) const Standard_OVERRIDE { return mySurf.UResolution (theR3d); }
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>.
virtual Standard_Real VResolution (const Standard_Real theR3d) const Standard_OVERRIDE { return mySurf.VResolution (theR3d); }
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
virtual GeomAbs_SurfaceType GetType() const Standard_OVERRIDE { return mySurf.GetType(); }
Standard_EXPORT gp_Pln Plane() const Standard_OVERRIDE;
Standard_EXPORT gp_Cylinder Cylinder() const Standard_OVERRIDE;
Standard_EXPORT gp_Cone Cone() const Standard_OVERRIDE;
Standard_EXPORT gp_Sphere Sphere() const Standard_OVERRIDE;
Standard_EXPORT gp_Torus Torus() const Standard_OVERRIDE;
virtual Standard_Integer UDegree() const Standard_OVERRIDE { return mySurf.UDegree(); }
virtual Standard_Integer NbUPoles() const Standard_OVERRIDE { return mySurf.NbUPoles(); }
@@ -219,27 +272,25 @@ public:
//! to it the myTsrf transformation
//! Be Careful when using this method
Standard_EXPORT Handle(Geom_BSplineSurface) BSpline() const Standard_OVERRIDE;
Standard_EXPORT gp_Ax1 AxeOfRevolution() const Standard_OVERRIDE;
Standard_EXPORT gp_Dir Direction() const Standard_OVERRIDE;
//! only for SurfaceOfExtrusion and SurfaceOfRevolution
//! Warning: this will make a copy of the underlying curve
//! since it applies to it the transformation
//! myTrsf. Be careful when using this method.
Standard_EXPORT Handle(Adaptor3d_Curve) BasisCurve() const Standard_OVERRIDE;
Standard_EXPORT Handle(Adaptor3d_Surface) BasisSurface() const Standard_OVERRIDE;
Standard_EXPORT Standard_Real OffsetValue() const Standard_OVERRIDE;
private:
GeomAdaptor_Surface mySurf;
gp_Trsf myTrsf;
TopoDS_Face myFace;
gp_Trsf myTrsf;
TopoDS_Face myFace;
};
#endif // _BRepAdaptor_Surface_HeaderFile