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

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

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

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

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

6
src/BlendFunc/BlendFunc.cxx
View File

@@ -18,7 +18,7 @@
// 30/12/1996 PMN Ajout de GetMinimalWeight
// 23/09/1997 PMN Supprimme GetCircle et GetTol (passe dans GeomFill)
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc.hxx>
#include <CSLib.hxx>
#include <CSLib_NormalStatus.hxx>
@@ -166,7 +166,7 @@ GeomAbs_Shape BlendFunc::NextShape (const GeomAbs_Shape S)
//purpose :
//=======================================================================
Standard_Boolean BlendFunc::ComputeNormal (const Handle(Adaptor3d_HSurface)& Surf,
Standard_Boolean BlendFunc::ComputeNormal (const Handle(Adaptor3d_Surface)& Surf,
const gp_Pnt2d& p2d, gp_Vec& Normal)
{
const Standard_Integer MaxOrder=3;
@@ -210,7 +210,7 @@ Standard_Boolean BlendFunc::ComputeNormal (const Handle(Adaptor3d_HSurface)& Sur
//purpose :
//=======================================================================
Standard_Boolean BlendFunc::ComputeDNormal (const Handle(Adaptor3d_HSurface)& Surf,
Standard_Boolean BlendFunc::ComputeDNormal (const Handle(Adaptor3d_Surface)& Surf,
const gp_Pnt2d& p2d, gp_Vec& Normal,
gp_Vec& DNu, gp_Vec& DNv)
{

14
src/BlendFunc/BlendFunc.hxx
View File

@@ -17,19 +17,13 @@
#ifndef _BlendFunc_HeaderFile
#define _BlendFunc_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_SectionShape.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Convert_ParameterisationType.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Boolean.hxx>
class Adaptor3d_HSurface;
class gp_Pnt2d;
class gp_Vec;
class BlendFunc_ConstRad;
@@ -69,9 +63,9 @@ public:
//! Used to obtain the next level of continuity.
Standard_EXPORT static GeomAbs_Shape NextShape (const GeomAbs_Shape S);
Standard_EXPORT static Standard_Boolean ComputeNormal (const Handle(Adaptor3d_HSurface)& Surf, const gp_Pnt2d& p2d, gp_Vec& Normal);
Standard_EXPORT static Standard_Boolean ComputeNormal (const Handle(Adaptor3d_Surface)& Surf, const gp_Pnt2d& p2d, gp_Vec& Normal);
Standard_EXPORT static Standard_Boolean ComputeDNormal (const Handle(Adaptor3d_HSurface)& Surf, const gp_Pnt2d& p2d, gp_Vec& Normal, gp_Vec& DNu, gp_Vec& DNv);
Standard_EXPORT static Standard_Boolean ComputeDNormal (const Handle(Adaptor3d_Surface)& Surf, const gp_Pnt2d& p2d, gp_Vec& Normal, gp_Vec& DNu, gp_Vec& DNv);

10
src/BlendFunc/BlendFunc_CSCircular.cxx
View File

@@ -18,8 +18,8 @@
// + Utilisation de GeomFill::GetCircle dans Section.
// Modified 23/06/1997 PMN : Pb de division par 0.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_CSCircular.hxx>
@@ -45,9 +45,9 @@
//purpose :
//=======================================================================
BlendFunc_CSCircular::BlendFunc_CSCircular(const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_HCurve)& C,
const Handle(Adaptor3d_HCurve)& CGuide,
BlendFunc_CSCircular::BlendFunc_CSCircular(const Handle(Adaptor3d_Surface)& S,
const Handle(Adaptor3d_Curve)& C,
const Handle(Adaptor3d_Curve)& CGuide,
const Handle(Law_Function)& L) :
surf(S),curv(C),guide(CGuide),law(L),istangent(Standard_True),
//prmc, dprmc, istangent, ray, choix, normtg,

25
src/BlendFunc/BlendFunc_CSCircular.hxx
View File

@@ -17,17 +17,11 @@
#ifndef _BlendFunc_CSCircular_HeaderFile
#define _BlendFunc_CSCircular_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Vec.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_Integer.hxx>
#include <BlendFunc_SectionShape.hxx>
#include <Convert_ParameterisationType.hxx>
#include <Blend_CSFunction.hxx>
@@ -39,19 +33,12 @@
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_Shape.hxx>
#include <TColStd_Array1OfInteger.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Law_Function;
class math_Matrix;
class gp_Pnt;
class gp_Pnt2d;
class gp_Vec;
class gp_Vec2d;
class gp_Circ;
class Blend_Point;
class BlendFunc_CSCircular : public Blend_CSFunction
{
public:
@@ -68,7 +55,7 @@ public:
//! below :
//! t is the current parameter on the guide line.
//! Pguide = C(L(t)); Nguide = CGuide'(t)/||CGuide'(t)||
Standard_EXPORT BlendFunc_CSCircular(const Handle(Adaptor3d_HSurface)& S, const Handle(Adaptor3d_HCurve)& C, const Handle(Adaptor3d_HCurve)& CGuide, const Handle(Law_Function)& L);
Standard_EXPORT BlendFunc_CSCircular(const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Curve)& CGuide, const Handle(Law_Function)& L);
Standard_EXPORT virtual Standard_Integer NbVariables() const Standard_OVERRIDE;
@@ -198,9 +185,9 @@ private:
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_HCurve) guide;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor3d_Curve) guide;
Handle(Law_Function) law;
gp_Pnt pts;
gp_Pnt ptc;

10
src/BlendFunc/BlendFunc_CSConstRad.cxx
View File

@@ -17,8 +17,8 @@
// Modified 10/09/1996 PMN Ajout de (Nb)Intervalles, IsRationnal
// + Utilisation de GeomFill::GetCircle dans Section.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_CSConstRad.hxx>
@@ -40,9 +40,9 @@
//function : BlendFunc_CSConstRad
//purpose :
//=======================================================================
BlendFunc_CSConstRad::BlendFunc_CSConstRad(const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_HCurve)& C,
const Handle(Adaptor3d_HCurve)& CG) :
BlendFunc_CSConstRad::BlendFunc_CSConstRad(const Handle(Adaptor3d_Surface)& S,
const Handle(Adaptor3d_Curve)& C,
const Handle(Adaptor3d_Curve)& CG) :
surf(S),curv(C),guide(CG), prmc(0.0),
istangent(Standard_True), ray(0.0),

25
src/BlendFunc/BlendFunc_CSConstRad.hxx
View File

@@ -17,17 +17,11 @@
#ifndef _BlendFunc_CSConstRad_HeaderFile
#define _BlendFunc_CSConstRad_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Vec.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_Integer.hxx>
#include <BlendFunc_SectionShape.hxx>
#include <Convert_ParameterisationType.hxx>
#include <Blend_CSFunction.hxx>
@@ -39,18 +33,11 @@
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_Shape.hxx>
#include <TColStd_Array1OfInteger.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class gp_Pnt2d;
class gp_Vec;
class gp_Vec2d;
class gp_Circ;
class Blend_Point;
class BlendFunc_CSConstRad : public Blend_CSFunction
{
public:
@@ -58,7 +45,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_CSConstRad(const Handle(Adaptor3d_HSurface)& S, const Handle(Adaptor3d_HCurve)& C, const Handle(Adaptor3d_HCurve)& CGuide);
Standard_EXPORT BlendFunc_CSConstRad(const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Curve)& CGuide);
//! returns the number of equations of the function (3).
Standard_EXPORT Standard_Integer NbEquations() const Standard_OVERRIDE;
@@ -185,9 +172,9 @@ private:
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_HCurve) guide;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor3d_Curve) guide;
gp_Pnt pts;
gp_Pnt ptc;
gp_Pnt2d pt2d;

10
src/BlendFunc/BlendFunc_ChAsym.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_ChAsym.hxx>
@@ -35,9 +35,9 @@
//function : BlendFunc_ChAsym
//purpose :
//=======================================================================
BlendFunc_ChAsym::BlendFunc_ChAsym(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C) :
BlendFunc_ChAsym::BlendFunc_ChAsym(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C) :
surf1(S1),surf2(S2),
curv(C), tcurv(C),
param(0),

26
src/BlendFunc/BlendFunc_ChAsym.hxx
View File

@@ -17,18 +17,12 @@
#ifndef _BlendFunc_ChAsym_HeaderFile
#define _BlendFunc_ChAsym_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Vec.hxx>
#include <gp_Pnt.hxx>
#include <math_Vector.hxx>
#include <math_Matrix.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_Integer.hxx>
#include <Blend_Function.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_Shape.hxx>
@@ -37,17 +31,11 @@
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class gp_Vec;
class gp_Vec2d;
class gp_Lin;
class Blend_Point;
class BlendFunc_ChAsym : public Blend_Function
{
public:
@@ -55,7 +43,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_ChAsym(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_ChAsym(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C);
//! returns the number of equations of the function.
Standard_EXPORT Standard_Integer NbEquations() const Standard_OVERRIDE;
@@ -185,10 +173,10 @@ private:
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_HCurve) tcurv;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor3d_Curve) tcurv;
Standard_Real param;
Standard_Real dist1;
Standard_Real angle;

14
src/BlendFunc/BlendFunc_ChAsymInv.cxx
View File

@@ -15,9 +15,9 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_ChAsymInv.hxx>
#include <math_Matrix.hxx>
@@ -27,9 +27,9 @@
//function : BlendFunc_ChAsymInv
//purpose :
//=======================================================================
BlendFunc_ChAsymInv::BlendFunc_ChAsymInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C) :
BlendFunc_ChAsymInv::BlendFunc_ChAsymInv(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C) :
surf1(S1),surf2(S2),
dist1(RealLast()),
angle(RealLast()),
@@ -73,7 +73,7 @@ Standard_Integer BlendFunc_ChAsymInv::NbEquations () const
//=======================================================================
void BlendFunc_ChAsymInv::Set(const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& C)
const Handle(Adaptor2d_Curve2d)& C)
{
first = OnFirst;
csurf = C;

26
src/BlendFunc/BlendFunc_ChAsymInv.hxx
View File

@@ -17,22 +17,10 @@
#ifndef _BlendFunc_ChAsymInv_HeaderFile
#define _BlendFunc_ChAsymInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <math_Vector.hxx>
#include <math_Matrix.hxx>
#include <Blend_FuncInv.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
class math_Matrix;
class BlendFunc_ChAsymInv : public Blend_FuncInv
{
@@ -41,9 +29,9 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_ChAsymInv(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_ChAsymInv(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT void Set (const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& COnSurf) Standard_OVERRIDE;
Standard_EXPORT void Set (const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& COnSurf) Standard_OVERRIDE;
Standard_EXPORT void GetTolerance (math_Vector& Tolerance, const Standard_Real Tol) const Standard_OVERRIDE;
@@ -93,13 +81,13 @@ private:
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Standard_Real dist1;
Standard_Real angle;
Standard_Real tgang;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor2d_HCurve2d) csurf;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor2d_Curve2d) csurf;
Standard_Integer choix;
Standard_Boolean first;
math_Vector FX;

12
src/BlendFunc/BlendFunc_ChamfInv.cxx
View File

@@ -15,9 +15,9 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_ChamfInv.hxx>
#include <math_Matrix.hxx>
@@ -28,9 +28,9 @@
//purpose :
//=======================================================================
BlendFunc_ChamfInv::BlendFunc_ChamfInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
BlendFunc_ChamfInv::BlendFunc_ChamfInv(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C)
: BlendFunc_GenChamfInv(S1,S2,C),
corde1(surf1,curv),corde2(surf2,curv)
{

16
src/BlendFunc/BlendFunc_ChamfInv.hxx
View File

@@ -17,23 +17,13 @@
#ifndef _BlendFunc_ChamfInv_HeaderFile
#define _BlendFunc_ChamfInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_Corde.hxx>
#include <BlendFunc_GenChamfInv.hxx>
#include <math_Vector.hxx>
#include <Standard_Real.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
class math_Matrix;
//! Class for a function used to compute a chamfer with two constant distances
//! on a surface's boundary
class BlendFunc_ChamfInv : public BlendFunc_GenChamfInv
@@ -43,7 +33,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_ChamfInv(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_ChamfInv(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT Standard_Boolean IsSolution (const math_Vector& Sol, const Standard_Real Tol) Standard_OVERRIDE;

10
src/BlendFunc/BlendFunc_Chamfer.cxx
View File

@@ -17,8 +17,8 @@
// Modified : 20/08/96 PMN Ajout des methodes (Nb)Intervals et IsRationnal
// Modified : 30/12/96 PMN Ajout GetMinimalWeight, GetSectionSize;
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_Chamfer.hxx>
@@ -36,9 +36,9 @@
//purpose :
//=======================================================================
BlendFunc_Chamfer::BlendFunc_Chamfer(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& CG)
BlendFunc_Chamfer::BlendFunc_Chamfer(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& CG)
: BlendFunc_GenChamfer(S1,S2,CG),
corde1(S1,CG),corde2(S2,CG)
{

15
src/BlendFunc/BlendFunc_Chamfer.hxx
View File

@@ -17,15 +17,9 @@
#ifndef _BlendFunc_Chamfer_HeaderFile
#define _BlendFunc_Chamfer_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_Corde.hxx>
#include <BlendFunc_GenChamfer.hxx>
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_Shape.hxx>
@@ -34,8 +28,7 @@
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class gp_Vec;
@@ -43,8 +36,6 @@ class gp_Vec2d;
class gp_Lin;
class Blend_Point;
//! Class for a function used to compute a "ordinary" chamfer:
//! when distances from spine to surfaces are constant
class BlendFunc_Chamfer : public BlendFunc_GenChamfer
@@ -54,7 +45,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_Chamfer(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& CG);
Standard_EXPORT BlendFunc_Chamfer(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& CG);
//! computes the values <F> of the Functions for the
//! variable <X>.

10
src/BlendFunc/BlendFunc_ConstRad.cxx
View File

@@ -18,8 +18,8 @@
// Optimisation, use of GetCircle
// Modified 20/02/1998 PMN Singular surfaces management
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_ConstRad.hxx>
@@ -47,9 +47,9 @@
//purpose :
//=======================================================================
BlendFunc_ConstRad::BlendFunc_ConstRad(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
BlendFunc_ConstRad::BlendFunc_ConstRad(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C)
:
surf1(S1),surf2(S2),
curv(C), tcurv(C),

26
src/BlendFunc/BlendFunc_ConstRad.hxx
View File

@@ -17,16 +17,10 @@
#ifndef _BlendFunc_ConstRad_HeaderFile
#define _BlendFunc_ConstRad_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Vec.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <math_Vector.hxx>
#include <math_Matrix.hxx>
#include <BlendFunc_Tensor.hxx>
@@ -40,18 +34,12 @@
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class gp_Vec;
class gp_Vec2d;
class gp_Circ;
class Blend_Point;
class gp_Ax1;
class BlendFunc_ConstRad : public Blend_Function
{
public:
@@ -59,7 +47,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_ConstRad(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_ConstRad(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C);
//! returns the number of equations of the function.
Standard_EXPORT Standard_Integer NbEquations() const Standard_OVERRIDE;
@@ -191,10 +179,10 @@ private:
Standard_EXPORT Standard_Boolean ComputeValues (const math_Vector& X, const Standard_Integer Order, const Standard_Boolean ByParam = Standard_False, const Standard_Real Param = 0);
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_HCurve) tcurv;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor3d_Curve) tcurv;
gp_Pnt pts1;
gp_Pnt pts2;
Standard_Boolean istangent;

14
src/BlendFunc/BlendFunc_ConstRadInv.cxx
View File

@@ -15,9 +15,9 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_ConstRadInv.hxx>
#include <math_Matrix.hxx>
@@ -26,9 +26,9 @@
#define Eps 1.e-15
BlendFunc_ConstRadInv::BlendFunc_ConstRadInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
BlendFunc_ConstRadInv::BlendFunc_ConstRadInv(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C)
: surf1(S1),
surf2(S2),
curv(C),
@@ -79,7 +79,7 @@ void BlendFunc_ConstRadInv::Set(const Standard_Real R,
}
void BlendFunc_ConstRadInv::Set(const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& C)
const Handle(Adaptor2d_Curve2d)& C)
{
first = OnFirst;
csurf = C;

26
src/BlendFunc/BlendFunc_ConstRadInv.hxx
View File

@@ -17,22 +17,12 @@
#ifndef _BlendFunc_ConstRadInv_HeaderFile
#define _BlendFunc_ConstRadInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_FuncInv.hxx>
#include <math_Vector.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
class math_Matrix;
class BlendFunc_ConstRadInv : public Blend_FuncInv
{
public:
@@ -40,9 +30,9 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_ConstRadInv(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_ConstRadInv(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT void Set (const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& COnSurf) Standard_OVERRIDE;
Standard_EXPORT void Set (const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& COnSurf) Standard_OVERRIDE;
Standard_EXPORT void GetTolerance (math_Vector& Tolerance, const Standard_Real Tol) const Standard_OVERRIDE;
@@ -86,10 +76,10 @@ private:
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor2d_HCurve2d) csurf;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor2d_Curve2d) csurf;
Standard_Real ray1;
Standard_Real ray2;
Standard_Integer choix;

10
src/BlendFunc/BlendFunc_ConstThroat.cxx
View File

@@ -12,8 +12,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_ConstThroat.hxx>
@@ -35,9 +35,9 @@
//purpose :
//=======================================================================
BlendFunc_ConstThroat::BlendFunc_ConstThroat(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
BlendFunc_ConstThroat::BlendFunc_ConstThroat(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C)
: BlendFunc_GenChamfer(S1,S2,C),
istangent(Standard_False),
param(0.0),

21
src/BlendFunc/BlendFunc_ConstThroat.hxx
View File

@@ -15,14 +15,8 @@
#ifndef _BlendFunc_ConstThroat_HeaderFile
#define _BlendFunc_ConstThroat_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_GenChamfer.hxx>
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_Shape.hxx>
@@ -31,16 +25,11 @@
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class gp_Vec;
class gp_Vec2d;
class gp_Lin;
class Blend_Point;
//! Class for a function used to compute a symmetric chamfer
//! with constant throat that is the height of isosceles triangle in section
class BlendFunc_ConstThroat : public BlendFunc_GenChamfer
@@ -50,9 +39,9 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_ConstThroat(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_ConstThroat(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C);
//! computes the values <F> of the Functions for the

12
src/BlendFunc/BlendFunc_ConstThroatInv.cxx
View File

@@ -13,9 +13,9 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_ConstThroatInv.hxx>
#include <math_Matrix.hxx>
@@ -26,9 +26,9 @@
//purpose :
//=======================================================================
BlendFunc_ConstThroatInv::BlendFunc_ConstThroatInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
BlendFunc_ConstThroatInv::BlendFunc_ConstThroatInv(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C)
: BlendFunc_GenChamfInv(S1,S2,C),
Throat(0.0),
param(0.0),

16
src/BlendFunc/BlendFunc_ConstThroatInv.hxx
View File

@@ -15,22 +15,12 @@
#ifndef _BlendFunc_ConstThroatInv_HeaderFile
#define _BlendFunc_ConstThroatInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_GenChamfInv.hxx>
#include <math_Vector.hxx>
#include <Standard_Real.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
class math_Matrix;
//! Class for a function used to compute a ConstThroat chamfer on a surface's boundary
class BlendFunc_ConstThroatInv : public BlendFunc_GenChamfInv
{
@@ -39,7 +29,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_ConstThroatInv(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_ConstThroatInv(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT Standard_Boolean IsSolution (const math_Vector& Sol, const Standard_Real Tol) Standard_OVERRIDE;

10
src/BlendFunc/BlendFunc_ConstThroatWithPenetration.cxx
View File

@@ -12,8 +12,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_ConstThroatWithPenetration.hxx>
@@ -36,9 +36,9 @@
//=======================================================================
BlendFunc_ConstThroatWithPenetration::
BlendFunc_ConstThroatWithPenetration(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
BlendFunc_ConstThroatWithPenetration(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C)
: BlendFunc_ConstThroat(S1,S2,C)
{
}

21
src/BlendFunc/BlendFunc_ConstThroatWithPenetration.hxx
View File

@@ -15,14 +15,8 @@
#ifndef _BlendFunc_ConstThroatWithPenetration_HeaderFile
#define _BlendFunc_ConstThroatWithPenetration_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_ConstThroat.hxx>
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_Shape.hxx>
@@ -31,16 +25,11 @@
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class gp_Vec;
class gp_Vec2d;
class gp_Lin;
class Blend_Point;
//! Class for a function used to compute a chamfer with constant throat:
//! the section of chamfer is right-angled triangle,
//! the first of two surfaces (where is the top of the chamfer)
@@ -55,9 +44,9 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_ConstThroatWithPenetration(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_ConstThroatWithPenetration(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C);
//! computes the values <F> of the Functions for the

12
src/BlendFunc/BlendFunc_ConstThroatWithPenetrationInv.cxx
View File

@@ -13,9 +13,9 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_ConstThroatWithPenetrationInv.hxx>
#include <math_Matrix.hxx>
@@ -27,9 +27,9 @@
//=======================================================================
BlendFunc_ConstThroatWithPenetrationInv::
BlendFunc_ConstThroatWithPenetrationInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
BlendFunc_ConstThroatWithPenetrationInv(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C)
: BlendFunc_ConstThroatInv(S1,S2,C)
{
}

20
src/BlendFunc/BlendFunc_ConstThroatWithPenetrationInv.hxx
View File

@@ -15,22 +15,12 @@
#ifndef _BlendFunc_ConstThroatWithPenetrationInv_HeaderFile
#define _BlendFunc_ConstThroatWithPenetrationInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_ConstThroatInv.hxx>
#include <math_Vector.hxx>
#include <Standard_Real.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
class math_Matrix;
//! Class for a function used to compute a ConstThroatWithPenetration chamfer
//! on a surface's boundary
class BlendFunc_ConstThroatWithPenetrationInv : public BlendFunc_ConstThroatInv
@@ -40,9 +30,9 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_ConstThroatWithPenetrationInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_ConstThroatWithPenetrationInv(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT Standard_Boolean IsSolution (const math_Vector& Sol, const Standard_Real Tol) Standard_OVERRIDE;

8
src/BlendFunc/BlendFunc_Corde.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_Corde.hxx>
#include <ElCLib.hxx>
@@ -33,8 +33,8 @@
//function : BlendFunc_Corde
//purpose :
//=======================================================================
BlendFunc_Corde::BlendFunc_Corde(const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_HCurve)& CG)
BlendFunc_Corde::BlendFunc_Corde(const Handle(Adaptor3d_Surface)& S,
const Handle(Adaptor3d_Curve)& CG)
: surf(S),
guide(CG),
dis(0.0),

21
src/BlendFunc/BlendFunc_Corde.hxx
View File

@@ -17,25 +17,14 @@
#ifndef _BlendFunc_Corde_HeaderFile
#define _BlendFunc_Corde_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Standard_Real.hxx>
#include <gp_Vec.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Standard_DomainError;
class math_Matrix;
class gp_Pnt;
class gp_Vec;
class gp_Vec2d;
class math_Matrix;
//! This function calculates point (pts) on the curve of
//! intersection between the normal to a curve (guide)
@@ -49,7 +38,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_Corde(const Handle(Adaptor3d_HSurface)& S, const Handle(Adaptor3d_HCurve)& CGuide);
Standard_EXPORT BlendFunc_Corde(const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor3d_Curve)& CGuide);
Standard_EXPORT void SetParam (const Standard_Real Param);
@@ -107,8 +96,8 @@ private:
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_HCurve) guide;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_Curve) guide;
gp_Pnt pts;
gp_Pnt2d pt2d;
Standard_Real dis;

10
src/BlendFunc/BlendFunc_EvolRad.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_EvolRad.hxx>
@@ -102,9 +102,9 @@ static void FusionneIntervalles(const TColStd_Array1OfReal& I1,
//purpose :
//=======================================================================
BlendFunc_EvolRad::BlendFunc_EvolRad(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C,
BlendFunc_EvolRad::BlendFunc_EvolRad(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C,
const Handle(Law_Function)& Law)
:
surf1(S1),surf2(S2),

26
src/BlendFunc/BlendFunc_EvolRad.hxx
View File

@@ -17,16 +17,10 @@
#ifndef _BlendFunc_EvolRad_HeaderFile
#define _BlendFunc_EvolRad_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Vec.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <math_Vector.hxx>
#include <math_Matrix.hxx>
#include <BlendFunc_Tensor.hxx>
@@ -40,18 +34,12 @@
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Law_Function;
class math_Matrix;
class gp_Pnt;
class gp_Vec;
class gp_Vec2d;
class gp_Circ;
class Blend_Point;
class BlendFunc_EvolRad : public Blend_Function
{
public:
@@ -59,7 +47,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_EvolRad(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& C, const Handle(Law_Function)& Law);
Standard_EXPORT BlendFunc_EvolRad(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C, const Handle(Law_Function)& Law);
//! returns the number of equations of the function.
Standard_EXPORT Standard_Integer NbEquations() const Standard_OVERRIDE;
@@ -188,10 +176,10 @@ private:
Standard_EXPORT Standard_Boolean ComputeValues (const math_Vector& X, const Standard_Integer Order, const Standard_Boolean ByParam = Standard_False, const Standard_Real Param = 0);
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_HCurve) tcurv;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor3d_Curve) tcurv;
Handle(Law_Function) fevol;
Handle(Law_Function) tevol;
gp_Pnt pts1;

14
src/BlendFunc/BlendFunc_EvolRadInv.cxx
View File

@@ -15,9 +15,9 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_EvolRadInv.hxx>
#include <Law_Function.hxx>
@@ -27,9 +27,9 @@
#define Eps 1.e-15
BlendFunc_EvolRadInv::BlendFunc_EvolRadInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C,
BlendFunc_EvolRadInv::BlendFunc_EvolRadInv(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C,
const Handle(Law_Function)& Law) :
surf1(S1),surf2(S2),curv(C)
{
@@ -75,7 +75,7 @@ void BlendFunc_EvolRadInv::Set(const Standard_Integer Choix)
}
void BlendFunc_EvolRadInv::Set(const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& C)
const Handle(Adaptor2d_Curve2d)& C)
{
first = OnFirst;
csurf = C;

26
src/BlendFunc/BlendFunc_EvolRadInv.hxx
View File

@@ -17,23 +17,13 @@
#ifndef _BlendFunc_EvolRadInv_HeaderFile
#define _BlendFunc_EvolRadInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_FuncInv.hxx>
#include <math_Vector.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
class Law_Function;
class math_Matrix;
class BlendFunc_EvolRadInv : public Blend_FuncInv
{
public:
@@ -41,9 +31,9 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_EvolRadInv(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& C, const Handle(Law_Function)& Law);
Standard_EXPORT BlendFunc_EvolRadInv(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C, const Handle(Law_Function)& Law);
Standard_EXPORT void Set (const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& COnSurf);
Standard_EXPORT void Set (const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& COnSurf);
Standard_EXPORT void GetTolerance (math_Vector& Tolerance, const Standard_Real Tol) const;
@@ -87,10 +77,10 @@ private:
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor2d_HCurve2d) csurf;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor2d_Curve2d) csurf;
Handle(Law_Function) fevol;
Standard_Real sg1;
Standard_Real sg2;

14
src/BlendFunc/BlendFunc_GenChamfInv.cxx
View File

@@ -13,9 +13,9 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_ChamfInv.hxx>
#include <math_Matrix.hxx>
@@ -26,9 +26,9 @@
//function : BlendFunc_GenChamfInv
//purpose :
//=======================================================================
BlendFunc_GenChamfInv::BlendFunc_GenChamfInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
BlendFunc_GenChamfInv::BlendFunc_GenChamfInv(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C)
: surf1(S1),
surf2(S2),
curv(C),
@@ -52,7 +52,7 @@ Standard_Integer BlendFunc_GenChamfInv::NbEquations () const
//purpose :
//=======================================================================
void BlendFunc_GenChamfInv::Set(const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& C)
void BlendFunc_GenChamfInv::Set(const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& C)
{
first = OnFirst;
csurf = C;

30
src/BlendFunc/BlendFunc_GenChamfInv.hxx
View File

@@ -15,23 +15,13 @@
#ifndef _BlendFunc_GenChamfInv_HeaderFile
#define _BlendFunc_GenChamfInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_Corde.hxx>
#include <Blend_FuncInv.hxx>
#include <math_Vector.hxx>
#include <Standard_Real.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
class math_Matrix;
//! Deferred class for a function used to compute a general chamfer on a surface's boundary
class BlendFunc_GenChamfInv : public Blend_FuncInv
{
@@ -39,12 +29,12 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_GenChamfInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_GenChamfInv(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT virtual void Set (const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& COnSurf) Standard_OVERRIDE;
const Handle(Adaptor2d_Curve2d)& COnSurf) Standard_OVERRIDE;
Standard_EXPORT void GetTolerance (math_Vector& Tolerance,
const Standard_Real Tol) const Standard_OVERRIDE;
@@ -72,10 +62,10 @@ public:
protected:
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor2d_HCurve2d) csurf;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor2d_Curve2d) csurf;
Standard_Integer choix;
Standard_Boolean first;

10
src/BlendFunc/BlendFunc_GenChamfer.cxx
View File

@@ -12,8 +12,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_Chamfer.hxx>
@@ -31,9 +31,9 @@
//function : BlendFunc_GenChamfer
//purpose :
//=======================================================================
BlendFunc_GenChamfer::BlendFunc_GenChamfer(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& CG)
BlendFunc_GenChamfer::BlendFunc_GenChamfer(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& CG)
: surf1(S1),
surf2(S2),
curv(CG),

28
src/BlendFunc/BlendFunc_GenChamfer.hxx
View File

@@ -15,15 +15,9 @@
#ifndef _BlendFunc_GenChamfer_HeaderFile
#define _BlendFunc_GenChamfer_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_Corde.hxx>
#include <Blend_Function.hxx>
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <GeomAbs_Shape.hxx>
@@ -32,17 +26,11 @@
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class gp_Vec;
class gp_Vec2d;
class gp_Lin;
class Blend_Point;
//! Deferred class for a function used to compute a general chamfer
class BlendFunc_GenChamfer : public Blend_Function
{
@@ -50,9 +38,9 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_GenChamfer(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& CG);
Standard_EXPORT BlendFunc_GenChamfer(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& CG);
//! returns the number of equations of the function.
Standard_EXPORT Standard_Integer NbEquations() const Standard_OVERRIDE;
@@ -178,9 +166,9 @@ public:
protected:
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_Curve) curv;
Standard_Integer choix;
Standard_Real tol;
Standard_Real distmin;

10
src/BlendFunc/BlendFunc_Ruled.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BlendFunc_Ruled.hxx>
@@ -31,9 +31,9 @@
#include <Standard_DomainError.hxx>
#include <Standard_NotImplemented.hxx>
BlendFunc_Ruled::BlendFunc_Ruled(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C) :
BlendFunc_Ruled::BlendFunc_Ruled(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C) :
surf1(S1),surf2(S2),curv(C),
istangent(Standard_True),

24
src/BlendFunc/BlendFunc_Ruled.hxx
View File

@@ -17,17 +17,11 @@
#ifndef _BlendFunc_Ruled_HeaderFile
#define _BlendFunc_Ruled_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Vec.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_Real.hxx>
#include <Blend_Function.hxx>
#include <Standard_Integer.hxx>
#include <math_Vector.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfVec.hxx>
@@ -36,17 +30,11 @@
#include <TColStd_Array1OfInteger.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class gp_Vec;
class gp_Vec2d;
class Blend_Point;
class gp_Ax1;
class BlendFunc_Ruled : public Blend_Function
{
public:
@@ -54,7 +42,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_Ruled(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_Ruled(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C);
//! returns the number of equations of the function.
Standard_EXPORT Standard_Integer NbEquations() const Standard_OVERRIDE;
@@ -174,9 +162,9 @@ private:
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_Curve) curv;
gp_Pnt pts1;
gp_Pnt pts2;
Standard_Boolean istangent;

14
src/BlendFunc/BlendFunc_RuledInv.cxx
View File

@@ -15,16 +15,16 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <BlendFunc_RuledInv.hxx>
#include <math_Matrix.hxx>
#include <Precision.hxx>
BlendFunc_RuledInv::BlendFunc_RuledInv(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_HCurve)& C)
BlendFunc_RuledInv::BlendFunc_RuledInv(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_Curve)& C)
: surf1(S1),
surf2(S2),
curv(C),
@@ -33,7 +33,7 @@ BlendFunc_RuledInv::BlendFunc_RuledInv(const Handle(Adaptor3d_HSurface)& S1,
}
void BlendFunc_RuledInv::Set(const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& C)
const Handle(Adaptor2d_Curve2d)& C)
{
first = OnFirst;
csurf = C;

26
src/BlendFunc/BlendFunc_RuledInv.hxx
View File

@@ -17,22 +17,12 @@
#ifndef _BlendFunc_RuledInv_HeaderFile
#define _BlendFunc_RuledInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_FuncInv.hxx>
#include <math_Vector.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
class math_Matrix;
class BlendFunc_RuledInv : public Blend_FuncInv
{
public:
@@ -40,9 +30,9 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BlendFunc_RuledInv(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BlendFunc_RuledInv(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT void Set (const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& COnSurf) Standard_OVERRIDE;
Standard_EXPORT void Set (const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& COnSurf) Standard_OVERRIDE;
Standard_EXPORT void GetTolerance (math_Vector& Tolerance, const Standard_Real Tol) const Standard_OVERRIDE;
@@ -84,10 +74,10 @@ private:
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor2d_HCurve2d) csurf;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor2d_Curve2d) csurf;
Standard_Boolean first;