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

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

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

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

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

24
src/BRepBlend/BRepBlend_BlendTool.cxx
View File

@@ -14,12 +14,12 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepBlend_BlendTool.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <BRep_Tool.hxx>
#include <BRepBlend_BlendTool.hxx>
#include <BRepBlend_HCurve2dTool.hxx>
#include <BRepClass_FaceClassifier.hxx>
#include <Extrema_EPCOfExtPC2d.hxx>
@@ -40,8 +40,8 @@
// pmn 8/10/98 : On retourne toujours une distance. (BUC60360)
//=======================================================================
Standard_Boolean BRepBlend_BlendTool::Project(const gp_Pnt2d& P,
const Handle(Adaptor3d_HSurface)&,
const Handle(Adaptor2d_HCurve2d)& C,
const Handle(Adaptor3d_Surface)&,
const Handle(Adaptor2d_Curve2d)& C,
Standard_Real& Paramproj,
Standard_Real& Dist)
{
@@ -60,7 +60,7 @@ Standard_Boolean BRepBlend_BlendTool::Project(const gp_Pnt2d& P,
const Standard_Real epsX = 1.e-8;
const Standard_Integer Nbu = 20;
const Standard_Real Tol = 1.e-5;
Extrema_EPCOfExtPC2d extrema(P, C->Curve2d(), Nbu, epsX, Tol);
Extrema_EPCOfExtPC2d extrema(P, *C, Nbu, epsX, Tol);
if (!extrema.IsDone())
return Standard_True;
@@ -83,8 +83,8 @@ Standard_Boolean BRepBlend_BlendTool::Project(const gp_Pnt2d& P,
//=======================================================================
Standard_Boolean BRepBlend_BlendTool::Inters(const gp_Pnt2d& P1,
const gp_Pnt2d& P2,
const Handle(Adaptor3d_HSurface)&,
const Handle(Adaptor2d_HCurve2d)& C,
const Handle(Adaptor3d_Surface)&,
const Handle(Adaptor2d_Curve2d)& C,
Standard_Real& Param,
Standard_Real& Dist)
{
@@ -97,7 +97,7 @@ Standard_Boolean BRepBlend_BlendTool::Inters(const gp_Pnt2d& P1,
Handle(Geom2d_Line) bid = new Geom2d_Line(P1,d);
Geom2dAdaptor_Curve seg(bid,-0.01*mag,1.01*mag);
Geom2dInt_GInter inter(seg,C->Curve2d(),Tol,Tol);
Geom2dInt_GInter inter (seg, *C, Tol, Tol);
if (!inter.IsDone())
return Standard_False;
@@ -112,7 +112,7 @@ Standard_Boolean BRepBlend_BlendTool::Inters(const gp_Pnt2d& P1,
}
Standard_Integer BRepBlend_BlendTool::NbSamplesV
(const Handle(Adaptor3d_HSurface)&,
(const Handle(Adaptor3d_Surface)&,
const Standard_Real,
const Standard_Real)
{
@@ -120,14 +120,14 @@ Standard_Integer BRepBlend_BlendTool::NbSamplesV
}
Standard_Integer BRepBlend_BlendTool::NbSamplesU
(const Handle(Adaptor3d_HSurface)&,
(const Handle(Adaptor3d_Surface)&,
const Standard_Real,
const Standard_Real)
{
return 10;
}
void BRepBlend_BlendTool::Bounds(const Handle(Adaptor2d_HCurve2d)& A,
void BRepBlend_BlendTool::Bounds(const Handle(Adaptor2d_Curve2d)& A,
Standard_Real& Ufirst,
Standard_Real& Ulast)
{

36
src/BRepBlend/BRepBlend_BlendTool.hxx
View File

@@ -17,20 +17,12 @@
#ifndef _BRepBlend_BlendTool_HeaderFile
#define _BRepBlend_BlendTool_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
class gp_Pnt2d;
class Adaptor3d_HSurface;
class Adaptor2d_HCurve2d;
class Adaptor2d_Curve2d;
class Adaptor3d_HVertex;
class BRepBlend_BlendTool
{
public:
@@ -45,38 +37,38 @@ public:
//! P and the curve..
//! If the method returns Standard_False, Param proj and Dist
//! are not significant.
Standard_EXPORT static Standard_Boolean Project (const gp_Pnt2d& P, const Handle(Adaptor3d_HSurface)& S, const Handle(Adaptor2d_HCurve2d)& C, Standard_Real& Paramproj, Standard_Real& Dist);
Standard_EXPORT static Standard_Boolean Project (const gp_Pnt2d& P, const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor2d_Curve2d)& C, Standard_Real& Paramproj, Standard_Real& Dist);
Standard_EXPORT static Standard_Boolean Inters (const gp_Pnt2d& P1, const gp_Pnt2d& P2, const Handle(Adaptor3d_HSurface)& S, const Handle(Adaptor2d_HCurve2d)& C, Standard_Real& Param, Standard_Real& Dist);
Standard_EXPORT static Standard_Boolean Inters (const gp_Pnt2d& P1, const gp_Pnt2d& P2, const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor2d_Curve2d)& C, Standard_Real& Param, Standard_Real& Dist);
//! Returns the parameter of the vertex V on the edge A.
static Standard_Real Parameter (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_HCurve2d)& A);
static Standard_Real Parameter (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_Curve2d)& A);
//! Returns the parametric tolerance on the arc A
//! used to consider that the vertex and another point meet,
//! i-e if Abs(Parameter(Vertex)-Parameter(OtherPnt))<=
//! Tolerance, the points are "merged".
static Standard_Real Tolerance (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_HCurve2d)& A);
static Standard_Real Tolerance (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_Curve2d)& A);
static Standard_Boolean SingularOnUMin (const Handle(Adaptor3d_HSurface)& S);
static Standard_Boolean SingularOnUMin (const Handle(Adaptor3d_Surface)& S);
static Standard_Boolean SingularOnUMax (const Handle(Adaptor3d_HSurface)& S);
static Standard_Boolean SingularOnUMax (const Handle(Adaptor3d_Surface)& S);
static Standard_Boolean SingularOnVMin (const Handle(Adaptor3d_HSurface)& S);
static Standard_Boolean SingularOnVMin (const Handle(Adaptor3d_Surface)& S);
static Standard_Boolean SingularOnVMax (const Handle(Adaptor3d_HSurface)& S);
static Standard_Boolean SingularOnVMax (const Handle(Adaptor3d_Surface)& S);
Standard_EXPORT static Standard_Integer NbSamplesU (const Handle(Adaptor3d_HSurface)& S, const Standard_Real u1, const Standard_Real u2);
Standard_EXPORT static Standard_Integer NbSamplesU (const Handle(Adaptor3d_Surface)& S, const Standard_Real u1, const Standard_Real u2);
Standard_EXPORT static Standard_Integer NbSamplesV (const Handle(Adaptor3d_HSurface)& S, const Standard_Real v1, const Standard_Real v2);
Standard_EXPORT static Standard_Integer NbSamplesV (const Handle(Adaptor3d_Surface)& S, const Standard_Real v1, const Standard_Real v2);
//! Returns the parametric limits on the arc C.
//! These limits must be finite : they are either
//! the real limits of the arc, for a finite arc,
//! or a bounding box for an infinite arc.
Standard_EXPORT static void Bounds (const Handle(Adaptor2d_HCurve2d)& C, Standard_Real& Ufirst, Standard_Real& Ulast);
Standard_EXPORT static void Bounds (const Handle(Adaptor2d_Curve2d)& C, Standard_Real& Ufirst, Standard_Real& Ulast);
static Handle(Adaptor2d_HCurve2d) CurveOnSurf (const Handle(Adaptor2d_HCurve2d)& C, const Handle(Adaptor3d_HSurface)& S);
static Handle(Adaptor2d_Curve2d) CurveOnSurf (const Handle(Adaptor2d_Curve2d)& C, const Handle(Adaptor3d_Surface)& S);

14
src/BRepBlend/BRepBlend_BlendTool.lxx
View File

@@ -16,39 +16,39 @@
#include <Adaptor3d_HVertex.hxx>
inline Standard_Boolean BRepBlend_BlendTool::SingularOnUMin (const Handle(Adaptor3d_HSurface)& )
inline Standard_Boolean BRepBlend_BlendTool::SingularOnUMin (const Handle(Adaptor3d_Surface)& )
{
return Standard_False;
}
inline Standard_Boolean BRepBlend_BlendTool::SingularOnUMax (const Handle(Adaptor3d_HSurface)& )
inline Standard_Boolean BRepBlend_BlendTool::SingularOnUMax (const Handle(Adaptor3d_Surface)& )
{
return Standard_False;
}
inline Standard_Boolean BRepBlend_BlendTool::SingularOnVMin (const Handle(Adaptor3d_HSurface)& )
inline Standard_Boolean BRepBlend_BlendTool::SingularOnVMin (const Handle(Adaptor3d_Surface)& )
{
return Standard_False;
}
inline Standard_Boolean BRepBlend_BlendTool::SingularOnVMax (const Handle(Adaptor3d_HSurface)& )
inline Standard_Boolean BRepBlend_BlendTool::SingularOnVMax (const Handle(Adaptor3d_Surface)& )
{
return Standard_False;
}
inline Standard_Real BRepBlend_BlendTool::Tolerance (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_HCurve2d)& A)
inline Standard_Real BRepBlend_BlendTool::Tolerance (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_Curve2d)& A)
{
// return Adaptor2d_HCurve2dTool::Resolution(A,1.e-6); // a voir
return V->Resolution(A); // a voir
}
inline Standard_Real BRepBlend_BlendTool::Parameter (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_HCurve2d)& C)
inline Standard_Real BRepBlend_BlendTool::Parameter (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_Curve2d)& C)
{
// return BRep_Tool::Parameter(V,A->Curve().Edge());
return V->Parameter(C);
}
inline Handle(Adaptor2d_HCurve2d) BRepBlend_BlendTool::CurveOnSurf (const Handle(Adaptor2d_HCurve2d)& C, const Handle(Adaptor3d_HSurface)&)
inline Handle(Adaptor2d_Curve2d) BRepBlend_BlendTool::CurveOnSurf (const Handle(Adaptor2d_Curve2d)& C, const Handle(Adaptor3d_Surface)&)
{
return C;
}

44
src/BRepBlend/BRepBlend_CSWalking.hxx
View File

@@ -17,25 +17,18 @@
#ifndef _BRepBlend_CSWalking_HeaderFile
#define _BRepBlend_CSWalking_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Blend_Point.hxx>
#include <Standard_Integer.hxx>
#include <BRepBlend_SequenceOfPointOnRst.hxx>
#include <math_Vector.hxx>
#include <Blend_Status.hxx>
class BRepBlend_Line;
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor3d_TopolTool;
class StdFail_NotDone;
class Adaptor3d_HVertex;
class Adaptor2d_HCurve2d;
class BRepBlend_HCurve2dTool;
class Adaptor3d_HSurfaceTool;
class BRepBlend_HCurveTool;
@@ -49,8 +42,6 @@ class gp_Pnt2d;
class gp_Vec;
class gp_Vec2d;
class BRepBlend_CSWalking
{
public:
@@ -58,7 +49,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_CSWalking(const Handle(Adaptor3d_HCurve)& Curv, const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& Domain);
Standard_EXPORT BRepBlend_CSWalking(const Handle(Adaptor3d_Curve)& Curv, const Handle(Adaptor3d_Surface)& Surf, const Handle(Adaptor3d_TopolTool)& Domain);
Standard_EXPORT void Perform (Blend_CSFunction& F, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Tolesp, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
@@ -68,21 +59,12 @@ public:
const Handle(BRepBlend_Line)& Line() const;
protected:
private:
Standard_EXPORT void InternalPerform (Blend_CSFunction& F, math_Vector& Sol, const Standard_Real Bound);
Standard_EXPORT void Transition (const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Param, IntSurf_Transition& TLine, IntSurf_Transition& TArc);
Standard_EXPORT void Transition (const Handle(Adaptor2d_Curve2d)& A, const Standard_Real Param, IntSurf_Transition& TLine, IntSurf_Transition& TArc);
Standard_EXPORT void MakeExtremity (BRepBlend_Extremity& Extrem, const Standard_Integer Index, const Standard_Real Param, const Standard_Boolean IsVtx, const Handle(Adaptor3d_HVertex)& Vtx);
@@ -95,8 +77,8 @@ private:
Standard_Boolean done;
Handle(BRepBlend_Line) line;
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor3d_TopolTool) domain;
Standard_Real tolesp;
Standard_Real tolgui;
@@ -116,12 +98,12 @@ private:
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheSurface Handle(Adaptor3d_HSurface)
#define TheSurface_hxx <Adaptor3d_HSurface.hxx>
#define TheCurve Handle(Adaptor3d_HCurve)
#define TheCurve_hxx <Adaptor3d_HCurve.hxx>
#define TheArc Handle(Adaptor2d_Curve2d)
#define TheArc_hxx <Adaptor2d_Curve2d.hxx>
#define TheSurface Handle(Adaptor3d_Surface)
#define TheSurface_hxx <Adaptor3d_Surface.hxx>
#define TheCurve Handle(Adaptor3d_Curve)
#define TheCurve_hxx <Adaptor3d_Curve.hxx>
#define TheVertexTool Standard_Integer
#define TheVertexTool_hxx <Standard_Integer.hxx>
#define TheArcTool BRepBlend_HCurve2dTool

18
src/BRepBlend/BRepBlend_CSWalking_0.cxx
View File

@@ -17,12 +17,12 @@
#include <BRepBlend_CSWalking.hxx>
#include <BRepBlend_Line.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <StdFail_NotDone.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <BRepBlend_HCurve2dTool.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <BRepBlend_HCurveTool.hxx>
@@ -39,12 +39,12 @@
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheSurface Handle(Adaptor3d_HSurface)
#define TheSurface_hxx <Adaptor3d_HSurface.hxx>
#define TheCurve Handle(Adaptor3d_HCurve)
#define TheCurve_hxx <Adaptor3d_HCurve.hxx>
#define TheArc Handle(Adaptor2d_Curve2d)
#define TheArc_hxx <Adaptor2d_Curve2d.hxx>
#define TheSurface Handle(Adaptor3d_Surface)
#define TheSurface_hxx <Adaptor3d_Surface.hxx>
#define TheCurve Handle(Adaptor3d_Curve)
#define TheCurve_hxx <Adaptor3d_Curve.hxx>
#define TheVertexTool Standard_Integer
#define TheVertexTool_hxx <Standard_Integer.hxx>
#define TheArcTool BRepBlend_HCurve2dTool

6
src/BRepBlend/BRepBlend_CurvPointRadInv.cxx
View File

@@ -15,7 +15,7 @@
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor3d_Curve.hxx>
#include <BRepBlend_CurvPointRadInv.hxx>
#include <gp_Pnt.hxx>
#include <math_Matrix.hxx>
@@ -25,8 +25,8 @@
//purpose :
//=======================================================================
BRepBlend_CurvPointRadInv::BRepBlend_CurvPointRadInv
(const Handle(Adaptor3d_HCurve)& C1,
const Handle(Adaptor3d_HCurve)& C2)
(const Handle(Adaptor3d_Curve)& C1,
const Handle(Adaptor3d_Curve)& C2)
: curv1(C1),
curv2(C2),
choix(0)

8
src/BRepBlend/BRepBlend_CurvPointRadInv.hxx
View File

@@ -27,7 +27,7 @@
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
#include <Standard_Real.hxx>
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
@@ -49,7 +49,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_CurvPointRadInv(const Handle(Adaptor3d_HCurve)& C1, const Handle(Adaptor3d_HCurve)& C2);
Standard_EXPORT BRepBlend_CurvPointRadInv(const Handle(Adaptor3d_Curve)& C1, const Handle(Adaptor3d_Curve)& C2);
Standard_EXPORT void Set (const Standard_Integer Choix);
@@ -105,8 +105,8 @@ private:
Handle(Adaptor3d_HCurve) curv1;
Handle(Adaptor3d_HCurve) curv2;
Handle(Adaptor3d_Curve) curv1;
Handle(Adaptor3d_Curve) curv2;
gp_Pnt point;
Standard_Integer choix;

8
src/BRepBlend/BRepBlend_Extremity.cxx
View File

@@ -12,10 +12,10 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <BRepBlend_Extremity.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <BRepBlend_PointOnRst.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
@@ -122,7 +122,7 @@ void BRepBlend_Extremity::SetVertex (const Handle(Adaptor3d_HVertex)& V)
vtx = V;
}
void BRepBlend_Extremity::AddArc (const Handle(Adaptor2d_HCurve2d)& A,
void BRepBlend_Extremity::AddArc (const Handle(Adaptor2d_Curve2d)& A,
const Standard_Real Param,
const IntSurf_Transition& TLine,
const IntSurf_Transition& TArc)

3
src/BRepBlend/BRepBlend_Extremity.hxx
View File

@@ -32,7 +32,6 @@ class Standard_DomainError;
class Standard_OutOfRange;
class gp_Pnt;
class gp_Vec;
class Adaptor2d_HCurve2d;
class IntSurf_Transition;
class BRepBlend_PointOnRst;
@@ -90,7 +89,7 @@ public:
//! Sets the values of a point which is on the arc
//! A, at parameter Param.
Standard_EXPORT void AddArc (const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Param, const IntSurf_Transition& TLine, const IntSurf_Transition& TArc);
Standard_EXPORT void AddArc (const Handle(Adaptor2d_Curve2d)& A, const Standard_Real Param, const IntSurf_Transition& TLine, const IntSurf_Transition& TArc);
//! This method returns the parameters of the point
//! on the concerned surface.

6
src/BRepBlend/BRepBlend_HCurve2dTool.cxx
View File

@@ -14,9 +14,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <BRepBlend_HCurve2dTool.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <GeomAbs_CurveType.hxx>
@@ -29,7 +29,7 @@
#include <TColStd_Array1OfReal.hxx>
//============================================================
Standard_Integer BRepBlend_HCurve2dTool::NbSamples (const Handle(Adaptor2d_HCurve2d)& C,
Standard_Integer BRepBlend_HCurve2dTool::NbSamples (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U0,
const Standard_Real U1) {
GeomAbs_CurveType typC = C->GetType();

78
src/BRepBlend/BRepBlend_HCurve2dTool.hxx
View File

@@ -17,33 +17,19 @@
#ifndef _BRepBlend_HCurve2dTool_HeaderFile
#define _BRepBlend_HCurve2dTool_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <GeomAbs_CurveType.hxx>
#include <GeomAbs_Shape.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Elips2d.hxx>
#include <gp_Hypr2d.hxx>
#include <gp_Parab2d.hxx>
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_DomainError;
class Adaptor2d_HCurve2d;
class gp_Pnt2d;
class gp_Vec2d;
class Geom2d_BezierCurve;
class Geom2d_BSplineCurve;
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
#include <gp_Hypr2d.hxx>
#include <TColStd_Array1OfReal.hxx>
class BRepBlend_HCurve2dTool
{
@@ -52,54 +38,54 @@ public:
DEFINE_STANDARD_ALLOC
static Standard_Real FirstParameter (const Handle(Adaptor2d_HCurve2d)& C);
static Standard_Real FirstParameter (const Handle(Adaptor2d_Curve2d)& C);
static Standard_Real LastParameter (const Handle(Adaptor2d_HCurve2d)& C);
static Standard_Real LastParameter (const Handle(Adaptor2d_Curve2d)& C);
static GeomAbs_Shape Continuity (const Handle(Adaptor2d_HCurve2d)& C);
static GeomAbs_Shape Continuity (const Handle(Adaptor2d_Curve2d)& C);
//! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(myclass) >= <S>
static Standard_Integer NbIntervals (const Handle(Adaptor2d_HCurve2d)& C, const GeomAbs_Shape S);
static Standard_Integer NbIntervals (const Handle(Adaptor2d_Curve2d)& C, const GeomAbs_Shape S);
//! 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()
static void Intervals (const Handle(Adaptor2d_HCurve2d)& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
static void Intervals (const Handle(Adaptor2d_Curve2d)& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
static Standard_Boolean IsClosed (const Handle(Adaptor2d_HCurve2d)& C);
static Standard_Boolean IsClosed (const Handle(Adaptor2d_Curve2d)& C);
static Standard_Boolean IsPeriodic (const Handle(Adaptor2d_HCurve2d)& C);
static Standard_Boolean IsPeriodic (const Handle(Adaptor2d_Curve2d)& C);
static Standard_Real Period (const Handle(Adaptor2d_HCurve2d)& C);
static Standard_Real Period (const Handle(Adaptor2d_Curve2d)& C);
//! Computes the point of parameter U on the curve.
static gp_Pnt2d Value (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Real U);
static gp_Pnt2d Value (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U);
//! Computes the point of parameter U on the curve.
static void D0 (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Real U, gp_Pnt2d& P);
static void D0 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P);
//! Computes the point of parameter U on the curve with its
//! first derivative.
//! Raised if the continuity of the current interval
//! is not C1.
static void D1 (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V);
static void D1 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V);
//! 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.
static void D2 (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
static void D2 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
//! 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.
static void D3 (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3);
static void D3 (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3);
//! The returned vector gives the value of the derivative for the
@@ -107,32 +93,32 @@ public:
//! Raised if the continuity of the current interval
//! is not CN.
//! Raised if N < 1.
static gp_Vec2d DN (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Real U, const Standard_Integer N);
static gp_Vec2d DN (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U, const Standard_Integer N);
//! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
static Standard_Real Resolution (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Real R3d);
static Standard_Real Resolution (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real R3d);
//! Returns the type of the curve in the current
//! interval : Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
static GeomAbs_CurveType GetType (const Handle(Adaptor2d_HCurve2d)& C);
static GeomAbs_CurveType GetType (const Handle(Adaptor2d_Curve2d)& C);
static gp_Lin2d Line (const Handle(Adaptor2d_HCurve2d)& C);
static gp_Lin2d Line (const Handle(Adaptor2d_Curve2d)& C);
static gp_Circ2d Circle (const Handle(Adaptor2d_HCurve2d)& C);
static gp_Circ2d Circle (const Handle(Adaptor2d_Curve2d)& C);
static gp_Elips2d Ellipse (const Handle(Adaptor2d_HCurve2d)& C);
static gp_Elips2d Ellipse (const Handle(Adaptor2d_Curve2d)& C);
static gp_Hypr2d Hyperbola (const Handle(Adaptor2d_HCurve2d)& C);
static gp_Hypr2d Hyperbola (const Handle(Adaptor2d_Curve2d)& C);
static gp_Parab2d Parabola (const Handle(Adaptor2d_HCurve2d)& C);
static gp_Parab2d Parabola (const Handle(Adaptor2d_Curve2d)& C);
static Handle(Geom2d_BezierCurve) Bezier (const Handle(Adaptor2d_HCurve2d)& C);
static Handle(Geom2d_BezierCurve) Bezier (const Handle(Adaptor2d_Curve2d)& C);
static Handle(Geom2d_BSplineCurve) BSpline (const Handle(Adaptor2d_HCurve2d)& C);
static Handle(Geom2d_BSplineCurve) BSpline (const Handle(Adaptor2d_Curve2d)& C);
Standard_EXPORT static Standard_Integer NbSamples (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Real U0, const Standard_Real U1);
Standard_EXPORT static Standard_Integer NbSamples (const Handle(Adaptor2d_Curve2d)& C, const Standard_Real U0, const Standard_Real U1);

46
src/BRepBlend/BRepBlend_HCurve2dTool.lxx
View File

@@ -31,59 +31,59 @@
#include <TColStd_Array1OfReal.hxx>
//============================================================
inline Standard_Real BRepBlend_HCurve2dTool::FirstParameter (const Handle(Adaptor2d_HCurve2d)& C) {
inline Standard_Real BRepBlend_HCurve2dTool::FirstParameter (const Handle(Adaptor2d_Curve2d)& C) {
return(C->FirstParameter());
}
//============================================================
inline Standard_Real BRepBlend_HCurve2dTool::LastParameter (const Handle(Adaptor2d_HCurve2d)& C) {
inline Standard_Real BRepBlend_HCurve2dTool::LastParameter (const Handle(Adaptor2d_Curve2d)& C) {
return(C->LastParameter());
}
//============================================================
inline GeomAbs_Shape BRepBlend_HCurve2dTool::Continuity (const Handle(Adaptor2d_HCurve2d)& C) {
inline GeomAbs_Shape BRepBlend_HCurve2dTool::Continuity (const Handle(Adaptor2d_Curve2d)& C) {
return(C->Continuity());
}
//============================================================
inline Standard_Integer BRepBlend_HCurve2dTool::NbIntervals(const Handle(Adaptor2d_HCurve2d)& C,const GeomAbs_Shape Sh) {
inline Standard_Integer BRepBlend_HCurve2dTool::NbIntervals(const Handle(Adaptor2d_Curve2d)& C,const GeomAbs_Shape Sh) {
return(C->NbIntervals(Sh));
}
//============================================================
inline void BRepBlend_HCurve2dTool::Intervals(const Handle(Adaptor2d_HCurve2d)& C,
inline void BRepBlend_HCurve2dTool::Intervals(const Handle(Adaptor2d_Curve2d)& C,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape Sh) {
C->Intervals(Tab,Sh);
}
//============================================================
inline Standard_Boolean BRepBlend_HCurve2dTool::IsClosed(const Handle(Adaptor2d_HCurve2d)& C) {
inline Standard_Boolean BRepBlend_HCurve2dTool::IsClosed(const Handle(Adaptor2d_Curve2d)& C) {
return(C->IsClosed());
}
//============================================================
inline Standard_Boolean BRepBlend_HCurve2dTool::IsPeriodic(const Handle(Adaptor2d_HCurve2d)& C) {
inline Standard_Boolean BRepBlend_HCurve2dTool::IsPeriodic(const Handle(Adaptor2d_Curve2d)& C) {
return(C->IsPeriodic());
}
//============================================================
inline Standard_Real BRepBlend_HCurve2dTool::Period(const Handle(Adaptor2d_HCurve2d)& C) {
inline Standard_Real BRepBlend_HCurve2dTool::Period(const Handle(Adaptor2d_Curve2d)& C) {
return(C->Period());
}
//============================================================
inline gp_Pnt2d BRepBlend_HCurve2dTool::Value (const Handle(Adaptor2d_HCurve2d)& C,
inline gp_Pnt2d BRepBlend_HCurve2dTool::Value (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U) {
return(C->Value(U));
}
//============================================================
inline void BRepBlend_HCurve2dTool::D0(const Handle(Adaptor2d_HCurve2d)& C,
inline void BRepBlend_HCurve2dTool::D0(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P) {
C->D0(U,P);
}
//============================================================
inline void BRepBlend_HCurve2dTool::D1 (const Handle(Adaptor2d_HCurve2d)& C,
inline void BRepBlend_HCurve2dTool::D1 (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& T) {
C->D1(U,P,T);
}
//============================================================
inline void BRepBlend_HCurve2dTool::D2 (const Handle(Adaptor2d_HCurve2d)& C,
inline void BRepBlend_HCurve2dTool::D2 (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& T,
@@ -92,7 +92,7 @@ inline void BRepBlend_HCurve2dTool::D2 (const Handle(Adaptor2d_HCurve2d)& C,
C->D2(U,P,T,N);
}
//============================================================
inline void BRepBlend_HCurve2dTool::D3 (const Handle(Adaptor2d_HCurve2d)& C,
inline void BRepBlend_HCurve2dTool::D3 (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& V1,
@@ -102,47 +102,47 @@ inline void BRepBlend_HCurve2dTool::D3 (const Handle(Adaptor2d_HCurve2d)& C,
C->D3(U,P,V1,V2,V3);
}
//============================================================
inline gp_Vec2d BRepBlend_HCurve2dTool::DN (const Handle(Adaptor2d_HCurve2d)& C,
inline gp_Vec2d BRepBlend_HCurve2dTool::DN (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U,
const Standard_Integer N) {
return(C->DN(U,N));
}
//============================================================
inline Standard_Real BRepBlend_HCurve2dTool::Resolution(const Handle(Adaptor2d_HCurve2d)& C,
inline Standard_Real BRepBlend_HCurve2dTool::Resolution(const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real R3d) {
return(C->Resolution(R3d));
}
//============================================================
inline GeomAbs_CurveType BRepBlend_HCurve2dTool::GetType(const Handle(Adaptor2d_HCurve2d)& C) {
inline GeomAbs_CurveType BRepBlend_HCurve2dTool::GetType(const Handle(Adaptor2d_Curve2d)& C) {
return(C->GetType());
}
//============================================================
inline gp_Lin2d BRepBlend_HCurve2dTool::Line (const Handle(Adaptor2d_HCurve2d)& C) {
inline gp_Lin2d BRepBlend_HCurve2dTool::Line (const Handle(Adaptor2d_Curve2d)& C) {
return(C->Line());
}
//============================================================
inline gp_Circ2d BRepBlend_HCurve2dTool::Circle (const Handle(Adaptor2d_HCurve2d)& C) {
inline gp_Circ2d BRepBlend_HCurve2dTool::Circle (const Handle(Adaptor2d_Curve2d)& C) {
return(C->Circle());
}
//============================================================
inline gp_Elips2d BRepBlend_HCurve2dTool::Ellipse (const Handle(Adaptor2d_HCurve2d)& C) {
inline gp_Elips2d BRepBlend_HCurve2dTool::Ellipse (const Handle(Adaptor2d_Curve2d)& C) {
return(C->Ellipse());
}
//============================================================
inline gp_Parab2d BRepBlend_HCurve2dTool::Parabola (const Handle(Adaptor2d_HCurve2d)& C) {
inline gp_Parab2d BRepBlend_HCurve2dTool::Parabola (const Handle(Adaptor2d_Curve2d)& C) {
return(C->Parabola());
}
//============================================================
inline gp_Hypr2d BRepBlend_HCurve2dTool::Hyperbola (const Handle(Adaptor2d_HCurve2d)& C) {
inline gp_Hypr2d BRepBlend_HCurve2dTool::Hyperbola (const Handle(Adaptor2d_Curve2d)& C) {
return(C->Hyperbola());
}
//============================================================
inline Handle(Geom2d_BezierCurve) BRepBlend_HCurve2dTool::Bezier (const Handle(Adaptor2d_HCurve2d)& C) {
inline Handle(Geom2d_BezierCurve) BRepBlend_HCurve2dTool::Bezier (const Handle(Adaptor2d_Curve2d)& C) {
return(C->Bezier());
}
//============================================================
inline Handle(Geom2d_BSplineCurve) BRepBlend_HCurve2dTool::BSpline (const Handle(Adaptor2d_HCurve2d)& C) {
inline Handle(Geom2d_BSplineCurve) BRepBlend_HCurve2dTool::BSpline (const Handle(Adaptor2d_Curve2d)& C) {
return(C->BSpline());
}
//============================================================

6
src/BRepBlend/BRepBlend_HCurveTool.cxx
View File

@@ -14,9 +14,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Adaptor3d_HCurve.hxx>
#include <BRepBlend_HCurveTool.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <GeomAbs_CurveType.hxx>
@@ -29,7 +29,7 @@
#include <TColStd_Array1OfReal.hxx>
//============================================================
Standard_Integer BRepBlend_HCurveTool::NbSamples (const Handle(Adaptor3d_HCurve)& C,
Standard_Integer BRepBlend_HCurveTool::NbSamples (const Handle(Adaptor3d_Curve)& C,
const Standard_Real U0,
const Standard_Real U1) {
GeomAbs_CurveType typC = C->GetType();

80
src/BRepBlend/BRepBlend_HCurveTool.hxx
View File

@@ -17,33 +17,19 @@
#ifndef _BRepBlend_HCurveTool_HeaderFile
#define _BRepBlend_HCurveTool_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <GeomAbs_CurveType.hxx>
#include <gp_Lin.hxx>
#include <GeomAbs_Shape.hxx>
#include <gp_Circ.hxx>
#include <gp_Elips.hxx>
#include <gp_Hypr.hxx>
#include <gp_Lin.hxx>
#include <gp_Parab.hxx>
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_DomainError;
class Adaptor3d_HCurve;
class gp_Pnt;
class gp_Vec;
class Geom_BezierCurve;
class Geom_BSplineCurve;
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <gp_Hypr.hxx>
#include <TColStd_Array1OfReal.hxx>
class BRepBlend_HCurveTool
{
@@ -52,54 +38,54 @@ public:
DEFINE_STANDARD_ALLOC
static Standard_Real FirstParameter (const Handle(Adaptor3d_HCurve)& C);
static Standard_Real FirstParameter (const Handle(Adaptor3d_Curve)& C);
static Standard_Real LastParameter (const Handle(Adaptor3d_HCurve)& C);
static Standard_Real LastParameter (const Handle(Adaptor3d_Curve)& C);
static GeomAbs_Shape Continuity (const Handle(Adaptor3d_HCurve)& C);
static GeomAbs_Shape Continuity (const Handle(Adaptor3d_Curve)& C);
//! Returns the number of intervals for continuity
//! <S>. May be one if Continuity(myclass) >= <S>
static Standard_Integer NbIntervals (const Handle(Adaptor3d_HCurve)& C, const GeomAbs_Shape S);
static Standard_Integer NbIntervals (const Handle(Adaptor3d_Curve)& C, const GeomAbs_Shape S);
//! 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()
static void Intervals (const Handle(Adaptor3d_HCurve)& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
static void Intervals (const Handle(Adaptor3d_Curve)& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
static Standard_Boolean IsClosed (const Handle(Adaptor3d_HCurve)& C);
static Standard_Boolean IsClosed (const Handle(Adaptor3d_Curve)& C);
static Standard_Boolean IsPeriodic (const Handle(Adaptor3d_HCurve)& C);
static Standard_Boolean IsPeriodic (const Handle(Adaptor3d_Curve)& C);
static Standard_Real Period (const Handle(Adaptor3d_HCurve)& C);
static Standard_Real Period (const Handle(Adaptor3d_Curve)& C);
//! Computes the point of parameter U on the curve.
static gp_Pnt Value (const Handle(Adaptor3d_HCurve)& C, const Standard_Real U);
static gp_Pnt Value (const Handle(Adaptor3d_Curve)& C, const Standard_Real U);
//! Computes the point of parameter U on the curve.
static void D0 (const Handle(Adaptor3d_HCurve)& C, const Standard_Real U, gp_Pnt& P);
static void D0 (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, gp_Pnt& P);
//! Computes the point of parameter U on the curve with its
//! first derivative.
//! Raised if the continuity of the current interval
//! is not C1.
static void D1 (const Handle(Adaptor3d_HCurve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V);
static void D1 (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V);
//! 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.
static void D2 (const Handle(Adaptor3d_HCurve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
static void D2 (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2);
//! 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.
static void D3 (const Handle(Adaptor3d_HCurve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
static void D3 (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, gp_Pnt& P, gp_Vec& V1, gp_Vec& V2, gp_Vec& V3);
//! The returned vector gives the value of the derivative for the
@@ -107,32 +93,32 @@ public:
//! Raised if the continuity of the current interval
//! is not CN.
//! Raised if N < 1.
static gp_Vec DN (const Handle(Adaptor3d_HCurve)& C, const Standard_Real U, const Standard_Integer N);
static gp_Vec DN (const Handle(Adaptor3d_Curve)& C, const Standard_Real U, const Standard_Integer N);
//! Returns the parametric resolution corresponding
//! to the real space resolution <R3d>.
static Standard_Real Resolution (const Handle(Adaptor3d_HCurve)& C, const Standard_Real R3d);
static Standard_Real Resolution (const Handle(Adaptor3d_Curve)& C, const Standard_Real R3d);
//! Returns the type of the curve in the current
//! interval : Line, Circle, Ellipse, Hyperbola,
//! Parabola, BezierCurve, BSplineCurve, OtherCurve.
static GeomAbs_CurveType GetType (const Handle(Adaptor3d_HCurve)& C);
static GeomAbs_CurveType GetType (const Handle(Adaptor3d_Curve)& C);
static gp_Lin Line (const Handle(Adaptor3d_HCurve)& C);
static gp_Lin Line (const Handle(Adaptor3d_Curve)& C);
static gp_Circ Circle (const Handle(Adaptor3d_HCurve)& C);
static gp_Circ Circle (const Handle(Adaptor3d_Curve)& C);
static gp_Elips Ellipse (const Handle(Adaptor3d_HCurve)& C);
static gp_Elips Ellipse (const Handle(Adaptor3d_Curve)& C);
static gp_Hypr Hyperbola (const Handle(Adaptor3d_HCurve)& C);
static gp_Hypr Hyperbola (const Handle(Adaptor3d_Curve)& C);
static gp_Parab Parabola (const Handle(Adaptor3d_HCurve)& C);
static gp_Parab Parabola (const Handle(Adaptor3d_Curve)& C);
static Handle(Geom_BezierCurve) Bezier (const Handle(Adaptor3d_HCurve)& C);
static Handle(Geom_BezierCurve) Bezier (const Handle(Adaptor3d_Curve)& C);
static Handle(Geom_BSplineCurve) BSpline (const Handle(Adaptor3d_HCurve)& C);
static Handle(Geom_BSplineCurve) BSpline (const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT static Standard_Integer NbSamples (const Handle(Adaptor3d_HCurve)& C, const Standard_Real U0, const Standard_Real U1);
Standard_EXPORT static Standard_Integer NbSamples (const Handle(Adaptor3d_Curve)& C, const Standard_Real U0, const Standard_Real U1);

46
src/BRepBlend/BRepBlend_HCurveTool.lxx
View File

@@ -31,59 +31,59 @@
#include <TColStd_Array1OfReal.hxx>
//============================================================
inline Standard_Real BRepBlend_HCurveTool::FirstParameter (const Handle(Adaptor3d_HCurve)& C) {
inline Standard_Real BRepBlend_HCurveTool::FirstParameter (const Handle(Adaptor3d_Curve)& C) {
return(C->FirstParameter());
}
//============================================================
inline Standard_Real BRepBlend_HCurveTool::LastParameter (const Handle(Adaptor3d_HCurve)& C) {
inline Standard_Real BRepBlend_HCurveTool::LastParameter (const Handle(Adaptor3d_Curve)& C) {
return(C->LastParameter());
}
//============================================================
inline GeomAbs_Shape BRepBlend_HCurveTool::Continuity (const Handle(Adaptor3d_HCurve)& C) {
inline GeomAbs_Shape BRepBlend_HCurveTool::Continuity (const Handle(Adaptor3d_Curve)& C) {
return(C->Continuity());
}
//============================================================
inline Standard_Integer BRepBlend_HCurveTool::NbIntervals(const Handle(Adaptor3d_HCurve)& C,const GeomAbs_Shape Sh) {
inline Standard_Integer BRepBlend_HCurveTool::NbIntervals(const Handle(Adaptor3d_Curve)& C,const GeomAbs_Shape Sh) {
return(C->NbIntervals(Sh));
}
//============================================================
inline void BRepBlend_HCurveTool::Intervals(const Handle(Adaptor3d_HCurve)& C,
inline void BRepBlend_HCurveTool::Intervals(const Handle(Adaptor3d_Curve)& C,
TColStd_Array1OfReal& Tab,
const GeomAbs_Shape Sh) {
C->Intervals(Tab,Sh);
}
//============================================================
inline Standard_Boolean BRepBlend_HCurveTool::IsClosed(const Handle(Adaptor3d_HCurve)& C) {
inline Standard_Boolean BRepBlend_HCurveTool::IsClosed(const Handle(Adaptor3d_Curve)& C) {
return(C->IsClosed());
}
//============================================================
inline Standard_Boolean BRepBlend_HCurveTool::IsPeriodic(const Handle(Adaptor3d_HCurve)& C) {
inline Standard_Boolean BRepBlend_HCurveTool::IsPeriodic(const Handle(Adaptor3d_Curve)& C) {
return(C->IsPeriodic());
}
//============================================================
inline Standard_Real BRepBlend_HCurveTool::Period(const Handle(Adaptor3d_HCurve)& C) {
inline Standard_Real BRepBlend_HCurveTool::Period(const Handle(Adaptor3d_Curve)& C) {
return(C->Period());
}
//============================================================
inline gp_Pnt BRepBlend_HCurveTool::Value (const Handle(Adaptor3d_HCurve)& C,
inline gp_Pnt BRepBlend_HCurveTool::Value (const Handle(Adaptor3d_Curve)& C,
const Standard_Real U) {
return(C->Value(U));
}
//============================================================
inline void BRepBlend_HCurveTool::D0(const Handle(Adaptor3d_HCurve)& C,
inline void BRepBlend_HCurveTool::D0(const Handle(Adaptor3d_Curve)& C,
const Standard_Real U,
gp_Pnt& P) {
C->D0(U,P);
}
//============================================================
inline void BRepBlend_HCurveTool::D1 (const Handle(Adaptor3d_HCurve)& C,
inline void BRepBlend_HCurveTool::D1 (const Handle(Adaptor3d_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& T) {
C->D1(U,P,T);
}
//============================================================
inline void BRepBlend_HCurveTool::D2 (const Handle(Adaptor3d_HCurve)& C,
inline void BRepBlend_HCurveTool::D2 (const Handle(Adaptor3d_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& T,
@@ -92,7 +92,7 @@ inline void BRepBlend_HCurveTool::D2 (const Handle(Adaptor3d_HCurve)& C,
C->D2(U,P,T,N);
}
//============================================================
inline void BRepBlend_HCurveTool::D3 (const Handle(Adaptor3d_HCurve)& C,
inline void BRepBlend_HCurveTool::D3 (const Handle(Adaptor3d_Curve)& C,
const Standard_Real U,
gp_Pnt& P,
gp_Vec& V1,
@@ -102,47 +102,47 @@ inline void BRepBlend_HCurveTool::D3 (const Handle(Adaptor3d_HCurve)& C,
C->D3(U,P,V1,V2,V3);
}
//============================================================
inline gp_Vec BRepBlend_HCurveTool::DN (const Handle(Adaptor3d_HCurve)& C,
inline gp_Vec BRepBlend_HCurveTool::DN (const Handle(Adaptor3d_Curve)& C,
const Standard_Real U,
const Standard_Integer N) {
return(C->DN(U,N));
}
//============================================================
inline Standard_Real BRepBlend_HCurveTool::Resolution(const Handle(Adaptor3d_HCurve)& C,
inline Standard_Real BRepBlend_HCurveTool::Resolution(const Handle(Adaptor3d_Curve)& C,
const Standard_Real R3d) {
return(C->Resolution(R3d));
}
//============================================================
inline GeomAbs_CurveType BRepBlend_HCurveTool::GetType(const Handle(Adaptor3d_HCurve)& C) {
inline GeomAbs_CurveType BRepBlend_HCurveTool::GetType(const Handle(Adaptor3d_Curve)& C) {
return(C->GetType());
}
//============================================================
inline gp_Lin BRepBlend_HCurveTool::Line (const Handle(Adaptor3d_HCurve)& C) {
inline gp_Lin BRepBlend_HCurveTool::Line (const Handle(Adaptor3d_Curve)& C) {
return(C->Line());
}
//============================================================
inline gp_Circ BRepBlend_HCurveTool::Circle (const Handle(Adaptor3d_HCurve)& C) {
inline gp_Circ BRepBlend_HCurveTool::Circle (const Handle(Adaptor3d_Curve)& C) {
return(C->Circle());
}
//============================================================
inline gp_Elips BRepBlend_HCurveTool::Ellipse (const Handle(Adaptor3d_HCurve)& C) {
inline gp_Elips BRepBlend_HCurveTool::Ellipse (const Handle(Adaptor3d_Curve)& C) {
return(C->Ellipse());
}
//============================================================
inline gp_Parab BRepBlend_HCurveTool::Parabola (const Handle(Adaptor3d_HCurve)& C) {
inline gp_Parab BRepBlend_HCurveTool::Parabola (const Handle(Adaptor3d_Curve)& C) {
return(C->Parabola());
}
//============================================================
inline gp_Hypr BRepBlend_HCurveTool::Hyperbola (const Handle(Adaptor3d_HCurve)& C) {
inline gp_Hypr BRepBlend_HCurveTool::Hyperbola (const Handle(Adaptor3d_Curve)& C) {
return(C->Hyperbola());
}
//============================================================
inline Handle(Geom_BezierCurve) BRepBlend_HCurveTool::Bezier (const Handle(Adaptor3d_HCurve)& C) {
inline Handle(Geom_BezierCurve) BRepBlend_HCurveTool::Bezier (const Handle(Adaptor3d_Curve)& C) {
return(C->Bezier());
}
//============================================================
inline Handle(Geom_BSplineCurve) BRepBlend_HCurveTool::BSpline (const Handle(Adaptor3d_HCurve)& C) {
inline Handle(Geom_BSplineCurve) BRepBlend_HCurveTool::BSpline (const Handle(Adaptor3d_Curve)& C) {
return(C->BSpline());
}
//============================================================

8
src/BRepBlend/BRepBlend_PointOnRst.cxx
View File

@@ -12,9 +12,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <BRepBlend_PointOnRst.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <IntSurf_Transition.hxx>
#include <Standard_DomainError.hxx>
@@ -24,7 +24,7 @@ BRepBlend_PointOnRst::BRepBlend_PointOnRst ()
}
BRepBlend_PointOnRst::BRepBlend_PointOnRst(const Handle(Adaptor2d_HCurve2d)& A,
BRepBlend_PointOnRst::BRepBlend_PointOnRst(const Handle(Adaptor2d_Curve2d)& A,
const Standard_Real Param,
const IntSurf_Transition& TLine,
const IntSurf_Transition& TArc):
@@ -32,7 +32,7 @@ BRepBlend_PointOnRst::BRepBlend_PointOnRst(const Handle(Adaptor2d_HCurve2d)& A,
arc(A),traline(TLine),traarc(TArc),prm(Param)
{}
void BRepBlend_PointOnRst::SetArc(const Handle(Adaptor2d_HCurve2d)& A,
void BRepBlend_PointOnRst::SetArc(const Handle(Adaptor2d_Curve2d)& A,
const Standard_Real Param,
const IntSurf_Transition& TLine,
const IntSurf_Transition& TArc)

17
src/BRepBlend/BRepBlend_PointOnRst.hxx
View File

@@ -17,17 +17,12 @@
#ifndef _BRepBlend_PointOnRst_HeaderFile
#define _BRepBlend_PointOnRst_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <IntSurf_Transition.hxx>
#include <Standard_Real.hxx>
class Adaptor2d_HCurve2d;
class Standard_DomainError;
class IntSurf_Transition;
//! Definition of an intersection point between a line
//! and a restriction on a surface.
//! Such a point is contains geometrical information (see
@@ -45,15 +40,15 @@ public:
//! Creates the PointOnRst on the arc A, at parameter Param,
//! with the transition TLine on the walking line, and
//! TArc on the arc A.
Standard_EXPORT BRepBlend_PointOnRst(const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Param, const IntSurf_Transition& TLine, const IntSurf_Transition& TArc);
Standard_EXPORT BRepBlend_PointOnRst(const Handle(Adaptor2d_Curve2d)& A, const Standard_Real Param, const IntSurf_Transition& TLine, const IntSurf_Transition& TArc);
//! Sets the values of a point which is on the arc
//! A, at parameter Param.
Standard_EXPORT void SetArc (const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Param, const IntSurf_Transition& TLine, const IntSurf_Transition& TArc);
Standard_EXPORT void SetArc (const Handle(Adaptor2d_Curve2d)& A, const Standard_Real Param, const IntSurf_Transition& TLine, const IntSurf_Transition& TArc);
//! Returns the arc of restriction containing the
//! vertex.
const Handle(Adaptor2d_HCurve2d)& Arc() const;
const Handle(Adaptor2d_Curve2d)& Arc() const;
//! Returns the transition of the point on the
//! line on surface.
@@ -80,7 +75,7 @@ private:
Handle(Adaptor2d_HCurve2d) arc;
Handle(Adaptor2d_Curve2d) arc;
IntSurf_Transition traline;
IntSurf_Transition traarc;
Standard_Real prm;

2
src/BRepBlend/BRepBlend_PointOnRst.lxx
View File

@@ -14,7 +14,7 @@
#include <Standard_DomainError.hxx>
inline const Handle(Adaptor2d_HCurve2d)& BRepBlend_PointOnRst::Arc () const
inline const Handle(Adaptor2d_Curve2d)& BRepBlend_PointOnRst::Arc () const
{
return arc;
}

26
src/BRepBlend/BRepBlend_RstRstConstRad.cxx
View File

@@ -14,13 +14,13 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepBlend_RstRstConstRad.hxx>
#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 <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BRepBlend_RstRstConstRad.hxx>
#include <ElCLib.hxx>
#include <GeomFill.hxx>
#include <gp.hxx>
@@ -60,11 +60,11 @@ static void t3dto2d(Standard_Real& a,
//=======================================================================
BRepBlend_RstRstConstRad::BRepBlend_RstRstConstRad
(const Handle(Adaptor3d_HSurface)& Surf1,
const Handle(Adaptor2d_HCurve2d)& Rst1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor2d_HCurve2d)& Rst2,
const Handle(Adaptor3d_HCurve)& CGuide):
(const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor2d_Curve2d)& Rst1,
const Handle(Adaptor3d_Surface)& Surf2,
const Handle(Adaptor2d_Curve2d)& Rst2,
const Handle(Adaptor3d_Curve)& CGuide):
surf1(Surf1), surf2(Surf2), rst1(Rst1), rst2(Rst2),
cons1(Rst1, Surf1), cons2(Rst2, Surf2),
guide(CGuide), tguide(CGuide),
@@ -155,10 +155,10 @@ Standard_Boolean BRepBlend_RstRstConstRad::Values(const math_Vector& X,
//purpose :
//=======================================================================
void BRepBlend_RstRstConstRad::Set(const Handle(Adaptor3d_HSurface)& SurfRef1,
const Handle(Adaptor2d_HCurve2d)& RstRef1,
const Handle(Adaptor3d_HSurface)& SurfRef2,
const Handle(Adaptor2d_HCurve2d)& RstRef2)
void BRepBlend_RstRstConstRad::Set(const Handle(Adaptor3d_Surface)& SurfRef1,
const Handle(Adaptor2d_Curve2d)& RstRef1,
const Handle(Adaptor3d_Surface)& SurfRef2,
const Handle(Adaptor2d_Curve2d)& RstRef2)
{
surfref1 = SurfRef1;
surfref2 = SurfRef2;

40
src/BRepBlend/BRepBlend_RstRstConstRad.hxx
View File

@@ -17,18 +17,12 @@
#ifndef _BRepBlend_RstRstConstRad_HeaderFile
#define _BRepBlend_RstRstConstRad_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_CurveOnSurface.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_RstRstFunction.hxx>
@@ -41,14 +35,8 @@
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor2d_HCurve2d;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class gp_Pnt2d;
class gp_Vec;
class gp_Vec2d;
class gp_Circ;
class Blend_Point;
@@ -62,7 +50,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_RstRstConstRad(const Handle(Adaptor3d_HSurface)& Surf1, const Handle(Adaptor2d_HCurve2d)& Rst1, const Handle(Adaptor3d_HSurface)& Surf2, const Handle(Adaptor2d_HCurve2d)& Rst2, const Handle(Adaptor3d_HCurve)& CGuide);
Standard_EXPORT BRepBlend_RstRstConstRad(const Handle(Adaptor3d_Surface)& Surf1, const Handle(Adaptor2d_Curve2d)& Rst1, const Handle(Adaptor3d_Surface)& Surf2, const Handle(Adaptor2d_Curve2d)& Rst2, const Handle(Adaptor3d_Curve)& CGuide);
//! Returns 2.
Standard_EXPORT Standard_Integer NbVariables() const Standard_OVERRIDE;
@@ -88,7 +76,7 @@ public:
//! False otherwise.
Standard_EXPORT Standard_Boolean Values (const math_Vector& X, math_Vector& F, math_Matrix& D) Standard_OVERRIDE;
Standard_EXPORT void Set (const Handle(Adaptor3d_HSurface)& SurfRef1, const Handle(Adaptor2d_HCurve2d)& RstRef1, const Handle(Adaptor3d_HSurface)& SurfRef2, const Handle(Adaptor2d_HCurve2d)& RstRef2);
Standard_EXPORT void Set (const Handle(Adaptor3d_Surface)& SurfRef1, const Handle(Adaptor2d_Curve2d)& RstRef1, const Handle(Adaptor3d_Surface)& SurfRef2, const Handle(Adaptor2d_Curve2d)& RstRef2);
Standard_EXPORT void Set (const Standard_Real Param) Standard_OVERRIDE;
@@ -209,14 +197,14 @@ private:
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor2d_HCurve2d) rst1;
Handle(Adaptor2d_HCurve2d) rst2;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor2d_Curve2d) rst1;
Handle(Adaptor2d_Curve2d) rst2;
Adaptor3d_CurveOnSurface cons1;
Adaptor3d_CurveOnSurface cons2;
Handle(Adaptor3d_HCurve) guide;
Handle(Adaptor3d_HCurve) tguide;
Handle(Adaptor3d_Curve) guide;
Handle(Adaptor3d_Curve) tguide;
gp_Pnt ptrst1;
gp_Pnt ptrst2;
gp_Pnt2d pt2drst1;
@@ -236,10 +224,10 @@ private:
gp_Vec nplan;
Standard_Real normtg;
Standard_Real theD;
Handle(Adaptor3d_HSurface) surfref1;
Handle(Adaptor2d_HCurve2d) rstref1;
Handle(Adaptor3d_HSurface) surfref2;
Handle(Adaptor2d_HCurve2d) rstref2;
Handle(Adaptor3d_Surface) surfref1;
Handle(Adaptor2d_Curve2d) rstref1;
Handle(Adaptor3d_Surface) surfref2;
Handle(Adaptor2d_Curve2d) rstref2;
Standard_Real maxang;
Standard_Real minang;
Standard_Real distmin;

26
src/BRepBlend/BRepBlend_RstRstEvolRad.cxx
View File

@@ -14,13 +14,13 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <BRepBlend_RstRstEvolRad.hxx>
#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 <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BRepBlend_RstRstEvolRad.hxx>
#include <ElCLib.hxx>
#include <GeomFill.hxx>
#include <gp.hxx>
@@ -119,11 +119,11 @@ static void FusionneIntervalles(const TColStd_Array1OfReal& I1,
//=======================================================================
BRepBlend_RstRstEvolRad::BRepBlend_RstRstEvolRad
(const Handle(Adaptor3d_HSurface)& Surf1,
const Handle(Adaptor2d_HCurve2d)& Rst1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor2d_HCurve2d)& Rst2,
const Handle(Adaptor3d_HCurve)& CGuide,
(const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor2d_Curve2d)& Rst1,
const Handle(Adaptor3d_Surface)& Surf2,
const Handle(Adaptor2d_Curve2d)& Rst2,
const Handle(Adaptor3d_Curve)& CGuide,
const Handle(Law_Function)& Evol):
surf1(Surf1), surf2(Surf2), rst1(Rst1), rst2(Rst2),
cons1(Rst1, Surf1), cons2(Rst2, Surf2),
@@ -215,10 +215,10 @@ Standard_Boolean BRepBlend_RstRstEvolRad::Values(const math_Vector& X,
//purpose :
//=======================================================================
void BRepBlend_RstRstEvolRad::Set(const Handle(Adaptor3d_HSurface)& SurfRef1,
const Handle(Adaptor2d_HCurve2d)& RstRef1,
const Handle(Adaptor3d_HSurface)& SurfRef2,
const Handle(Adaptor2d_HCurve2d)& RstRef2)
void BRepBlend_RstRstEvolRad::Set(const Handle(Adaptor3d_Surface)& SurfRef1,
const Handle(Adaptor2d_Curve2d)& RstRef1,
const Handle(Adaptor3d_Surface)& SurfRef2,
const Handle(Adaptor2d_Curve2d)& RstRef2)
{
surfref1 = SurfRef1;
surfref2 = SurfRef2;

40
src/BRepBlend/BRepBlend_RstRstEvolRad.hxx
View File

@@ -17,18 +17,12 @@
#ifndef _BRepBlend_RstRstEvolRad_HeaderFile
#define _BRepBlend_RstRstEvolRad_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_CurveOnSurface.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_RstRstFunction.hxx>
@@ -41,15 +35,9 @@
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor2d_HCurve2d;
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;
@@ -63,7 +51,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_RstRstEvolRad(const Handle(Adaptor3d_HSurface)& Surf1, const Handle(Adaptor2d_HCurve2d)& Rst1, const Handle(Adaptor3d_HSurface)& Surf2, const Handle(Adaptor2d_HCurve2d)& Rst2, const Handle(Adaptor3d_HCurve)& CGuide, const Handle(Law_Function)& Evol);
Standard_EXPORT BRepBlend_RstRstEvolRad(const Handle(Adaptor3d_Surface)& Surf1, const Handle(Adaptor2d_Curve2d)& Rst1, const Handle(Adaptor3d_Surface)& Surf2, const Handle(Adaptor2d_Curve2d)& Rst2, const Handle(Adaptor3d_Curve)& CGuide, const Handle(Law_Function)& Evol);
//! Returns 2.
Standard_EXPORT Standard_Integer NbVariables() const Standard_OVERRIDE;
@@ -89,7 +77,7 @@ public:
//! False otherwise.
Standard_EXPORT Standard_Boolean Values (const math_Vector& X, math_Vector& F, math_Matrix& D) Standard_OVERRIDE;
Standard_EXPORT void Set (const Handle(Adaptor3d_HSurface)& SurfRef1, const Handle(Adaptor2d_HCurve2d)& RstRef1, const Handle(Adaptor3d_HSurface)& SurfRef2, const Handle(Adaptor2d_HCurve2d)& RstRef2);
Standard_EXPORT void Set (const Handle(Adaptor3d_Surface)& SurfRef1, const Handle(Adaptor2d_Curve2d)& RstRef1, const Handle(Adaptor3d_Surface)& SurfRef2, const Handle(Adaptor2d_Curve2d)& RstRef2);
Standard_EXPORT void Set (const Standard_Real Param) Standard_OVERRIDE;
@@ -210,14 +198,14 @@ private:
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor2d_HCurve2d) rst1;
Handle(Adaptor2d_HCurve2d) rst2;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor2d_Curve2d) rst1;
Handle(Adaptor2d_Curve2d) rst2;
Adaptor3d_CurveOnSurface cons1;
Adaptor3d_CurveOnSurface cons2;
Handle(Adaptor3d_HCurve) guide;
Handle(Adaptor3d_HCurve) tguide;
Handle(Adaptor3d_Curve) guide;
Handle(Adaptor3d_Curve) tguide;
gp_Pnt ptrst1;
gp_Pnt ptrst2;
gp_Pnt2d pt2drst1;
@@ -238,10 +226,10 @@ private:
gp_Vec nplan;
Standard_Real normtg;
Standard_Real theD;
Handle(Adaptor3d_HSurface) surfref1;
Handle(Adaptor2d_HCurve2d) rstref1;
Handle(Adaptor3d_HSurface) surfref2;
Handle(Adaptor2d_HCurve2d) rstref2;
Handle(Adaptor3d_Surface) surfref1;
Handle(Adaptor2d_Curve2d) rstref1;
Handle(Adaptor3d_Surface) surfref2;
Handle(Adaptor2d_Curve2d) rstref2;
Standard_Real maxang;
Standard_Real minang;
Standard_Real distmin;

20
src/BRepBlend/BRepBlend_RstRstLineBuilder.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <Blend_CurvPointFuncInv.hxx>
@@ -168,11 +168,11 @@ static void Drawsect(const Standard_Real param,
//=======================================================================
BRepBlend_RstRstLineBuilder::BRepBlend_RstRstLineBuilder
(const Handle(Adaptor3d_HSurface)& Surf1,
const Handle(Adaptor2d_HCurve2d)& Rst1,
(const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor2d_Curve2d)& Rst1,
const Handle(Adaptor3d_TopolTool)& Domain1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor2d_HCurve2d)& Rst2,
const Handle(Adaptor3d_Surface)& Surf2,
const Handle(Adaptor2d_Curve2d)& Rst2,
const Handle(Adaptor3d_TopolTool)& Domain2):
done(Standard_False), sol(1, 2), surf1(Surf1),
domain1(Domain1), surf2(Surf2),
@@ -327,7 +327,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::PerformFirstSection
math_Vector solinvp1(1, 2), solinvp2(1, 2), solinvrst1(1, 3), solinvrst2(1, 3);
Handle(Adaptor3d_HVertex) Vtxp1, Vtxp2, Vtxrst1, Vtxrst2, Vtxc;
Standard_Boolean IsVtxp1 = 0, IsVtxp2 = 0, IsVtxrst1 = 0, IsVtxrst2 = 0;
Handle(Adaptor2d_HCurve2d) Arc;
Handle(Adaptor2d_Curve2d) Arc;
wp1 = wp2 = wrst1 = wrst2 = Pmax;
param = Pdep;
Func.Set(param);
@@ -1321,7 +1321,7 @@ Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre2(Blend_CurvPointFuncInv&
//=======================================================================
void BRepBlend_RstRstLineBuilder::Transition(const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& Arc,
const Handle(Adaptor2d_Curve2d)& Arc,
const Standard_Real Param,
IntSurf_Transition& TLine,
IntSurf_Transition& TArc)
@@ -1371,7 +1371,7 @@ void BRepBlend_RstRstLineBuilder::Transition(const Standard_Boolean OnF
void BRepBlend_RstRstLineBuilder::MakeExtremity(BRepBlend_Extremity& Extrem,
const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& Arc,
const Handle(Adaptor2d_Curve2d)& Arc,
const Standard_Real Param,
const Standard_Boolean IsVtx,
const Handle(Adaptor3d_HVertex)& Vtx)
@@ -1404,7 +1404,7 @@ void BRepBlend_RstRstLineBuilder::MakeExtremity(BRepBlend_Extremity&
else {
Extrem.SetVertex(Vtx);
while (Iter->More()) {
Handle(Adaptor2d_HCurve2d) arc = Iter->Value();
Handle(Adaptor2d_Curve2d) arc = Iter->Value();
if (arc != Arc) {
Iter->Initialize(arc);
Iter->InitVertexIterator();

24
src/BRepBlend/BRepBlend_RstRstLineBuilder.hxx
View File

@@ -17,21 +17,15 @@
#ifndef _BRepBlend_RstRstLineBuilder_HeaderFile
#define _BRepBlend_RstRstLineBuilder_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <math_Vector.hxx>
#include <Standard_Real.hxx>
#include <Blend_Point.hxx>
#include <Blend_DecrochStatus.hxx>
#include <Blend_Status.hxx>
#include <TopAbs_State.hxx>
class BRepBlend_Line;
class Adaptor3d_HSurface;
class Adaptor3d_TopolTool;
class Adaptor2d_HCurve2d;
class Blend_RstRstFunction;
class Blend_SurfCurvFuncInv;
class Blend_CurvPointFuncInv;
@@ -77,7 +71,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_RstRstLineBuilder(const Handle(Adaptor3d_HSurface)& Surf1, const Handle(Adaptor2d_HCurve2d)& Rst1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_HSurface)& Surf2, const Handle(Adaptor2d_HCurve2d)& Rst2, const Handle(Adaptor3d_TopolTool)& Domain2);
Standard_EXPORT BRepBlend_RstRstLineBuilder(const Handle(Adaptor3d_Surface)& Surf1, const Handle(Adaptor2d_Curve2d)& Rst1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_Surface)& Surf2, const Handle(Adaptor2d_Curve2d)& Rst2, const Handle(Adaptor3d_TopolTool)& Domain2);
Standard_EXPORT void Perform (Blend_RstRstFunction& Func, Blend_SurfCurvFuncInv& Finv1, Blend_CurvPointFuncInv& FinvP1, Blend_SurfCurvFuncInv& Finv2, Blend_CurvPointFuncInv& FinvP2, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Tolesp, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
@@ -119,9 +113,9 @@ private:
Standard_EXPORT Standard_Boolean Recadre2 (Blend_CurvPointFuncInv& FinvP, math_Vector& Solinv, Standard_Boolean& IsVtx, Handle(Adaptor3d_HVertex)& Vtx);
Standard_EXPORT void Transition (const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& Arc, const Standard_Real Param, IntSurf_Transition& TLine, IntSurf_Transition& TArc);
Standard_EXPORT void Transition (const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& Arc, const Standard_Real Param, IntSurf_Transition& TLine, IntSurf_Transition& TArc);
Standard_EXPORT void MakeExtremity (BRepBlend_Extremity& Extrem, const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& Arc, const Standard_Real Param, const Standard_Boolean IsVtx, const Handle(Adaptor3d_HVertex)& Vtx);
Standard_EXPORT void MakeExtremity (BRepBlend_Extremity& Extrem, const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& Arc, const Standard_Real Param, const Standard_Boolean IsVtx, const Handle(Adaptor3d_HVertex)& Vtx);
Standard_EXPORT Blend_Status CheckDeflectionOnRst1 (const Blend_Point& CurPoint);
@@ -135,12 +129,12 @@ private:
Standard_Boolean done;
Handle(BRepBlend_Line) line;
math_Vector sol;
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_TopolTool) domain1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_TopolTool) domain2;
Handle(Adaptor2d_HCurve2d) rst1;
Handle(Adaptor2d_HCurve2d) rst2;
Handle(Adaptor2d_Curve2d) rst1;
Handle(Adaptor2d_Curve2d) rst2;
Standard_Real tolesp;
Standard_Real tolgui;
Standard_Real pasmax;

14
src/BRepBlend/BRepBlend_SurfCurvConstRadInv.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 <BRepBlend_SurfCurvConstRadInv.hxx>
#include <math_Matrix.hxx>
@@ -26,9 +26,9 @@
//purpose :
//=======================================================================
BRepBlend_SurfCurvConstRadInv::BRepBlend_SurfCurvConstRadInv
(const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_HCurve)& C,
const Handle(Adaptor3d_HCurve)& Cg)
(const Handle(Adaptor3d_Surface)& S,
const Handle(Adaptor3d_Curve)& C,
const Handle(Adaptor3d_Curve)& Cg)
: surf(S),
curv(C),
guide(Cg),
@@ -274,7 +274,7 @@ Standard_Boolean BRepBlend_SurfCurvConstRadInv::Values(const math_Vector& X,
//purpose :
//=======================================================================
void BRepBlend_SurfCurvConstRadInv::Set(const Handle(Adaptor2d_HCurve2d)& Rst)
void BRepBlend_SurfCurvConstRadInv::Set(const Handle(Adaptor2d_Curve2d)& Rst)
{
rst = Rst;
}

24
src/BRepBlend/BRepBlend_SurfCurvConstRadInv.hxx
View File

@@ -17,18 +17,10 @@
#ifndef _BRepBlend_SurfCurvConstRadInv_HeaderFile
#define _BRepBlend_SurfCurvConstRadInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_SurfCurvFuncInv.hxx>
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
class math_Matrix;
@@ -50,7 +42,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_SurfCurvConstRadInv(const Handle(Adaptor3d_HSurface)& S, const Handle(Adaptor3d_HCurve)& C, const Handle(Adaptor3d_HCurve)& Cg);
Standard_EXPORT BRepBlend_SurfCurvConstRadInv(const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Curve)& Cg);
Standard_EXPORT void Set (const Standard_Real R, const Standard_Integer Choix);
@@ -76,7 +68,7 @@ public:
Standard_EXPORT Standard_Boolean Values (const math_Vector& X, math_Vector& F, math_Matrix& D);
//! Set the restriction on which a solution has to be found.
Standard_EXPORT void Set (const Handle(Adaptor2d_HCurve2d)& Rst);
Standard_EXPORT void Set (const Handle(Adaptor2d_Curve2d)& Rst);
//! Returns in the vector Tolerance the parametric tolerance
//! for each of the 3 variables;
@@ -106,10 +98,10 @@ private:
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_HCurve) guide;
Handle(Adaptor2d_HCurve2d) rst;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor3d_Curve) guide;
Handle(Adaptor2d_Curve2d) rst;
Standard_Real ray;
Standard_Integer choix;

14
src/BRepBlend/BRepBlend_SurfCurvEvolRadInv.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 <BRepBlend_SurfCurvEvolRadInv.hxx>
#include <Law_Function.hxx>
#include <math_Matrix.hxx>
@@ -27,9 +27,9 @@
//purpose :
//=======================================================================
BRepBlend_SurfCurvEvolRadInv::BRepBlend_SurfCurvEvolRadInv
(const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_HCurve)& C,
const Handle(Adaptor3d_HCurve)& Cg,
(const Handle(Adaptor3d_Surface)& S,
const Handle(Adaptor3d_Curve)& C,
const Handle(Adaptor3d_Curve)& Cg,
const Handle(Law_Function)& Evol): surf(S),curv(C),guide(Cg)
{ tevol=Evol;
}
@@ -276,7 +276,7 @@ const Handle(Adaptor3d_HCurve)& Cg,
//function :
//purpose :
//=======================================================================
void BRepBlend_SurfCurvEvolRadInv::Set(const Handle(Adaptor2d_HCurve2d)& Rst)
void BRepBlend_SurfCurvEvolRadInv::Set(const Handle(Adaptor2d_Curve2d)& Rst)
{
rst = Rst;
}

24
src/BRepBlend/BRepBlend_SurfCurvEvolRadInv.hxx
View File

@@ -17,18 +17,10 @@
#ifndef _BRepBlend_SurfCurvEvolRadInv_HeaderFile
#define _BRepBlend_SurfCurvEvolRadInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_SurfCurvFuncInv.hxx>
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
class Law_Function;
class math_Matrix;
@@ -51,7 +43,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_SurfCurvEvolRadInv(const Handle(Adaptor3d_HSurface)& S, const Handle(Adaptor3d_HCurve)& C, const Handle(Adaptor3d_HCurve)& Cg, const Handle(Law_Function)& Evol);
Standard_EXPORT BRepBlend_SurfCurvEvolRadInv(const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor3d_Curve)& C, const Handle(Adaptor3d_Curve)& Cg, const Handle(Law_Function)& Evol);
Standard_EXPORT void Set (const Standard_Integer Choix);
@@ -77,7 +69,7 @@ public:
Standard_EXPORT Standard_Boolean Values (const math_Vector& X, math_Vector& F, math_Matrix& D);
//! Set the restriction on which a solution has to be found.
Standard_EXPORT void Set (const Handle(Adaptor2d_HCurve2d)& Rst);
Standard_EXPORT void Set (const Handle(Adaptor2d_Curve2d)& Rst);
//! Returns in the vector Tolerance the parametric tolerance
//! for each of the 3 variables;
@@ -107,10 +99,10 @@ private:
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_HCurve) guide;
Handle(Adaptor2d_HCurve2d) rst;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_Curve) curv;
Handle(Adaptor3d_Curve) guide;
Handle(Adaptor2d_Curve2d) rst;
Standard_Real ray;
Standard_Integer choix;
Handle(Law_Function) tevol;

8
src/BRepBlend/BRepBlend_SurfPointConstRadInv.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 <BRepBlend_SurfPointConstRadInv.hxx>
#include <gp_Pnt.hxx>
#include <math_Matrix.hxx>
@@ -26,8 +26,8 @@
//purpose :
//=======================================================================
BRepBlend_SurfPointConstRadInv::BRepBlend_SurfPointConstRadInv
(const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_HCurve)& C)
(const Handle(Adaptor3d_Surface)& S,
const Handle(Adaptor3d_Curve)& C)
: surf(S),
curv(C),
ray(0.0),

19
src/BRepBlend/BRepBlend_SurfPointConstRadInv.hxx
View File

@@ -17,21 +17,12 @@
#ifndef _BRepBlend_SurfPointConstRadInv_HeaderFile
#define _BRepBlend_SurfPointConstRadInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Blend_SurfPointFuncInv.hxx>
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class math_Matrix;
//! Function of reframing between a point and a surface.
//! This function is used to find a solution on a done
@@ -49,7 +40,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_SurfPointConstRadInv(const Handle(Adaptor3d_HSurface)& S, const Handle(Adaptor3d_HCurve)& C);
Standard_EXPORT BRepBlend_SurfPointConstRadInv(const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor3d_Curve)& C);
Standard_EXPORT void Set (const Standard_Real R, const Standard_Integer Choix);
@@ -105,8 +96,8 @@ private:
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_Curve) curv;
gp_Pnt point;
Standard_Real ray;
Standard_Integer choix;

8
src/BRepBlend/BRepBlend_SurfPointEvolRadInv.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 <BRepBlend_SurfPointEvolRadInv.hxx>
#include <gp_Pnt.hxx>
#include <Law_Function.hxx>
@@ -27,8 +27,8 @@
//purpose :
//=======================================================================
BRepBlend_SurfPointEvolRadInv::BRepBlend_SurfPointEvolRadInv
(const Handle(Adaptor3d_HSurface)& S,
const Handle(Adaptor3d_HCurve)& C,
(const Handle(Adaptor3d_Surface)& S,
const Handle(Adaptor3d_Curve)& C,
const Handle(Law_Function)& Evol
) : surf(S), curv(C)
{ tevol=Evol;

18
src/BRepBlend/BRepBlend_SurfPointEvolRadInv.hxx
View File

@@ -17,21 +17,13 @@
#ifndef _BRepBlend_SurfPointEvolRadInv_HeaderFile
#define _BRepBlend_SurfPointEvolRadInv_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Blend_SurfPointFuncInv.hxx>
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
class Adaptor3d_HSurface;
class Adaptor3d_HCurve;
class Law_Function;
class math_Matrix;
class gp_Pnt;
//! Function of reframing between a point and a surface.
@@ -50,7 +42,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_SurfPointEvolRadInv(const Handle(Adaptor3d_HSurface)& S, const Handle(Adaptor3d_HCurve)& C, const Handle(Law_Function)& Evol);
Standard_EXPORT BRepBlend_SurfPointEvolRadInv(const Handle(Adaptor3d_Surface)& S, const Handle(Adaptor3d_Curve)& C, const Handle(Law_Function)& Evol);
Standard_EXPORT void Set (const Standard_Integer Choix);
@@ -106,8 +98,8 @@ private:
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_HCurve) curv;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_Curve) curv;
gp_Pnt point;
Standard_Real ray;
Standard_Integer choix;

18
src/BRepBlend/BRepBlend_SurfRstConstRad.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 <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BRepBlend_SurfRstConstRad.hxx>
@@ -60,10 +60,10 @@ static void t3dto2d(Standard_Real& a,
//=======================================================================
BRepBlend_SurfRstConstRad::BRepBlend_SurfRstConstRad
(const Handle(Adaptor3d_HSurface)& Surf,
const Handle(Adaptor3d_HSurface)& SurfRst,
const Handle(Adaptor2d_HCurve2d)& Rst,
const Handle(Adaptor3d_HCurve)& CGuide):
(const Handle(Adaptor3d_Surface)& Surf,
const Handle(Adaptor3d_Surface)& SurfRst,
const Handle(Adaptor2d_Curve2d)& Rst,
const Handle(Adaptor3d_Curve)& CGuide):
surf(Surf), surfrst(SurfRst), rst(Rst), cons(Rst,SurfRst),
guide(CGuide), tguide(CGuide),
prmrst(0.0), istangent(Standard_True),
@@ -259,8 +259,8 @@ Standard_Boolean BRepBlend_SurfRstConstRad::Values(const math_Vector& X,
//purpose :
//=======================================================================
void BRepBlend_SurfRstConstRad::Set(const Handle(Adaptor3d_HSurface)& SurfRef,
const Handle(Adaptor2d_HCurve2d)& RstRef)
void BRepBlend_SurfRstConstRad::Set(const Handle(Adaptor3d_Surface)& SurfRef,
const Handle(Adaptor2d_Curve2d)& RstRef)
{
surfref = SurfRef;
rstref = RstRef;

34
src/BRepBlend/BRepBlend_SurfRstConstRad.hxx
View File

@@ -17,18 +17,12 @@
#ifndef _BRepBlend_SurfRstConstRad_HeaderFile
#define _BRepBlend_SurfRstConstRad_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_CurveOnSurface.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_SurfRstFunction.hxx>
@@ -40,14 +34,8 @@
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor2d_HCurve2d;
class Adaptor3d_HCurve;
class math_Matrix;
class gp_Pnt;
class gp_Pnt2d;
class gp_Vec;
class gp_Vec2d;
class gp_Circ;
class Blend_Point;
@@ -61,7 +49,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_SurfRstConstRad(const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_HSurface)& SurfRst, const Handle(Adaptor2d_HCurve2d)& Rst, const Handle(Adaptor3d_HCurve)& CGuide);
Standard_EXPORT BRepBlend_SurfRstConstRad(const Handle(Adaptor3d_Surface)& Surf, const Handle(Adaptor3d_Surface)& SurfRst, const Handle(Adaptor2d_Curve2d)& Rst, const Handle(Adaptor3d_Curve)& CGuide);
//! Returns 3.
Standard_EXPORT Standard_Integer NbVariables() const Standard_OVERRIDE;
@@ -87,7 +75,7 @@ public:
//! False otherwise.
Standard_EXPORT Standard_Boolean Values (const math_Vector& X, math_Vector& F, math_Matrix& D) Standard_OVERRIDE;
Standard_EXPORT void Set (const Handle(Adaptor3d_HSurface)& SurfRef, const Handle(Adaptor2d_HCurve2d)& RstRef);
Standard_EXPORT void Set (const Handle(Adaptor3d_Surface)& SurfRef, const Handle(Adaptor2d_Curve2d)& RstRef);
Standard_EXPORT void Set (const Standard_Real Param) Standard_OVERRIDE;
@@ -203,12 +191,12 @@ private:
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_HSurface) surfrst;
Handle(Adaptor2d_HCurve2d) rst;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_Surface) surfrst;
Handle(Adaptor2d_Curve2d) rst;
Adaptor3d_CurveOnSurface cons;
Handle(Adaptor3d_HCurve) guide;
Handle(Adaptor3d_HCurve) tguide;
Handle(Adaptor3d_Curve) guide;
Handle(Adaptor3d_Curve) tguide;
gp_Pnt pts;
gp_Pnt ptrst;
gp_Pnt2d pt2ds;
@@ -227,8 +215,8 @@ private:
gp_Vec nplan;
Standard_Real normtg;
Standard_Real theD;
Handle(Adaptor3d_HSurface) surfref;
Handle(Adaptor2d_HCurve2d) rstref;
Handle(Adaptor3d_Surface) surfref;
Handle(Adaptor2d_Curve2d) rstref;
Standard_Real maxang;
Standard_Real minang;
Standard_Real distmin;

18
src/BRepBlend/BRepBlend_SurfRstEvolRad.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 <Blend_Point.hxx>
#include <BlendFunc.hxx>
#include <BRepBlend_SurfRstEvolRad.hxx>
@@ -115,10 +115,10 @@ static void FusionneIntervalles(const TColStd_Array1OfReal& I1,
//purpose : Contructor
//=======================================================================
BRepBlend_SurfRstEvolRad::BRepBlend_SurfRstEvolRad
(const Handle(Adaptor3d_HSurface)& Surf,
const Handle(Adaptor3d_HSurface)& SurfRst,
const Handle(Adaptor2d_HCurve2d)& Rst,
const Handle(Adaptor3d_HCurve)& CGuide,
(const Handle(Adaptor3d_Surface)& Surf,
const Handle(Adaptor3d_Surface)& SurfRst,
const Handle(Adaptor2d_Curve2d)& Rst,
const Handle(Adaptor3d_Curve)& CGuide,
const Handle(Law_Function)& Evol):
surf(Surf), surfrst(SurfRst),
rst(Rst), cons(Rst,SurfRst),
@@ -309,8 +309,8 @@ Standard_Boolean BRepBlend_SurfRstEvolRad::Values
//purpose :
//=======================================================================
void BRepBlend_SurfRstEvolRad::Set
(const Handle(Adaptor3d_HSurface)& SurfRef,
const Handle(Adaptor2d_HCurve2d)& RstRef)
(const Handle(Adaptor3d_Surface)& SurfRef,
const Handle(Adaptor2d_Curve2d)& RstRef)
{
surfref = SurfRef;
rstref = RstRef;

34
src/BRepBlend/BRepBlend_SurfRstEvolRad.hxx
View File

@@ -17,18 +17,12 @@
#ifndef _BRepBlend_SurfRstEvolRad_HeaderFile
#define _BRepBlend_SurfRstEvolRad_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_CurveOnSurface.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_SurfRstFunction.hxx>
@@ -40,15 +34,9 @@
#include <TColgp_Array1OfVec.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColgp_Array1OfVec2d.hxx>
class Adaptor3d_HSurface;
class Adaptor2d_HCurve2d;
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;
@@ -62,7 +50,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_SurfRstEvolRad(const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_HSurface)& SurfRst, const Handle(Adaptor2d_HCurve2d)& Rst, const Handle(Adaptor3d_HCurve)& CGuide, const Handle(Law_Function)& Evol);
Standard_EXPORT BRepBlend_SurfRstEvolRad(const Handle(Adaptor3d_Surface)& Surf, const Handle(Adaptor3d_Surface)& SurfRst, const Handle(Adaptor2d_Curve2d)& Rst, const Handle(Adaptor3d_Curve)& CGuide, const Handle(Law_Function)& Evol);
//! Returns 3.
Standard_EXPORT Standard_Integer NbVariables() const Standard_OVERRIDE;
@@ -88,7 +76,7 @@ public:
//! False otherwise.
Standard_EXPORT Standard_Boolean Values (const math_Vector& X, math_Vector& F, math_Matrix& D) Standard_OVERRIDE;
Standard_EXPORT void Set (const Handle(Adaptor3d_HSurface)& SurfRef, const Handle(Adaptor2d_HCurve2d)& RstRef);
Standard_EXPORT void Set (const Handle(Adaptor3d_Surface)& SurfRef, const Handle(Adaptor2d_Curve2d)& RstRef);
Standard_EXPORT void Set (const Standard_Real Param) Standard_OVERRIDE;
@@ -202,12 +190,12 @@ private:
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_HSurface) surfrst;
Handle(Adaptor2d_HCurve2d) rst;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_Surface) surfrst;
Handle(Adaptor2d_Curve2d) rst;
Adaptor3d_CurveOnSurface cons;
Handle(Adaptor3d_HCurve) guide;
Handle(Adaptor3d_HCurve) tguide;
Handle(Adaptor3d_Curve) guide;
Handle(Adaptor3d_Curve) tguide;
gp_Pnt pts;
gp_Pnt ptrst;
gp_Pnt2d pt2ds;
@@ -227,8 +215,8 @@ private:
gp_Vec nplan;
Standard_Real normtg;
Standard_Real theD;
Handle(Adaptor3d_HSurface) surfref;
Handle(Adaptor2d_HCurve2d) rstref;
Handle(Adaptor3d_Surface) surfref;
Handle(Adaptor2d_Curve2d) rstref;
Standard_Real maxang;
Standard_Real minang;
Standard_Real distmin;

22
src/BRepBlend/BRepBlend_SurfRstLineBuilder.cxx
View File

@@ -15,8 +15,8 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <Blend_FuncInv.hxx>
@@ -207,10 +207,10 @@ Standard_Integer BRepBlend_SurfRstLineBuilder::
//=======================================================================
BRepBlend_SurfRstLineBuilder::BRepBlend_SurfRstLineBuilder
(const Handle(Adaptor3d_HSurface)& Surf1,
(const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_TopolTool)& Domain1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor2d_HCurve2d)& Rst,
const Handle(Adaptor3d_Surface)& Surf2,
const Handle(Adaptor2d_Curve2d)& Rst,
const Handle(Adaptor3d_TopolTool)& Domain2):
done(Standard_False), sol(1, 3), surf1(Surf1),
domain1(Domain1), surf2(Surf2), rst(Rst),
@@ -362,7 +362,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::PerformFirstSection
math_Vector solinvp(1,3),solinvrst(1,4),solinvs(1,3);
Handle(Adaptor3d_HVertex) Vtxp,Vtxrst,Vtxs,Vtxc;
Standard_Boolean IsVtxp = 0,IsVtxrst = 0,IsVtxs = 0;
Handle(Adaptor2d_HCurve2d) Arc;
Handle(Adaptor2d_Curve2d) Arc;
wp = wrst = ws = Pmax;
param = Pdep;
Func.Set(param);
@@ -536,7 +536,7 @@ void BRepBlend_SurfRstLineBuilder::InternalPerform(Blend_SurfRstFunction& Func,
Handle(Adaptor3d_HVertex) Vtxp,Vtxrst,Vtxs,Vtxc;
Standard_Boolean IsVtxp = 0,IsVtxrst = 0,IsVtxs = 0;
BRepBlend_Extremity Extrst,Exts;
Handle(Adaptor2d_HCurve2d) Arc;
Handle(Adaptor2d_Curve2d) Arc;
//IntSurf_Transition Tline,Tarc;
@@ -917,7 +917,7 @@ void BRepBlend_SurfRstLineBuilder::InternalPerform(Blend_SurfRstFunction& Func,
Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfCurvFuncInv& FinvC,
math_Vector& Solinv,
Handle(Adaptor2d_HCurve2d)& Arc,
Handle(Adaptor2d_Curve2d)& Arc,
Standard_Boolean& IsVtx,
Handle(Adaptor3d_HVertex)& Vtx)
{
@@ -1180,7 +1180,7 @@ Standard_Boolean BRepBlend_SurfRstLineBuilder::Recadre(Blend_SurfPointFuncInv&
//=======================================================================
void BRepBlend_SurfRstLineBuilder::Transition(const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& Arc,
const Handle(Adaptor2d_Curve2d)& Arc,
const Standard_Real Param,
IntSurf_Transition& TLine,
IntSurf_Transition& TArc)
@@ -1230,7 +1230,7 @@ void BRepBlend_SurfRstLineBuilder::Transition(const Standard_Boolean On
void BRepBlend_SurfRstLineBuilder::MakeExtremity(BRepBlend_Extremity& Extrem,
const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& Arc,
const Handle(Adaptor2d_Curve2d)& Arc,
const Standard_Real Param,
const Standard_Boolean IsVtx,
const Handle(Adaptor3d_HVertex)& Vtx)
@@ -1263,7 +1263,7 @@ void BRepBlend_SurfRstLineBuilder::MakeExtremity(BRepBlend_Extremity&
else {
Extrem.SetVertex(Vtx);
while (Iter->More()) {
Handle(Adaptor2d_HCurve2d) arc = Iter->Value();
Handle(Adaptor2d_Curve2d) arc = Iter->Value();
if (arc != Arc) {
Iter->Initialize(arc);
Iter->InitVertexIterator();

26
src/BRepBlend/BRepBlend_SurfRstLineBuilder.hxx
View File

@@ -17,21 +17,14 @@
#ifndef _BRepBlend_SurfRstLineBuilder_HeaderFile
#define _BRepBlend_SurfRstLineBuilder_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <math_Vector.hxx>
#include <Standard_Real.hxx>
#include <Blend_Point.hxx>
#include <Standard_Integer.hxx>
#include <Blend_Status.hxx>
#include <TopAbs_State.hxx>
class BRepBlend_Line;
class Adaptor3d_HSurface;
class Adaptor3d_TopolTool;
class Adaptor2d_HCurve2d;
class Blend_SurfRstFunction;
class Blend_FuncInv;
class Blend_SurfPointFuncInv;
@@ -42,7 +35,6 @@ class IntSurf_Transition;
class BRepBlend_Extremity;
class Blend_Point;
//! This class processes data resulting from
//! Blend_CSWalking taking in consideration the Surface
//! supporting the curve to detect the breakpoint.
@@ -78,7 +70,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_SurfRstLineBuilder(const Handle(Adaptor3d_HSurface)& Surf1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_HSurface)& Surf2, const Handle(Adaptor2d_HCurve2d)& Rst, const Handle(Adaptor3d_TopolTool)& Domain2);
Standard_EXPORT BRepBlend_SurfRstLineBuilder(const Handle(Adaptor3d_Surface)& Surf1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_Surface)& Surf2, const Handle(Adaptor2d_Curve2d)& Rst, const Handle(Adaptor3d_TopolTool)& Domain2);
Standard_EXPORT void Perform (Blend_SurfRstFunction& Func, Blend_FuncInv& Finv, Blend_SurfPointFuncInv& FinvP, Blend_SurfCurvFuncInv& FinvC, const Standard_Real Pdep, const Standard_Real Pmax, const Standard_Real MaxStep, const Standard_Real TolGuide, const math_Vector& Soldep, const Standard_Real Tolesp, const Standard_Real Fleche, const Standard_Boolean Appro = Standard_False);
@@ -110,15 +102,15 @@ private:
Standard_EXPORT void InternalPerform (Blend_SurfRstFunction& Func, Blend_FuncInv& Finv, Blend_SurfPointFuncInv& FinvP, Blend_SurfCurvFuncInv& FinvC, const Standard_Real Bound);
Standard_EXPORT Standard_Boolean Recadre (Blend_SurfCurvFuncInv& FinvC, math_Vector& Solinv, Handle(Adaptor2d_HCurve2d)& Arc, Standard_Boolean& IsVtx, Handle(Adaptor3d_HVertex)& Vtx);
Standard_EXPORT Standard_Boolean Recadre (Blend_SurfCurvFuncInv& FinvC, math_Vector& Solinv, Handle(Adaptor2d_Curve2d)& Arc, Standard_Boolean& IsVtx, Handle(Adaptor3d_HVertex)& Vtx);
Standard_EXPORT Standard_Boolean Recadre (Blend_SurfRstFunction& Func, Blend_FuncInv& Finv, math_Vector& Solinv, Standard_Boolean& IsVtx, Handle(Adaptor3d_HVertex)& Vtx);
Standard_EXPORT Standard_Boolean Recadre (Blend_SurfPointFuncInv& FinvP, math_Vector& Solinv, Standard_Boolean& IsVtx, Handle(Adaptor3d_HVertex)& Vtx);
Standard_EXPORT void Transition (const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& Arc, const Standard_Real Param, IntSurf_Transition& TLine, IntSurf_Transition& TArc);
Standard_EXPORT void Transition (const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& Arc, const Standard_Real Param, IntSurf_Transition& TLine, IntSurf_Transition& TArc);
Standard_EXPORT void MakeExtremity (BRepBlend_Extremity& Extrem, const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& Arc, const Standard_Real Param, const Standard_Boolean IsVtx, const Handle(Adaptor3d_HVertex)& Vtx);
Standard_EXPORT void MakeExtremity (BRepBlend_Extremity& Extrem, const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& Arc, const Standard_Real Param, const Standard_Boolean IsVtx, const Handle(Adaptor3d_HVertex)& Vtx);
Standard_EXPORT Blend_Status CheckDeflectionOnSurf (const Blend_Point& CurPoint);
@@ -132,10 +124,10 @@ private:
Standard_Boolean done;
Handle(BRepBlend_Line) line;
math_Vector sol;
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_TopolTool) domain1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor2d_HCurve2d) rst;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor2d_Curve2d) rst;
Handle(Adaptor3d_TopolTool) domain2;
Standard_Real tolesp;
Standard_Real tolgui;

44
src/BRepBlend/BRepBlend_Walking.hxx
View File

@@ -17,27 +17,19 @@
#ifndef _BRepBlend_Walking_HeaderFile
#define _BRepBlend_Walking_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Blend_Point.hxx>
#include <math_Vector.hxx>
#include <Blend_SequenceOfPoint.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <BRepBlend_SequenceOfPointOnRst.hxx>
#include <TopAbs_State.hxx>
#include <Blend_Status.hxx>
#include <BRepBlend_SequenceOfPointOnRst.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <math_Vector.hxx>
#include <TopAbs_State.hxx>
class BRepBlend_Line;
class Adaptor3d_HSurface;
class Adaptor3d_TopolTool;
class ChFiDS_HElSpine;
class StdFail_NotDone;
class Adaptor3d_HVertex;
class Adaptor2d_HCurve2d;
class Adaptor3d_HCurve;
class BRepBlend_HCurve2dTool;
class Adaptor3d_HSurfaceTool;
class BRepBlend_HCurveTool;
@@ -51,8 +43,6 @@ class gp_Pnt;
class gp_Pnt2d;
class IntSurf_Transition;
class BRepBlend_Walking
{
public:
@@ -60,7 +50,7 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT BRepBlend_Walking(const Handle(Adaptor3d_HSurface)& Surf1, const Handle(Adaptor3d_HSurface)& Surf2, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_TopolTool)& Domain2, const Handle(ChFiDS_HElSpine)& HGuide);
Standard_EXPORT BRepBlend_Walking(const Handle(Adaptor3d_Surface)& Surf1, const Handle(Adaptor3d_Surface)& Surf2, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_TopolTool)& Domain2, const Handle(ChFiDS_ElSpine)& HGuide);
//! To define different domains for control and clipping.
Standard_EXPORT void SetDomainsToRecadre (const Handle(Adaptor3d_TopolTool)& RecDomain1, const Handle(Adaptor3d_TopolTool)& RecDomain2);
@@ -116,7 +106,7 @@ private:
Standard_EXPORT Standard_Boolean Recadre (Blend_FuncInv& FInv, const Standard_Boolean OnFirst, const math_Vector& Sol, math_Vector& Solrst, Standard_Integer& Indexsol, Standard_Boolean& IsVtx, Handle(Adaptor3d_HVertex)& Vtx, const Standard_Real Extrap = 0.0);
Standard_EXPORT void Transition (const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Param, IntSurf_Transition& TLine, IntSurf_Transition& TArc);
Standard_EXPORT void Transition (const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& A, const Standard_Real Param, IntSurf_Transition& TLine, IntSurf_Transition& TArc);
Standard_EXPORT void MakeExtremity (BRepBlend_Extremity& Extrem, const Standard_Boolean OnFirst, const Standard_Integer Index, const Standard_Real Param, const Standard_Boolean IsVtx, const Handle(Adaptor3d_HVertex)& Vtx);
@@ -131,13 +121,13 @@ private:
Handle(BRepBlend_Line) line;
math_Vector sol;
Blend_SequenceOfPoint jalons;
Handle(Adaptor3d_HSurface) surf1;
Handle(Adaptor3d_HSurface) surf2;
Handle(Adaptor3d_Surface) surf1;
Handle(Adaptor3d_Surface) surf2;
Handle(Adaptor3d_TopolTool) domain1;
Handle(Adaptor3d_TopolTool) domain2;
Handle(Adaptor3d_TopolTool) recdomain1;
Handle(Adaptor3d_TopolTool) recdomain2;
Handle(ChFiDS_HElSpine) hguide;
Handle(ChFiDS_ElSpine) hguide;
Standard_Boolean ToCorrectOnRst1;
Standard_Boolean ToCorrectOnRst2;
Standard_Real CorrectedParam;
@@ -163,12 +153,12 @@ private:
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheSurface Handle(Adaptor3d_HSurface)
#define TheSurface_hxx <Adaptor3d_HSurface.hxx>
#define TheCurve Handle(Adaptor3d_HCurve)
#define TheCurve_hxx <Adaptor3d_HCurve.hxx>
#define TheArc Handle(Adaptor2d_Curve2d)
#define TheArc_hxx <Adaptor2d_Curve2d.hxx>
#define TheSurface Handle(Adaptor3d_Surface)
#define TheSurface_hxx <Adaptor3d_Surface.hxx>
#define TheCurve Handle(Adaptor3d_Curve)
#define TheCurve_hxx <Adaptor3d_Curve.hxx>
#define TheVertexTool Standard_Integer
#define TheVertexTool_hxx <Standard_Integer.hxx>
#define TheArcTool BRepBlend_HCurve2dTool

20
src/BRepBlend/BRepBlend_Walking_0.cxx
View File

@@ -17,13 +17,13 @@
#include <BRepBlend_Walking.hxx>
#include <BRepBlend_Line.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <ChFiDS_HElSpine.hxx>
#include <ChFiDS_ElSpine.hxx>
#include <StdFail_NotDone.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HCurve.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <BRepBlend_HCurve2dTool.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <BRepBlend_HCurveTool.hxx>
@@ -40,12 +40,12 @@
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheSurface Handle(Adaptor3d_HSurface)
#define TheSurface_hxx <Adaptor3d_HSurface.hxx>
#define TheCurve Handle(Adaptor3d_HCurve)
#define TheCurve_hxx <Adaptor3d_HCurve.hxx>
#define TheArc Handle(Adaptor2d_Curve2d)
#define TheArc_hxx <Adaptor2d_Curve2d.hxx>
#define TheSurface Handle(Adaptor3d_Surface)
#define TheSurface_hxx <Adaptor3d_Surface.hxx>
#define TheCurve Handle(Adaptor3d_Curve)
#define TheCurve_hxx <Adaptor3d_Curve.hxx>
#define TheVertexTool Standard_Integer
#define TheVertexTool_hxx <Standard_Integer.hxx>
#define TheArcTool BRepBlend_HCurve2dTool