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

10
src/IntPatch/IntPatch_ALineToWLine.cxx
View File

@@ -16,7 +16,7 @@
#include <IntPatch_ALineToWLine.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <ElSLib.hxx>
#include <IntPatch_ALine.hxx>
#include <IntPatch_Point.hxx>
@@ -67,8 +67,8 @@ static void AddVertexPoint(Handle(IntSurf_LineOn2S)& theLine,
// theSingularSurfaceID contains the ID of surface with
// special point (0 - none, 1 - theS1, 2 - theS2)
//=======================================================================
static IntPatch_SpecPntType IsPoleOrSeam(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
static IntPatch_SpecPntType IsPoleOrSeam(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const IntSurf_PntOn2S& thePIsoRef,
Handle(IntSurf_LineOn2S)& theLine,
IntPatch_Point &theVertex,
@@ -138,8 +138,8 @@ static IntPatch_SpecPntType IsPoleOrSeam(const Handle(Adaptor3d_HSurface)& theS1
//function : IntPatch_ALineToWLine
//purpose :
//=======================================================================
IntPatch_ALineToWLine::IntPatch_ALineToWLine(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
IntPatch_ALineToWLine::IntPatch_ALineToWLine(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const Standard_Integer theNbPoints) :
myS1(theS1),
myS2(theS2),

13
src/IntPatch/IntPatch_ALineToWLine.hxx
View File

@@ -17,13 +17,10 @@
#ifndef _IntPatch_ALineToWLine_HeaderFile
#define _IntPatch_ALineToWLine_HeaderFile
#include <Adaptor3d_Surface.hxx>
#include <IntPatch_SequenceOfLine.hxx>
#include <IntSurf_Quadric.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Macro.hxx>
class Adaptor3d_HSurface;
class IntPatch_ALine;
class IntSurf_PntOn2S;
@@ -34,8 +31,8 @@ public:
DEFINE_STANDARD_ALLOC
//! Constructor
Standard_EXPORT IntPatch_ALineToWLine(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
Standard_EXPORT IntPatch_ALineToWLine(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const Standard_Integer theNbPoints = 200);
Standard_EXPORT void SetTolOpenDomain (const Standard_Real aT);
@@ -96,8 +93,8 @@ protected:
private:
Handle(Adaptor3d_HSurface) myS1;
Handle(Adaptor3d_HSurface) myS2;
Handle(Adaptor3d_Surface) myS1;
Handle(Adaptor3d_Surface) myS2;
IntSurf_Quadric myQuad1;
IntSurf_Quadric myQuad2;

4
src/IntPatch/IntPatch_ArcFunction.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 <gp_Pnt.hxx>
#include <IntPatch_ArcFunction.hxx>
#include <IntPatch_HInterTool.hxx>

27
src/IntPatch/IntPatch_ArcFunction.hxx
View File

@@ -17,23 +17,10 @@
#ifndef _IntPatch_ArcFunction_HeaderFile
#define _IntPatch_ArcFunction_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <IntSurf_Quadric.hxx>
#include <gp_Pnt.hxx>
#include <TColgp_SequenceOfPnt.hxx>
#include <math_FunctionWithDerivative.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
class Adaptor2d_HCurve2d;
class Adaptor3d_HSurface;
class IntSurf_Quadric;
class gp_Pnt;
class IntPatch_ArcFunction : public math_FunctionWithDerivative
{
@@ -46,9 +33,9 @@ public:
void SetQuadric (const IntSurf_Quadric& Q);
void Set (const Handle(Adaptor2d_HCurve2d)& A);
void Set (const Handle(Adaptor2d_Curve2d)& A);
void Set (const Handle(Adaptor3d_HSurface)& S);
void Set (const Handle(Adaptor3d_Surface)& S);
Standard_EXPORT Standard_Boolean Value (const Standard_Real X, Standard_Real& F) Standard_OVERRIDE;
@@ -64,9 +51,9 @@ public:
const IntSurf_Quadric& Quadric() const;
const Handle(Adaptor2d_HCurve2d)& Arc() const;
const Handle(Adaptor2d_Curve2d)& Arc() const;
const Handle(Adaptor3d_HSurface)& Surface() const;
const Handle(Adaptor3d_Surface)& Surface() const;
//! Returns the point, which has been computed
//! while the last calling Value() method
@@ -84,8 +71,8 @@ private:
Handle(Adaptor2d_HCurve2d) myArc;
Handle(Adaptor3d_HSurface) mySurf;
Handle(Adaptor2d_Curve2d) myArc;
Handle(Adaptor3d_Surface) mySurf;
IntSurf_Quadric myQuad;
gp_Pnt ptsol;
TColgp_SequenceOfPnt seqpt;

8
src/IntPatch/IntPatch_ArcFunction.lxx
View File

@@ -19,13 +19,13 @@ inline const gp_Pnt& IntPatch_ArcFunction::Valpoint (const Standard_Integer Inde
return seqpt(Index);
}
inline void IntPatch_ArcFunction::Set(const Handle(Adaptor2d_HCurve2d)& A)
inline void IntPatch_ArcFunction::Set(const Handle(Adaptor2d_Curve2d)& A)
{
myArc = A;
seqpt.Clear();
}
inline void IntPatch_ArcFunction::Set(const Handle(Adaptor3d_HSurface)& S)
inline void IntPatch_ArcFunction::Set(const Handle(Adaptor3d_Surface)& S)
{
mySurf = S;
seqpt.Clear();
@@ -42,12 +42,12 @@ inline const IntSurf_Quadric& IntPatch_ArcFunction::Quadric() const
return(myQuad);
}
inline const Handle(Adaptor2d_HCurve2d)& IntPatch_ArcFunction::Arc() const
inline const Handle(Adaptor2d_Curve2d)& IntPatch_ArcFunction::Arc() const
{
return(myArc);
}
inline const Handle(Adaptor3d_HSurface)& IntPatch_ArcFunction::Surface() const
inline const Handle(Adaptor3d_Surface)& IntPatch_ArcFunction::Surface() const
{
return(mySurf);
}

20
src/IntPatch/IntPatch_CSFunction.cxx
View File

@@ -13,8 +13,8 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
@@ -30,13 +30,13 @@
#endif
#define SURFACE1 (*((Handle(Adaptor3d_HSurface) *)(surface1)))
#define SURFACE2 (*((Handle(Adaptor3d_HSurface) *)(surface2)))
#define CURVE (*((Handle(Adaptor2d_HCurve2d) *)(curve)))
#define SURFACE1 (*((Handle(Adaptor3d_Surface) *)(surface1)))
#define SURFACE2 (*((Handle(Adaptor3d_Surface) *)(surface2)))
#define CURVE (*((Handle(Adaptor2d_Curve2d) *)(curve)))
IntPatch_CSFunction::IntPatch_CSFunction(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor2d_HCurve2d)& C,
const Handle(Adaptor3d_HSurface)& S2)
IntPatch_CSFunction::IntPatch_CSFunction(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor2d_Curve2d)& C,
const Handle(Adaptor3d_Surface)& S2)
{
surface1 = (Standard_Address)(&S1);
surface2 = (Standard_Address)(&S2);
@@ -124,10 +124,10 @@ const gp_Pnt& IntPatch_CSFunction::Point() const { return p;}
Standard_Real IntPatch_CSFunction::Root() const { return f;}
const Handle(Adaptor3d_HSurface)& IntPatch_CSFunction::AuxillarSurface() const {
const Handle(Adaptor3d_Surface)& IntPatch_CSFunction::AuxillarSurface() const {
return SURFACE1;}
const Handle(Adaptor2d_HCurve2d)& IntPatch_CSFunction::AuxillarCurve() const {
const Handle(Adaptor2d_Curve2d)& IntPatch_CSFunction::AuxillarCurve() const {
return CURVE;}
#undef SURFACE1

22
src/IntPatch/IntPatch_CSFunction.hxx
View File

@@ -17,22 +17,12 @@
#ifndef _IntPatch_CSFunction_HeaderFile
#define _IntPatch_CSFunction_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Real.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <math_FunctionSetWithDerivatives.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Boolean.hxx>
#include <math_Vector.hxx>
class Adaptor3d_HSurface;
class Adaptor2d_HCurve2d;
class math_Matrix;
class gp_Pnt;
class math_Matrix;
//! this function is associated to the intersection between
//! a curve on surface and a surface .
@@ -45,7 +35,7 @@ public:
//! S1 is the surface on which the intersection is searched.
//! C is a curve on the surface S2.
Standard_EXPORT IntPatch_CSFunction(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor2d_HCurve2d)& C, const Handle(Adaptor3d_HSurface)& S2);
Standard_EXPORT IntPatch_CSFunction(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor2d_Curve2d)& C, const Handle(Adaptor3d_Surface)& S2);
Standard_EXPORT Standard_Integer NbVariables() const;
@@ -61,9 +51,9 @@ public:
Standard_EXPORT Standard_Real Root() const;
Standard_EXPORT const Handle(Adaptor3d_HSurface)& AuxillarSurface() const;
Standard_EXPORT const Handle(Adaptor3d_Surface)& AuxillarSurface() const;
Standard_EXPORT const Handle(Adaptor2d_HCurve2d)& AuxillarCurve() const;
Standard_EXPORT const Handle(Adaptor2d_Curve2d)& AuxillarCurve() const;

16
src/IntPatch/IntPatch_CurvIntSurf.hxx
View File

@@ -17,24 +17,12 @@
#ifndef _IntPatch_CurvIntSurf_HeaderFile
#define _IntPatch_CurvIntSurf_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <IntPatch_CSFunction.hxx>
#include <Standard_Real.hxx>
class StdFail_NotDone;
class Standard_DomainError;
class Adaptor3d_HSurface;
class Adaptor3d_HSurfaceTool;
class Adaptor2d_HCurve2d;
class IntPatch_HCurve2dTool;
class IntPatch_CSFunction;
class math_FunctionSetRoot;
class gp_Pnt;
class IntPatch_CurvIntSurf
{

12
src/IntPatch/IntPatch_CurvIntSurf_0.cxx
View File

@@ -18,21 +18,21 @@
#include <StdFail_NotDone.hxx>
#include <Standard_DomainError.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <IntPatch_HCurve2dTool.hxx>
#include <IntPatch_CSFunction.hxx>
#include <math_FunctionSetRoot.hxx>
#include <gp_Pnt.hxx>
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurface Handle(Adaptor3d_Surface)
#define ThePSurface_hxx <Adaptor3d_Surface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define TheCurve Handle(Adaptor2d_HCurve2d)
#define TheCurve_hxx <Adaptor2d_HCurve2d.hxx>
#define TheCurve Handle(Adaptor2d_Curve2d)
#define TheCurve_hxx <Adaptor2d_Curve2d.hxx>
#define TheCurveTool IntPatch_HCurve2dTool
#define TheCurveTool_hxx <IntPatch_HCurve2dTool.hxx>
#define TheFunction IntPatch_CSFunction

4
src/IntPatch/IntPatch_HCurve2dTool.cxx
View File

@@ -15,7 +15,7 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.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 IntPatch_HCurve2dTool::NbSamples (const Handle(Adaptor2d_HCurve2d)& C,
Standard_Integer IntPatch_HCurve2dTool::NbSamples (const Handle(Adaptor2d_Curve2d)& C,
const Standard_Real U0,
const Standard_Real U1)
{

49
src/IntPatch/IntPatch_HCurve2dTool.hxx
View File

@@ -37,7 +37,6 @@
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_DomainError;
class Adaptor2d_HCurve2d;
class gp_Pnt2d;
class gp_Vec2d;
class Geom2d_BezierCurve;
@@ -52,54 +51,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 +106,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);

48
src/IntPatch/IntPatch_HCurve2dTool.lxx
View File

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

42
src/IntPatch/IntPatch_HInterTool.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 <Extrema_EPCOfExtPC2d.hxx>
#include <Extrema_POnCurv2d.hxx>
@@ -35,7 +35,7 @@ IntPatch_HInterTool::IntPatch_HInterTool() :
{
}
Standard_Integer IntPatch_HInterTool::NbSamplesV (const Handle(Adaptor3d_HSurface)& S,
Standard_Integer IntPatch_HInterTool::NbSamplesV (const Handle(Adaptor3d_Surface)& S,
const Standard_Real, const Standard_Real)
{
switch (S->GetType())
@@ -64,7 +64,7 @@ Standard_Integer IntPatch_HInterTool::NbSamplesV (const Handle(Adaptor3d_HSurfac
return 10;
}
Standard_Integer IntPatch_HInterTool::NbSamplesU (const Handle(Adaptor3d_HSurface)& S,
Standard_Integer IntPatch_HInterTool::NbSamplesU (const Handle(Adaptor3d_Surface)& S,
const Standard_Real, const Standard_Real)
{
switch (S->GetType())
@@ -92,7 +92,7 @@ Standard_Integer IntPatch_HInterTool::NbSamplesU (const Handle(Adaptor3d_HSurfac
return 10;
}
Standard_Integer IntPatch_HInterTool::NbSamplePoints (const Handle(Adaptor3d_HSurface)& S)
Standard_Integer IntPatch_HInterTool::NbSamplePoints (const Handle(Adaptor3d_Surface)& S)
{
uinf = S->FirstUParameter();
usup = S->LastUParameter();
@@ -134,7 +134,7 @@ Standard_Integer IntPatch_HInterTool::NbSamplePoints (const Handle(Adaptor3d_HSu
return(m);
}
void IntPatch_HInterTool::SamplePoint (const Handle(Adaptor3d_HSurface)& S,
void IntPatch_HInterTool::SamplePoint (const Handle(Adaptor3d_Surface)& S,
const Standard_Integer Index,
Standard_Real& U,
Standard_Real& V ) const
@@ -192,7 +192,7 @@ void IntPatch_HInterTool::SamplePoint (const Handle(Adaptor3d_HSurface)& S,
}
Standard_Integer IntPatch_HInterTool::NbSamplesOnArc (const Handle(Adaptor2d_HCurve2d)& A)
Standard_Integer IntPatch_HInterTool::NbSamplesOnArc (const Handle(Adaptor2d_Curve2d)& A)
{
GeomAbs_CurveType CurveType = A->GetType();
@@ -222,7 +222,7 @@ Standard_Integer IntPatch_HInterTool::NbSamplesOnArc (const Handle(Adaptor2d_HCu
return(nbsOnC);
}
void IntPatch_HInterTool::Bounds(const Handle(Adaptor2d_HCurve2d)& A,
void IntPatch_HInterTool::Bounds(const Handle(Adaptor2d_Curve2d)& A,
Standard_Real& Ufirst,
Standard_Real& Ulast)
{
@@ -230,7 +230,7 @@ void IntPatch_HInterTool::Bounds(const Handle(Adaptor2d_HCurve2d)& A,
Ulast = A->LastParameter();
}
Standard_Boolean IntPatch_HInterTool::Project (const Handle(Adaptor2d_HCurve2d)& C,
Standard_Boolean IntPatch_HInterTool::Project (const Handle(Adaptor2d_Curve2d)& C,
const gp_Pnt2d& P,
Standard_Real& Paramproj,
gp_Pnt2d& Ptproj)
@@ -240,7 +240,7 @@ Standard_Boolean IntPatch_HInterTool::Project (const Handle(Adaptor2d_HCurve2d)&
Standard_Real Tol = 1.e-5;
Standard_Real Dist2;
Extrema_EPCOfExtPC2d extrema(P,C->Curve2d(),Nbu,epsX,Tol);
Extrema_EPCOfExtPC2d extrema(P,*C,Nbu,epsX,Tol);
if (!extrema.IsDone()) {
return Standard_False;
}
@@ -262,28 +262,28 @@ Standard_Boolean IntPatch_HInterTool::Project (const Handle(Adaptor2d_HCurve2d)&
}
Standard_Real IntPatch_HInterTool::Tolerance (const Handle(Adaptor3d_HVertex)& V,
const Handle(Adaptor2d_HCurve2d)& C)
const Handle(Adaptor2d_Curve2d)& C)
{
return V->Resolution(C);
}
Standard_Real IntPatch_HInterTool::Parameter (const Handle(Adaptor3d_HVertex)& V,
const Handle(Adaptor2d_HCurve2d)& C)
const Handle(Adaptor2d_Curve2d)& C)
{
return V->Parameter(C);
}
Standard_Boolean IntPatch_HInterTool::HasBeenSeen(const Handle(Adaptor2d_HCurve2d)&)
Standard_Boolean IntPatch_HInterTool::HasBeenSeen(const Handle(Adaptor2d_Curve2d)&)
{
return Standard_False;
}
Standard_Integer IntPatch_HInterTool::NbPoints(const Handle(Adaptor2d_HCurve2d)&)
Standard_Integer IntPatch_HInterTool::NbPoints(const Handle(Adaptor2d_Curve2d)&)
{
return 0;
}
void IntPatch_HInterTool::Value(const Handle(Adaptor2d_HCurve2d)&,
void IntPatch_HInterTool::Value(const Handle(Adaptor2d_Curve2d)&,
const Standard_Integer,
gp_Pnt&,
Standard_Real&,
@@ -292,39 +292,39 @@ void IntPatch_HInterTool::Value(const Handle(Adaptor2d_HCurve2d)&,
throw Standard_OutOfRange();
}
Standard_Boolean IntPatch_HInterTool::IsVertex(const Handle(Adaptor2d_HCurve2d)&,
Standard_Boolean IntPatch_HInterTool::IsVertex(const Handle(Adaptor2d_Curve2d)&,
const Standard_Integer)
{
return Standard_False;
}
void IntPatch_HInterTool::Vertex(const Handle(Adaptor2d_HCurve2d)&,
void IntPatch_HInterTool::Vertex(const Handle(Adaptor2d_Curve2d)&,
const Standard_Integer,
Handle(Adaptor3d_HVertex)&)
{
throw Standard_OutOfRange();
}
Standard_Integer IntPatch_HInterTool::NbSegments(const Handle(Adaptor2d_HCurve2d)&)
Standard_Integer IntPatch_HInterTool::NbSegments(const Handle(Adaptor2d_Curve2d)&)
{
return 0;
}
Standard_Boolean IntPatch_HInterTool::HasFirstPoint (const Handle(Adaptor2d_HCurve2d)&,
Standard_Boolean IntPatch_HInterTool::HasFirstPoint (const Handle(Adaptor2d_Curve2d)&,
const Standard_Integer,
Standard_Integer&)
{
throw Standard_OutOfRange();
}
Standard_Boolean IntPatch_HInterTool::HasLastPoint (const Handle(Adaptor2d_HCurve2d)&,
Standard_Boolean IntPatch_HInterTool::HasLastPoint (const Handle(Adaptor2d_Curve2d)&,
const Standard_Integer,
Standard_Integer&)
{
throw Standard_OutOfRange();
}
Standard_Boolean IntPatch_HInterTool::IsAllSolution (const Handle(Adaptor2d_HCurve2d)&)
Standard_Boolean IntPatch_HInterTool::IsAllSolution (const Handle(Adaptor2d_Curve2d)&)
{
return Standard_False;
}

55
src/IntPatch/IntPatch_HInterTool.hxx
View File

@@ -17,20 +17,13 @@
#ifndef _IntPatch_HInterTool_HeaderFile
#define _IntPatch_HInterTool_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Adaptor3d_HSurface;
class Adaptor2d_HCurve2d;
class gp_Pnt2d;
class Adaptor3d_HVertex;
class gp_Pnt;
//! Tool for the intersection between 2 surfaces.
//! Regroupe pour l instant les methodes hors Adaptor3d...
class IntPatch_HInterTool
@@ -42,39 +35,39 @@ public:
Standard_EXPORT IntPatch_HInterTool();
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);
Standard_EXPORT Standard_Integer NbSamplePoints (const Handle(Adaptor3d_HSurface)& S);
Standard_EXPORT Standard_Integer NbSamplePoints (const Handle(Adaptor3d_Surface)& S);
Standard_EXPORT void SamplePoint (const Handle(Adaptor3d_HSurface)& S, const Standard_Integer Index, Standard_Real& U, Standard_Real& V) const;
Standard_EXPORT void SamplePoint (const Handle(Adaptor3d_Surface)& S, const Standard_Integer Index, Standard_Real& U, Standard_Real& V) const;
//! Returns True if all the intersection point and edges
//! are known on the Arc.
//! The intersection point are given as vertices.
//! The intersection edges are given as intervals between
//! two vertices.
Standard_EXPORT static Standard_Boolean HasBeenSeen (const Handle(Adaptor2d_HCurve2d)& C);
Standard_EXPORT static Standard_Boolean HasBeenSeen (const Handle(Adaptor2d_Curve2d)& C);
//! returns the number of points which is used to make
//! a sample on the arc. this number is a function of
//! the Surface and the CurveOnSurface complexity.
Standard_EXPORT static Standard_Integer NbSamplesOnArc (const Handle(Adaptor2d_HCurve2d)& A);
Standard_EXPORT static Standard_Integer NbSamplesOnArc (const Handle(Adaptor2d_Curve2d)& A);
//! 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);
//! Projects the point P on the arc C.
//! If the methods returns Standard_True, the projection is
@@ -82,36 +75,36 @@ public:
//! of the projected point, Ptproj is the projected Point.
//! If the method returns Standard_False, Param proj and Ptproj
//! are not significant.
Standard_EXPORT static Standard_Boolean Project (const Handle(Adaptor2d_HCurve2d)& C, const gp_Pnt2d& P, Standard_Real& Paramproj, gp_Pnt2d& Ptproj);
Standard_EXPORT static Standard_Boolean Project (const Handle(Adaptor2d_Curve2d)& C, const gp_Pnt2d& P, Standard_Real& Paramproj, gp_Pnt2d& Ptproj);
//! Returns the parametric tolerance used to consider
//! that the vertex and another point meet, i-e
//! if Abs(parameter(Vertex) - parameter(OtherPnt))<=
//! Tolerance, the points are "merged".
Standard_EXPORT static Standard_Real Tolerance (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_HCurve2d)& C);
Standard_EXPORT static Standard_Real Tolerance (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_Curve2d)& C);
//! Returns the parameter of the vertex V on the arc A.
Standard_EXPORT static Standard_Real Parameter (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_HCurve2d)& C);
Standard_EXPORT static Standard_Real Parameter (const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_Curve2d)& C);
//! Returns the number of intersection points on the arc A.
Standard_EXPORT static Standard_Integer NbPoints (const Handle(Adaptor2d_HCurve2d)& C);
Standard_EXPORT static Standard_Integer NbPoints (const Handle(Adaptor2d_Curve2d)& C);
//! Returns the value (Pt), the tolerance (Tol), and
//! the parameter (U) on the arc A , of the intersection
//! point of range Index.
Standard_EXPORT static void Value (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Integer Index, gp_Pnt& Pt, Standard_Real& Tol, Standard_Real& U);
Standard_EXPORT static void Value (const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer Index, gp_Pnt& Pt, Standard_Real& Tol, Standard_Real& U);
//! Returns True if the intersection point of range Index
//! corresponds with a vertex on the arc A.
Standard_EXPORT static Standard_Boolean IsVertex (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Integer Index);
Standard_EXPORT static Standard_Boolean IsVertex (const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer Index);
//! When IsVertex returns True, this method returns the
//! vertex on the arc A.
Standard_EXPORT static void Vertex (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Integer Index, Handle(Adaptor3d_HVertex)& V);
Standard_EXPORT static void Vertex (const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer Index, Handle(Adaptor3d_HVertex)& V);
//! returns the number of part of A solution of the
//! of intersection problem.
Standard_EXPORT static Standard_Integer NbSegments (const Handle(Adaptor2d_HCurve2d)& C);
Standard_EXPORT static Standard_Integer NbSegments (const Handle(Adaptor2d_Curve2d)& C);
//! Returns True when the segment of range Index is not
//! open at the left side. In that case, IndFirst is the
@@ -119,7 +112,7 @@ public:
//! of the one which defines the left bound of the segment.
//! Otherwise, the method has to return False, and IndFirst
//! has no meaning.
Standard_EXPORT static Standard_Boolean HasFirstPoint (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Integer Index, Standard_Integer& IndFirst);
Standard_EXPORT static Standard_Boolean HasFirstPoint (const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer Index, Standard_Integer& IndFirst);
//! Returns True when the segment of range Index is not
//! open at the right side. In that case, IndLast is the
@@ -127,11 +120,11 @@ public:
//! of the one which defines the right bound of the segment.
//! Otherwise, the method has to return False, and IndLast
//! has no meaning.
Standard_EXPORT static Standard_Boolean HasLastPoint (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Integer Index, Standard_Integer& IndLast);
Standard_EXPORT static Standard_Boolean HasLastPoint (const Handle(Adaptor2d_Curve2d)& C, const Standard_Integer Index, Standard_Integer& IndLast);
//! Returns True when the whole restriction is solution
//! of the intersection problem.
Standard_EXPORT static Standard_Boolean IsAllSolution (const Handle(Adaptor2d_HCurve2d)& C);
Standard_EXPORT static Standard_Boolean IsAllSolution (const Handle(Adaptor2d_Curve2d)& C);

8
src/IntPatch/IntPatch_HInterTool.lxx
View File

@@ -14,22 +14,22 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
inline Standard_Boolean IntPatch_HInterTool::SingularOnUMin (const Handle(Adaptor3d_HSurface)& )
inline Standard_Boolean IntPatch_HInterTool::SingularOnUMin (const Handle(Adaptor3d_Surface)& )
{
return Standard_False;
}
inline Standard_Boolean IntPatch_HInterTool::SingularOnUMax (const Handle(Adaptor3d_HSurface)& )
inline Standard_Boolean IntPatch_HInterTool::SingularOnUMax (const Handle(Adaptor3d_Surface)& )
{
return Standard_False;
}
inline Standard_Boolean IntPatch_HInterTool::SingularOnVMin (const Handle(Adaptor3d_HSurface)& )
inline Standard_Boolean IntPatch_HInterTool::SingularOnVMin (const Handle(Adaptor3d_Surface)& )
{
return Standard_False;
}
inline Standard_Boolean IntPatch_HInterTool::SingularOnVMax (const Handle(Adaptor3d_HSurface)& )
inline Standard_Boolean IntPatch_HInterTool::SingularOnVMax (const Handle(Adaptor3d_Surface)& )
{
return Standard_False;
}

4
src/IntPatch/IntPatch_ImpImpIntersection.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 <ElCLib.hxx>

23
src/IntPatch/IntPatch_ImpImpIntersection.hxx
View File

@@ -17,25 +17,12 @@
#ifndef _IntPatch_ImpImpIntersection_HeaderFile
#define _IntPatch_ImpImpIntersection_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <IntPatch_SequenceOfPoint.hxx>
#include <IntPatch_SequenceOfLine.hxx>
#include <IntPatch_TheSOnBounds.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
class StdFail_NotDone;
class Standard_OutOfRange;
class Standard_DomainError;
class Standard_ConstructionError;
class Adaptor3d_HSurface;
class Adaptor3d_TopolTool;
class IntPatch_Point;
class IntPatch_Line;
class Adaptor3d_TopolTool;
//! Implementation of the intersection between two
//! quadric patches : Plane, Cone, Cylinder or Sphere.
@@ -69,7 +56,7 @@ public:
//! When intersection result returns IntPatch_RLine and another
//! IntPatch_Line (not restriction) we (in case of theIsReqToKeepRLine==TRUE)
//! will always keep both lines even if they are coincided.
Standard_EXPORT IntPatch_ImpImpIntersection(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, const Standard_Boolean theIsReqToKeepRLine = Standard_False);
Standard_EXPORT IntPatch_ImpImpIntersection(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, const Standard_Boolean theIsReqToKeepRLine = Standard_False);
//! Flag theIsReqToKeepRLine has been entered only for
//! compatibility with TopOpeBRep package. It shall be deleted
@@ -77,9 +64,9 @@ public:
//! When intersection result returns IntPatch_RLine and another
//! IntPatch_Line (not restriction) we (in case of theIsReqToKeepRLine==TRUE)
//! will always keep both lines even if they are coincided.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& S1,
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang,

48
src/IntPatch/IntPatch_ImpImpIntersection_0.gxx
View File

@@ -31,8 +31,8 @@
#include <IntPatch_ALine.hxx>
static void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
static void PutPointsOnLine(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const IntPatch_SequenceOfPathPointOfTheSOnBounds&,
const IntPatch_SequenceOfLine&,
const Standard_Boolean,
@@ -77,7 +77,7 @@ static Standard_Boolean FindLine(gp_Pnt& Psurf,
gp_Vec& Vtgtint,
Standard_Integer& theLineIdx,
Standard_Integer OnlyThisLine,
const Handle(Adaptor2d_HCurve2d)& thearc,
const Handle(Adaptor2d_Curve2d)& thearc,
Standard_Real& theparameteronarc,
gp_Pnt& thepointonarc,
const IntSurf_Quadric& QuadSurf1,
@@ -101,7 +101,7 @@ static void ProcessRLine (IntPatch_SequenceOfLine&,
Standard_Boolean IntersectionWithAnArc(gp_Pnt& PSurf,
const Handle(IntPatch_ALine)& alin,
Standard_Real& para,
const Handle(Adaptor2d_HCurve2d)& thearc,
const Handle(Adaptor2d_Curve2d)& thearc,
Standard_Real& _theparameteronarc,
gp_Pnt& thepointonarc,
const IntSurf_Quadric& QuadSurf,
@@ -262,8 +262,8 @@ Standard_Boolean IntersectionWithAnArc(gp_Pnt& PSurf,
//-- ======================================================================
static void Recadre(const Handle(Adaptor3d_HSurface)& myHS1,
const Handle(Adaptor3d_HSurface)& myHS2,
static void Recadre(const Handle(Adaptor3d_Surface)& myHS1,
const Handle(Adaptor3d_Surface)& myHS2,
Standard_Real& u1,
Standard_Real& v1,
Standard_Real& u2,
@@ -361,8 +361,8 @@ static void Recadre(const Handle(Adaptor3d_HSurface)& myHS1,
//function : PutPointsOnLine
//purpose :
//=======================================================================
void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_HSurface)& S2,
void PutPointsOnLine(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_Surface)& S2,
const IntPatch_SequenceOfPathPointOfTheSOnBounds& listpnt,
const IntPatch_SequenceOfLine& slin,
const Standard_Boolean OnFirst,
@@ -398,7 +398,7 @@ void PutPointsOnLine(const Handle(Adaptor3d_HSurface)& S1,
IntSurf_Transition Transline,Transarc;
Handle(Adaptor2d_HCurve2d) currentarc;
Handle(Adaptor2d_Curve2d) currentarc;
Handle(Adaptor3d_HVertex) vtx,vtxbis;
IntPatch_Point solpnt;
@@ -627,7 +627,7 @@ Standard_Boolean MultiplePoint (const IntPatch_SequenceOfPathPointOfTheSOnBound
IntPatch_Point intpt;
Handle(Adaptor2d_HCurve2d) currentarc;
Handle(Adaptor2d_Curve2d) currentarc;
Handle(Adaptor3d_HVertex) vtx,vtxbis;
Standard_Integer nbpnt = listpnt.Length();
@@ -800,7 +800,7 @@ Standard_Boolean PointOnSecondDom (const IntPatch_SequenceOfPathPointOfTheSOnBou
IntSurf_Transition Transline,Transarc;
IntPatch_Point intpt;
Handle(Adaptor2d_HCurve2d) currentarc;
Handle(Adaptor2d_Curve2d) currentarc;
Handle(Adaptor3d_HVertex) vtx,vtxbis;
gp_Pnt ptbid;
gp_Vec Vtgrst;
@@ -931,7 +931,7 @@ Standard_Boolean FindLine(gp_Pnt& Psurf,
gp_Vec& Vtgtint,
Standard_Integer& theLineIdx,
Standard_Integer OnlyThisLine,
const Handle(Adaptor2d_HCurve2d)& thearc,
const Handle(Adaptor2d_Curve2d)& thearc,
Standard_Real& theparameteronarc,
gp_Pnt& thepointonarc,
const IntSurf_Quadric& QuadSurf1,
@@ -1330,7 +1330,7 @@ void ProcessSegments (const IntPatch_SequenceOfSegmentOfTheSOnBounds& listedg,
Standard_Integer nbedg = listedg.Length();
Standard_Integer Nblines,Nbpts;
Handle(Adaptor2d_HCurve2d) arcRef;
Handle(Adaptor2d_Curve2d) arcRef;
IntPatch_Point ptvtx, newptvtx;
Handle(IntPatch_RLine) rline; //-- On fait rline = new ... par la suite
@@ -1502,7 +1502,7 @@ void ProcessSegments (const IntPatch_SequenceOfSegmentOfTheSOnBounds& listedg,
}
tgline.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
if (ptvtx.IsOnDomS1()) {
const Handle(Adaptor2d_HCurve2d)& thearc = ptvtx.ArcOnS1();
const Handle(Adaptor2d_Curve2d)& thearc = ptvtx.ArcOnS1();
thearc->D1(ptvtx.ParameterOnArc1(),p2d,d2d);
Quad1.D1(p2d.X(),p2d.Y(),valpt,d1u,d1v);
tgarc.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
@@ -1518,7 +1518,7 @@ void ProcessSegments (const IntPatch_SequenceOfSegmentOfTheSOnBounds& listedg,
TRest,TArc);
}
if (ptvtx.IsOnDomS2()) {
const Handle(Adaptor2d_HCurve2d)& thearc = ptvtx.ArcOnS2();
const Handle(Adaptor2d_Curve2d)& thearc = ptvtx.ArcOnS2();
thearc->D1(ptvtx.ParameterOnArc2(),p2d,d2d);
Quad2.D1(p2d.X(),p2d.Y(),valpt,d1u,d1v);
tgarc.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
@@ -1568,7 +1568,7 @@ void ProcessSegments (const IntPatch_SequenceOfSegmentOfTheSOnBounds& listedg,
}
tgline.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
if (ptvtx.IsOnDomS1()) {
const Handle(Adaptor2d_HCurve2d)& thearc = ptvtx.ArcOnS1();
const Handle(Adaptor2d_Curve2d)& thearc = ptvtx.ArcOnS1();
thearc->D1(ptvtx.ParameterOnArc1(),p2d,d2d);
Quad1.D1(p2d.X(),p2d.Y(),valpt,d1u,d1v);
tgarc.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
@@ -1584,7 +1584,7 @@ void ProcessSegments (const IntPatch_SequenceOfSegmentOfTheSOnBounds& listedg,
TRest,TArc);
}
if (ptvtx.IsOnDomS2()) {
const Handle(Adaptor2d_HCurve2d)& thearc = ptvtx.ArcOnS2();
const Handle(Adaptor2d_Curve2d)& thearc = ptvtx.ArcOnS2();
thearc->D1(ptvtx.ParameterOnArc2(),p2d,d2d);
Quad2.D1(p2d.X(),p2d.Y(),valpt,d1u,d1v);
tgarc.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
@@ -1767,7 +1767,7 @@ static Standard_Boolean IsRLineGood(const IntSurf_Quadric& Quad1,
gp_Pnt aPMid;
if(theRLine->IsArcOnS1())
{
const Handle(Adaptor2d_HCurve2d)& anAC2d = theRLine->ArcOnS1();
const Handle(Adaptor2d_Curve2d)& anAC2d = theRLine->ArcOnS1();
const Standard_Real aParF = anAC2d->FirstParameter(),
aParL = anAC2d->LastParameter();
gp_Pnt2d aP2d(anAC2d->Value(0.5*(aParF+aParL)));
@@ -1775,7 +1775,7 @@ static Standard_Boolean IsRLineGood(const IntSurf_Quadric& Quad1,
}
else
{
const Handle(Adaptor2d_HCurve2d)& anAC2d = theRLine->ArcOnS2();
const Handle(Adaptor2d_Curve2d)& anAC2d = theRLine->ArcOnS2();
const Standard_Real aParF = anAC2d->FirstParameter(),
aParL = anAC2d->LastParameter();
gp_Pnt2d aP2d(anAC2d->Value(0.5*(aParF+aParL)));
@@ -1800,8 +1800,8 @@ static Standard_Boolean IsRLineGood(const IntSurf_Quadric& Quad1,
void ProcessRLine (IntPatch_SequenceOfLine& slin,
// const Handle(Adaptor3d_HSurface)& Surf1,
// const Handle(Adaptor3d_HSurface)& Surf2,
// const Handle(Adaptor3d_Surface)& Surf1,
// const Handle(Adaptor3d_Surface)& Surf2,
const IntSurf_Quadric& Quad1,
const IntSurf_Quadric& Quad2,
const Standard_Real _TolArc,
@@ -1820,7 +1820,7 @@ void ProcessRLine (IntPatch_SequenceOfLine& slin,
Standard_Boolean OnFirst = Standard_False,project = Standard_False,keeppoint = Standard_False;
Handle(Adaptor2d_HCurve2d) arcref;
Handle(Adaptor2d_Curve2d) arcref;
Standard_Real paramproj,paramf,paraml;
TColgp_SequenceOfPnt seq_Pnt3d;
@@ -2002,7 +2002,7 @@ void ProcessRLine (IntPatch_SequenceOfLine& slin,
Quad1.D1(p2d.X(),p2d.Y(),valpt,d1u,d1v);
tgrest.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
const Handle(Adaptor2d_HCurve2d)& thearc = Ptvtx.ArcOnS2();
const Handle(Adaptor2d_Curve2d)& thearc = Ptvtx.ArcOnS2();
thearc->D1(Ptvtx.ParameterOnArc2(),p2d,d2d);
Quad2.D1(p2d.X(),p2d.Y(),valpt,d1u,d1v);
tgarc.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
@@ -2022,7 +2022,7 @@ void ProcessRLine (IntPatch_SequenceOfLine& slin,
Quad2.D1(p2d.X(),p2d.Y(),valpt,d1u,d1v);
tgrest.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);
const Handle(Adaptor2d_HCurve2d)& thearc = Ptvtx.ArcOnS1();
const Handle(Adaptor2d_Curve2d)& thearc = Ptvtx.ArcOnS1();
thearc->D1(Ptvtx.ParameterOnArc1(),p2d,d2d);
Quad1.D1(p2d.X(),p2d.Y(),valpt,d1u,d1v);
tgarc.SetLinearForm(d2d.X(),d1u,d2d.Y(),d1v);

14
src/IntPatch/IntPatch_ImpImpIntersection_2.gxx
View File

@@ -17,7 +17,7 @@
#include <IntPatch_WLine.hxx>
static
Standard_Integer SetQuad(const Handle(Adaptor3d_HSurface)& theS,
Standard_Integer SetQuad(const Handle(Adaptor3d_Surface)& theS,
GeomAbs_SurfaceType& theTS,
IntSurf_Quadric& theQuad);
@@ -37,9 +37,9 @@ oppo(Standard_False)
//purpose :
//=======================================================================
IntPatch_ImpImpIntersection::IntPatch_ImpImpIntersection
(const Handle(Adaptor3d_HSurface)& S1,
(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang,
@@ -51,9 +51,9 @@ IntPatch_ImpImpIntersection::IntPatch_ImpImpIntersection
//function : Perform
//purpose :
//=======================================================================
void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang,
@@ -112,7 +112,7 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
case 21: { // Plane/Cylinder
Standard_Real VMin, VMax, H;
//
const Handle(Adaptor3d_HSurface)& aSCyl = bReverse ? S1 : S2;
const Handle(Adaptor3d_Surface)& aSCyl = bReverse ? S1 : S2;
VMin = aSCyl->FirstVParameter();
VMax = aSCyl->LastVParameter();
H = (Precision::IsNegativeInfinite(VMin) ||
@@ -546,7 +546,7 @@ void IntPatch_ImpImpIntersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
//function : SetQuad
//purpose :
//=======================================================================
Standard_Integer SetQuad(const Handle(Adaptor3d_HSurface)& theS,
Standard_Integer SetQuad(const Handle(Adaptor3d_Surface)& theS,
GeomAbs_SurfaceType& theTS,
IntSurf_Quadric& theQuad)
{

79
src/IntPatch/IntPatch_ImpPrmIntersection.cxx
View File

@@ -16,7 +16,7 @@
#include <IntPatch_ImpPrmIntersection.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <ElCLib.hxx>
#include <ElSLib.hxx>
@@ -33,6 +33,7 @@
#include <IntSurf_Quadric.hxx>
#include <IntSurf_QuadricTool.hxx>
#include <IntSurf_SequenceOfPathPoint.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TopAbs_Orientation.hxx>
#include <TopTrans_CurveTransition.hxx>
#include <math_Matrix.hxx>
@@ -47,8 +48,8 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
const Standard_Boolean IsReversed,
const IntSurf_Quadric& theQuad,
const Handle(Adaptor3d_TopolTool)& thePDomain,
const Handle(Adaptor3d_HSurface)& theQSurf,
const Handle(Adaptor3d_HSurface)& theOtherSurf,
const Handle(Adaptor3d_Surface)& theQSurf,
const Handle(Adaptor3d_Surface)& theOtherSurf,
const Standard_Real theArcTol,
const Standard_Real theTolTang,
IntPatch_SequenceOfLine& theLines);
@@ -57,7 +58,7 @@ static
IntSurf_SequenceOfPathPoint& seqpdep,
const Handle(Adaptor3d_TopolTool)& Domain,
IntPatch_TheSurfFunction& Func,
const Handle(Adaptor3d_HSurface)& PSurf,
const Handle(Adaptor3d_Surface)& PSurf,
TColStd_Array1OfInteger& Destination);
static
void Recadre(const Standard_Boolean ,
@@ -74,7 +75,7 @@ static
static
Standard_Boolean IsCoincide(IntPatch_TheSurfFunction& theFunc,
const Handle(IntPatch_PointLine)& theLine,
const Handle(Adaptor2d_HCurve2d)& theArc,
const Handle(Adaptor2d_Curve2d)& theArc,
const Standard_Boolean isTheSurface1Using,
const Standard_Real theToler3D,
const Standard_Real theToler2D,
@@ -84,7 +85,7 @@ static
//function : IsSeamOrPole
//purpose :
//=======================================================================
static IntPatch_SpecPntType IsSeamOrPole(const Handle(Adaptor3d_HSurface)& theQSurf,
static IntPatch_SpecPntType IsSeamOrPole(const Handle(Adaptor3d_Surface)& theQSurf,
const Handle(IntSurf_LineOn2S)& theLine,
const Standard_Boolean IsReversed,
const Standard_Integer theRefIndex,
@@ -189,9 +190,9 @@ IntPatch_ImpPrmIntersection::IntPatch_ImpPrmIntersection ()
//=======================================================================
IntPatch_ImpPrmIntersection::IntPatch_ImpPrmIntersection
(const Handle(Adaptor3d_HSurface)& Surf1,
(const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor3d_Surface)& Surf2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang,
@@ -227,14 +228,14 @@ void ComputeTangency (const IntPatch_TheSOnBounds& solrst,
IntSurf_SequenceOfPathPoint& seqpdep,
const Handle(Adaptor3d_TopolTool)& Domain,
IntPatch_TheSurfFunction& Func,
const Handle(Adaptor3d_HSurface)& PSurf,
const Handle(Adaptor3d_Surface)& PSurf,
TColStd_Array1OfInteger& Destination)
{
Standard_Integer i,k, NbPoints, seqlength;
Standard_Real theparam,test;
Standard_Boolean fairpt, ispassing;
TopAbs_Orientation arcorien,vtxorien;
Handle(Adaptor2d_HCurve2d) thearc;
Handle(Adaptor2d_Curve2d) thearc;
Handle(Adaptor3d_HVertex) vtx,vtxbis;
//Standard_Boolean ispassing;
IntPatch_ThePathPointOfTheSOnBounds PStart;
@@ -484,9 +485,9 @@ void Recadre(const Standard_Boolean ,
//function : Perform
//purpose :
//=======================================================================
void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Surf1,
void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor3d_Surface)& Surf2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang,
@@ -517,7 +518,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
gp_Pnt2d p2d;
gp_Vec2d d2d;
Handle(Adaptor2d_HCurve2d) currentarc;
Handle(Adaptor2d_Curve2d) currentarc;
GeomAbs_SurfaceType typeS1, typeS2;
IntSurf_Quadric Quad;
IntPatch_TheSurfFunction Func;
@@ -1360,7 +1361,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
gp_Pnt ptpoly;
IntSurf_PntOn2S p2s;
Handle(IntSurf_LineOn2S) Thelin = new IntSurf_LineOn2S ();
Handle(Adaptor2d_HCurve2d) arcsegm = thesegm.Curve();
Handle(Adaptor2d_Curve2d) arcsegm = thesegm.Curve();
Standard_Integer nbsample = 100;
if (!reversed) {
@@ -1496,8 +1497,8 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
// after (higher indices) - only Walking-line.
const Standard_Real aTol3d = Max(Func.Tolerance(), TolTang);
const Handle(Adaptor3d_HSurface)& aQSurf = (reversed) ? Surf2 : Surf1;
const Handle(Adaptor3d_HSurface)& anOtherSurf = (reversed) ? Surf1 : Surf2;
const Handle(Adaptor3d_Surface)& aQSurf = (reversed) ? Surf2 : Surf1;
const Handle(Adaptor3d_Surface)& anOtherSurf = (reversed) ? Surf1 : Surf2;
for (Standard_Integer i = 1; i <= slin.Length(); i++)
{
@@ -1510,10 +1511,10 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
break;
}
const Handle(Adaptor2d_HCurve2d)& anArc = aRL1->IsArcOnS1() ?
const Handle(Adaptor2d_Curve2d)& anArc = aRL1->IsArcOnS1() ?
aRL1->ArcOnS1() :
aRL1->ArcOnS2();
if(anArc->Curve2d().GetType() != GeomAbs_Line)
if(anArc->GetType() != GeomAbs_Line)
{
//Restriction line must be isoline.
//Other cases are not supported by
@@ -1534,10 +1535,10 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
if(!aRL2.IsNull())
{
const Handle(Adaptor2d_HCurve2d)& anArc2 = aRL2->IsArcOnS1() ?
const Handle(Adaptor2d_Curve2d)& anArc2 = aRL2->IsArcOnS1() ?
aRL2->ArcOnS1() :
aRL2->ArcOnS2();
if(anArc2->Curve2d().GetType() != GeomAbs_Line)
if(anArc2->GetType() != GeomAbs_Line)
{
//Restriction line must be isoline.
//Other cases are not supported by
@@ -1550,7 +1551,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
//aDir can be equal to one of following four values only
//(because Reastriction line is boundary of rectangular surface):
//either {0, 1} or {0, -1} or {1, 0} or {-1, 0}.
const gp_Dir2d aDir = anArc->Curve2d().Line().Direction();
const gp_Dir2d aDir = anArc->Line().Direction();
Standard_Real aTol2d = anOtherSurf->UResolution(aTol3d),
aPeriod = anOtherSurf->IsVPeriodic() ? anOtherSurf->VPeriod() : 0.0;
@@ -1573,7 +1574,7 @@ void IntPatch_ImpPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Sur
}
else
{//Restriction-Restriction
const Handle(Adaptor2d_HCurve2d)& anArc2 = aRL2->IsArcOnS1() ?
const Handle(Adaptor2d_Curve2d)& anArc2 = aRL2->IsArcOnS1() ?
aRL2->ArcOnS1() :
aRL2->ArcOnS2();
@@ -1818,7 +1819,7 @@ static inline void Correct2DBounds(const Standard_Real UF,
static void AdjustLine(Handle(IntSurf_LineOn2S)& Line,
const Standard_Boolean IsReversed,
const Handle(Adaptor3d_HSurface)& QSurf,
const Handle(Adaptor3d_Surface)& QSurf,
const Standard_Real TOL2D)
{
Standard_Real VF = QSurf->FirstVParameter();
@@ -2344,11 +2345,11 @@ static void PutIntVertices(const Handle(IntPatch_PointLine)& Line,
//In fact, aRLine is always on the parametric surface.
//If (theIsReversed == TRUE) then (U1, V1) - point on
//parametric surface, otherwise - point on quadric.
const Handle(Adaptor2d_HCurve2d)& anArc = aRLine->IsArcOnS1() ?
const Handle(Adaptor2d_Curve2d)& anArc = aRLine->IsArcOnS1() ?
aRLine->ArcOnS1() :
aRLine->ArcOnS2();
const gp_Lin2d aLin(anArc->Curve2d().Line());
const gp_Lin2d aLin(anArc->Line());
gp_Pnt2d aPSurf;
if(theIsReversed)
@@ -2500,7 +2501,7 @@ static Standard_Boolean IsPointOnBoundary(const Standard_Real theToler2D,
//purpose : Can change values of theNewLine (by adding the computed point on boundary,
// which parameter will be adjusted) and theIsOnBoundary variables.
//=======================================================================
static void DetectOfBoundaryAchievement(const Handle(Adaptor3d_HSurface)& theQSurf, // quadric
static void DetectOfBoundaryAchievement(const Handle(Adaptor3d_Surface)& theQSurf, // quadric
const Standard_Boolean theIsReversed,
const Handle(IntSurf_LineOn2S)& theSourceLine,
const Standard_Integer thePointIndex,
@@ -2584,8 +2585,8 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
const Standard_Boolean IsReversed,
const IntSurf_Quadric& theQuad,
const Handle(Adaptor3d_TopolTool)& thePDomain,
const Handle(Adaptor3d_HSurface)& theQSurf, //quadric
const Handle(Adaptor3d_HSurface)& thePSurf, //parametric
const Handle(Adaptor3d_Surface)& theQSurf, //quadric
const Handle(Adaptor3d_Surface)& thePSurf, //parametric
const Standard_Real theArcTol,
const Standard_Real theTolTang,
IntPatch_SequenceOfLine& theLines)
@@ -2595,10 +2596,10 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
const Handle(IntPatch_RLine)& aRL = Handle(IntPatch_RLine)::DownCast(theLine);
if(!aRL.IsNull())
{
const Handle(Adaptor2d_HCurve2d)& anArc = aRL->IsArcOnS1() ?
const Handle(Adaptor2d_Curve2d)& anArc = aRL->IsArcOnS1() ?
aRL->ArcOnS1() :
aRL->ArcOnS2();
if(anArc->Curve2d().GetType() != GeomAbs_Line)
if(anArc->GetType() != GeomAbs_Line)
{
//Restriction line must be isoline.
//Other cases are not supported by
@@ -3054,7 +3055,7 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
PutIntVertices(aRLine,sline,IsReversed,aVLine,theArcTol);
}
const Handle(Adaptor2d_HCurve2d)& anArc = aRLine->IsArcOnS1() ?
const Handle(Adaptor2d_Curve2d)& anArc = aRLine->IsArcOnS1() ?
aRLine->ArcOnS1() :
aRLine->ArcOnS2();
@@ -3064,7 +3065,7 @@ static Standard_Boolean DecomposeResult(const Handle(IntPatch_PointLine)& theLin
const IntSurf_PntOn2S &aRFirst = sline->Value(1),
&aRLast = sline->Value(sline->NbPoints());
const gp_Lin2d aLin(anArc->Curve2d().Line());
const gp_Lin2d aLin(anArc->Line());
for(Standard_Integer aFLIndex = 0; aFLIndex < 2; aFLIndex++)
{
@@ -3163,7 +3164,7 @@ static Standard_Boolean CheckSegmSegm(const Standard_Real theRefParF,
//=======================================================================
Standard_Boolean IsCoincide(IntPatch_TheSurfFunction& theFunc,
const Handle(IntPatch_PointLine)& theLine,
const Handle(Adaptor2d_HCurve2d)& theArc,
const Handle(Adaptor2d_Curve2d)& theArc,
const Standard_Boolean isTheSurface1Using, //Surf1 is parametric?
const Standard_Real theToler3D,
const Standard_Real theToler2D,
@@ -3174,9 +3175,9 @@ Standard_Boolean IsCoincide(IntPatch_TheSurfFunction& theFunc,
if(theLine->ArcType() == IntPatch_Restriction)
{//Restriction-restriction processing
const Handle(IntPatch_RLine)& aRL2 = Handle(IntPatch_RLine)::DownCast(theLine);
const Handle(Adaptor2d_HCurve2d)& anArc = aRL2->IsArcOnS1() ? aRL2->ArcOnS1() : aRL2->ArcOnS2();
const Handle(Adaptor2d_Curve2d)& anArc = aRL2->IsArcOnS1() ? aRL2->ArcOnS1() : aRL2->ArcOnS2();
if(anArc->Curve2d().GetType() != GeomAbs_Line)
if(anArc->GetType() != GeomAbs_Line)
{
//Restriction line must be isoline.
//Other cases are not supported by
@@ -3185,8 +3186,8 @@ Standard_Boolean IsCoincide(IntPatch_TheSurfFunction& theFunc,
return Standard_False;
}
const gp_Lin2d aLin1(theArc->Curve2d().Line()),
aLin2(anArc->Curve2d().Line());
const gp_Lin2d aLin1(theArc->Line()),
aLin2(anArc->Line());
if(!aLin1.Direction().IsParallel(aLin2.Direction(), Precision::Angular()))
{
@@ -3194,7 +3195,7 @@ Standard_Boolean IsCoincide(IntPatch_TheSurfFunction& theFunc,
}
const Standard_Real aDist =
theArc->Curve2d().Line().Distance(anArc->Curve2d().Line());
theArc->Line().Distance(anArc->Line());
if((aDist < theToler2D) || (Abs(aDist - thePeriod) < theToler2D))
{
const Standard_Real aRf = theArc->FirstParameter(),
@@ -3223,7 +3224,7 @@ Standard_Boolean IsCoincide(IntPatch_TheSurfFunction& theFunc,
const Standard_Integer aNbPnts = theLine->NbPnts();
const Standard_Real aUAf = theArc->FirstParameter(),
aUAl = theArc->LastParameter();
const gp_Lin2d anArcLin(theArc->Curve2d().Line());
const gp_Lin2d anArcLin(theArc->Line());
math_Vector aX(1, 2), aVal(1, 1);

21
src/IntPatch/IntPatch_ImpPrmIntersection.hxx
View File

@@ -17,26 +17,13 @@
#ifndef _IntPatch_ImpPrmIntersection_HeaderFile
#define _IntPatch_ImpPrmIntersection_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <IntPatch_SequenceOfPoint.hxx>
#include <IntPatch_SequenceOfLine.hxx>
#include <IntPatch_TheSOnBounds.hxx>
#include <IntPatch_TheSearchInside.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
class StdFail_NotDone;
class Standard_OutOfRange;
class Standard_DomainError;
class Standard_ConstructionError;
class Adaptor3d_HSurface;
class Adaptor3d_TopolTool;
class IntPatch_Point;
class IntPatch_Line;
class Adaptor3d_TopolTool;
//! Implementation of the intersection between a natural
//! quadric patch : Plane, Cone, Cylinder or Sphere and
@@ -50,12 +37,12 @@ public:
Standard_EXPORT IntPatch_ImpPrmIntersection();
Standard_EXPORT IntPatch_ImpPrmIntersection(const Handle(Adaptor3d_HSurface)& Surf1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& Surf2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, const Standard_Real Fleche, const Standard_Real Pas);
Standard_EXPORT IntPatch_ImpPrmIntersection(const Handle(Adaptor3d_Surface)& Surf1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& Surf2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, const Standard_Real Fleche, const Standard_Real Pas);
//! to search for solution from the given point
Standard_EXPORT void SetStartPoint (const Standard_Real U, const Standard_Real V);
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Surf1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& Surf2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, const Standard_Real Fleche, const Standard_Real Pas);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& Surf1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& Surf2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, const Standard_Real Fleche, const Standard_Real Pas);
//! Returns true if the calculus was succesfull.
Standard_Boolean IsDone() const;

114
src/IntPatch/IntPatch_Intersection.cxx
View File

@@ -15,7 +15,7 @@
#include <stdio.h>
#include <IntPatch_Intersection.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <IntPatch_ALine.hxx>
#include <IntPatch_ALineToWLine.hxx>
@@ -28,8 +28,8 @@
#include <ProjLib_ProjectOnPlane.hxx>
#include <Geom_Plane.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <ProjLib_ProjectedCurve.hxx>
#include <Geom2dInt_GInter.hxx>
#include <Geom2dAdaptor_Curve.hxx>
@@ -61,9 +61,9 @@ IntPatch_Intersection::IntPatch_Intersection ()
//======================================================================
// function: IntPatch_Intersection
//======================================================================
IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_HSurface)& S1,
IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolArc,
const Standard_Real TolTang)
@@ -89,7 +89,7 @@ IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_HSurface)&
//======================================================================
// function: IntPatch_Intersection
//======================================================================
IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_HSurface)& S1,
IntPatch_Intersection::IntPatch_Intersection(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Standard_Real TolArc,
const Standard_Real TolTang)
@@ -133,7 +133,7 @@ void IntPatch_Intersection::SetTolerances(const Standard_Real TolArc,
//======================================================================
// function: Perform
//======================================================================
void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
void IntPatch_Intersection::Perform(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Standard_Real TolArc,
const Standard_Real TolTang)
@@ -163,12 +163,12 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
{
gp_Dir aDirection = S1->Direction();
gp_Ax3 anAxis(gp::Origin(), aDirection);
Handle(Adaptor3d_HCurve) aBasisCurve = S1->BasisCurve();
Handle(Adaptor3d_Curve) aBasisCurve = S1->BasisCurve();
ProjLib_ProjectOnPlane Projector(anAxis);
Projector.Load(aBasisCurve, Precision::Confusion());
Handle(GeomAdaptor_HCurve) aProjCurve = Projector.GetResult();
Handle(GeomAdaptor_Curve) aProjCurve = Projector.GetResult();
Handle(Geom_Plane) aPlane = new Geom_Plane(anAxis);
Handle(GeomAdaptor_HSurface) aGAHsurf = new GeomAdaptor_HSurface(aPlane);
Handle(GeomAdaptor_Surface) aGAHsurf = new GeomAdaptor_Surface(aPlane);
ProjLib_ProjectedCurve aProjectedCurve(aGAHsurf, aProjCurve);
Handle(Geom2d_Curve) aPCurve;
ProjLib::MakePCurveOfType(aProjectedCurve, aPCurve);
@@ -216,10 +216,10 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
#include <Geom2d_Curve.hxx>
#include <Geom2dAPI_InterCurveCurve.hxx>
#include <GeomAdaptor.hxx>
#include <GeomAdaptor_HCurve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Curve.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <GeomAdaptor_HSurface.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <Geom_Plane.hxx>
#include <ProjLib_ProjectOnPlane.hxx>
#include <GeomProjLib.hxx>
@@ -234,7 +234,7 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
//===============================================================
//function: FUN_GetMinMaxXYZPnt
//===============================================================
static void FUN_GetMinMaxXYZPnt( const Handle(Adaptor3d_HSurface)& S,
static void FUN_GetMinMaxXYZPnt( const Handle(Adaptor3d_Surface)& S,
gp_Pnt& pMin, gp_Pnt& pMax )
{
const Standard_Real DU = 0.25 * Abs(S->LastUParameter() - S->FirstUParameter());
@@ -260,13 +260,13 @@ static void FUN_GetMinMaxXYZPnt( const Handle(Adaptor3d_HSurface)& S,
//==========================================================================
static void FUN_TrimInfSurf(const gp_Pnt& Pmin,
const gp_Pnt& Pmax,
const Handle(Adaptor3d_HSurface)& InfSurf,
const Handle(Adaptor3d_Surface)& InfSurf,
const Standard_Real& AlternativeTrimPrm,
Handle(Adaptor3d_HSurface)& TrimS)
Handle(Adaptor3d_Surface)& TrimS)
{
Standard_Real TP = AlternativeTrimPrm;
Extrema_ExtPS ext1(Pmin, InfSurf->Surface(), 1.e-7, 1.e-7);
Extrema_ExtPS ext2(Pmax, InfSurf->Surface(), 1.e-7, 1.e-7);
Extrema_ExtPS ext1(Pmin, *InfSurf, 1.e-7, 1.e-7);
Extrema_ExtPS ext2(Pmax, *InfSurf, 1.e-7, 1.e-7);
if(ext1.IsDone() || ext2.IsDone())
{
Standard_Real Umax = -1.e+100, Umin = 1.e+100, Vmax = -1.e+100, Vmin = 1.e+100, cU, cV;
@@ -303,7 +303,7 @@ static void FUN_TrimInfSurf(const gp_Pnt& Pmin,
const Standard_Boolean Usup = Precision::IsPositiveInfinite(InfSurf->LastUParameter());
const Standard_Boolean Vinf = Precision::IsNegativeInfinite(InfSurf->FirstVParameter());
const Standard_Boolean Vsup = Precision::IsPositiveInfinite(InfSurf->LastVParameter());
Handle(Adaptor3d_HSurface) TmpSS;
Handle(Adaptor3d_Surface) TmpSS;
Standard_Integer IsTrimed = 0;
const Standard_Real tp = 1000.0 * TP;
if(Vinf && Vsup) { TrimS = InfSurf->VTrim(-tp, tp, 1.0e-7); IsTrimed = 1; }
@@ -467,9 +467,9 @@ static void FUN_GetViso(const Handle(Geom_Surface)& GS,
//================================================================================
//function: FUN_PL_Intersection
//================================================================================
static void FUN_PL_Intersection(const Handle(Adaptor3d_HSurface)& S1,
static void FUN_PL_Intersection(const Handle(Adaptor3d_Surface)& S1,
const GeomAbs_SurfaceType& T1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const GeomAbs_SurfaceType& T2,
Standard_Boolean& IsOk,
TColgp_SequenceOfPnt& SP,
@@ -481,8 +481,8 @@ static void FUN_PL_Intersection(const Handle(Adaptor3d_HSurface)& S1,
Standard_Boolean isoS1isLine[2] = {0, 0};
Standard_Boolean isoS2isLine[2] = {0, 0};
Handle(Geom_Curve) C1, C2;
const GeomAdaptor_Surface & gas1 = *(GeomAdaptor_Surface*)(&(S1->Surface()));
const GeomAdaptor_Surface & gas2 = *(GeomAdaptor_Surface*)(&(S2->Surface()));
const GeomAdaptor_Surface & gas1 = *(GeomAdaptor_Surface*)(S1.get());
const GeomAdaptor_Surface & gas2 = *(GeomAdaptor_Surface*)(S2.get());
const Handle(Geom_Surface) gs1 = gas1.Surface();
const Handle(Geom_Surface) gs2 = gas2.Surface();
Standard_Real MS1[2], MS2[2];
@@ -673,16 +673,16 @@ static void FUN_NewFirstLast(const GeomAbs_CurveType& ga_ct,
//================================================================================
//function: FUN_TrimBothSurf
//================================================================================
static void FUN_TrimBothSurf(const Handle(Adaptor3d_HSurface)& S1,
static void FUN_TrimBothSurf(const Handle(Adaptor3d_Surface)& S1,
const GeomAbs_SurfaceType& T1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const GeomAbs_SurfaceType& T2,
const Standard_Real& TV,
Handle(Adaptor3d_HSurface)& NS1,
Handle(Adaptor3d_HSurface)& NS2)
Handle(Adaptor3d_Surface)& NS1,
Handle(Adaptor3d_Surface)& NS2)
{
const GeomAdaptor_Surface & gas1 = *(GeomAdaptor_Surface*)(&(S1->Surface()));
const GeomAdaptor_Surface & gas2 = *(GeomAdaptor_Surface*)(&(S2->Surface()));
const GeomAdaptor_Surface & gas1 = *(GeomAdaptor_Surface*)(S1.get());
const GeomAdaptor_Surface & gas2 = *(GeomAdaptor_Surface*)(S2.get());
const Handle(Geom_Surface) gs1 = gas1.Surface();
const Handle(Geom_Surface) gs2 = gas2.Surface();
const Standard_Real UM1 = 0.5 * (S1->LastUParameter() + S1->FirstUParameter());
@@ -728,7 +728,7 @@ static void FUN_TrimBothSurf(const Handle(Adaptor3d_HSurface)& S1,
{
if(TrmV1)
{
Handle(Adaptor3d_HSurface) TS = NS1;
Handle(Adaptor3d_Surface) TS = NS1;
NS1 = TS->UTrim(U1S1, U2S1, 1.0e-7);
}
else NS1 = S1->UTrim(U1S1, U2S1, 1.0e-7);
@@ -737,7 +737,7 @@ static void FUN_TrimBothSurf(const Handle(Adaptor3d_HSurface)& S1,
{
if(TrmV2)
{
Handle(Adaptor3d_HSurface) TS = NS2;
Handle(Adaptor3d_Surface) TS = NS2;
NS2 = TS->UTrim(U1S2, U2S2, 1.0e-7);
}
else NS2 = S2->UTrim(U1S2, U2S2, 1.0e-7);
@@ -748,9 +748,9 @@ static void FUN_TrimBothSurf(const Handle(Adaptor3d_HSurface)& S1,
//function : Perform
//purpose :
//=======================================================================
void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
void IntPatch_Intersection::Perform(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(Adaptor3d_TopolTool)& theD2,
const Standard_Real TolArc,
const Standard_Real TolTang,
@@ -785,9 +785,9 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
GeomAbs_SurfaceType aCTType;
Standard_Boolean bToCheck;
//
const Handle(Adaptor3d_HSurface)& aCTSurf =
const Handle(Adaptor3d_Surface)& aCTSurf =
(typs1 == GeomAbs_Cone || typs1 == GeomAbs_Torus) ? theS1 : theS2;
const Handle(Adaptor3d_HSurface)& aGeomSurf =
const Handle(Adaptor3d_Surface)& aGeomSurf =
(typs1 == GeomAbs_Cone || typs1 == GeomAbs_Torus) ? theS2 : theS1;
//
aCTType = aCTSurf->GetType();
@@ -1006,9 +1006,9 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
//function : Perform
//purpose :
//=======================================================================
void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
void IntPatch_Intersection::Perform(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(Adaptor3d_TopolTool)& theD2,
const Standard_Real TolArc,
const Standard_Real TolTang,
@@ -1044,9 +1044,9 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
GeomAbs_SurfaceType aCTType;
Standard_Boolean bToCheck;
//
const Handle(Adaptor3d_HSurface)& aCTSurf =
const Handle(Adaptor3d_Surface)& aCTSurf =
(typs1 == GeomAbs_Cone || typs1 == GeomAbs_Torus) ? theS1 : theS2;
const Handle(Adaptor3d_HSurface)& aGeomSurf =
const Handle(Adaptor3d_Surface)& aGeomSurf =
(typs1 == GeomAbs_Cone || typs1 == GeomAbs_Torus) ? theS2 : theS1;
//
aCTType = aCTSurf->GetType();
@@ -1243,9 +1243,9 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& theS1,
//function : ParamParamPerfom
//purpose :
//=======================================================================
void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_HSurface)& theS1,
void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(Adaptor3d_TopolTool)& theD2,
const Standard_Real TolArc,
const Standard_Real TolTang,
@@ -1273,7 +1273,7 @@ void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_HSurface)&
const Standard_Real MU = Max(Abs(theS2->FirstUParameter()),Abs(theS2->LastUParameter()));
const Standard_Real MV = Max(Abs(theS2->FirstVParameter()),Abs(theS2->LastVParameter()));
const Standard_Real AP = Max(MU, MV);
Handle(Adaptor3d_HSurface) SS;
Handle(Adaptor3d_Surface) SS;
FUN_TrimInfSurf(pMinXYZ, pMaxXYZ, theS1, AP, SS);
interpp.Perform(SS,theD1,theS2,theD2,TolTang,TolArc,myFleche,myUVMaxStep);
}
@@ -1283,7 +1283,7 @@ void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_HSurface)&
const Standard_Real MU = Max(Abs(theS1->FirstUParameter()),Abs(theS1->LastUParameter()));
const Standard_Real MV = Max(Abs(theS1->FirstVParameter()),Abs(theS1->LastVParameter()));
const Standard_Real AP = Max(MU, MV);
Handle(Adaptor3d_HSurface) SS;
Handle(Adaptor3d_Surface) SS;
FUN_TrimInfSurf(pMinXYZ, pMaxXYZ, theS2, AP, SS);
interpp.Perform(theS1, theD1, SS, theD2,TolTang, TolArc,myFleche,myUVMaxStep);
}
@@ -1321,8 +1321,8 @@ void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_HSurface)&
}// 'COLLINEAR LINES'
else
{
Handle(Adaptor3d_HSurface) nS1 = theS1;
Handle(Adaptor3d_HSurface) nS2 = theS2;
Handle(Adaptor3d_Surface) nS1 = theS1;
Handle(Adaptor3d_Surface) nS2 = theS2;
FUN_TrimBothSurf(theS1,typs1,theS2,typs2,1.e+8,nS1,nS2);
interpp.Perform(nS1,theD1,nS2,theD2,TolTang,TolArc,myFleche,myUVMaxStep);
}// 'NON - COLLINEAR LINES'
@@ -1352,9 +1352,9 @@ void IntPatch_Intersection::ParamParamPerfom(const Handle(Adaptor3d_HSurface)&
////function : GeomGeomPerfom
//purpose :
//=======================================================================
void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& theS1,
void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(Adaptor3d_TopolTool)& theD2,
const Standard_Real TolArc,
const Standard_Real TolTang,
@@ -1483,9 +1483,9 @@ void IntPatch_Intersection::GeomGeomPerfom(const Handle(Adaptor3d_HSurface)& the
//purpose :
//=======================================================================
void IntPatch_Intersection::
GeomParamPerfom(const Handle(Adaptor3d_HSurface)& theS1,
GeomParamPerfom(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_TopolTool)& theD1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(Adaptor3d_TopolTool)& theD2,
const Standard_Boolean isNotAnalitical,
const GeomAbs_SurfaceType typs1,
@@ -1527,8 +1527,8 @@ void IntPatch_Intersection::
}
else
{
Handle(Adaptor3d_HSurface) nS1 = theS1;
Handle(Adaptor3d_HSurface) nS2 = theS2;
Handle(Adaptor3d_Surface) nS1 = theS1;
Handle(Adaptor3d_Surface) nS2 = theS2;
FUN_TrimBothSurf(theS1,typs1,theS2,typs2,1.e+5,nS1,nS2);
interip.Perform(nS1,theD1,nS2,theD2,myTolArc,myTolTang,myFleche,myUVMaxStep);
}
@@ -1562,9 +1562,9 @@ void IntPatch_Intersection::
}
}
void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
void IntPatch_Intersection::Perform(const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real U1,
const Standard_Real V1,
@@ -1653,8 +1653,8 @@ void IntPatch_Intersection::Perform(const Handle(Adaptor3d_HSurface)& S1,
#ifdef DUMPOFIntPatch_Intersection
void IntPatch_Intersection__MAJ_R(Handle(Adaptor2d_HCurve2d) *R1,
Handle(Adaptor2d_HCurve2d) *,
void IntPatch_Intersection__MAJ_R(Handle(Adaptor2d_Curve2d) *R1,
Handle(Adaptor2d_Curve2d) *,
int *NR1,
int *,
Standard_Integer nbR1,
@@ -1679,9 +1679,9 @@ void IntPatch_Intersection__MAJ_R(Handle(Adaptor2d_HCurve2d) *R1,
#endif
void IntPatch_Intersection::Dump(const Standard_Integer /*Mode*/,
const Handle(Adaptor3d_HSurface)& /*S1*/,
const Handle(Adaptor3d_Surface)& /*S1*/,
const Handle(Adaptor3d_TopolTool)& /*D1*/,
const Handle(Adaptor3d_HSurface)& /*S2*/,
const Handle(Adaptor3d_Surface)& /*S2*/,
const Handle(Adaptor3d_TopolTool)& /*D2*/) const
{
#ifdef DUMPOFIntPatch_Intersection
@@ -1690,7 +1690,7 @@ void IntPatch_Intersection::Dump(const Standard_Integer /*Mode*/,
//-- construction de la liste des restrictions & vertex
//--
int NR1[MAXR],NR2[MAXR];
Handle(Adaptor2d_HCurve2d) R1[MAXR],R2[MAXR];
Handle(Adaptor2d_Curve2d) R1[MAXR],R2[MAXR];
Standard_Integer nbR1=0,nbR2=0;
for(D1->Init();D1->More() && nbR1<MAXR; D1->Next()) {
R1[nbR1]=D1->Value();

36
src/IntPatch/IntPatch_Intersection.hxx
View File

@@ -17,25 +17,13 @@
#ifndef _IntPatch_Intersection_HeaderFile
#define _IntPatch_Intersection_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <IntPatch_SequenceOfPoint.hxx>
#include <IntPatch_SequenceOfLine.hxx>
#include <Standard_Real.hxx>
#include <IntSurf_ListOfPntOn2S.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <Standard_Integer.hxx>
class StdFail_NotDone;
class Standard_OutOfRange;
class Standard_DomainError;
class Standard_ConstructionError;
class Adaptor3d_HSurface;
class Adaptor3d_TopolTool;
class IntPatch_Point;
class IntPatch_Line;
//! This class provides a generic algorithm to intersect
@@ -49,9 +37,9 @@ public:
Standard_EXPORT IntPatch_Intersection();
Standard_EXPORT IntPatch_Intersection(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang);
Standard_EXPORT IntPatch_Intersection(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang);
Standard_EXPORT IntPatch_Intersection(const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Standard_Real TolArc, const Standard_Real TolTang);
Standard_EXPORT IntPatch_Intersection(const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Standard_Real TolArc, const Standard_Real TolTang);
//! Set the tolerances used by the algorithms:
//! --- Implicit - Parametric
@@ -84,7 +72,7 @@ public:
//! after deleting TopOpeBRep.
//! If theIsReqToPostWLProc == FALSE, then we will work with Walking-line
//! obtained after intersection algorithm directly (wothout any post-processing).
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, const Standard_Boolean isGeomInt = Standard_True, const Standard_Boolean theIsReqToKeepRLine = Standard_False, const Standard_Boolean theIsReqToPostWLProc = Standard_True);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, const Standard_Boolean isGeomInt = Standard_True, const Standard_Boolean theIsReqToKeepRLine = Standard_False, const Standard_Boolean theIsReqToPostWLProc = Standard_True);
//! If isGeomInt == Standard_False, then method
//! Param-Param intersection will be used.
@@ -99,13 +87,13 @@ public:
//! after deleting TopOpeBRep.
//! If theIsReqToPostWLProc == FALSE, then we will work with Walking-line
//! obtained after intersection algorithm directly (without any post-processing).
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, IntSurf_ListOfPntOn2S& LOfPnts, const Standard_Boolean isGeomInt = Standard_True, const Standard_Boolean theIsReqToKeepRLine = Standard_False, const Standard_Boolean theIsReqToPostWLProc = Standard_True);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, IntSurf_ListOfPntOn2S& LOfPnts, const Standard_Boolean isGeomInt = Standard_True, const Standard_Boolean theIsReqToKeepRLine = Standard_False, const Standard_Boolean theIsReqToPostWLProc = Standard_True);
//! Perform with start point
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2, const Standard_Real TolArc, const Standard_Real TolTang);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2, const Standard_Real TolArc, const Standard_Real TolTang);
//! Uses for finding self-intersected surfaces.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Standard_Real TolArc, const Standard_Real TolTang);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Standard_Real TolArc, const Standard_Real TolTang);
//! Returns True if the calculus was successful.
Standard_Boolean IsDone() const;
@@ -143,7 +131,7 @@ public:
//! Dump of each result line.
//! Mode for more accurate dumps.
Standard_EXPORT void Dump (const Standard_Integer Mode, const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2) const;
Standard_EXPORT void Dump (const Standard_Integer Mode, const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2) const;
@@ -157,7 +145,7 @@ protected:
private:
Standard_EXPORT void ParamParamPerfom (const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, IntSurf_ListOfPntOn2S& LOfPnts, const GeomAbs_SurfaceType typs1, const GeomAbs_SurfaceType typs2);
Standard_EXPORT void ParamParamPerfom (const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, IntSurf_ListOfPntOn2S& LOfPnts, const GeomAbs_SurfaceType typs1, const GeomAbs_SurfaceType typs2);
//! Flag theIsReqToKeepRLine has been entered only for
//! compatibility with TopOpeBRep package. It shall be deleted
@@ -165,9 +153,9 @@ private:
//! When intersection result returns IntPatch_RLine and another
//! IntPatch_Line (not restriction) we (in case of theIsReqToKeepRLine==TRUE)
//! will always keep both lines even if they are coincided.
Standard_EXPORT void GeomGeomPerfom (const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, IntSurf_ListOfPntOn2S& LOfPnts, const GeomAbs_SurfaceType typs1, const GeomAbs_SurfaceType typs2, const Standard_Boolean theIsReqToKeepRLine);
Standard_EXPORT void GeomGeomPerfom (const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real TolArc, const Standard_Real TolTang, IntSurf_ListOfPntOn2S& LOfPnts, const GeomAbs_SurfaceType typs1, const GeomAbs_SurfaceType typs2, const Standard_Boolean theIsReqToKeepRLine);
Standard_EXPORT void GeomParamPerfom (const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Boolean isNotAnalitical, const GeomAbs_SurfaceType typs1, const GeomAbs_SurfaceType typs2);
Standard_EXPORT void GeomParamPerfom (const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Boolean isNotAnalitical, const GeomAbs_SurfaceType typs1, const GeomAbs_SurfaceType typs2);
Standard_Boolean done;

84
src/IntPatch/IntPatch_LineConstructor.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_TopolTool.hxx>
#include <IntPatch_ALine.hxx>
#include <IntPatch_GLine.hxx>
@@ -46,8 +46,8 @@
//purpose :
//=======================================================================
static void Recadre(const Handle(Adaptor3d_HSurface)& myHS1,
const Handle(Adaptor3d_HSurface)& myHS2,
static void Recadre(const Handle(Adaptor3d_Surface)& myHS1,
const Handle(Adaptor3d_Surface)& myHS2,
Standard_Real& u1,
Standard_Real& v1,
Standard_Real& u2,
@@ -136,8 +136,8 @@ static void Recadre(const Handle(Adaptor3d_HSurface)& myHS1,
//purpose :
//=======================================================================
static void Parameters(const Handle(Adaptor3d_HSurface)& myHS1,
const Handle(Adaptor3d_HSurface)& myHS2,
static void Parameters(const Handle(Adaptor3d_Surface)& myHS1,
const Handle(Adaptor3d_Surface)& myHS2,
const gp_Pnt& Ptref,
Standard_Real& U1,
Standard_Real& V1,
@@ -145,43 +145,43 @@ static void Parameters(const Handle(Adaptor3d_HSurface)& myHS1,
Standard_Real& V2)
{
IntSurf_Quadric quad1,quad2;
GeomAbs_SurfaceType typs = myHS1->Surface().GetType();
GeomAbs_SurfaceType typs = myHS1->GetType();
switch (typs) {
case GeomAbs_Plane:
quad1.SetValue(myHS1->Surface().Plane());
quad1.SetValue(myHS1->Plane());
break;
case GeomAbs_Cylinder:
quad1.SetValue(myHS1->Surface().Cylinder());
quad1.SetValue(myHS1->Cylinder());
break;
case GeomAbs_Cone:
quad1.SetValue(myHS1->Surface().Cone());
quad1.SetValue(myHS1->Cone());
break;
case GeomAbs_Sphere:
quad1.SetValue(myHS1->Surface().Sphere());
quad1.SetValue(myHS1->Sphere());
break;
case GeomAbs_Torus:
quad1.SetValue(myHS1->Surface().Torus());
quad1.SetValue(myHS1->Torus());
break;
default:
throw Standard_ConstructionError("IntPatch_IntSS::MakeCurve");
}
typs = myHS2->Surface().GetType();
typs = myHS2->GetType();
switch (typs) {
case GeomAbs_Plane:
quad2.SetValue(myHS2->Surface().Plane());
quad2.SetValue(myHS2->Plane());
break;
case GeomAbs_Cylinder:
quad2.SetValue(myHS2->Surface().Cylinder());
quad2.SetValue(myHS2->Cylinder());
break;
case GeomAbs_Cone:
quad2.SetValue(myHS2->Surface().Cone());
quad2.SetValue(myHS2->Cone());
break;
case GeomAbs_Sphere:
quad2.SetValue(myHS2->Surface().Sphere());
quad2.SetValue(myHS2->Sphere());
break;
case GeomAbs_Torus:
quad2.SetValue(myHS2->Surface().Torus());
quad2.SetValue(myHS2->Torus());
break;
default:
throw Standard_ConstructionError("IntPatch_IntSS::MakeCurve");
@@ -824,7 +824,7 @@ static Standard_Boolean TestWLineIsARLine(const IntPatch_SequenceOfLine& slinref
for (Standard_Integer is=0; is<2; is++) {
Standard_Boolean onFirst = is==0;
if((onFirst && rlin->IsArcOnS1()) || (!onFirst && rlin->IsArcOnS2())) {
Handle(Adaptor2d_HCurve2d) arc;
Handle(Adaptor2d_Curve2d) arc;
Standard_Real u,v,u1,v1;
if (onFirst) {
arc = rlin->ArcOnS1();
@@ -840,7 +840,7 @@ static Standard_Boolean TestWLineIsARLine(const IntPatch_SequenceOfLine& slinref
u = (u+u1)*0.5;
v = (v+v1)*0.5;
}
const Adaptor2d_Curve2d& C2d=arc->Curve2d();
const Adaptor2d_Curve2d& C2d = *arc;
gp_Pnt2d PObt,P2d(u,v);
Standard_Real par= Geom2dInt_TheProjPCurOfGInter::FindParameter(C2d,P2d,1e-7);
PObt=C2d.Value(par);
@@ -861,9 +861,9 @@ static Standard_Boolean TestWLineIsARLine(const IntPatch_SequenceOfLine& slinref
static Standard_Boolean TestIfWLineIsRestriction(const IntPatch_SequenceOfLine& slinref,
const Handle(IntPatch_WLine)& wlin,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Handle(Adaptor3d_TopolTool)&D1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Handle(Adaptor3d_TopolTool)&D2,
Standard_Real TolArc) {
@@ -914,8 +914,8 @@ static Standard_Boolean TestIfWLineIsRestriction(const IntPatch_SequenceOfLine&
static Standard_Boolean ProjectOnArc(const Standard_Real u,
const Standard_Real v,
const Handle(Adaptor2d_HCurve2d)& arc,
const Handle(Adaptor3d_HSurface)& surf,
const Handle(Adaptor2d_Curve2d)& arc,
const Handle(Adaptor3d_Surface)& surf,
const Standard_Real TolArc,
Standard_Real& par,
Standard_Real& dist)
@@ -924,7 +924,7 @@ static Standard_Boolean ProjectOnArc(const Standard_Real u,
gp_Vec ad1u, ad1v;
surf->D1(u,v,aPbid,ad1u,ad1v);
Standard_Real tol2d = ComputeParametricTolerance(TolArc,ad1u,ad1v);
const Adaptor2d_Curve2d& C2d=arc->Curve2d();
const Adaptor2d_Curve2d& C2d = *arc;
gp_Pnt2d aP(u,v),aPprj;
par=Geom2dInt_TheProjPCurOfGInter::FindParameter(C2d,aP,1e-7);
aPprj=C2d.Value(par);
@@ -939,9 +939,9 @@ static Standard_Boolean ProjectOnArc(const Standard_Real u,
static void TestWLineToRLine(const IntPatch_SequenceOfLine& slinref,
IntPatch_SequenceOfLine& slin,
const Handle(Adaptor3d_HSurface)& mySurf1,
const Handle(Adaptor3d_Surface)& mySurf1,
const Handle(Adaptor3d_TopolTool)& myDom1,
const Handle(Adaptor3d_HSurface)& mySurf2,
const Handle(Adaptor3d_Surface)& mySurf2,
const Handle(Adaptor3d_TopolTool)& myDom2,
const Standard_Real TolArc) {
@@ -967,7 +967,7 @@ static void TestWLineToRLine(const IntPatch_SequenceOfLine& slinref,
typedef void (IntSurf_PntOn2S::* PiParOnS)(Standard_Real&,Standard_Real&) const;
typedef Standard_Boolean (IntPatch_Point::* PQuery)() const;
typedef const Handle(Adaptor2d_HCurve2d)& (IntPatch_Point::* PArcOnS)() const;
typedef const Handle(Adaptor2d_Curve2d)& (IntPatch_Point::* PArcOnS)() const;
typedef Standard_Real (IntPatch_Point::* PParOnArc)() const;
// cycle for both surfaces
@@ -980,7 +980,7 @@ static void TestWLineToRLine(const IntPatch_SequenceOfLine& slinref,
PQuery pIsOnDomS;
PArcOnS pArcOnS;
PParOnArc pParOnArc;
Handle(Adaptor3d_HSurface) surf;
Handle(Adaptor3d_Surface) surf;
Handle(Adaptor3d_TopolTool) aDomain;
if (onFirst) {
piParOnS = &IntSurf_PntOn2S::ParametersOnS1;
@@ -1003,14 +1003,14 @@ static void TestWLineToRLine(const IntPatch_SequenceOfLine& slinref,
Standard_Real utst,vtst;
TColStd_Array1OfReal paramsResolved(1,nbvtx);
TColStd_Array1OfTransient arcsResolved(1,nbvtx);
arcsResolved.Init(Handle(Adaptor2d_HCurve2d)());
arcsResolved.Init(Handle(Adaptor2d_Curve2d)());
for (iv=1; iv <= nbvtx; iv++) {
if (!(WLine->Vertex(iv).*pIsOnDomS)()) {
Standard_Integer ip = (Standard_Integer) WLine->Vertex(iv).ParameterOnLine();
(WLine->Point(ip).*piParOnS)(utst,vtst);
Standard_Real distmin=RealLast();
for (aDomain->Init(); aDomain->More(); aDomain->Next()) {
const Handle(Adaptor2d_HCurve2d)& arc = aDomain->Value();
const Handle(Adaptor2d_Curve2d)& arc = aDomain->Value();
Standard_Real par,dist;
if (ProjectOnArc(utst,vtst,arc,surf,TolArc,par,dist) && dist < distmin) {
arcsResolved(iv) = arc;
@@ -1026,36 +1026,36 @@ static void TestWLineToRLine(const IntPatch_SequenceOfLine& slinref,
Standard_Integer i;
for (i=1; i <= indicesV1.Length(); i++) {
iv = indicesV1(i);
Handle(Adaptor2d_HCurve2d) arc;
Handle(Adaptor2d_Curve2d) arc;
if ((WLine->Vertex(iv).*pIsOnDomS)()) arc = (WLine->Vertex(iv).*pArcOnS)();
else arc = Handle(Adaptor2d_HCurve2d)::DownCast (arcsResolved(iv));
else arc = Handle(Adaptor2d_Curve2d)::DownCast (arcsResolved(iv));
if (!arc.IsNull()) mapArcsV1.Add(arc);
}
for (i=1; i <= indicesV2.Length(); i++) {
iv = indicesV2(i);
Handle(Adaptor2d_HCurve2d) arc;
Handle(Adaptor2d_Curve2d) arc;
if ((WLine->Vertex(iv).*pIsOnDomS)()) arc = (WLine->Vertex(iv).*pArcOnS)();
else arc = Handle(Adaptor2d_HCurve2d)::DownCast (arcsResolved(iv));
else arc = Handle(Adaptor2d_Curve2d)::DownCast (arcsResolved(iv));
if (!arc.IsNull() && mapArcsV1.Contains(arc)) mapArcs.Add(arc);
}
// for each common arc
for (Standard_Integer ia=1; ia <= mapArcs.Extent(); ia++) {
const Handle(Adaptor2d_HCurve2d) arc (Handle(Adaptor2d_HCurve2d)::DownCast (mapArcs(ia)));
const Handle(Adaptor2d_Curve2d) arc (Handle(Adaptor2d_Curve2d)::DownCast (mapArcs(ia)));
// get end vertices of wline linked with this arc
Standard_Integer iv1=0,iv2=0;
for (i=1; i <= indicesV1.Length() && iv1==0; i++) {
iv = indicesV1(i);
Handle(Adaptor2d_HCurve2d) arc1;
Handle(Adaptor2d_Curve2d) arc1;
if ((WLine->Vertex(iv).*pIsOnDomS)()) arc1 = (WLine->Vertex(iv).*pArcOnS)();
else arc1 = Handle(Adaptor2d_HCurve2d)::DownCast (arcsResolved(iv));
else arc1 = Handle(Adaptor2d_Curve2d)::DownCast (arcsResolved(iv));
if (!arc1.IsNull() && arc1 == arc) iv1 = iv;
}
for (i=1; i <= indicesV2.Length() && iv2==0; i++) {
iv = indicesV2(i);
Handle(Adaptor2d_HCurve2d) arc1;
Handle(Adaptor2d_Curve2d) arc1;
if ((WLine->Vertex(iv).*pIsOnDomS)()) arc1 = (WLine->Vertex(iv).*pArcOnS)();
else arc1 = Handle(Adaptor2d_HCurve2d)::DownCast (arcsResolved(iv));
else arc1 = Handle(Adaptor2d_Curve2d)::DownCast (arcsResolved(iv));
if (!arc1.IsNull() && arc1 == arc) iv2 = iv;
}
if (!iv1 || !iv2) {
@@ -1182,9 +1182,9 @@ static void TestWLineToRLine(const IntPatch_SequenceOfLine& slinref,
void IntPatch_LineConstructor::Perform(const IntPatch_SequenceOfLine& slinref,
const Handle(IntPatch_Line)& L,
const Handle(Adaptor3d_HSurface)& mySurf1,
const Handle(Adaptor3d_Surface)& mySurf1,
const Handle(Adaptor3d_TopolTool)& myDom1,
const Handle(Adaptor3d_HSurface)& mySurf2,
const Handle(Adaptor3d_Surface)& mySurf2,
const Handle(Adaptor3d_TopolTool)& myDom2,
const Standard_Real TolArc) {

13
src/IntPatch/IntPatch_LineConstructor.hxx
View File

@@ -17,17 +17,10 @@
#ifndef _IntPatch_LineConstructor_HeaderFile
#define _IntPatch_LineConstructor_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <IntPatch_SequenceOfLine.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
class IntPatch_Line;
class Adaptor3d_HSurface;
class Adaptor3d_TopolTool;
class Adaptor3d_TopolTool;
//! The intersections algorithms compute the intersection
//! on two surfaces and return the intersections lines as
@@ -41,7 +34,7 @@ public:
Standard_EXPORT IntPatch_LineConstructor(const Standard_Integer mode);
Standard_EXPORT void Perform (const IntPatch_SequenceOfLine& SL, const Handle(IntPatch_Line)& L, const Handle(Adaptor3d_HSurface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_HSurface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real Tol);
Standard_EXPORT void Perform (const IntPatch_SequenceOfLine& SL, const Handle(IntPatch_Line)& L, const Handle(Adaptor3d_Surface)& S1, const Handle(Adaptor3d_TopolTool)& D1, const Handle(Adaptor3d_Surface)& S2, const Handle(Adaptor3d_TopolTool)& D2, const Standard_Real Tol);
Standard_EXPORT Standard_Integer NbLines() const;

4
src/IntPatch/IntPatch_Point.cxx
View File

@@ -15,7 +15,7 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <gp_Pnt.hxx>
#include <IntPatch_Point.hxx>
@@ -53,7 +53,7 @@ void IntPatch_Point::SetVertex(const Standard_Boolean OnFirst, const Handle(Adap
}
void IntPatch_Point::SetArc (const Standard_Boolean OnFirst,
const Handle(Adaptor2d_HCurve2d)& A,
const Handle(Adaptor2d_Curve2d)& A,
const Standard_Real Param,
const IntSurf_Transition& TLine,
const IntSurf_Transition& TArc)

12
src/IntPatch/IntPatch_Point.hxx
View File

@@ -25,7 +25,7 @@
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <IntSurf_Transition.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
class Adaptor3d_HVertex;
class Standard_DomainError;
@@ -81,7 +81,7 @@ public:
//! If OnFirst is True, the point is on the domain of the
//! first patch, otherwise the point is on the domain of the
//! second surface.
Standard_EXPORT void SetArc (const Standard_Boolean OnFirst, const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Param, const IntSurf_Transition& TLine, const IntSurf_Transition& TArc);
Standard_EXPORT void SetArc (const Standard_Boolean OnFirst, const Handle(Adaptor2d_Curve2d)& A, const Standard_Real Param, const IntSurf_Transition& TLine, const IntSurf_Transition& TArc);
//! Sets (or unsets) the point as a point on several
//! intersection line.
@@ -133,7 +133,7 @@ public:
//! vertex.
//! The exception DomainError is raised if
//! IsOnDomS1 returns False.
const Handle(Adaptor2d_HCurve2d)& ArcOnS1() const;
const Handle(Adaptor2d_Curve2d)& ArcOnS1() const;
//! Returns the transition of the point on the
//! intersection line with the arc on S1.
@@ -172,7 +172,7 @@ public:
//! vertex.
//! The exception DomainError is raised if
//! IsOnDomS2 returns False.
const Handle(Adaptor2d_HCurve2d)& ArcOnS2() const;
const Handle(Adaptor2d_Curve2d)& ArcOnS2() const;
//! Returns the transition of the point on the
//! intersection line with the arc on S2.
@@ -229,14 +229,14 @@ private:
Standard_Boolean onS1;
Standard_Boolean vtxonS1;
Handle(Adaptor3d_HVertex) vS1;
Handle(Adaptor2d_HCurve2d) arcS1;
Handle(Adaptor2d_Curve2d) arcS1;
IntSurf_Transition traline1;
IntSurf_Transition tra1;
Standard_Real prm1;
Standard_Boolean onS2;
Standard_Boolean vtxonS2;
Handle(Adaptor3d_HVertex) vS2;
Handle(Adaptor2d_HCurve2d) arcS2;
Handle(Adaptor2d_Curve2d) arcS2;
IntSurf_Transition traline2;
IntSurf_Transition tra2;
Standard_Real prm2;

4
src/IntPatch/IntPatch_Point.lxx
View File

@@ -124,7 +124,7 @@ inline const Handle(Adaptor3d_HVertex)& IntPatch_Point::VertexOnS1 () const
}
inline const Handle(Adaptor2d_HCurve2d)& IntPatch_Point::ArcOnS1 () const
inline const Handle(Adaptor2d_Curve2d)& IntPatch_Point::ArcOnS1 () const
{
if (!onS1) {throw Standard_DomainError();}
return arcS1;
@@ -171,7 +171,7 @@ inline const Handle(Adaptor3d_HVertex)& IntPatch_Point::VertexOnS2 () const
}
inline const Handle(Adaptor2d_HCurve2d)& IntPatch_Point::ArcOnS2 () const
inline const Handle(Adaptor2d_Curve2d)& IntPatch_Point::ArcOnS2 () const
{
if (!onS2) {throw Standard_DomainError();}
return arcS2;

6
src/IntPatch/IntPatch_PointLine.cxx
View File

@@ -16,7 +16,7 @@
#include <IntPatch_PointLine.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <IntSurf_PntOn2S.hxx>
#include <Precision.hxx>
@@ -45,8 +45,8 @@ IntPatch_PointLine::IntPatch_PointLine (const Standard_Boolean Tang) :
// Returns negative value if computation is not possible
//=======================================================================
Standard_Real IntPatch_PointLine::
CurvatureRadiusOfIntersLine(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
CurvatureRadiusOfIntersLine(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const IntSurf_PntOn2S& theUVPoint)
{
const Standard_Real aSmallValue = 1.0/Precision::Infinite();

7
src/IntPatch/IntPatch_PointLine.hxx
View File

@@ -17,15 +17,14 @@
#ifndef _IntPatch_PointLine_HeaderFile
#define _IntPatch_PointLine_HeaderFile
#include <Adaptor3d_Surface.hxx>
#include <IntPatch_Line.hxx>
#include <Standard_Type.hxx>
class gp_Pnt;
class gp_Pnt2d;
class IntSurf_PntOn2S;
class IntSurf_LineOn2S;
class IntPatch_Point;
class Adaptor3d_HSurface;
DEFINE_STANDARD_HANDLE(IntPatch_PointLine, IntPatch_Line)
@@ -84,8 +83,8 @@ public:
//! the intersection line in given point.
//! Returns negative value if computation is not possible.
Standard_EXPORT static Standard_Real
CurvatureRadiusOfIntersLine(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
CurvatureRadiusOfIntersLine(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const IntSurf_PntOn2S& theUVPoint);
DEFINE_STANDARD_RTTIEXT(IntPatch_PointLine,IntPatch_Line)

4
src/IntPatch/IntPatch_PolyArc.cxx
View File

@@ -15,7 +15,7 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Bnd_Box2d.hxx>
#include <gp_Pnt2d.hxx>
#include <IntPatch_PolyArc.hxx>
@@ -32,7 +32,7 @@ inline void MinMax (const Standard_Real a1, const Standard_Real a2,
}
}
IntPatch_PolyArc::IntPatch_PolyArc(const Handle(Adaptor2d_HCurve2d)& Line ,
IntPatch_PolyArc::IntPatch_PolyArc(const Handle(Adaptor2d_Curve2d)& Line ,
const Standard_Integer NbSample,
const Standard_Real aPdeb,
const Standard_Real aPfin,

3
src/IntPatch/IntPatch_PolyArc.hxx
View File

@@ -28,7 +28,6 @@
#include <IntPatch_Polygo.hxx>
#include <Standard_Integer.hxx>
class Standard_ConstructionError;
class Adaptor2d_HCurve2d;
class Bnd_Box2d;
class gp_Pnt2d;
@@ -44,7 +43,7 @@ public:
//! Creates the polygon of the arc A on the surface S.
//! The arc is limited by the parameters Pfirst and Plast.
//! None of these parameters can be infinite.
Standard_EXPORT IntPatch_PolyArc(const Handle(Adaptor2d_HCurve2d)& A, const Standard_Integer NbSample, const Standard_Real Pfirst, const Standard_Real Plast, const Bnd_Box2d& BoxOtherPolygon);
Standard_EXPORT IntPatch_PolyArc(const Handle(Adaptor2d_Curve2d)& A, const Standard_Integer NbSample, const Standard_Real Pfirst, const Standard_Real Plast, const Bnd_Box2d& BoxOtherPolygon);
Standard_EXPORT virtual Standard_Boolean Closed() const Standard_OVERRIDE;

12
src/IntPatch/IntPatch_Polyhedron.cxx
View File

@@ -15,7 +15,7 @@
// commercial license or contractual agreement.
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Bnd_Array1OfBox.hxx>
#include <Bnd_Box.hxx>
#include <gp_Pnt.hxx>
@@ -37,7 +37,7 @@
#define NBMAXUV 30
//================================================================================
static Standard_Integer NbPOnU (const Handle(Adaptor3d_HSurface)& S)
static Standard_Integer NbPOnU (const Handle(Adaptor3d_Surface)& S)
{
const Standard_Real u0 = S->FirstUParameter();
const Standard_Real u1 = S->LastUParameter();
@@ -45,7 +45,7 @@ static Standard_Integer NbPOnU (const Handle(Adaptor3d_HSurface)& S)
return (nbpu>NBMAXUV? NBMAXUV : nbpu);
}
//================================================================================
static Standard_Integer NbPOnV (const Handle(Adaptor3d_HSurface)& S)
static Standard_Integer NbPOnV (const Handle(Adaptor3d_Surface)& S)
{
const Standard_Real v0 = S->FirstVParameter();
const Standard_Real v1 = S->LastVParameter();
@@ -69,7 +69,7 @@ void IntPatch_Polyhedron::Destroy()
//function : IntPatch_Polyhedron
//purpose :
//=======================================================================
IntPatch_Polyhedron::IntPatch_Polyhedron (const Handle(Adaptor3d_HSurface)& Surface)
IntPatch_Polyhedron::IntPatch_Polyhedron (const Handle(Adaptor3d_Surface)& Surface)
: TheDeflection(Epsilon(100.)),
nbdeltaU(NbPOnU(Surface)),
nbdeltaV(NbPOnV(Surface)),
@@ -126,7 +126,7 @@ IntPatch_Polyhedron::IntPatch_Polyhedron (const Handle(Adaptor3d_HSurface)& Surf
//function : IntPatch_Polyhedron
//purpose :
//=======================================================================
IntPatch_Polyhedron::IntPatch_Polyhedron (const Handle(Adaptor3d_HSurface)& Surface,
IntPatch_Polyhedron::IntPatch_Polyhedron (const Handle(Adaptor3d_Surface)& Surface,
const Standard_Integer nbu,
const Standard_Integer nbv)
: TheDeflection(Epsilon(100.)),
@@ -188,7 +188,7 @@ IntPatch_Polyhedron::IntPatch_Polyhedron (const Handle(Adaptor3d_HSurface)& Surf
//=======================================================================
Standard_Real IntPatch_Polyhedron::DeflectionOnTriangle
(const Handle(Adaptor3d_HSurface)& Surface,
(const Handle(Adaptor3d_Surface)& Surface,
const Standard_Integer Triang) const
{
Standard_Integer i1,i2,i3;

23
src/IntPatch/IntPatch_Polyhedron.hxx
View File

@@ -17,22 +17,9 @@
#ifndef _IntPatch_Polyhedron_HeaderFile
#define _IntPatch_Polyhedron_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Bnd_Box.hxx>
#include <Bnd_HArray1OfBox.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Address.hxx>
#include <Standard_Boolean.hxx>
class Standard_OutOfRange;
class Adaptor3d_HSurface;
class gp_Pnt;
class Bnd_Box;
class gp_XYZ;
//! This class provides a linear approximation of the PSurface.
//! preview a constructor on a zone of a surface
@@ -45,9 +32,9 @@ public:
//! MaTriangle constructor with an double array of pnt for the
//! representation of a double array of triangles.
Standard_EXPORT IntPatch_Polyhedron(const Handle(Adaptor3d_HSurface)& Surface, const Standard_Integer nbdU, const Standard_Integer nbdV);
Standard_EXPORT IntPatch_Polyhedron(const Handle(Adaptor3d_Surface)& Surface, const Standard_Integer nbdU, const Standard_Integer nbdV);
Standard_EXPORT IntPatch_Polyhedron(const Handle(Adaptor3d_HSurface)& Surface);
Standard_EXPORT IntPatch_Polyhedron(const Handle(Adaptor3d_Surface)& Surface);
Standard_EXPORT void Destroy();
~IntPatch_Polyhedron()
@@ -55,11 +42,11 @@ public:
Destroy();
}
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Surface, const Standard_Integer nbdU, const Standard_Integer nbdV);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& Surface, const Standard_Integer nbdU, const Standard_Integer nbdV);
Standard_EXPORT void DeflectionOverEstimation (const Standard_Real flec);
Standard_EXPORT Standard_Real DeflectionOnTriangle (const Handle(Adaptor3d_HSurface)& Surface, const Standard_Integer Index) const;
Standard_EXPORT Standard_Real DeflectionOnTriangle (const Handle(Adaptor3d_Surface)& Surface, const Standard_Integer Index) const;
Standard_EXPORT void UMinSingularity (const Standard_Boolean Sing);

58
src/IntPatch/IntPatch_PrmPrmIntersection.cxx
View File

@@ -17,7 +17,7 @@
// modified by Edward AGAPOV (eap) Tue Jan 22 12:29:55 2002
// modified by Oleg FEDYAED (ofv) Fri Nov 29 16:08:02 2002
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>
@@ -53,8 +53,8 @@ static void SectionPointToParameters(const Intf_SectionPoint& Sp,
static
void AdjustOnPeriodic(const Handle(Adaptor3d_HSurface)& Surf1,
const Handle(Adaptor3d_HSurface)& Surf2,
void AdjustOnPeriodic(const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_Surface)& Surf2,
IntPatch_SequenceOfLine& aSLin);
static
@@ -70,8 +70,8 @@ static void AddWLine(IntPatch_SequenceOfLine &theLines,
const Handle(IntPatch_WLine) &theWLine,
const Standard_Real Deflection);
static void SeveralWlinesProcessing(const Handle(Adaptor3d_HSurface)& theSurf1,
const Handle(Adaptor3d_HSurface)& theSurf2,
static void SeveralWlinesProcessing(const Handle(Adaptor3d_Surface)& theSurf1,
const Handle(Adaptor3d_Surface)& theSurf2,
const IntPatch_SequenceOfLine& theSLin,
const Standard_Real* const thePeriodsArr,
const IntSurf_TypeTrans theTrans1,
@@ -114,10 +114,10 @@ static void SeveralWlinesProcessing(const Handle(Adaptor3d_HSurface)& theSurf1,
const gp_Pnt2d aPTS1(aU1, aV1), aPTS2(aU2, aV2);
Standard_Real tDistance = cPV.Distance(tPV);
Standard_Real uRs1 = theSurf1->Surface().UResolution(tDistance);
Standard_Real vRs1 = theSurf1->Surface().VResolution(tDistance);
Standard_Real uRs2 = theSurf2->Surface().UResolution(tDistance);
Standard_Real vRs2 = theSurf2->Surface().VResolution(tDistance);
Standard_Real uRs1 = theSurf1->UResolution(tDistance);
Standard_Real vRs1 = theSurf1->VResolution(tDistance);
Standard_Real uRs2 = theSurf2->UResolution(tDistance);
Standard_Real vRs2 = theSurf2->VResolution(tDistance);
Standard_Real RmaxS1 = Max(uRs1,vRs1);
Standard_Real RmaxS2 = Max(uRs2,vRs2);
@@ -312,7 +312,7 @@ IntPatch_PrmPrmIntersection::IntPatch_PrmPrmIntersection()
// function : Perform
// purpose :
//==================================================================================
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Surf1,
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_TopolTool)& D1,
const Standard_Real TolTangency,
const Standard_Real Epsilon,
@@ -327,10 +327,10 @@ void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& S
// function : Perform
// purpose :
//==================================================================================
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Surf1,
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_Surface)& Surf1,
const IntPatch_Polyhedron& Poly1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor3d_Surface)& Surf2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolTangency,
const Standard_Real Epsilon,
@@ -345,9 +345,9 @@ void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& S
// function : Perform
// purpose :
//==================================================================================
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Surf1,
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor3d_Surface)& Surf2,
const IntPatch_Polyhedron& Poly2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolTangency,
@@ -363,10 +363,10 @@ void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& S
// function : Perform
// purpose :
//==================================================================================
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Surf1,
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_Surface)& Surf1,
const IntPatch_Polyhedron& Poly1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor3d_Surface)& Surf2,
const IntPatch_Polyhedron& Poly2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolTangency,
@@ -787,7 +787,7 @@ void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)&
// function : Perform
// purpose :
//==================================================================================
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Surf1,
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_Surface)& Surf1,
const IntPatch_Polyhedron& Poly1,
const Handle(Adaptor3d_TopolTool)& D1,
const Standard_Real TolTangency,
@@ -1236,8 +1236,8 @@ void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)&
// function : NewLine
// purpose :
//==================================================================================
Handle(IntPatch_Line) IntPatch_PrmPrmIntersection::NewLine (const Handle(Adaptor3d_HSurface)& Surf1,
const Handle(Adaptor3d_HSurface)& Surf2,
Handle(IntPatch_Line) IntPatch_PrmPrmIntersection::NewLine (const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_Surface)& Surf2,
const Standard_Integer NumLine,
const Standard_Integer Low,
const Standard_Integer High,
@@ -1557,9 +1557,9 @@ void IntPatch_PrmPrmIntersection::Remplit(const Standard_Integer a,
//function : Perform
//purpose :
//=======================================================================
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Surf1,
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor3d_Surface)& Surf2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolTangency,
const Standard_Real Epsilon,
@@ -1847,9 +1847,9 @@ void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)&
//function : Perform
//purpose :
//=======================================================================
void IntPatch_PrmPrmIntersection::Perform(const Handle(Adaptor3d_HSurface)& Surf1,
void IntPatch_PrmPrmIntersection::Perform(const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor3d_Surface)& Surf2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real U1Depart,
const Standard_Real V1Depart,
@@ -1994,8 +1994,8 @@ void IntPatch_PrmPrmIntersection::Perform(const Handle(Adaptor3d_HSurface)& S
// function : AdjustOnPeriodic
// purpose :
//==================================================================================
void AdjustOnPeriodic(const Handle(Adaptor3d_HSurface)& Surf1,
const Handle(Adaptor3d_HSurface)& Surf2,
void AdjustOnPeriodic(const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_Surface)& Surf2,
IntPatch_SequenceOfLine& aSLin)
{
Standard_Boolean bIsPeriodic[4], bModified, bIsNull, bIsPeriod;
@@ -2134,9 +2134,9 @@ IntSurf_PntOn2S MakeNewPoint(const IntSurf_PntOn2S& replacePnt,
// function : Perform
// purpose : base SS Int. function
//==================================================================================
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_HSurface)& Surf1,
void IntPatch_PrmPrmIntersection::Perform (const Handle(Adaptor3d_Surface)& Surf1,
const Handle(Adaptor3d_TopolTool)& D1,
const Handle(Adaptor3d_HSurface)& Surf2,
const Handle(Adaptor3d_Surface)& Surf2,
const Handle(Adaptor3d_TopolTool)& D2,
const Standard_Real TolTangency,
const Standard_Real Epsilon,
@@ -3050,10 +3050,10 @@ private:
// purpose :
//==================================================================================
void IntPatch_PrmPrmIntersection::PointDepart(Handle(IntSurf_LineOn2S)& LineOn2S,
const Handle(Adaptor3d_HSurface)& S1,
const Handle(Adaptor3d_Surface)& S1,
const Standard_Integer SU_1,
const Standard_Integer SV_1,
const Handle(Adaptor3d_HSurface)& S2,
const Handle(Adaptor3d_Surface)& S2,
const Standard_Integer SU_2,
const Standard_Integer SV_2) const
{

36
src/IntPatch/IntPatch_PrmPrmIntersection.hxx
View File

@@ -17,25 +17,15 @@
#ifndef _IntPatch_PrmPrmIntersection_HeaderFile
#define _IntPatch_PrmPrmIntersection_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <IntPatch_SequenceOfLine.hxx>
#include <Standard_Real.hxx>
#include <IntSurf_ListOfPntOn2S.hxx>
#include <Standard_Integer.hxx>
class Standard_OutOfRange;
class StdFail_NotDone;
class Adaptor3d_HSurface;
class IntPatch_Polyhedron;
class Adaptor3d_TopolTool;
class IntPatch_Line;
class IntPatch_Polyhedron;
class IntPatch_PrmPrmIntersection_T3Bits;
class IntSurf_LineOn2S;
//! Implementation of the Intersection between two
//! bi-parametrised surfaces.
//!
@@ -56,29 +46,29 @@ public:
//! Performs the intersection between <Caro1> and
//! <Caro2>. Associated Polyhedrons <Polyhedron1>
//! and <Polyhedron2> are given.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Caro1, const IntPatch_Polyhedron& Polyhedron1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_HSurface)& Caro2, const IntPatch_Polyhedron& Polyhedron2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& Caro1, const IntPatch_Polyhedron& Polyhedron1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_Surface)& Caro2, const IntPatch_Polyhedron& Polyhedron2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Caro1, const IntPatch_Polyhedron& Polyhedron1, const Handle(Adaptor3d_TopolTool)& Domain1, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& Caro1, const IntPatch_Polyhedron& Polyhedron1, const Handle(Adaptor3d_TopolTool)& Domain1, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
//! Performs the intersection between <Caro1> and
//! <Caro2>. The method computes the polyhedron on
//! each surface.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Caro1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_HSurface)& Caro2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment, const Standard_Boolean ClearFlag = Standard_True);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& Caro1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_Surface)& Caro2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment, const Standard_Boolean ClearFlag = Standard_True);
//! Performs the intersection between <Caro1> and
//! <Caro2>. The method computes the polyhedron on
//! each surface.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Caro1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_HSurface)& Caro2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment, IntSurf_ListOfPntOn2S& ListOfPnts);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& Caro1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_Surface)& Caro2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment, IntSurf_ListOfPntOn2S& ListOfPnts);
//! Performs the intersection between <Caro1> and
//! <Caro2>. The method computes the polyhedron on
//! each surface.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Caro1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_HSurface)& Caro2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& Caro1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_Surface)& Caro2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real U1, const Standard_Real V1, const Standard_Real U2, const Standard_Real V2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
//! Performs the intersection between <Caro1> and
//! <Caro2>. The method computes the polyhedron on
//! each surface.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Caro1, const Handle(Adaptor3d_TopolTool)& Domain1, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& Caro1, const Handle(Adaptor3d_TopolTool)& Domain1, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
//! Performs the intersection between <Caro1> and
//! <Caro2>.
@@ -86,7 +76,7 @@ public:
//! The polyhedron which approximates <Caro2>,
//! <Polyhedron2> is given. The other one is
//! computed.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Caro1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_HSurface)& Caro2, const IntPatch_Polyhedron& Polyhedron2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& Caro1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_Surface)& Caro2, const IntPatch_Polyhedron& Polyhedron2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
//! Performs the intersection between <Caro1> and
//! <Caro2>.
@@ -94,7 +84,7 @@ public:
//! The polyhedron which approximates <Caro1>,
//! <Polyhedron1> is given. The other one is
//! computed.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Caro1, const IntPatch_Polyhedron& Polyhedron1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_HSurface)& Caro2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
Standard_EXPORT void Perform (const Handle(Adaptor3d_Surface)& Caro1, const IntPatch_Polyhedron& Polyhedron1, const Handle(Adaptor3d_TopolTool)& Domain1, const Handle(Adaptor3d_Surface)& Caro2, const Handle(Adaptor3d_TopolTool)& Domain2, const Standard_Real TolTangency, const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Increment);
//! Returns true if the calculus was succesfull.
Standard_Boolean IsDone() const;
@@ -121,7 +111,7 @@ public:
//!
//! An exception is raised if Index<=0 or Index>NbLine.
//! or if IsDone returns False
Standard_EXPORT Handle(IntPatch_Line) NewLine (const Handle(Adaptor3d_HSurface)& Caro1, const Handle(Adaptor3d_HSurface)& Caro2, const Standard_Integer IndexLine, const Standard_Integer LowPoint, const Standard_Integer HighPoint, const Standard_Integer NbPoints) const;
Standard_EXPORT Handle(IntPatch_Line) NewLine (const Handle(Adaptor3d_Surface)& Caro1, const Handle(Adaptor3d_Surface)& Caro2, const Standard_Integer IndexLine, const Standard_Integer LowPoint, const Standard_Integer HighPoint, const Standard_Integer NbPoints) const;
Standard_Integer GrilleInteger (const Standard_Integer ix, const Standard_Integer iy, const Standard_Integer iz) const;
@@ -139,7 +129,7 @@ public:
Standard_Integer CodeReject (const Standard_Real x1, const Standard_Real y1, const Standard_Real z1, const Standard_Real x2, const Standard_Real y2, const Standard_Real z2, const Standard_Real x3, const Standard_Real y3, const Standard_Real z3) const;
Standard_EXPORT void PointDepart (Handle(IntSurf_LineOn2S)& LineOn2S, const Handle(Adaptor3d_HSurface)& S1, const Standard_Integer SU1, const Standard_Integer SV1, const Handle(Adaptor3d_HSurface)& S2, const Standard_Integer SU2, const Standard_Integer SV2) const;
Standard_EXPORT void PointDepart (Handle(IntSurf_LineOn2S)& LineOn2S, const Handle(Adaptor3d_Surface)& S1, const Standard_Integer SU1, const Standard_Integer SV1, const Handle(Adaptor3d_Surface)& S2, const Standard_Integer SU2, const Standard_Integer SV2) const;

6
src/IntPatch/IntPatch_RLine.cxx
View File

@@ -15,7 +15,7 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <IntPatch_Point.hxx>
#include <IntPatch_RLine.hxx>
#include <IntSurf_LineOn2S.hxx>
@@ -110,12 +110,12 @@ void IntPatch_RLine::ParamOnS2(Standard_Real& a,Standard_Real& b) const {
}
void IntPatch_RLine::SetArcOnS1(const Handle(Adaptor2d_HCurve2d)& A) {
void IntPatch_RLine::SetArcOnS1(const Handle(Adaptor2d_Curve2d)& A) {
theArcOnS1 = A;
onS1=Standard_True;
}
void IntPatch_RLine::SetArcOnS2(const Handle(Adaptor2d_HCurve2d)& A) {
void IntPatch_RLine::SetArcOnS2(const Handle(Adaptor2d_Curve2d)& A) {
theArcOnS2 = A;
onS2=Standard_True;
}

14
src/IntPatch/IntPatch_RLine.hxx
View File

@@ -28,7 +28,7 @@
#include <IntSurf_LineOn2S.hxx>
#include <IntSurf_Situation.hxx>
#include <IntSurf_TypeTrans.hxx>
class Adaptor2d_HCurve2d;
class Standard_DomainError;
class Standard_OutOfRange;
class IntPatch_Point;
@@ -86,19 +86,19 @@ public:
//! the second patch.
Standard_Boolean IsArcOnS2() const;
Standard_EXPORT void SetArcOnS1 (const Handle(Adaptor2d_HCurve2d)& A);
Standard_EXPORT void SetArcOnS1 (const Handle(Adaptor2d_Curve2d)& A);
Standard_EXPORT void SetArcOnS2 (const Handle(Adaptor2d_HCurve2d)& A);
Standard_EXPORT void SetArcOnS2 (const Handle(Adaptor2d_Curve2d)& A);
Standard_EXPORT void SetParamOnS1 (const Standard_Real p1, const Standard_Real p2);
Standard_EXPORT void SetParamOnS2 (Standard_Real& p1, Standard_Real& p2);
//! Returns the concerned arc.
const Handle(Adaptor2d_HCurve2d)& ArcOnS1() const;
const Handle(Adaptor2d_Curve2d)& ArcOnS1() const;
//! Returns the concerned arc.
const Handle(Adaptor2d_HCurve2d)& ArcOnS2() const;
const Handle(Adaptor2d_Curve2d)& ArcOnS2() const;
Standard_EXPORT void ParamOnS1 (Standard_Real& p1, Standard_Real& p2) const;
@@ -199,8 +199,8 @@ protected:
private:
Handle(Adaptor2d_HCurve2d) theArcOnS1;
Handle(Adaptor2d_HCurve2d) theArcOnS2;
Handle(Adaptor2d_Curve2d) theArcOnS1;
Handle(Adaptor2d_Curve2d) theArcOnS2;
Standard_Boolean onS1;
Standard_Boolean onS2;
Standard_Real ParamInf1;

8
src/IntPatch/IntPatch_RLine.lxx
View File

@@ -19,18 +19,18 @@
#include <IntPatch_Point.hxx>
inline const Handle(Adaptor2d_HCurve2d)& IntPatch_RLine::ArcOnS1() const
inline const Handle(Adaptor2d_Curve2d)& IntPatch_RLine::ArcOnS1() const
{
return theArcOnS1;
}
inline const Handle(Adaptor2d_HCurve2d)& IntPatch_RLine::ArcOnS2() const
inline const Handle(Adaptor2d_Curve2d)& IntPatch_RLine::ArcOnS2() const
{
return theArcOnS2;
}
//-- Il faut mettre cet include ici , car l include fait un define Handle(Adaptor2d_HCurve2d) ...
//-- et en fin de fichier un undef Handle(Adaptor2d_HCurve2d) ...
//-- Il faut mettre cet include ici , car l include fait un define Handle(Adaptor2d_Curve2d) ...
//-- et en fin de fichier un undef Handle(Adaptor2d_Curve2d) ...
inline void IntPatch_RLine::AddVertex (const IntPatch_Point& thePnt,
const Standard_Boolean theIsPrepend)

24
src/IntPatch/IntPatch_RstInt.cxx
View File

@@ -25,8 +25,8 @@
//-- - Pour rester coherent avec cette facon de faire,
//-- Chercher(Nbvtx++).
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <gp_Pnt2d.hxx>
#include <Intf_SectionPoint.hxx>
@@ -109,7 +109,7 @@ inline Standard_Real Tol3d (const Handle(Adaptor3d_HVertex)& vtx,
: tolDef);
}
inline Standard_Real Tol3d (const Handle(Adaptor2d_HCurve2d)& arc,
inline Standard_Real Tol3d (const Handle(Adaptor2d_Curve2d)& arc,
const Handle(Adaptor3d_TopolTool)& Domain,
const Standard_Real tolDef = 0.)
{
@@ -119,8 +119,8 @@ inline Standard_Real Tol3d (const Handle(Adaptor2d_HCurve2d)& arc,
}
static Standard_Boolean CoincideOnArc(const gp_Pnt& Ptsommet,
const Handle(Adaptor2d_HCurve2d)& A,
const Handle(Adaptor3d_HSurface)& Surf,
const Handle(Adaptor2d_Curve2d)& A,
const Handle(Adaptor3d_Surface)& Surf,
const Standard_Real Toler,
const Handle(Adaptor3d_TopolTool)& Domain,
Handle(Adaptor3d_HVertex)& Vtx)
@@ -235,7 +235,7 @@ static void GetLinePoint2d (const Handle(IntPatch_Line)& L,
}
static Standard_Boolean FindParameter(const Handle(IntPatch_Line)& L,
const Handle(Adaptor3d_HSurface)& OtherSurf,
const Handle(Adaptor3d_Surface)& OtherSurf,
const Standard_Real Tol,
const gp_Pnt& Ptsom,
const gp_Pnt2d& Ptsom2d,
@@ -366,9 +366,9 @@ inline Standard_Boolean ArePnt2dEqual(const gp_Pnt2d& p1, const gp_Pnt2d& p2,
//=======================================================================
void IntPatch_RstInt::PutVertexOnLine (const Handle(IntPatch_Line)& L,
const Handle(Adaptor3d_HSurface)& Surf,
const Handle(Adaptor3d_Surface)& Surf,
const Handle(Adaptor3d_TopolTool)& Domain,
const Handle(Adaptor3d_HSurface)& OtherSurf,
const Handle(Adaptor3d_Surface)& OtherSurf,
const Standard_Boolean OnFirst,
const Standard_Real Tol)
{
@@ -404,7 +404,7 @@ void IntPatch_RstInt::PutVertexOnLine (const Handle(IntPatch_Line)& L,
IntPatch_Point Sommet, ptline;
Handle(Adaptor3d_HVertex) vtxarc,vtxline;
Handle(Adaptor2d_HCurve2d) arc;
Handle(Adaptor2d_Curve2d) arc;
Standard_Boolean VtxOnArc, duplicate, found;
IntSurf_Transition transarc,transline;
@@ -447,8 +447,8 @@ void IntPatch_RstInt::PutVertexOnLine (const Handle(IntPatch_Line)& L,
//-- il faut dans ce cas considerer la restriction --
//-- la restriction decalee de +-2PI --
//------------------------------------------------------------------------
const Handle(Adaptor3d_HSurface)& Surf1 = (OnFirst ? Surf : OtherSurf);
const Handle(Adaptor3d_HSurface)& Surf2 = (OnFirst ? OtherSurf : Surf);
const Handle(Adaptor3d_Surface)& Surf1 = (OnFirst ? Surf : OtherSurf);
const Handle(Adaptor3d_Surface)& Surf2 = (OnFirst ? OtherSurf : Surf);
GeomAbs_SurfaceType TypeS1 = Surf1->GetType();
GeomAbs_SurfaceType TypeS2 = Surf2->GetType();
Standard_Boolean SurfaceIsPeriodic = Standard_False;
@@ -509,7 +509,7 @@ void IntPatch_RstInt::PutVertexOnLine (const Handle(IntPatch_Line)& L,
Standard_Real aXmin, aYmin, aXmax, aYmax;
BPLin.Get(aXmin, aYmin, aXmax, aYmax);
gp_Lin2d aLin = arc->Curve2d().Line();
gp_Lin2d aLin = arc->Line();
const gp_Pnt2d& aLoc = aLin.Location();
const gp_Dir2d& aDir = aLin.Direction();

12
src/IntPatch/IntPatch_RstInt.hxx
View File

@@ -17,18 +17,12 @@
#ifndef _IntPatch_RstInt_HeaderFile
#define _IntPatch_RstInt_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
class Standard_DomainError;
class IntPatch_Line;
class Adaptor3d_HSurface;
class Adaptor3d_TopolTool;
//! trouver les points d intersection entre la ligne de
//! cheminement et les arcs de restriction
class IntPatch_RstInt
@@ -39,9 +33,9 @@ public:
Standard_EXPORT static void PutVertexOnLine (const Handle(IntPatch_Line)& L,
const Handle(Adaptor3d_HSurface)& Surf,
const Handle(Adaptor3d_Surface)& Surf,
const Handle(Adaptor3d_TopolTool)& Domain,
const Handle(Adaptor3d_HSurface)& OtherSurf,
const Handle(Adaptor3d_Surface)& OtherSurf,
const Standard_Boolean OnFirst,
const Standard_Real Tol);

34
src/IntPatch/IntPatch_SpecialPoints.cxx
View File

@@ -15,7 +15,7 @@
#include <IntPatch_SpecialPoints.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <ElCLib.hxx>
#include <Extrema_ExtPS.hxx>
#include <Extrema_GenLocateExtPS.hxx>
@@ -34,8 +34,8 @@
class FuncPreciseSeam: public math_FunctionSetWithDerivatives
{
public:
FuncPreciseSeam(const Handle(Adaptor3d_HSurface)& theQSurf, // quadric
const Handle(Adaptor3d_HSurface)& thePSurf, // another surface
FuncPreciseSeam(const Handle(Adaptor3d_Surface)& theQSurf, // quadric
const Handle(Adaptor3d_Surface)& thePSurf, // another surface
const Standard_Boolean isTheUSeam,
const Standard_Real theIsoParameter):
myQSurf(theQSurf),
@@ -131,8 +131,8 @@ protected:
FuncPreciseSeam operator=(FuncPreciseSeam&);
private:
const Handle(Adaptor3d_HSurface)& myQSurf;
const Handle(Adaptor3d_HSurface)& myPSurf;
const Handle(Adaptor3d_Surface)& myQSurf;
const Handle(Adaptor3d_Surface)& myPSurf;
//! 1 for U-coordinate, 0 - for V one.
const Standard_Integer mySeamCoordInd;
@@ -164,7 +164,7 @@ static inline void GetTangent(const Standard_Real theConeSemiAngle,
// Returns the foot of projection (theProjPt) and its parameters
// on theSurf.
//=======================================================================
static Standard_Boolean IsPointOnSurface(const Handle(Adaptor3d_HSurface)& theSurf,
static Standard_Boolean IsPointOnSurface(const Handle(Adaptor3d_Surface)& theSurf,
const gp_Pnt& thePt,
const Standard_Real theTol,
gp_Pnt& theProjPt,
@@ -183,7 +183,7 @@ static Standard_Boolean IsPointOnSurface(const Handle(Adaptor3d_HSurface)& theSu
case GeomAbs_SurfaceOfExtrusion:
case GeomAbs_SurfaceOfRevolution:
{
Extrema_ExtPS anExtr(thePt, theSurf->Surface(), theSurf->UResolution(theTol),
Extrema_ExtPS anExtr(thePt, *theSurf, theSurf->UResolution(theTol),
theSurf->VResolution(theTol), Extrema_ExtFlag_MIN);
if(!anExtr.IsDone() || (anExtr.NbExt() < 1))
{
@@ -218,7 +218,7 @@ static Standard_Boolean IsPointOnSurface(const Handle(Adaptor3d_HSurface)& theSu
break;
default:
{
Extrema_GenLocateExtPS anExtr(theSurf->Surface());
Extrema_GenLocateExtPS anExtr (*theSurf);
anExtr.Perform(thePt, theUpar, theVpar);
if(!anExtr.IsDone() || (anExtr.SquareDistance() > theTol*theTol))
{
@@ -243,8 +243,8 @@ static Standard_Boolean IsPointOnSurface(const Handle(Adaptor3d_HSurface)& theSu
// thePSurf is another surface to intersect.
//=======================================================================
Standard_Boolean IntPatch_SpecialPoints::
AddCrossUVIsoPoint(const Handle(Adaptor3d_HSurface)& theQSurf,
const Handle(Adaptor3d_HSurface)& thePSurf,
AddCrossUVIsoPoint(const Handle(Adaptor3d_Surface)& theQSurf,
const Handle(Adaptor3d_Surface)& thePSurf,
const IntSurf_PntOn2S& theRefPt,
const Standard_Real theTol,
IntSurf_PntOn2S& theAddedPoint,
@@ -268,7 +268,7 @@ Standard_Boolean IntPatch_SpecialPoints::
theQSurf->D0(aUquad, aVquad, aPQuad);
Extrema_GenLocateExtPS anExtr(thePSurf->Surface());
Extrema_GenLocateExtPS anExtr (*thePSurf);
anExtr.Perform(aPQuad, aU0, aV0);
if(!anExtr.IsDone())
@@ -300,8 +300,8 @@ Standard_Boolean IntPatch_SpecialPoints::
// thePSurf is another surface to intersect.
//=======================================================================
Standard_Boolean IntPatch_SpecialPoints::
AddPointOnUorVIso(const Handle(Adaptor3d_HSurface)& theQSurf,
const Handle(Adaptor3d_HSurface)& thePSurf,
AddPointOnUorVIso(const Handle(Adaptor3d_Surface)& theQSurf,
const Handle(Adaptor3d_Surface)& thePSurf,
const IntSurf_PntOn2S& theRefPt,
const Standard_Boolean theIsU,
const Standard_Real theIsoParameter,
@@ -780,8 +780,8 @@ Standard_Integer IntPatch_SpecialPoints::GetTangentToIntLineForCone(const Standa
// Returns TRUE, if the pole is an intersection point.
//=======================================================================
Standard_Boolean IntPatch_SpecialPoints::
AddSingularPole(const Handle(Adaptor3d_HSurface)& theQSurf,
const Handle(Adaptor3d_HSurface)& thePSurf,
AddSingularPole(const Handle(Adaptor3d_Surface)& theQSurf,
const Handle(Adaptor3d_Surface)& thePSurf,
const IntSurf_PntOn2S& thePtIso,
IntPatch_Point& theVertex,
IntSurf_PntOn2S& theAddedPoint,
@@ -951,8 +951,8 @@ to the inters. curve. In this case @U_{q}@ must be recomputed.
*/
//=======================================================================
Standard_Boolean IntPatch_SpecialPoints::
ContinueAfterSpecialPoint(const Handle(Adaptor3d_HSurface)& theQSurf,
const Handle(Adaptor3d_HSurface)& thePSurf,
ContinueAfterSpecialPoint(const Handle(Adaptor3d_Surface)& theQSurf,
const Handle(Adaptor3d_Surface)& thePSurf,
const IntSurf_PntOn2S& theRefPt,
const IntPatch_SpecPntType theSPType,
const Standard_Real theTol2D,

19
src/IntPatch/IntPatch_SpecialPoints.hxx
View File

@@ -20,10 +20,9 @@
//! (such as apex of cone, pole of sphere,
//! point on surface boundary etc.) in the intersection line.
#include <Adaptor3d_Surface.hxx>
#include <IntPatch_SpecPntType.hxx>
#include <Standard_Handle.hxx>
class Adaptor3d_HSurface;
class gp_Cone;
class gp_Vec;
class gp_XYZ;
@@ -41,8 +40,8 @@ public:
//! second (otherwise, the first) surface while forming
//! intersection point IntSurf_PntOn2S.
Standard_EXPORT static Standard_Boolean
AddCrossUVIsoPoint(const Handle(Adaptor3d_HSurface)& theQSurf,
const Handle(Adaptor3d_HSurface)& thePSurf,
AddCrossUVIsoPoint(const Handle(Adaptor3d_Surface)& theQSurf,
const Handle(Adaptor3d_Surface)& thePSurf,
const IntSurf_PntOn2S& theRefPt,
const Standard_Real theTol3d,
IntSurf_PntOn2S& theAddedPoint,
@@ -61,8 +60,8 @@ public:
//! [3] - U- (if V-isoline is considered) or V-parameter
//! (if U-isoline is considered) of theQSurf.
Standard_EXPORT static Standard_Boolean
AddPointOnUorVIso(const Handle(Adaptor3d_HSurface)& theQSurf,
const Handle(Adaptor3d_HSurface)& thePSurf,
AddPointOnUorVIso(const Handle(Adaptor3d_Surface)& theQSurf,
const Handle(Adaptor3d_Surface)& thePSurf,
const IntSurf_PntOn2S& theRefPt,
const Standard_Boolean theIsU,
const Standard_Real theIsoParameter,
@@ -86,8 +85,8 @@ public:
//! ATTENTION!!!
//! theVertex must be initialized before calling the method .
Standard_EXPORT static Standard_Boolean
AddSingularPole(const Handle(Adaptor3d_HSurface)& theQSurf,
const Handle(Adaptor3d_HSurface)& thePSurf,
AddSingularPole(const Handle(Adaptor3d_Surface)& theQSurf,
const Handle(Adaptor3d_Surface)& thePSurf,
const IntSurf_PntOn2S& thePtIso,
IntPatch_Point& theVertex,
IntSurf_PntOn2S& theAddedPoint,
@@ -103,8 +102,8 @@ public:
//! theNewPoint is not only Output parameter. It is Input/Output one. I.e.
//! theNewPoint is reference point together with theRefPt.
Standard_EXPORT static Standard_Boolean
ContinueAfterSpecialPoint(const Handle(Adaptor3d_HSurface)& theQSurf,
const Handle(Adaptor3d_HSurface)& thePSurf,
ContinueAfterSpecialPoint(const Handle(Adaptor3d_Surface)& theQSurf,
const Handle(Adaptor3d_Surface)& thePSurf,
const IntSurf_PntOn2S& theRefPt,
const IntPatch_SpecPntType theSPType,
const Standard_Real theTol2D,

19
src/IntPatch/IntPatch_TheIWalking.hxx
View File

@@ -17,13 +17,8 @@
#ifndef _IntPatch_TheIWalking_HeaderFile
#define _IntPatch_TheIWalking_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <IntSurf_SequenceOfPathPoint.hxx>
#include <Standard_Real.hxx>
#include <math_Vector.hxx>
#include <IntWalk_VectorOfWalkingData.hxx>
#include <IntWalk_VectorOfInteger.hxx>
@@ -38,13 +33,11 @@
#include <TColStd_SequenceOfReal.hxx>
#include <IntWalk_StatusDeflection.hxx>
#include <Bnd_Range.hxx>
class StdFail_NotDone;
class Standard_OutOfRange;
class IntSurf_PathPoint;
class IntSurf_PathPointTool;
class IntSurf_InteriorPoint;
class IntSurf_InteriorPointTool;
class Adaptor3d_HSurface;
class Adaptor3d_HSurfaceTool;
class IntPatch_TheSurfFunction;
class IntPatch_TheIWLineOfTheIWalking;
@@ -81,11 +74,11 @@ public:
//! Searches a set of polylines starting on a point of Pnts1
//! or Pnts2.
//! Each point on a resulting polyline verifies F(u,v)=0
Standard_EXPORT void Perform (const IntSurf_SequenceOfPathPoint& Pnts1, const IntSurf_SequenceOfInteriorPoint& Pnts2, IntPatch_TheSurfFunction& Func, const Handle(Adaptor3d_HSurface)& S, const Standard_Boolean Reversed = Standard_False);
Standard_EXPORT void Perform (const IntSurf_SequenceOfPathPoint& Pnts1, const IntSurf_SequenceOfInteriorPoint& Pnts2, IntPatch_TheSurfFunction& Func, const Handle(Adaptor3d_Surface)& S, const Standard_Boolean Reversed = Standard_False);
//! Searches a set of polylines starting on a point of Pnts1.
//! Each point on a resulting polyline verifies F(u,v)=0
Standard_EXPORT void Perform (const IntSurf_SequenceOfPathPoint& Pnts1, IntPatch_TheSurfFunction& Func, const Handle(Adaptor3d_HSurface)& S, const Standard_Boolean Reversed = Standard_False);
Standard_EXPORT void Perform (const IntSurf_SequenceOfPathPoint& Pnts1, IntPatch_TheSurfFunction& Func, const Handle(Adaptor3d_Surface)& S, const Standard_Boolean Reversed = Standard_False);
//! Returns true if the calculus was successful.
Standard_Boolean IsDone() const;
@@ -204,8 +197,8 @@ private:
#define ThePointOfLoopTool_hxx <IntSurf_InteriorPointTool.hxx>
#define ThePOLIterator IntSurf_SequenceOfInteriorPoint
#define ThePOLIterator_hxx <IntSurf_SequenceOfInteriorPoint.hxx>
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurface Handle(Adaptor3d_Surface)
#define ThePSurface_hxx <Adaptor3d_Surface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define TheIWFunction IntPatch_TheSurfFunction

6
src/IntPatch/IntPatch_TheIWalking_0.cxx
View File

@@ -22,7 +22,7 @@
#include <IntSurf_PathPointTool.hxx>
#include <IntSurf_InteriorPoint.hxx>
#include <IntSurf_InteriorPointTool.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <IntPatch_TheSurfFunction.hxx>
#include <IntPatch_TheIWLineOfTheIWalking.hxx>
@@ -41,8 +41,8 @@
#define ThePointOfLoopTool_hxx <IntSurf_InteriorPointTool.hxx>
#define ThePOLIterator IntSurf_SequenceOfInteriorPoint
#define ThePOLIterator_hxx <IntSurf_SequenceOfInteriorPoint.hxx>
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurface Handle(Adaptor3d_Surface)
#define ThePSurface_hxx <Adaptor3d_Surface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define TheIWFunction IntPatch_TheSurfFunction

27
src/IntPatch/IntPatch_ThePathPointOfTheSOnBounds.hxx
View File

@@ -17,20 +17,13 @@
#ifndef _IntPatch_ThePathPointOfTheSOnBounds_HeaderFile
#define _IntPatch_ThePathPointOfTheSOnBounds_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
class Adaptor3d_HVertex;
class Adaptor2d_HCurve2d;
class Standard_DomainError;
class gp_Pnt;
class IntPatch_ThePathPointOfTheSOnBounds
{
public:
@@ -40,13 +33,13 @@ public:
Standard_EXPORT IntPatch_ThePathPointOfTheSOnBounds();
Standard_EXPORT IntPatch_ThePathPointOfTheSOnBounds(const gp_Pnt& P, const Standard_Real Tol, const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Parameter);
Standard_EXPORT IntPatch_ThePathPointOfTheSOnBounds(const gp_Pnt& P, const Standard_Real Tol, const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_Curve2d)& A, const Standard_Real Parameter);
Standard_EXPORT IntPatch_ThePathPointOfTheSOnBounds(const gp_Pnt& P, const Standard_Real Tol, const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Parameter);
Standard_EXPORT IntPatch_ThePathPointOfTheSOnBounds(const gp_Pnt& P, const Standard_Real Tol, const Handle(Adaptor2d_Curve2d)& A, const Standard_Real Parameter);
void SetValue (const gp_Pnt& P, const Standard_Real Tol, const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Parameter);
void SetValue (const gp_Pnt& P, const Standard_Real Tol, const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_Curve2d)& A, const Standard_Real Parameter);
void SetValue (const gp_Pnt& P, const Standard_Real Tol, const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Parameter);
void SetValue (const gp_Pnt& P, const Standard_Real Tol, const Handle(Adaptor2d_Curve2d)& A, const Standard_Real Parameter);
const gp_Pnt& Value() const;
@@ -56,7 +49,7 @@ public:
const Handle(Adaptor3d_HVertex)& Vertex() const;
const Handle(Adaptor2d_HCurve2d)& Arc() const;
const Handle(Adaptor2d_Curve2d)& Arc() const;
Standard_Real Parameter() const;
@@ -77,7 +70,7 @@ private:
Standard_Real tol;
Standard_Boolean isnew;
Handle(Adaptor3d_HVertex) vtx;
Handle(Adaptor2d_HCurve2d) arc;
Handle(Adaptor2d_Curve2d) arc;
Standard_Real param;
@@ -85,8 +78,8 @@ private:
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheArc Handle(Adaptor2d_Curve2d)
#define TheArc_hxx <Adaptor2d_Curve2d.hxx>
#define IntStart_PathPoint IntPatch_ThePathPointOfTheSOnBounds
#define IntStart_PathPoint_hxx <IntPatch_ThePathPointOfTheSOnBounds.hxx>

6
src/IntPatch/IntPatch_ThePathPointOfTheSOnBounds_0.cxx
View File

@@ -17,15 +17,15 @@
#include <IntPatch_ThePathPointOfTheSOnBounds.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Standard_DomainError.hxx>
#include <gp_Pnt.hxx>
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheArc Handle(Adaptor2d_Curve2d)
#define TheArc_hxx <Adaptor2d_Curve2d.hxx>
#define IntStart_PathPoint IntPatch_ThePathPointOfTheSOnBounds
#define IntStart_PathPoint_hxx <IntPatch_ThePathPointOfTheSOnBounds.hxx>
#include <IntStart_PathPoint.gxx>

5
src/IntPatch/IntPatch_TheSOnBounds.hxx
View File

@@ -30,7 +30,6 @@ class StdFail_NotDone;
class Standard_OutOfRange;
class Standard_ConstructionError;
class Adaptor3d_HVertex;
class Adaptor2d_HCurve2d;
class IntPatch_HCurve2dTool;
class IntPatch_HInterTool;
class Adaptor3d_TopolTool;
@@ -108,8 +107,8 @@ private:
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheArc Handle(Adaptor2d_Curve2d)
#define TheArc_hxx <Adaptor2d_Curve2d.hxx>
#define TheArcTool IntPatch_HCurve2dTool
#define TheArcTool_hxx <IntPatch_HCurve2dTool.hxx>
#define TheSOBTool IntPatch_HInterTool

6
src/IntPatch/IntPatch_TheSOnBounds_0.cxx
View File

@@ -20,7 +20,7 @@
#include <Standard_OutOfRange.hxx>
#include <Standard_ConstructionError.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <IntPatch_HCurve2dTool.hxx>
#include <IntPatch_HInterTool.hxx>
#include <Adaptor3d_TopolTool.hxx>
@@ -32,8 +32,8 @@
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheArc Handle(Adaptor2d_Curve2d)
#define TheArc_hxx <Adaptor2d_Curve2d.hxx>
#define TheArcTool IntPatch_HCurve2dTool
#define TheArcTool_hxx <IntPatch_HCurve2dTool.hxx>
#define TheSOBTool IntPatch_HInterTool

25
src/IntPatch/IntPatch_TheSearchInside.hxx
View File

@@ -17,24 +17,13 @@
#ifndef _IntPatch_TheSearchInside_HeaderFile
#define _IntPatch_TheSearchInside_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Adaptor3d_Surface.hxx>
#include <IntSurf_SequenceOfInteriorPoint.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
class StdFail_NotDone;
class Standard_OutOfRange;
class Adaptor3d_HSurface;
class Adaptor3d_HSurfaceTool;
class Adaptor3d_TopolTool;
class IntPatch_HInterTool;
class IntPatch_TheSurfFunction;
class IntSurf_InteriorPoint;
class IntPatch_TheSearchInside
{
@@ -45,11 +34,11 @@ public:
Standard_EXPORT IntPatch_TheSearchInside();
Standard_EXPORT IntPatch_TheSearchInside(IntPatch_TheSurfFunction& F, const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& T, const Standard_Real Epsilon);
Standard_EXPORT IntPatch_TheSearchInside(IntPatch_TheSurfFunction& F, const Handle(Adaptor3d_Surface)& Surf, const Handle(Adaptor3d_TopolTool)& T, const Standard_Real Epsilon);
Standard_EXPORT void Perform (IntPatch_TheSurfFunction& F, const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& T, const Standard_Real Epsilon);
Standard_EXPORT void Perform (IntPatch_TheSurfFunction& F, const Handle(Adaptor3d_Surface)& Surf, const Handle(Adaptor3d_TopolTool)& T, const Standard_Real Epsilon);
Standard_EXPORT void Perform (IntPatch_TheSurfFunction& F, const Handle(Adaptor3d_HSurface)& Surf, const Standard_Real UStart, const Standard_Real VStart);
Standard_EXPORT void Perform (IntPatch_TheSurfFunction& F, const Handle(Adaptor3d_Surface)& Surf, const Standard_Real UStart, const Standard_Real VStart);
Standard_Boolean IsDone() const;
@@ -84,8 +73,8 @@ private:
};
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurface Handle(Adaptor3d_Surface)
#define ThePSurface_hxx <Adaptor3d_Surface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define Handle_TheTopolTool Handle(Adaptor3d_TopolTool)

6
src/IntPatch/IntPatch_TheSearchInside_0.cxx
View File

@@ -18,7 +18,7 @@
#include <StdFail_NotDone.hxx>
#include <Standard_OutOfRange.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <IntPatch_HInterTool.hxx>
@@ -26,8 +26,8 @@
#include <IntSurf_InteriorPoint.hxx>
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurface Handle(Adaptor3d_Surface)
#define ThePSurface_hxx <Adaptor3d_Surface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define Handle_TheTopolTool Handle(Adaptor3d_TopolTool)

12
src/IntPatch/IntPatch_TheSegmentOfTheSOnBounds.hxx
View File

@@ -23,7 +23,7 @@
#include <Standard_Boolean.hxx>
#include <IntPatch_ThePathPointOfTheSOnBounds.hxx>
class Adaptor2d_HCurve2d;
class Standard_DomainError;
class Adaptor3d_HVertex;
class IntPatch_ThePathPointOfTheSOnBounds;
@@ -41,7 +41,7 @@ public:
Standard_EXPORT IntPatch_TheSegmentOfTheSOnBounds();
//! Defines the concerned arc.
void SetValue (const Handle(Adaptor2d_HCurve2d)& A);
void SetValue (const Handle(Adaptor2d_Curve2d)& A);
//! Defines the first point or the last point,
//! depending on the value of the boolean First.
@@ -49,7 +49,7 @@ public:
//! Returns the geometric curve on the surface 's domain
//! which is solution.
const Handle(Adaptor2d_HCurve2d)& Curve() const;
const Handle(Adaptor2d_Curve2d)& Curve() const;
//! Returns True if there is a vertex (ThePathPoint) defining
//! the lowest valid parameter on the arc.
@@ -78,7 +78,7 @@ private:
Handle(Adaptor2d_HCurve2d) arc;
Handle(Adaptor2d_Curve2d) arc;
Standard_Boolean hasfp;
IntPatch_ThePathPointOfTheSOnBounds thefp;
Standard_Boolean haslp;
@@ -89,8 +89,8 @@ private:
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheArc Handle(Adaptor2d_Curve2d)
#define TheArc_hxx <Adaptor2d_Curve2d.hxx>
#define ThePathPoint IntPatch_ThePathPointOfTheSOnBounds
#define ThePathPoint_hxx <IntPatch_ThePathPointOfTheSOnBounds.hxx>
#define IntStart_Segment IntPatch_TheSegmentOfTheSOnBounds

6
src/IntPatch/IntPatch_TheSegmentOfTheSOnBounds_0.cxx
View File

@@ -16,7 +16,7 @@
#include <IntPatch_TheSegmentOfTheSOnBounds.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Standard_DomainError.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <IntPatch_ThePathPointOfTheSOnBounds.hxx>
@@ -24,8 +24,8 @@
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheArc Handle(Adaptor2d_Curve2d)
#define TheArc_hxx <Adaptor2d_Curve2d.hxx>
#define ThePathPoint IntPatch_ThePathPointOfTheSOnBounds
#define ThePathPoint_hxx <IntPatch_ThePathPointOfTheSOnBounds.hxx>
#define IntStart_Segment IntPatch_TheSegmentOfTheSOnBounds

27
src/IntPatch/IntPatch_TheSurfFunction.hxx
View File

@@ -17,30 +17,17 @@
#ifndef _IntPatch_TheSurfFunction_HeaderFile
#define _IntPatch_TheSurfFunction_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
#include <Standard_Real.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Vec.hxx>
#include <gp_Dir2d.hxx>
#include <math_FunctionSetWithDerivatives.hxx>
#include <Standard_Integer.hxx>
#include <math_Vector.hxx>
class StdFail_UndefinedDerivative;
class Adaptor3d_HSurface;
class Adaptor3d_HSurfaceTool;
class IntSurf_Quadric;
class IntSurf_QuadricTool;
class math_Matrix;
class gp_Pnt;
class gp_Vec;
class gp_Dir2d;
class IntPatch_TheSurfFunction : public math_FunctionSetWithDerivatives
{
@@ -51,11 +38,11 @@ public:
Standard_EXPORT IntPatch_TheSurfFunction();
Standard_EXPORT IntPatch_TheSurfFunction(const Handle(Adaptor3d_HSurface)& PS, const IntSurf_Quadric& IS);
Standard_EXPORT IntPatch_TheSurfFunction(const Handle(Adaptor3d_Surface)& PS, const IntSurf_Quadric& IS);
Standard_EXPORT IntPatch_TheSurfFunction(const IntSurf_Quadric& IS);
void Set (const Handle(Adaptor3d_HSurface)& PS);
void Set (const Handle(Adaptor3d_Surface)& PS);
void SetImplicitSurface (const IntSurf_Quadric& IS);
@@ -85,7 +72,7 @@ public:
const gp_Dir2d& Direction2d();
const Handle(Adaptor3d_HSurface)& PSurface() const;
const Handle(Adaptor3d_Surface)& PSurface() const;
const IntSurf_Quadric& ISurface() const;
@@ -123,8 +110,8 @@ private:
};
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurface Handle(Adaptor3d_Surface)
#define ThePSurface_hxx <Adaptor3d_Surface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define TheISurface IntSurf_Quadric

6
src/IntPatch/IntPatch_TheSurfFunction_0.cxx
View File

@@ -17,7 +17,7 @@
#include <IntPatch_TheSurfFunction.hxx>
#include <StdFail_UndefinedDerivative.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <IntSurf_Quadric.hxx>
#include <IntSurf_QuadricTool.hxx>
@@ -27,8 +27,8 @@
#include <gp_Dir2d.hxx>
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurface Handle(Adaptor3d_Surface)
#define ThePSurface_hxx <Adaptor3d_Surface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define TheISurface IntSurf_Quadric

10
src/IntPatch/IntPatch_WLine.cxx
View File

@@ -15,7 +15,7 @@
// commercial license or contractual agreement.
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <IntPatch_Point.hxx>
@@ -945,12 +945,12 @@ Standard_Boolean IntPatch_WLine::HasArcOnS1() const {
return(hasArcOnS1);
}
void IntPatch_WLine::SetArcOnS1(const Handle(Adaptor2d_HCurve2d)& A) {
void IntPatch_WLine::SetArcOnS1(const Handle(Adaptor2d_Curve2d)& A) {
hasArcOnS1=Standard_True;
theArcOnS1=A;
}
const Handle(Adaptor2d_HCurve2d)& IntPatch_WLine::GetArcOnS1() const {
const Handle(Adaptor2d_Curve2d)& IntPatch_WLine::GetArcOnS1() const {
return(theArcOnS1);
}
@@ -958,12 +958,12 @@ Standard_Boolean IntPatch_WLine::HasArcOnS2() const {
return(hasArcOnS2);
}
void IntPatch_WLine::SetArcOnS2(const Handle(Adaptor2d_HCurve2d)& A) {
void IntPatch_WLine::SetArcOnS2(const Handle(Adaptor2d_Curve2d)& A) {
hasArcOnS2=Standard_True;
theArcOnS2=A;
}
const Handle(Adaptor2d_HCurve2d)& IntPatch_WLine::GetArcOnS2() const {
const Handle(Adaptor2d_Curve2d)& IntPatch_WLine::GetArcOnS2() const {
return(theArcOnS2);
}

14
src/IntPatch/IntPatch_WLine.hxx
View File

@@ -28,7 +28,7 @@
#include <IntSurf_LineOn2S.hxx>
#include <IntSurf_Situation.hxx>
#include <IntSurf_TypeTrans.hxx>
class Adaptor2d_HCurve2d;
class Standard_OutOfRange;
class Standard_DomainError;
class IntPatch_Point;
@@ -165,17 +165,17 @@ public:
Standard_EXPORT Standard_Real V2Period() const;
Standard_EXPORT void SetArcOnS1 (const Handle(Adaptor2d_HCurve2d)& A);
Standard_EXPORT void SetArcOnS1 (const Handle(Adaptor2d_Curve2d)& A);
Standard_EXPORT Standard_Boolean HasArcOnS1() const;
Standard_EXPORT const Handle(Adaptor2d_HCurve2d)& GetArcOnS1() const;
Standard_EXPORT const Handle(Adaptor2d_Curve2d)& GetArcOnS1() const;
Standard_EXPORT void SetArcOnS2 (const Handle(Adaptor2d_HCurve2d)& A);
Standard_EXPORT void SetArcOnS2 (const Handle(Adaptor2d_Curve2d)& A);
Standard_EXPORT Standard_Boolean HasArcOnS2() const;
Standard_EXPORT const Handle(Adaptor2d_HCurve2d)& GetArcOnS2() const;
Standard_EXPORT const Handle(Adaptor2d_Curve2d)& GetArcOnS2() const;
//! Removes vertices from the line (i.e. cleans svtx member)
virtual void ClearVertexes() Standard_OVERRIDE;
@@ -237,9 +237,9 @@ private:
Standard_Real u2period;
Standard_Real v2period;
Standard_Boolean hasArcOnS1;
Handle(Adaptor2d_HCurve2d) theArcOnS1;
Handle(Adaptor2d_Curve2d) theArcOnS1;
Standard_Boolean hasArcOnS2;
Handle(Adaptor2d_HCurve2d) theArcOnS2;
Handle(Adaptor2d_Curve2d) theArcOnS2;
Standard_Boolean myIsPurgerAllowed;
//! identifies the way of <*this> creation

52
src/IntPatch/IntPatch_WLineTool.cxx
View File

@@ -13,7 +13,7 @@
#include <IntPatch_WLineTool.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <Bnd_Range.hxx>
#include <ElCLib.hxx>
@@ -191,7 +191,7 @@ static Handle(IntPatch_WLine) MakeNewWLine(const Handle(IntPatch_WLine)
// because walking algorithm should care for closeness to the param space.
// Static subfunction in ComputePurgedWLine.
//=========================================================================
static void MovePoint(const Handle(Adaptor3d_HSurface) &theS1,
static void MovePoint(const Handle(Adaptor3d_Surface) &theS1,
Standard_Real &U1, Standard_Real &V1)
{
if (U1 < theS1->FirstUParameter())
@@ -214,8 +214,8 @@ static void MovePoint(const Handle(Adaptor3d_HSurface) &theS1,
//=========================================================================
static Handle(IntPatch_WLine)
DeleteOuterPoints(const Handle(IntPatch_WLine) &theWLine,
const Handle(Adaptor3d_HSurface) &theS1,
const Handle(Adaptor3d_HSurface) &theS2,
const Handle(Adaptor3d_Surface) &theS1,
const Handle(Adaptor3d_Surface) &theS2,
const Handle(Adaptor3d_TopolTool) &theDom1,
const Handle(Adaptor3d_TopolTool) &theDom2)
{
@@ -392,8 +392,8 @@ static const Standard_Integer aNbSingleBezier = 30;
//=========================================================================
static Handle(IntPatch_WLine)
DeleteByTube(const Handle(IntPatch_WLine) &theWLine,
const Handle(Adaptor3d_HSurface) &theS1,
const Handle(Adaptor3d_HSurface) &theS2)
const Handle(Adaptor3d_Surface) &theS1,
const Handle(Adaptor3d_Surface) &theS2)
{
// III: Check points for tube criteria:
// Workaround to handle case of small amount points after purge.
@@ -656,8 +656,8 @@ static Standard_Boolean IsSeamOrBound(const IntSurf_PntOn2S& thePtf,
// will be recomputed and returned.
//=======================================================================
static Standard_Boolean IsIntersectionPoint(const gp_Pnt& thePmid,
const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const IntSurf_PntOn2S& theRefPt,
const Standard_Real theTol,
const Standard_Real* const theArrPeriods,
@@ -837,8 +837,8 @@ static Standard_Boolean IsOutOfDomain(const Bnd_Box2d& theBoxS1,
// (see IntPatch_WLineTool::ExtendTwoWLines)
//=======================================================================
static IntPatchWT_WLsConnectionType
CheckArgumentsToExtend(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
CheckArgumentsToExtend(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const IntSurf_PntOn2S& thePtWL1,
const IntSurf_PntOn2S& thePtWL2,
IntSurf_PntOn2S& theNewPoint,
@@ -994,8 +994,8 @@ static IntPatchWT_WLsConnectionType
//purpose : Check if joining is possible
// (see IntPatch_WLineTool::JoinWLines(...))
//=======================================================================
Standard_Boolean CheckArgumentsToJoin(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
Standard_Boolean CheckArgumentsToJoin(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const IntSurf_PntOn2S& thePnt,
const gp_Pnt& theP1,
const gp_Pnt& theP2,
@@ -1045,8 +1045,8 @@ Standard_Boolean CheckArgumentsToJoin(const Handle(Adaptor3d_HSurface)& theS1,
//purpose : Performs extending theWLine1 and theWLine2 through their
// respecting start point.
//=======================================================================
static void ExtendTwoWLFirstFirst(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
static void ExtendTwoWLFirstFirst(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(IntPatch_WLine)& theWLine1,
const Handle(IntPatch_WLine)& theWLine2,
const IntSurf_PntOn2S& thePtWL1,
@@ -1119,8 +1119,8 @@ static void ExtendTwoWLFirstFirst(const Handle(Adaptor3d_HSurface)& theS1,
//purpose : Performs extending theWLine1 through its start point and theWLine2
// through its end point.
//=======================================================================
static void ExtendTwoWLFirstLast(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
static void ExtendTwoWLFirstLast(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(IntPatch_WLine)& theWLine1,
const Handle(IntPatch_WLine)& theWLine2,
const IntSurf_PntOn2S& thePtWL1,
@@ -1191,8 +1191,8 @@ static void ExtendTwoWLFirstLast(const Handle(Adaptor3d_HSurface)& theS1,
//purpose : Performs extending theWLine1 through its end point and theWLine2
// through its start point.
//=======================================================================
static void ExtendTwoWLLastFirst(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
static void ExtendTwoWLLastFirst(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(IntPatch_WLine)& theWLine1,
const Handle(IntPatch_WLine)& theWLine2,
const IntSurf_PntOn2S& thePtWL1,
@@ -1259,8 +1259,8 @@ static void ExtendTwoWLLastFirst(const Handle(Adaptor3d_HSurface)& theS1,
//function : ExtendTwoWLLastLast
//purpose :
//=======================================================================
static void ExtendTwoWLLastLast(const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
static void ExtendTwoWLLastLast(const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const Handle(IntPatch_WLine)& theWLine1,
const Handle(IntPatch_WLine)& theWLine2,
const IntSurf_PntOn2S& thePtWL1,
@@ -1327,8 +1327,8 @@ static void ExtendTwoWLLastLast(const Handle(Adaptor3d_HSurface)& theS1,
//=========================================================================
Handle(IntPatch_WLine) IntPatch_WLineTool::
ComputePurgedWLine(const Handle(IntPatch_WLine) &theWLine,
const Handle(Adaptor3d_HSurface) &theS1,
const Handle(Adaptor3d_HSurface) &theS2,
const Handle(Adaptor3d_Surface) &theS1,
const Handle(Adaptor3d_Surface) &theS2,
const Handle(Adaptor3d_TopolTool) &theDom1,
const Handle(Adaptor3d_TopolTool) &theDom2)
{
@@ -1455,8 +1455,8 @@ Handle(IntPatch_WLine) IntPatch_WLineTool::
//=======================================================================
void IntPatch_WLineTool::JoinWLines(IntPatch_SequenceOfLine& theSlin,
IntPatch_SequenceOfPoint& theSPnt,
Handle(Adaptor3d_HSurface) theS1,
Handle(Adaptor3d_HSurface) theS2,
Handle(Adaptor3d_Surface) theS1,
Handle(Adaptor3d_Surface) theS2,
const Standard_Real theTol3D)
{
if(theSlin.Length() == 0)
@@ -1683,8 +1683,8 @@ void IntPatch_WLineTool::JoinWLines(IntPatch_SequenceOfLine& theSlin,
//=======================================================================
void IntPatch_WLineTool::
ExtendTwoWLines(IntPatch_SequenceOfLine& theSlin,
const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const Standard_Real theToler3D,
const Standard_Real* const theArrPeriods,
const Bnd_Box2d& theBoxS1,

12
src/IntPatch/IntPatch_WLineTool.hxx
View File

@@ -45,8 +45,8 @@ public:
//! of the points is less than 2.
Standard_EXPORT static
Handle(IntPatch_WLine) ComputePurgedWLine(const Handle(IntPatch_WLine) &theWLine,
const Handle(Adaptor3d_HSurface) &theS1,
const Handle(Adaptor3d_HSurface) &theS2,
const Handle(Adaptor3d_Surface) &theS1,
const Handle(Adaptor3d_Surface) &theS2,
const Handle(Adaptor3d_TopolTool) &theDom1,
const Handle(Adaptor3d_TopolTool) &theDom2);
@@ -59,8 +59,8 @@ public:
//! this point will be deleted.
Standard_EXPORT static void JoinWLines(IntPatch_SequenceOfLine& theSlin,
IntPatch_SequenceOfPoint& theSPnt,
Handle(Adaptor3d_HSurface) theS1,
Handle(Adaptor3d_HSurface) theS2,
Handle(Adaptor3d_Surface) theS1,
Handle(Adaptor3d_Surface) theS2,
const Standard_Real theTol3D);
//! Extends every line from theSlin (if it is possible) to be started/finished
@@ -76,8 +76,8 @@ public:
//! theListOfCriticalPoints must contain 3D-points where joining is disabled.
Standard_EXPORT static void
ExtendTwoWLines(IntPatch_SequenceOfLine& theSlin,
const Handle(Adaptor3d_HSurface)& theS1,
const Handle(Adaptor3d_HSurface)& theS2,
const Handle(Adaptor3d_Surface)& theS1,
const Handle(Adaptor3d_Surface)& theS2,
const Standard_Real theToler3D,
const Standard_Real* const theArrPeriods,
const Bnd_Box2d& theBoxS1,