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

0024002: Overall code and build procedure refactoring -- automatic

Automatic upgrade of OCCT code by command "occt_upgrade . -nocdl":
- WOK-generated header files from inc and sources from drv are moved to src
- CDL files removed
- All packages are converted to nocdlpack
This commit is contained in:
abv
2015-07-12 07:42:38 +03:00
parent 543a996496
commit 42cf5bc1ca
15354 changed files with 623957 additions and 509844 deletions

View File

@@ -1,95 +0,0 @@
-- Created on: 1993-02-05
-- Created by: Jacques GOUSSARD
-- Copyright (c) 1993-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
package Contap
---Purpose:
uses Standard,StdFail,MMgt, GeomAbs, TopAbs, TCollection, gp, TColgp,
math, IntSurf, IntStart, IntWalk,
Geom2d, TColStd, Geom, Adaptor3d, Adaptor2d
is
class Point;
class Line;
class SurfFunction;
class ArcFunction;
class SurfProps;
class Contour;
imported TheSequenceOfPoint;
imported transient class TheHSequenceOfPoint;
imported TheSequenceOfLine;
class TheSearch instantiates SearchOnBoundaries from IntStart
(HVertex from Adaptor3d,
HCurve2d from Adaptor2d,
HCurve2dTool from Contap,
HContTool from Contap,
TopolTool from Adaptor3d,
ArcFunction from Contap);
class TheIWalking instantiates IWalking from IntWalk
(PathPoint from IntSurf,
PathPointTool from IntSurf,
SequenceOfPathPoint from IntSurf,
InteriorPoint from IntSurf,
InteriorPointTool from IntSurf,
SequenceOfInteriorPoint from IntSurf,
HSurface from Adaptor3d,
HSurfaceTool from Adaptor3d,
SurfFunction from Contap);
class TheSearchInside instantiates SearchInside from IntStart
(HSurface from Adaptor3d,
HSurfaceTool from Adaptor3d,
TopolTool from Adaptor3d,
HContTool from Contap,
SurfFunction from Contap);
class ContAna;
enumeration TFunction is
ContourStd,
ContourPrs,
DraftStd,
DraftPrs
end TFunction;
enumeration IType is -- a replacer dans IntSurf et fusionner avec IntPatch
-- type of the line of contour
Lin, -- pour conflit avec deferred class Line
Circle,
Walking,
Restriction
end IType;
class HContTool;
class HCurve2dTool;
end Contap;

View File

@@ -1,133 +0,0 @@
-- Created on: 1993-06-03
-- Created by: Jacques GOUSSARD
-- Copyright (c) 1993-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class ArcFunction from Contap inherits FunctionWithDerivative from math
uses Pnt from gp,
Dir from gp,
SequenceOfPnt from TColgp,
TFunction from Contap,
--modified by NIZNHY-PKV Thu Mar 29 16:52:28 2001 f
Quadric from IntSurf,
--modified by NIZNHY-PKV Thu Mar 29 16:52:31 2001
HCurve2d from Adaptor2d,
HSurface from Adaptor3d,
HCurve2dTool from Contap,
HSurfaceTool from Adaptor3d,
SurfProps from Contap,
HContTool from Contap
is
Create
returns ArcFunction from Contap;
Set(me: in out; S: HSurface from Adaptor3d)
is static;
Set(me: in out; Direction: Dir from gp)
---C++: inline
is static;
Set(me: in out; Direction: Dir from gp; Angle: Real from Standard)
---C++: inline
is static;
Set(me: in out; Eye: Pnt from gp)
---C++: inline
is static;
Set(me: in out; Eye: Pnt from gp; Angle: Real from Standard)
---C++: inline
is static;
Set(me: in out; A: HCurve2d from Adaptor2d)
---C++: inline
is static;
Value(me: in out; X: Real from Standard; F: out Real from Standard)
returns Boolean from Standard;
Derivative(me: in out; X: Real from Standard; D: out Real from Standard)
returns Boolean from Standard;
Values(me: in out; X: Real from Standard; F,D: out Real from Standard)
returns Boolean from Standard;
NbSamples(me)
returns Integer from Standard
is static;
GetStateNumber(me: in out)
returns Integer from Standard
is redefined;
Valpoint(me; Index: Integer from Standard)
returns Pnt from gp
---C++: return const&
---C++: inline
is static;
--modified by NIZNHY-PKV Thu Mar 29 16:51:24 2001 f
Quadric(me)
returns Quadric from IntSurf
---C++: return const&
is static;
--modified by NIZNHY-PKV Thu Mar 29 16:51:31 2001 t
fields
myArc : HCurve2d from Adaptor2d;
mySurf : HSurface from Adaptor3d;
myMean : Real from Standard;
myType : TFunction from Contap;
myDir : Dir from gp;
myCosAng : Real from Standard;
myEye : Pnt from gp;
solpt : Pnt from gp;
seqpt : SequenceOfPnt from TColgp;
--modified by NIZNHY-PKV Thu Mar 29 16:51:41 2001f
myQuad : Quadric from IntSurf;
--modified by NIZNHY-PKV Thu Mar 29 16:51:47 2001t
end ArcFunction;

View File

@@ -14,11 +14,16 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_ArcFunction.ixx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Contap_ArcFunction.hxx>
#include <Contap_HContTool.hxx>
#include <Contap_SurfProps.hxx>
#include <Contap_HCurve2dTool.hxx>
#include <Contap_SurfProps.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>
#include <IntSurf_Quadric.hxx>
Contap_ArcFunction::Contap_ArcFunction ():
myMean(1.),

View File

@@ -0,0 +1,110 @@
// Created on: 1993-06-03
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_ArcFunction_HeaderFile
#define _Contap_ArcFunction_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <Contap_TFunction.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>
#include <TColgp_SequenceOfPnt.hxx>
#include <IntSurf_Quadric.hxx>
#include <math_FunctionWithDerivative.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
class Adaptor2d_HCurve2d;
class Adaptor3d_HSurface;
class gp_Dir;
class gp_Pnt;
class IntSurf_Quadric;
class Contap_ArcFunction : public math_FunctionWithDerivative
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Contap_ArcFunction();
Standard_EXPORT void Set (const Handle(Adaptor3d_HSurface)& S);
void Set (const gp_Dir& Direction);
void Set (const gp_Dir& Direction, const Standard_Real Angle);
void Set (const gp_Pnt& Eye);
void Set (const gp_Pnt& Eye, const Standard_Real Angle);
void Set (const Handle(Adaptor2d_HCurve2d)& A);
Standard_EXPORT Standard_Boolean Value (const Standard_Real X, Standard_Real& F);
Standard_EXPORT Standard_Boolean Derivative (const Standard_Real X, Standard_Real& D);
Standard_EXPORT Standard_Boolean Values (const Standard_Real X, Standard_Real& F, Standard_Real& D);
Standard_EXPORT Standard_Integer NbSamples() const;
Standard_EXPORT virtual Standard_Integer GetStateNumber() Standard_OVERRIDE;
const gp_Pnt& Valpoint (const Standard_Integer Index) const;
Standard_EXPORT const IntSurf_Quadric& Quadric() const;
protected:
private:
Handle(Adaptor2d_HCurve2d) myArc;
Handle(Adaptor3d_HSurface) mySurf;
Standard_Real myMean;
Contap_TFunction myType;
gp_Dir myDir;
Standard_Real myCosAng;
gp_Pnt myEye;
gp_Pnt solpt;
TColgp_SequenceOfPnt seqpt;
IntSurf_Quadric myQuad;
};
#include <Contap_ArcFunction.lxx>
#endif // _Contap_ArcFunction_HeaderFile

View File

@@ -1,166 +0,0 @@
-- Created on: 1993-03-04
-- Created by: Jacques GOUSSARD
-- Copyright (c) 1993-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class ContAna from Contap
---Purpose: This class provides the computation of the contours
-- for quadric surfaces.
uses Sphere from gp,
Cylinder from gp,
Cone from gp,
Lin from gp,
Circ from gp,
Pnt from gp,
Dir from gp,
CurveType from GeomAbs
raises NotDone from StdFail,
DomainError from Standard,
OutOfRange from Standard
is
Create
returns ContAna from Contap;
Perform(me: in out; S: Sphere from gp; D: Dir from gp)
is static;
Perform(me: in out; S: Sphere from gp; D : Dir from gp;
Ang: Real from Standard)
is static;
Perform(me: in out; S: Sphere from gp; Eye: Pnt from gp)
is static;
Perform(me: in out; C: Cylinder from gp; D: Dir from gp)
is static;
Perform(me: in out; C: Cylinder from gp; D : Dir from gp;
Ang: Real from Standard)
is static;
Perform(me: in out; C: Cylinder from gp; Eye: Pnt from gp)
---Purpose:
is static;
Perform(me: in out; C: Cone from gp; D: Dir from gp)
is static;
Perform(me: in out; C: Cone from gp; D : Dir from gp;
Ang: Real from Standard)
is static;
Perform(me: in out; C: Cone from gp; Eye: Pnt from gp)
---Purpose:
is static;
IsDone(me)
returns Boolean from Standard
---C++: inline
is static;
NbContours(me)
returns Integer from Standard
---C++: inline
raises NotDone from StdFail
is static;
TypeContour(me)
---Purpose: Returns GeomAbs_Line or GeomAbs_Circle, when
-- IsDone() returns True.
returns CurveType from GeomAbs
---C++: inline
raises NotDone from StdFail,
DomainError from Standard
is static;
Circle(me)
returns Circ from gp
---C++: inline
raises NotDone from StdFail,
DomainError from Standard
is static;
Line(me; Index: Integer from Standard)
returns Lin from gp
raises NotDone from StdFail,
DomainError from Standard,
OutOfRange from Standard
is static;
fields
done : Boolean from Standard;
nbSol : Integer from Standard;
typL : CurveType from GeomAbs;
pt1 : Pnt from gp;
pt2 : Pnt from gp;
pt3 : Pnt from gp;
pt4 : Pnt from gp;
dir1 : Dir from gp;
dir2 : Dir from gp;
dir3 : Dir from gp;
dir4 : Dir from gp;
prm : Real from Standard;
end ContAna;

View File

@@ -14,10 +14,19 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_ContAna.ixx>
#include <gp_XYZ.hxx>
#include <Contap_ContAna.hxx>
#include <gp.hxx>
#include <gp_Cone.hxx>
#include <gp_Cylinder.hxx>
#include <gp_Dir.hxx>
#include <gp_Lin.hxx>
#include <gp_Pnt.hxx>
#include <gp_Sphere.hxx>
#include <gp_XYZ.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>
#define Tolpetit 1.e-8

View File

@@ -0,0 +1,119 @@
// Created on: 1993-03-04
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_ContAna_HeaderFile
#define _Contap_ContAna_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <GeomAbs_CurveType.hxx>
#include <gp_Pnt.hxx>
#include <gp_Dir.hxx>
#include <Standard_Real.hxx>
#include <gp_Circ.hxx>
class StdFail_NotDone;
class Standard_DomainError;
class Standard_OutOfRange;
class gp_Sphere;
class gp_Dir;
class gp_Pnt;
class gp_Cylinder;
class gp_Cone;
class gp_Lin;
//! This class provides the computation of the contours
//! for quadric surfaces.
class Contap_ContAna
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Contap_ContAna();
Standard_EXPORT void Perform (const gp_Sphere& S, const gp_Dir& D);
Standard_EXPORT void Perform (const gp_Sphere& S, const gp_Dir& D, const Standard_Real Ang);
Standard_EXPORT void Perform (const gp_Sphere& S, const gp_Pnt& Eye);
Standard_EXPORT void Perform (const gp_Cylinder& C, const gp_Dir& D);
Standard_EXPORT void Perform (const gp_Cylinder& C, const gp_Dir& D, const Standard_Real Ang);
Standard_EXPORT void Perform (const gp_Cylinder& C, const gp_Pnt& Eye);
Standard_EXPORT void Perform (const gp_Cone& C, const gp_Dir& D);
Standard_EXPORT void Perform (const gp_Cone& C, const gp_Dir& D, const Standard_Real Ang);
Standard_EXPORT void Perform (const gp_Cone& C, const gp_Pnt& Eye);
Standard_Boolean IsDone() const;
Standard_Integer NbContours() const;
//! Returns GeomAbs_Line or GeomAbs_Circle, when
//! IsDone() returns True.
GeomAbs_CurveType TypeContour() const;
gp_Circ Circle() const;
Standard_EXPORT gp_Lin Line (const Standard_Integer Index) const;
protected:
private:
Standard_Boolean done;
Standard_Integer nbSol;
GeomAbs_CurveType typL;
gp_Pnt pt1;
gp_Pnt pt2;
gp_Pnt pt3;
gp_Pnt pt4;
gp_Dir dir1;
gp_Dir dir2;
gp_Dir dir3;
gp_Dir dir4;
Standard_Real prm;
};
#include <Contap_ContAna.lxx>
#endif // _Contap_ContAna_HeaderFile

View File

@@ -1,208 +0,0 @@
-- Created on: 1993-02-05
-- Created by: Jacques GOUSSARD
-- Copyright (c) 1993-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class Contour from Contap
uses PathPoint from IntSurf,
PathPointTool from IntSurf,
SequenceOfPathPoint from IntSurf,
InteriorPoint from IntSurf,
InteriorPointTool from IntSurf,
SequenceOfInteriorPoint from IntSurf,
Pnt from gp,
Vec from gp,
Point from Contap,
Line from Contap,
SurfFunction from Contap,
ArcFunction from Contap,
TheSequenceOfLine from Contap,
TheSearch from Contap,
TheSearchInside from Contap,
HSurface from Adaptor3d,
TopolTool from Adaptor3d
raises NotDone from StdFail,
OutOfRange from Standard,
ConstructionError from Standard
is
Create
returns Contour from Contap;
Create(Direction: Vec from gp)
returns Contour from Contap;
Create(Direction: Vec from gp; Angle: Real from Standard)
returns Contour from Contap;
Create(Eye: Pnt from gp)
returns Contour from Contap;
Create(Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Direction: Vec from gp)
---Purpose: Creates the contour in a given direction.
returns Contour from Contap;
Create(Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Direction: Vec from gp; Angle: Real from Standard)
---Purpose: Creates the contour in a given direction.
returns Contour from Contap;
Create(Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Eye: Pnt from gp)
---Purpose: Creates the contour for a perspective view.
returns Contour from Contap;
Perform(me: in out; Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d)
---Purpose: Creates the contour in a given direction.
raises ConstructionError from Standard
is static;
Perform(me: in out; Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Direction: Vec from gp)
---Purpose: Creates the contour in a given direction.
is static;
Perform(me: in out; Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Direction: Vec from gp; Angle: Real from Standard)
---Purpose: Creates the contour in a given direction.
is static;
Perform(me: in out; Surf: HSurface from Adaptor3d; Domain: TopolTool from Adaptor3d;
Eye: Pnt from gp)
---Purpose: Creates the contour for a perspective view.
is static;
Init(me: in out; Direction: Vec from gp)
is static;
Init(me: in out; Direction: Vec from gp; Angle: Real from Standard)
is static;
Init(me: in out; Eye: Pnt from gp)
is static;
IsDone(me)
returns Boolean from Standard
---C++: inline
is static;
IsEmpty(me)
---Purpose: Returns true if the is no line.
returns Boolean from Standard
---C++: inline
raises NotDone from StdFail
is static;
NbLines(me)
returns Integer from Standard
---C++: inline
raises NotDone from StdFail
is static;
Line(me; Index: Integer from Standard)
returns Line from Contap
---C++: return const&
---C++: inline
raises NotDone from StdFail,
OutOfRange from Standard
is static;
SurfaceFunction(me : in out)
returns SurfFunction
---Purpose: Returns a reference on the internal
-- SurfaceFunction. This is used to compute tangents
-- on the lines.
---C++: return &
---C++: inline
is static;
Perform(me: in out; Domain: TopolTool from Adaptor3d)
is static private;
PerformAna(me: in out; Domain: TopolTool from Adaptor3d)
is static private;
fields
done : Boolean from Standard;
slin : TheSequenceOfLine from Contap;
solrst : TheSearch from Contap;
solins : TheSearchInside from Contap;
mySFunc : SurfFunction from Contap;
myAFunc : ArcFunction from Contap;
modeset : Boolean from Standard;
end Contour;

View File

@@ -14,33 +14,35 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_Contour.ixx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <Bnd_Box.hxx>
#include <BndLib_AddSurface.hxx>
#include <Contap_ContAna.hxx>
#include <Contap_Contour.hxx>
#include <Contap_HContTool.hxx>
#include <Contap_HCurve2dTool.hxx>
#include <Contap_Line.hxx>
#include <Contap_SurfFunction.hxx>
#include <Contap_SurfProps.hxx>
#include <Contap_TheIWalking.hxx>
#include <Contap_ThePathPointOfTheSearch.hxx>
#include <Contap_TheSegmentOfTheSearch.hxx>
#include <ElCLib.hxx>
#include <ElSLib.hxx>
#include <math_FunctionSetRoot.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <IntSurf.hxx>
#include <IntSurf_InteriorPoint.hxx>
#include <IntSurf_SequenceOfPathPoint.hxx>
#include <TopTrans_CurveTransition.hxx>
#include <math_FunctionSetRoot.hxx>
#include <Standard_ConstructionError.hxx>
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <BndLib_AddSurface.hxx>
#include <Bnd_Box.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <Contap_ContAna.hxx>
#include <Contap_HContTool.hxx>
#include <Contap_HCurve2dTool.hxx>
#include <Contap_SurfProps.hxx>
#include <Contap_TheIWalking.hxx>
#include <Contap_TheSegmentOfTheSearch.hxx>
#include <Contap_ThePathPointOfTheSearch.hxx>
#include <TopTrans_CurveTransition.hxx>
#define Tolpetit 1.e-10 // pour dist au carre

View File

@@ -0,0 +1,135 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_Contour_HeaderFile
#define _Contap_Contour_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Contap_TheSequenceOfLine.hxx>
#include <Contap_TheSearch.hxx>
#include <Contap_TheSearchInside.hxx>
#include <Contap_SurfFunction.hxx>
#include <Contap_ArcFunction.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
class StdFail_NotDone;
class Standard_OutOfRange;
class Standard_ConstructionError;
class gp_Vec;
class gp_Pnt;
class Adaptor3d_HSurface;
class Adaptor3d_TopolTool;
class Contap_Line;
class Contap_SurfFunction;
class Contap_Contour
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Contap_Contour();
Standard_EXPORT Contap_Contour(const gp_Vec& Direction);
Standard_EXPORT Contap_Contour(const gp_Vec& Direction, const Standard_Real Angle);
Standard_EXPORT Contap_Contour(const gp_Pnt& Eye);
//! Creates the contour in a given direction.
Standard_EXPORT Contap_Contour(const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& Domain, const gp_Vec& Direction);
//! Creates the contour in a given direction.
Standard_EXPORT Contap_Contour(const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& Domain, const gp_Vec& Direction, const Standard_Real Angle);
//! Creates the contour for a perspective view.
Standard_EXPORT Contap_Contour(const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& Domain, const gp_Pnt& Eye);
//! Creates the contour in a given direction.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& Domain);
//! Creates the contour in a given direction.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& Domain, const gp_Vec& Direction);
//! Creates the contour in a given direction.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& Domain, const gp_Vec& Direction, const Standard_Real Angle);
//! Creates the contour for a perspective view.
Standard_EXPORT void Perform (const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& Domain, const gp_Pnt& Eye);
Standard_EXPORT void Init (const gp_Vec& Direction);
Standard_EXPORT void Init (const gp_Vec& Direction, const Standard_Real Angle);
Standard_EXPORT void Init (const gp_Pnt& Eye);
Standard_Boolean IsDone() const;
//! Returns true if the is no line.
Standard_Boolean IsEmpty() const;
Standard_Integer NbLines() const;
const Contap_Line& Line (const Standard_Integer Index) const;
//! Returns a reference on the internal
//! SurfaceFunction. This is used to compute tangents
//! on the lines.
Contap_SurfFunction& SurfaceFunction();
protected:
private:
Standard_EXPORT void Perform (const Handle(Adaptor3d_TopolTool)& Domain);
Standard_EXPORT void PerformAna (const Handle(Adaptor3d_TopolTool)& Domain);
Standard_Boolean done;
Contap_TheSequenceOfLine slin;
Contap_TheSearch solrst;
Contap_TheSearchInside solins;
Contap_SurfFunction mySFunc;
Contap_ArcFunction myAFunc;
Standard_Boolean modeset;
};
#include <Contap_Contour.lxx>
#endif // _Contap_Contour_HeaderFile

View File

@@ -1,196 +0,0 @@
-- Created on: 1995-07-02
-- Created by: Laurent BUCHARD
-- Copyright (c) 1995-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class HContTool from Contap
---Purpose: Tool for the intersection between 2 surfaces.
-- Regroupe pour l instant les methodes hors Adaptor3d...
uses
Pnt2d from gp,
Pnt from gp,
HVertex from Adaptor3d,
HCurve2d from Adaptor2d,
HSurface from Adaptor3d,
HCurve2dTool from Contap,
HSurfaceTool from Adaptor3d
is
NbSamplesU(myclass; S: HSurface from Adaptor3d; u1,u2: Real from Standard)
returns Integer from Standard;
NbSamplesV(myclass; S: HSurface from Adaptor3d; v1,v2: Real from Standard)
returns Integer from Standard;
-- Methodes pour recherche des points interieurs
NbSamplePoints(myclass; S: HSurface from Adaptor3d)
returns Integer from Standard;
SamplePoint(myclass; S : HSurface from Adaptor3d;
Index: Integer from Standard;
U,V: out Real from Standard);
-- Methodes sur un arc de restriction
HasBeenSeen(myclass; C: HCurve2d from Adaptor2d)
---Purpose: 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.
returns Boolean from Standard;
NbSamplesOnArc(myclass; A: HCurve2d from Adaptor2d)
---Purpose: 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.
returns Integer from Standard;
Bounds(myclass; C: HCurve2d from Adaptor2d;
Ufirst,Ulast: out Real from Standard);
---Purpose: 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.
Project(myclass; C: HCurve2d from Adaptor2d;
P: Pnt2d from gp;
Paramproj: out Real from Standard;
Ptproj : out Pnt2d from gp)
---Purpose: Projects the point P on the arc C.
-- If the methods returns Standard_True, the projection is
-- successful, and Paramproj is the parameter on the arc
-- of the projected point, Ptproj is the projected Point.
-- If the method returns Standard_False, Param proj and Ptproj
-- are not significant.
--
returns Boolean from Standard;
-- Methods on a vertex
Tolerance(myclass; V: HVertex from Adaptor3d; C: HCurve2d from Adaptor2d)
---Purpose: 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".
returns Real from Standard;
Parameter(myclass; V: HVertex from Adaptor3d; C: HCurve2d from Adaptor2d)
---Purpose: Returns the parameter of the vertex V on the arc A.
returns Real from Standard;
-- The following methods are used when HasBeenSeen returns Standard_True
NbPoints(myclass; C: HCurve2d from Adaptor2d)
---Purpose: Returns the number of intersection points on the arc A.
returns Integer from Standard;
Value(myclass; C: HCurve2d from Adaptor2d; Index: Integer from Standard;
Pt: out Pnt from gp; Tol: out Real from Standard;
U: out Real from Standard);
---Purpose: Returns the value (Pt), the tolerance (Tol), and
-- the parameter (U) on the arc A , of the intersection
-- point of range Index.
IsVertex(myclass; C: HCurve2d from Adaptor2d;
Index: Integer from Standard)
---Purpose: Returns True if the intersection point of range Index
-- corresponds with a vertex on the arc A.
returns Boolean from Standard;
Vertex(myclass; C: HCurve2d from Adaptor2d; Index: Integer from Standard;
V: out HVertex from Adaptor3d);
---Purpose: When IsVertex returns True, this method returns the
-- vertex on the arc A.
NbSegments(myclass; C: HCurve2d from Adaptor2d)
---Purpose: returns the number of part of A solution of the
-- of intersection problem.
returns Integer from Standard;
HasFirstPoint(myclass; C: HCurve2d from Adaptor2d;
Index: Integer from Standard;
IndFirst: out Integer from Standard)
---Purpose: Returns True when the segment of range Index is not
-- open at the left side. In that case, IndFirst is the
-- range in the list intersection points (see NbPoints)
-- of the one which defines the left bound of the segment.
-- Otherwise, the method has to return False, and IndFirst
-- has no meaning.
returns Boolean from Standard;
HasLastPoint(myclass; C: HCurve2d from Adaptor2d;
Index: Integer from Standard;
IndLast: out Integer from Standard)
---Purpose: Returns True when the segment of range Index is not
-- open at the right side. In that case, IndLast is the
-- range in the list intersection points (see NbPoints)
-- of the one which defines the right bound of the segment.
-- Otherwise, the method has to return False, and IndLast
-- has no meaning.
returns Boolean from Standard;
IsAllSolution(myclass; C: HCurve2d from Adaptor2d)
---Purpose: Returns True when the whole restriction is solution
-- of the intersection problem.
returns Boolean from Standard;
end HContTool;

View File

@@ -14,10 +14,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_HContTool.ixx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Contap_HContTool.hxx>
#include <Extrema_EPCOfExtPC2d.hxx>
#include <Extrema_POnCurv2d.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
static Standard_Real uinf,vinf,usup,vsup;

View File

@@ -0,0 +1,149 @@
// Created on: 1995-07-02
// Created by: Laurent BUCHARD
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_HContTool_HeaderFile
#define _Contap_HContTool_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.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 Contap_HContTool
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT static Standard_Integer NbSamplesU (const Handle(Adaptor3d_HSurface)& 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 NbSamplePoints (const Handle(Adaptor3d_HSurface)& S);
Standard_EXPORT static void SamplePoint (const Handle(Adaptor3d_HSurface)& S, const Standard_Integer Index, Standard_Real& U, Standard_Real& V);
//! 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);
//! 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);
//! 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);
//! Projects the point P on the arc C.
//! If the methods returns Standard_True, the projection is
//! successful, and Paramproj is the parameter on the arc
//! 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);
//! 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);
//! 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);
//! Returns the number of intersection points on the arc A.
Standard_EXPORT static Standard_Integer NbPoints (const Handle(Adaptor2d_HCurve2d)& 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);
//! 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);
//! 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);
//! returns the number of part of A solution of the
//! of intersection problem.
Standard_EXPORT static Standard_Integer NbSegments (const Handle(Adaptor2d_HCurve2d)& C);
//! Returns True when the segment of range Index is not
//! open at the left side. In that case, IndFirst is the
//! range in the list intersection points (see NbPoints)
//! 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);
//! Returns True when the segment of range Index is not
//! open at the right side. In that case, IndLast is the
//! range in the list intersection points (see NbPoints)
//! 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);
//! Returns True when the whole restriction is solution
//! of the intersection problem.
Standard_EXPORT static Standard_Boolean IsAllSolution (const Handle(Adaptor2d_HCurve2d)& C);
protected:
private:
};
#endif // _Contap_HContTool_HeaderFile

View File

@@ -1,234 +0,0 @@
-- Created on: 1995-07-17
-- Created by: Laurent BUCHARD
-- Copyright (c) 1995-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class HCurve2dTool from Contap
uses
Array1OfReal from TColStd,
Shape from GeomAbs,
CurveType from GeomAbs,
Vec2d from gp,
Pnt2d from gp,
Circ2d from gp,
Elips2d from gp,
Hypr2d from gp,
Parab2d from gp,
Lin2d from gp,
BezierCurve from Geom2d,
BSplineCurve from Geom2d,
HCurve2d from Adaptor2d
raises
OutOfRange from Standard,
NoSuchObject from Standard,
DomainError from Standard
is
--
-- Global methods - Apply to the whole curve.
--
FirstParameter(myclass; C: HCurve2d from Adaptor2d) returns Real
---C++: inline
;
LastParameter(myclass; C: HCurve2d from Adaptor2d) returns Real
---C++: inline
;
--
-- Services to break the curves to the expected continuity
--
-- If for example you need the curve to be C2 and the method
-- Continuity returns you something lower than C2 (say C1 for
-- example).
--
-- First compute the number of intervals with the requested
-- continuity with the method NbIntervals(). Note that if the
-- continuity is higher than the one you need NbIntervals will
-- return 1.
--
-- Then you get the parameters bounding the intervals with the
-- method Intervals, using an array of length at least
-- NbIntervals()+1.
--
-- If you need to create a curve with a restricted span you can
-- use the method Trim().
Continuity(myclass; C: HCurve2d from Adaptor2d) returns Shape from GeomAbs
---Purpose:
---C++: inline
;
NbIntervals(myclass; C: HCurve2d from Adaptor2d; S : Shape from GeomAbs) returns Integer
---Purpose: Returns the number of intervals for continuity
-- <S>. May be one if Continuity(myclass) >= <S>
---C++: inline
;
Intervals(myclass; C: HCurve2d from Adaptor2d; T : in out Array1OfReal from TColStd;
S : Shape from GeomAbs)
---Purpose: Stores in <T> the parameters bounding the intervals
-- of continuity <S>.
--
-- The array must provide enough room to accomodate
-- for the parameters. i.e. T.Length() > NbIntervals()
raises
OutOfRange from Standard
---C++: inline
;
IsClosed(myclass; C: HCurve2d from Adaptor2d) returns Boolean
---C++: inline
;
IsPeriodic(myclass; C: HCurve2d from Adaptor2d) returns Boolean
---C++: inline
;
Period(myclass; C: HCurve2d from Adaptor2d) returns Real
raises
DomainError from Standard -- if the curve is not periodic
---C++: inline
;
Value(myclass; C: HCurve2d from Adaptor2d; U : Real) returns Pnt2d from gp
--- Purpose : Computes the point of parameter U on the curve.
---C++: inline
;
D0 (myclass; C: HCurve2d from Adaptor2d; U : Real; P : out Pnt2d from gp)
--- Purpose : Computes the point of parameter U on the curve.
---C++: inline
;
D1 (myclass; C: HCurve2d from Adaptor2d; U : Real; P : out Pnt2d from gp ; V : out Vec2d from gp)
--- Purpose : Computes the point of parameter U on the curve with its
-- first derivative.
raises
DomainError from Standard
--- Purpose : Raised if the continuity of the current interval
-- is not C1.
---C++: inline
;
D2 (myclass; C: HCurve2d from Adaptor2d; U : Real; P : out Pnt2d from gp; V1, V2 : out Vec2d from gp)
--- Purpose :
-- Returns the point P of parameter U, the first and second
-- derivatives V1 and V2.
raises
DomainError from Standard
--- Purpose : Raised if the continuity of the current interval
-- is not C2.
---C++: inline
;
D3 (myclass; C: HCurve2d from Adaptor2d; U : Real; P : out Pnt2d from gp; V1, V2, V3 : out Vec2d from gp)
--- Purpose :
-- Returns the point P of parameter U, the first, the second
-- and the third derivative.
raises
DomainError from Standard
--- Purpose : Raised if the continuity of the current interval
-- is not C3.
---C++: inline
;
DN (myclass; C: HCurve2d from Adaptor2d; U : Real; N : Integer) returns Vec2d from gp
--- Purpose :
-- The returned vector gives the value of the derivative for the
-- order of derivation N.
raises
DomainError from Standard,
--- Purpose : Raised if the continuity of the current interval
-- is not CN.
OutOfRange from Standard
--- Purpose : Raised if N < 1.
---C++: inline
;
Resolution(myclass; C: HCurve2d from Adaptor2d; R3d : Real) returns Real
---Purpose : Returns the parametric resolution corresponding
-- to the real space resolution <R3d>.
---C++: inline
;
GetType(myclass; C: HCurve2d from Adaptor2d) returns CurveType from GeomAbs
---Purpose: Returns the type of the curve in the current
-- interval : Line, Circle, Ellipse, Hyperbola,
-- Parabola, BezierCurve, BSplineCurve, OtherCurve.
---C++: inline
;
--
-- The following methods must be called when GetType returned
-- the corresponding type.
--
Line(myclass; C: HCurve2d from Adaptor2d) returns Lin2d from gp
raises
NoSuchObject from Standard
---C++: inline
;
Circle(myclass; C: HCurve2d from Adaptor2d) returns Circ2d from gp
raises
NoSuchObject from Standard
---C++: inline
;
Ellipse(myclass; C: HCurve2d from Adaptor2d) returns Elips2d from gp
raises
NoSuchObject from Standard
---C++: inline
;
Hyperbola(myclass; C: HCurve2d from Adaptor2d) returns Hypr2d from gp
raises
NoSuchObject from Standard
---C++: inline
;
Parabola(myclass; C: HCurve2d from Adaptor2d) returns Parab2d from gp
raises
NoSuchObject from Standard
---C++: inline
;
Bezier(myclass; C: HCurve2d from Adaptor2d) returns BezierCurve from Geom2d
raises
NoSuchObject from Standard
---C++: inline
;
BSpline(myclass; C: HCurve2d from Adaptor2d) returns BSplineCurve from Geom2d
raises
NoSuchObject from Standard
---C++: inline
;
NbSamples(myclass; C: HCurve2d from Adaptor2d; U0,U1: Real from Standard)
returns Integer from Standard;
end HCurve2dTool;

View File

@@ -14,7 +14,16 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_HCurve2dTool.ixx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Contap_HCurve2dTool.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_OutOfRange.hxx>
//============================================================
Standard_Integer Contap_HCurve2dTool::NbSamples (const Handle(Adaptor2d_HCurve2d)& C,

View File

@@ -0,0 +1,161 @@
// Created on: 1995-07-17
// Created by: Laurent BUCHARD
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_HCurve2dTool_HeaderFile
#define _Contap_HCurve2dTool_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <Standard_Boolean.hxx>
#include <gp_Pnt2d.hxx>
#include <gp_Vec2d.hxx>
#include <GeomAbs_CurveType.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Elips2d.hxx>
#include <gp_Hypr2d.hxx>
#include <gp_Parab2d.hxx>
class Standard_OutOfRange;
class Standard_NoSuchObject;
class Standard_DomainError;
class Adaptor2d_HCurve2d;
class gp_Pnt2d;
class gp_Vec2d;
class Geom2d_BezierCurve;
class Geom2d_BSplineCurve;
class Contap_HCurve2dTool
{
public:
DEFINE_STANDARD_ALLOC
static Standard_Real FirstParameter (const Handle(Adaptor2d_HCurve2d)& C);
static Standard_Real LastParameter (const Handle(Adaptor2d_HCurve2d)& C);
static GeomAbs_Shape Continuity (const Handle(Adaptor2d_HCurve2d)& 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);
//! Stores in <T> the parameters bounding the intervals
//! of continuity <S>.
//!
//! The array must provide enough room to accomodate
//! for the parameters. i.e. T.Length() > NbIntervals()
static void Intervals (const Handle(Adaptor2d_HCurve2d)& C, TColStd_Array1OfReal& T, const GeomAbs_Shape S);
static Standard_Boolean IsClosed (const Handle(Adaptor2d_HCurve2d)& C);
static Standard_Boolean IsPeriodic (const Handle(Adaptor2d_HCurve2d)& C);
static Standard_Real Period (const Handle(Adaptor2d_HCurve2d)& C);
//! Computes the point of parameter U on the curve.
static gp_Pnt2d Value (const Handle(Adaptor2d_HCurve2d)& 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);
//! 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);
//! 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);
//! 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);
//! The returned vector gives the value of the derivative for the
//! order of derivation N.
//! Raised if the continuity of the current interval
//! is not CN.
//! Raised if N < 1.
static gp_Vec2d DN (const Handle(Adaptor2d_HCurve2d)& 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);
//! 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 gp_Lin2d Line (const Handle(Adaptor2d_HCurve2d)& C);
static gp_Circ2d Circle (const Handle(Adaptor2d_HCurve2d)& C);
static gp_Elips2d Ellipse (const Handle(Adaptor2d_HCurve2d)& C);
static gp_Hypr2d Hyperbola (const Handle(Adaptor2d_HCurve2d)& C);
static gp_Parab2d Parabola (const Handle(Adaptor2d_HCurve2d)& C);
static Handle(Geom2d_BezierCurve) Bezier (const Handle(Adaptor2d_HCurve2d)& C);
static Handle(Geom2d_BSplineCurve) BSpline (const Handle(Adaptor2d_HCurve2d)& C);
Standard_EXPORT static Standard_Integer NbSamples (const Handle(Adaptor2d_HCurve2d)& C, const Standard_Real U0, const Standard_Real U1);
protected:
private:
};
#include <Contap_HCurve2dTool.lxx>
#endif // _Contap_HCurve2dTool_HeaderFile

View File

@@ -0,0 +1,29 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_IType_HeaderFile
#define _Contap_IType_HeaderFile
enum Contap_IType
{
Contap_Lin,
Contap_Circle,
Contap_Walking,
Contap_Restriction
};
#endif // _Contap_IType_HeaderFile

View File

@@ -1,213 +0,0 @@
-- Created on: 1993-02-05
-- Created by: Jacques GOUSSARD
-- Copyright (c) 1993-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class Line from Contap
---Purpose:
uses Pnt from gp,
LineOn2S from IntSurf,
PntOn2S from IntSurf,
TypeTrans from IntSurf,
Lin from gp,
Circ from gp,
Dir from gp,
IType from Contap, -- duplique IntPatch_IType. Mettre ds IntSurf
HVertex from Adaptor3d,
HCurve2d from Adaptor2d,
Point from Contap,
TheHSequenceOfPoint from Contap
raises DomainError from Standard,
OutOfRange from Standard
is
Create
returns Line from Contap;
SetLineOn2S(me: in out; L: LineOn2S from IntSurf)
is static;
Clear(me: in out)
is static;
LineOn2S(me)
returns LineOn2S from IntSurf
---C++: inline
---C++: return const&
is static;
ResetSeqOfVertex(me: in out)
is static;
Add(me: in out; P: PntOn2S from IntSurf)
---C++: inline
is static;
SetValue(me: in out; L: Lin from gp)
is static;
SetValue(me: in out; C: Circ from gp)
is static;
SetValue(me: in out; A: HCurve2d from Adaptor2d)
is static;
Add(me: in out; P: Point from Contap)
is static;
NbVertex(me)
returns Integer from Standard
---C++: inline
is static;
Vertex(me; Index: Integer from Standard)
returns Point from Contap
---C++: return &
---C++: inline
raises OutOfRange from Standard
is static;
TypeContour(me)
---Purpose: Returns Contap_Lin for a line, Contap_Circle for
-- a circle, and Contap_Walking for a Walking line,
-- Contap_Restriction for a part of boundarie.
returns IType from Contap
---C++: inline
is static;
NbPnts(me)
returns Integer from Standard
---C++: inline
raises DomainError from Standard
-- The exception DomainError is raised if TypeContour does not return
-- Contap_Walking.
is static;
Point(me; Index: Integer from Standard)
returns PntOn2S from IntSurf
---C++: return const&
---C++: inline
raises DomainError from Standard,
OutOfRange from Standard
-- The exception DomainError is raised if TypeContour does not return
-- Contap_Walking.
-- The exception OutOfRange is raised if Index<=0 or Index>NbPoints.
is static;
Line(me)
returns Lin from gp
---C++: inline
raises DomainError from Standard
-- The exception DomainError is raised if TypeContour does not return
-- Contap_Lin.
is static;
Circle(me)
returns Circ from gp
---C++: inline
raises DomainError from Standard
-- The exception DomainError is raised if TypeContour does not return
-- Contap_Circle.
is static;
Arc(me)
returns any HCurve2d from Adaptor2d
---C++: return const&
raises DomainError from Standard
-- The exception DomainError is raised if TypeContour does not return
-- Contap_Restriction.
is static;
SetTransitionOnS(me: in out; T: TypeTrans from IntSurf)
---Purpose: Set The Tansition of the line.
--
is static;
TransitionOnS(me)
---Purpose: returns IN if at the "left" of the line, the normale of the
-- surface is oriented to the observator.
returns TypeTrans from IntSurf
is static;
fields
Trans : TypeTrans from IntSurf;
curv : LineOn2S from IntSurf;
svtx : TheHSequenceOfPoint from Contap;
thearc : HCurve2d from Adaptor2d;
typL : IType from Contap;
pt : Pnt from gp;
dir1 : Dir from gp;
dir2 : Dir from gp;
rad : Real from Standard;
end Line;

View File

@@ -14,7 +14,16 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_Line.ixx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Contap_Line.hxx>
#include <Contap_Point.hxx>
#include <gp_Circ.hxx>
#include <gp_Lin.hxx>
#include <IntSurf_LineOn2S.hxx>
#include <IntSurf_PntOn2S.hxx>
#include <Standard_DomainError.hxx>
#include <Standard_OutOfRange.hxx>
Contap_Line::Contap_Line () {
svtx = new Contap_TheHSequenceOfPoint ();

130
src/Contap/Contap_Line.hxx Normal file
View File

@@ -0,0 +1,130 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_Line_HeaderFile
#define _Contap_Line_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <IntSurf_TypeTrans.hxx>
#include <Contap_TheHSequenceOfPoint.hxx>
#include <Contap_IType.hxx>
#include <gp_Pnt.hxx>
#include <gp_Dir.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <gp_Lin.hxx>
#include <gp_Circ.hxx>
class IntSurf_LineOn2S;
class Adaptor2d_HCurve2d;
class Standard_DomainError;
class Standard_OutOfRange;
class IntSurf_PntOn2S;
class gp_Lin;
class gp_Circ;
class Contap_Point;
class Contap_Line
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Contap_Line();
Standard_EXPORT void SetLineOn2S (const Handle(IntSurf_LineOn2S)& L);
Standard_EXPORT void Clear();
const Handle(IntSurf_LineOn2S)& LineOn2S() const;
Standard_EXPORT void ResetSeqOfVertex();
void Add (const IntSurf_PntOn2S& P);
Standard_EXPORT void SetValue (const gp_Lin& L);
Standard_EXPORT void SetValue (const gp_Circ& C);
Standard_EXPORT void SetValue (const Handle(Adaptor2d_HCurve2d)& A);
Standard_EXPORT void Add (const Contap_Point& P);
Standard_Integer NbVertex() const;
Contap_Point& Vertex (const Standard_Integer Index) const;
//! Returns Contap_Lin for a line, Contap_Circle for
//! a circle, and Contap_Walking for a Walking line,
//! Contap_Restriction for a part of boundarie.
Contap_IType TypeContour() const;
Standard_Integer NbPnts() const;
const IntSurf_PntOn2S& Point (const Standard_Integer Index) const;
gp_Lin Line() const;
gp_Circ Circle() const;
Standard_EXPORT const Handle(Adaptor2d_HCurve2d)& Arc() const;
//! Set The Tansition of the line.
Standard_EXPORT void SetTransitionOnS (const IntSurf_TypeTrans T);
//! returns IN if at the "left" of the line, the normale of the
//! surface is oriented to the observator.
Standard_EXPORT IntSurf_TypeTrans TransitionOnS() const;
protected:
private:
IntSurf_TypeTrans Trans;
Handle(IntSurf_LineOn2S) curv;
Handle(Contap_TheHSequenceOfPoint) svtx;
Handle(Adaptor2d_HCurve2d) thearc;
Contap_IType typL;
gp_Pnt pt;
gp_Dir dir1;
gp_Dir dir2;
Standard_Real rad;
};
#include <Contap_Line.lxx>
#endif // _Contap_Line_HeaderFile

View File

@@ -1,271 +0,0 @@
-- Created on: 1993-03-04
-- Created by: Jacques GOUSSARD
-- Copyright (c) 1993-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class Point from Contap
---Purpose: Definition of a vertex on the contour line.
-- Most of the time, such a point is an intersection
-- between the contour and a restriction of the surface.
-- When it is not tyhe method IsOnArc return False.
-- Such a point is contains geometrical informations (see
-- the Value method) and logical informations.
uses Pnt from gp,
Transition from IntSurf,
HVertex from Adaptor3d,
HCurve2d from Adaptor2d
raises DomainError from Standard
is
Create
---Purpose: Empty constructor.
returns Point from Contap;
Create(Pt: Pnt from gp; U,V: Real from Standard)
---Purpose: Creates a point.
returns Point from Contap;
SetValue(me: in out; Pt: Pnt from gp; U,V: Real from Standard)
---Purpose: Sets the values for a point.
---C++: inline
is static;
SetParameter(me: in out; Para: Real from Standard)
---Purpose: Set the value of the parameter on the intersection line.
---C++: inline
is static;
SetVertex(me: in out; V: HVertex from Adaptor3d)
---Purpose: Sets the values of a point which is a vertex on
-- the initial facet of restriction of one
-- of the surface.
---C++: inline
is static;
SetArc(me: in out; A: HCurve2d from Adaptor2d; Param: Real from Standard;
TLine,TArc: Transition from IntSurf)
---Purpose: Sets the value of the arc and of the parameter on
-- this arc of the point.
---C++: inline
is static;
SetMultiple(me: in out)
---C++: inline
is static;
SetInternal(me : in out)
---C++: inline
is static;
Value(me)
---Purpose: Returns the intersection point (geometric information).
returns Pnt from gp
---C++: return const&
---C++: inline
is static;
ParameterOnLine(me)
---Purpose: This method returns the parameter of the point
-- on the intersection line.
-- If the points does not belong to an intersection line,
-- the value returned does not have any sens.
returns Real from Standard
---C++: inline
is static;
Parameters(me; U1,V1: out Real from Standard)
---Purpose: Returns the parameters on the surface of the point.
---C++: inline
is static;
IsOnArc(me)
---Purpose: Returns True when the point is an intersection between
-- the contour and a restriction.
returns Boolean from Standard
---C++: inline
is static;
Arc(me)
---Purpose: Returns the arc of restriction containing the
-- vertex.
returns any HCurve2d from Adaptor2d
---C++: return const&
---C++: inline
raises DomainError from Standard
--- The exception DomianError is raised when IsOnArc
-- returns Standard_False.
is static;
ParameterOnArc(me)
---Purpose: Returns the parameter of the point on the
-- arc returned by the method Arc().
returns Real from Standard
---C++: inline
raises DomainError from Standard
--- The exception DomianError is raised when IsOnArc
-- returns Standard_False.
is static;
TransitionOnLine(me)
---Purpose: Returns the transition of the point on the contour.
returns Transition from IntSurf
---C++: inline
---C++: return const&
raises DomainError from Standard
--- The exception DomianError is raised when IsOnArc
-- returns Standard_False.
is static;
TransitionOnArc(me)
---Purpose: Returns the transition of the point on the arc.
returns Transition from IntSurf
---C++: inline
---C++: return const&
raises DomainError from Standard
--- The exception DomianError is raised when IsOnArc
-- returns Standard_False.
is static;
IsVertex(me)
---Purpose: Returns TRUE if the point is a vertex on the initial
-- restriction facet of the surface.
returns Boolean from Standard
---C++: inline
is static;
Vertex(me)
---Purpose: Returns the information about the point when it is
-- on the domain of the patch, i-e when the function
-- IsVertex returns True.
-- Otherwise, an exception is raised.
returns any HVertex from Adaptor3d
---C++: return const&
---C++: inline
raises DomainError from Standard
is static;
IsMultiple(me)
---Purpose: Returns True if the point belongs to several
-- lines.
returns Boolean from Standard
---C++: inline
is static;
IsInternal(me)
---Purpose: Returns True if the point is an internal one, i.e
-- if the tangent to the line on the point and the
-- eye direction are parallel.
returns Boolean from Standard
---C++: inline
is static;
fields
pt : Pnt from gp;
uparam : Real from Standard;
vparam : Real from Standard;
paraline : Real from Standard;
onarc : Boolean from Standard;
arc : HCurve2d from Adaptor2d;
traline : Transition from IntSurf;
traarc : Transition from IntSurf;
prmarc : Real from Standard;
isvtx : Boolean from Standard;
vtx : HVertex from Adaptor3d;
ismult : Boolean from Standard;
myInternal : Boolean from Standard;
end Point;

View File

@@ -14,7 +14,13 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_Point.ixx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Contap_Point.hxx>
#include <gp_Pnt.hxx>
#include <IntSurf_Transition.hxx>
#include <Standard_DomainError.hxx>
Contap_Point::Contap_Point ():
onarc(Standard_False),isvtx(Standard_False),ismult(Standard_False),

159
src/Contap/Contap_Point.hxx Normal file
View File

@@ -0,0 +1,159 @@
// Created on: 1993-03-04
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_Point_HeaderFile
#define _Contap_Point_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <IntSurf_Transition.hxx>
class Adaptor2d_HCurve2d;
class Adaptor3d_HVertex;
class Standard_DomainError;
class gp_Pnt;
class IntSurf_Transition;
//! Definition of a vertex on the contour line.
//! Most of the time, such a point is an intersection
//! between the contour and a restriction of the surface.
//! When it is not tyhe method IsOnArc return False.
//! Such a point is contains geometrical informations (see
//! the Value method) and logical informations.
class Contap_Point
{
public:
DEFINE_STANDARD_ALLOC
//! Empty constructor.
Standard_EXPORT Contap_Point();
//! Creates a point.
Standard_EXPORT Contap_Point(const gp_Pnt& Pt, const Standard_Real U, const Standard_Real V);
//! Sets the values for a point.
void SetValue (const gp_Pnt& Pt, const Standard_Real U, const Standard_Real V);
//! Set the value of the parameter on the intersection line.
void SetParameter (const Standard_Real Para);
//! Sets the values of a point which is a vertex on
//! the initial facet of restriction of one
//! of the surface.
void SetVertex (const Handle(Adaptor3d_HVertex)& V);
//! Sets the value of the arc and of the parameter on
//! this arc of the point.
void SetArc (const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Param, const IntSurf_Transition& TLine, const IntSurf_Transition& TArc);
void SetMultiple();
void SetInternal();
//! Returns the intersection point (geometric information).
const gp_Pnt& Value() const;
//! This method returns the parameter of the point
//! on the intersection line.
//! If the points does not belong to an intersection line,
//! the value returned does not have any sens.
Standard_Real ParameterOnLine() const;
//! Returns the parameters on the surface of the point.
void Parameters (Standard_Real& U1, Standard_Real& V1) const;
//! Returns True when the point is an intersection between
//! the contour and a restriction.
Standard_Boolean IsOnArc() const;
//! Returns the arc of restriction containing the
//! vertex.
const Handle(Adaptor2d_HCurve2d)& Arc() const;
//! Returns the parameter of the point on the
//! arc returned by the method Arc().
Standard_Real ParameterOnArc() const;
//! Returns the transition of the point on the contour.
const IntSurf_Transition& TransitionOnLine() const;
//! Returns the transition of the point on the arc.
const IntSurf_Transition& TransitionOnArc() const;
//! Returns TRUE if the point is a vertex on the initial
//! restriction facet of the surface.
Standard_Boolean IsVertex() const;
//! Returns the information about the point when it is
//! on the domain of the patch, i-e when the function
//! IsVertex returns True.
//! Otherwise, an exception is raised.
const Handle(Adaptor3d_HVertex)& Vertex() const;
//! Returns True if the point belongs to several
//! lines.
Standard_Boolean IsMultiple() const;
//! Returns True if the point is an internal one, i.e
//! if the tangent to the line on the point and the
//! eye direction are parallel.
Standard_Boolean IsInternal() const;
protected:
private:
gp_Pnt pt;
Standard_Real uparam;
Standard_Real vparam;
Standard_Real paraline;
Standard_Boolean onarc;
Handle(Adaptor2d_HCurve2d) arc;
IntSurf_Transition traline;
IntSurf_Transition traarc;
Standard_Real prmarc;
Standard_Boolean isvtx;
Handle(Adaptor3d_HVertex) vtx;
Standard_Boolean ismult;
Standard_Boolean myInternal;
};
#include <Contap_Point.lxx>
#endif // _Contap_Point_HeaderFile

View File

@@ -0,0 +1,82 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking_HeaderFile
#define _Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <TCollection_SeqNode.hxx>
#include <TCollection_SeqNodePtr.hxx>
class Contap_TheIWLineOfTheIWalking;
class Contap_SequenceOfIWLineOfTheIWalking;
class Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking;
DEFINE_STANDARD_HANDLE(Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking, TCollection_SeqNode)
class Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking : public TCollection_SeqNode
{
public:
Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking(const Handle(Contap_TheIWLineOfTheIWalking)& I, const TCollection_SeqNodePtr& n, const TCollection_SeqNodePtr& p);
Handle(Contap_TheIWLineOfTheIWalking)& Value() const;
DEFINE_STANDARD_RTTI(Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking,TCollection_SeqNode)
protected:
private:
Handle(Contap_TheIWLineOfTheIWalking) myValue;
};
#define SeqItem Handle(Contap_TheIWLineOfTheIWalking)
#define SeqItem_hxx <Contap_TheIWLineOfTheIWalking.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking)
#define TCollection_Sequence Contap_SequenceOfIWLineOfTheIWalking
#define TCollection_Sequence_hxx <Contap_SequenceOfIWLineOfTheIWalking.hxx>
#include <TCollection_SequenceNode.lxx>
#undef SeqItem
#undef SeqItem_hxx
#undef TCollection_SequenceNode
#undef TCollection_SequenceNode_hxx
#undef Handle_TCollection_SequenceNode
#undef TCollection_Sequence
#undef TCollection_Sequence_hxx
#endif // _Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking_HeaderFile

View File

@@ -0,0 +1,41 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#include <Standard_Type.hxx>
#include <Contap_TheIWLineOfTheIWalking.hxx>
#include <Contap_SequenceOfIWLineOfTheIWalking.hxx>
#define SeqItem Handle(Contap_TheIWLineOfTheIWalking)
#define SeqItem_hxx <Contap_TheIWLineOfTheIWalking.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking)
#define TCollection_Sequence Contap_SequenceOfIWLineOfTheIWalking
#define TCollection_Sequence_hxx <Contap_SequenceOfIWLineOfTheIWalking.hxx>
#include <TCollection_SequenceNode.gxx>

View File

@@ -0,0 +1,83 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch_HeaderFile
#define _Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Contap_ThePathPointOfTheSearch.hxx>
#include <TCollection_SeqNode.hxx>
#include <TCollection_SeqNodePtr.hxx>
class Contap_ThePathPointOfTheSearch;
class Contap_SequenceOfPathPointOfTheSearch;
class Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch;
DEFINE_STANDARD_HANDLE(Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch, TCollection_SeqNode)
class Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch : public TCollection_SeqNode
{
public:
Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch(const Contap_ThePathPointOfTheSearch& I, const TCollection_SeqNodePtr& n, const TCollection_SeqNodePtr& p);
Contap_ThePathPointOfTheSearch& Value() const;
DEFINE_STANDARD_RTTI(Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch,TCollection_SeqNode)
protected:
private:
Contap_ThePathPointOfTheSearch myValue;
};
#define SeqItem Contap_ThePathPointOfTheSearch
#define SeqItem_hxx <Contap_ThePathPointOfTheSearch.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch)
#define TCollection_Sequence Contap_SequenceOfPathPointOfTheSearch
#define TCollection_Sequence_hxx <Contap_SequenceOfPathPointOfTheSearch.hxx>
#include <TCollection_SequenceNode.lxx>
#undef SeqItem
#undef SeqItem_hxx
#undef TCollection_SequenceNode
#undef TCollection_SequenceNode_hxx
#undef Handle_TCollection_SequenceNode
#undef TCollection_Sequence
#undef TCollection_Sequence_hxx
#endif // _Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch_HeaderFile

View File

@@ -0,0 +1,41 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#include <Standard_Type.hxx>
#include <Contap_ThePathPointOfTheSearch.hxx>
#include <Contap_SequenceOfPathPointOfTheSearch.hxx>
#define SeqItem Contap_ThePathPointOfTheSearch
#define SeqItem_hxx <Contap_ThePathPointOfTheSearch.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch)
#define TCollection_Sequence Contap_SequenceOfPathPointOfTheSearch
#define TCollection_Sequence_hxx <Contap_SequenceOfPathPointOfTheSearch.hxx>
#include <TCollection_SequenceNode.gxx>

View File

@@ -0,0 +1,83 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch_HeaderFile
#define _Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Contap_TheSegmentOfTheSearch.hxx>
#include <TCollection_SeqNode.hxx>
#include <TCollection_SeqNodePtr.hxx>
class Contap_TheSegmentOfTheSearch;
class Contap_SequenceOfSegmentOfTheSearch;
class Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch;
DEFINE_STANDARD_HANDLE(Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch, TCollection_SeqNode)
class Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch : public TCollection_SeqNode
{
public:
Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch(const Contap_TheSegmentOfTheSearch& I, const TCollection_SeqNodePtr& n, const TCollection_SeqNodePtr& p);
Contap_TheSegmentOfTheSearch& Value() const;
DEFINE_STANDARD_RTTI(Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch,TCollection_SeqNode)
protected:
private:
Contap_TheSegmentOfTheSearch myValue;
};
#define SeqItem Contap_TheSegmentOfTheSearch
#define SeqItem_hxx <Contap_TheSegmentOfTheSearch.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch)
#define TCollection_Sequence Contap_SequenceOfSegmentOfTheSearch
#define TCollection_Sequence_hxx <Contap_SequenceOfSegmentOfTheSearch.hxx>
#include <TCollection_SequenceNode.lxx>
#undef SeqItem
#undef SeqItem_hxx
#undef TCollection_SequenceNode
#undef TCollection_SequenceNode_hxx
#undef Handle_TCollection_SequenceNode
#undef TCollection_Sequence
#undef TCollection_Sequence_hxx
#endif // _Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch_HeaderFile

View File

@@ -0,0 +1,41 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#include <Standard_Type.hxx>
#include <Contap_TheSegmentOfTheSearch.hxx>
#include <Contap_SequenceOfSegmentOfTheSearch.hxx>
#define SeqItem Contap_TheSegmentOfTheSearch
#define SeqItem_hxx <Contap_TheSegmentOfTheSearch.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch)
#define TCollection_Sequence Contap_SequenceOfSegmentOfTheSearch
#define TCollection_Sequence_hxx <Contap_SequenceOfSegmentOfTheSearch.hxx>
#include <TCollection_SequenceNode.gxx>

View File

@@ -0,0 +1,134 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_SequenceOfIWLineOfTheIWalking_HeaderFile
#define _Contap_SequenceOfIWLineOfTheIWalking_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <TCollection_BaseSequence.hxx>
#include <Standard_Integer.hxx>
class Standard_NoSuchObject;
class Standard_OutOfRange;
class Contap_TheIWLineOfTheIWalking;
class Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking;
class Contap_SequenceOfIWLineOfTheIWalking : public TCollection_BaseSequence
{
public:
DEFINE_STANDARD_ALLOC
Contap_SequenceOfIWLineOfTheIWalking();
Standard_EXPORT Contap_SequenceOfIWLineOfTheIWalking(const Contap_SequenceOfIWLineOfTheIWalking& Other);
Standard_EXPORT void Clear();
~Contap_SequenceOfIWLineOfTheIWalking()
{
Clear();
}
Standard_EXPORT const Contap_SequenceOfIWLineOfTheIWalking& Assign (const Contap_SequenceOfIWLineOfTheIWalking& Other);
const Contap_SequenceOfIWLineOfTheIWalking& operator = (const Contap_SequenceOfIWLineOfTheIWalking& Other)
{
return Assign(Other);
}
Standard_EXPORT void Append (const Handle(Contap_TheIWLineOfTheIWalking)& T);
void Append (Contap_SequenceOfIWLineOfTheIWalking& S);
Standard_EXPORT void Prepend (const Handle(Contap_TheIWLineOfTheIWalking)& T);
void Prepend (Contap_SequenceOfIWLineOfTheIWalking& S);
void InsertBefore (const Standard_Integer Index, const Handle(Contap_TheIWLineOfTheIWalking)& T);
void InsertBefore (const Standard_Integer Index, Contap_SequenceOfIWLineOfTheIWalking& S);
Standard_EXPORT void InsertAfter (const Standard_Integer Index, const Handle(Contap_TheIWLineOfTheIWalking)& T);
void InsertAfter (const Standard_Integer Index, Contap_SequenceOfIWLineOfTheIWalking& S);
Standard_EXPORT const Handle(Contap_TheIWLineOfTheIWalking)& First() const;
Standard_EXPORT const Handle(Contap_TheIWLineOfTheIWalking)& Last() const;
void Split (const Standard_Integer Index, Contap_SequenceOfIWLineOfTheIWalking& Sub);
Standard_EXPORT const Handle(Contap_TheIWLineOfTheIWalking)& Value (const Standard_Integer Index) const;
const Handle(Contap_TheIWLineOfTheIWalking)& operator() (const Standard_Integer Index) const
{
return Value(Index);
}
Standard_EXPORT void SetValue (const Standard_Integer Index, const Handle(Contap_TheIWLineOfTheIWalking)& I);
Standard_EXPORT Handle(Contap_TheIWLineOfTheIWalking)& ChangeValue (const Standard_Integer Index);
Handle(Contap_TheIWLineOfTheIWalking)& operator() (const Standard_Integer Index)
{
return ChangeValue(Index);
}
Standard_EXPORT void Remove (const Standard_Integer Index);
Standard_EXPORT void Remove (const Standard_Integer FromIndex, const Standard_Integer ToIndex);
protected:
private:
};
#define SeqItem Handle(Contap_TheIWLineOfTheIWalking)
#define SeqItem_hxx <Contap_TheIWLineOfTheIWalking.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking)
#define TCollection_Sequence Contap_SequenceOfIWLineOfTheIWalking
#define TCollection_Sequence_hxx <Contap_SequenceOfIWLineOfTheIWalking.hxx>
#include <TCollection_Sequence.lxx>
#undef SeqItem
#undef SeqItem_hxx
#undef TCollection_SequenceNode
#undef TCollection_SequenceNode_hxx
#undef Handle_TCollection_SequenceNode
#undef TCollection_Sequence
#undef TCollection_Sequence_hxx
#endif // _Contap_SequenceOfIWLineOfTheIWalking_HeaderFile

View File

@@ -0,0 +1,33 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_SequenceOfIWLineOfTheIWalking.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_OutOfRange.hxx>
#include <Contap_TheIWLineOfTheIWalking.hxx>
#include <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#define SeqItem Handle(Contap_TheIWLineOfTheIWalking)
#define SeqItem_hxx <Contap_TheIWLineOfTheIWalking.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking)
#define TCollection_Sequence Contap_SequenceOfIWLineOfTheIWalking
#define TCollection_Sequence_hxx <Contap_SequenceOfIWLineOfTheIWalking.hxx>
#include <TCollection_Sequence.gxx>

View File

@@ -0,0 +1,134 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_SequenceOfPathPointOfTheSearch_HeaderFile
#define _Contap_SequenceOfPathPointOfTheSearch_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <TCollection_BaseSequence.hxx>
#include <Standard_Integer.hxx>
class Standard_NoSuchObject;
class Standard_OutOfRange;
class Contap_ThePathPointOfTheSearch;
class Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch;
class Contap_SequenceOfPathPointOfTheSearch : public TCollection_BaseSequence
{
public:
DEFINE_STANDARD_ALLOC
Contap_SequenceOfPathPointOfTheSearch();
Standard_EXPORT Contap_SequenceOfPathPointOfTheSearch(const Contap_SequenceOfPathPointOfTheSearch& Other);
Standard_EXPORT void Clear();
~Contap_SequenceOfPathPointOfTheSearch()
{
Clear();
}
Standard_EXPORT const Contap_SequenceOfPathPointOfTheSearch& Assign (const Contap_SequenceOfPathPointOfTheSearch& Other);
const Contap_SequenceOfPathPointOfTheSearch& operator = (const Contap_SequenceOfPathPointOfTheSearch& Other)
{
return Assign(Other);
}
Standard_EXPORT void Append (const Contap_ThePathPointOfTheSearch& T);
void Append (Contap_SequenceOfPathPointOfTheSearch& S);
Standard_EXPORT void Prepend (const Contap_ThePathPointOfTheSearch& T);
void Prepend (Contap_SequenceOfPathPointOfTheSearch& S);
void InsertBefore (const Standard_Integer Index, const Contap_ThePathPointOfTheSearch& T);
void InsertBefore (const Standard_Integer Index, Contap_SequenceOfPathPointOfTheSearch& S);
Standard_EXPORT void InsertAfter (const Standard_Integer Index, const Contap_ThePathPointOfTheSearch& T);
void InsertAfter (const Standard_Integer Index, Contap_SequenceOfPathPointOfTheSearch& S);
Standard_EXPORT const Contap_ThePathPointOfTheSearch& First() const;
Standard_EXPORT const Contap_ThePathPointOfTheSearch& Last() const;
void Split (const Standard_Integer Index, Contap_SequenceOfPathPointOfTheSearch& Sub);
Standard_EXPORT const Contap_ThePathPointOfTheSearch& Value (const Standard_Integer Index) const;
const Contap_ThePathPointOfTheSearch& operator() (const Standard_Integer Index) const
{
return Value(Index);
}
Standard_EXPORT void SetValue (const Standard_Integer Index, const Contap_ThePathPointOfTheSearch& I);
Standard_EXPORT Contap_ThePathPointOfTheSearch& ChangeValue (const Standard_Integer Index);
Contap_ThePathPointOfTheSearch& operator() (const Standard_Integer Index)
{
return ChangeValue(Index);
}
Standard_EXPORT void Remove (const Standard_Integer Index);
Standard_EXPORT void Remove (const Standard_Integer FromIndex, const Standard_Integer ToIndex);
protected:
private:
};
#define SeqItem Contap_ThePathPointOfTheSearch
#define SeqItem_hxx <Contap_ThePathPointOfTheSearch.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch)
#define TCollection_Sequence Contap_SequenceOfPathPointOfTheSearch
#define TCollection_Sequence_hxx <Contap_SequenceOfPathPointOfTheSearch.hxx>
#include <TCollection_Sequence.lxx>
#undef SeqItem
#undef SeqItem_hxx
#undef TCollection_SequenceNode
#undef TCollection_SequenceNode_hxx
#undef Handle_TCollection_SequenceNode
#undef TCollection_Sequence
#undef TCollection_Sequence_hxx
#endif // _Contap_SequenceOfPathPointOfTheSearch_HeaderFile

View File

@@ -0,0 +1,33 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_SequenceOfPathPointOfTheSearch.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_OutOfRange.hxx>
#include <Contap_ThePathPointOfTheSearch.hxx>
#include <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#define SeqItem Contap_ThePathPointOfTheSearch
#define SeqItem_hxx <Contap_ThePathPointOfTheSearch.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch)
#define TCollection_Sequence Contap_SequenceOfPathPointOfTheSearch
#define TCollection_Sequence_hxx <Contap_SequenceOfPathPointOfTheSearch.hxx>
#include <TCollection_Sequence.gxx>

View File

@@ -0,0 +1,134 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_SequenceOfSegmentOfTheSearch_HeaderFile
#define _Contap_SequenceOfSegmentOfTheSearch_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <TCollection_BaseSequence.hxx>
#include <Standard_Integer.hxx>
class Standard_NoSuchObject;
class Standard_OutOfRange;
class Contap_TheSegmentOfTheSearch;
class Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch;
class Contap_SequenceOfSegmentOfTheSearch : public TCollection_BaseSequence
{
public:
DEFINE_STANDARD_ALLOC
Contap_SequenceOfSegmentOfTheSearch();
Standard_EXPORT Contap_SequenceOfSegmentOfTheSearch(const Contap_SequenceOfSegmentOfTheSearch& Other);
Standard_EXPORT void Clear();
~Contap_SequenceOfSegmentOfTheSearch()
{
Clear();
}
Standard_EXPORT const Contap_SequenceOfSegmentOfTheSearch& Assign (const Contap_SequenceOfSegmentOfTheSearch& Other);
const Contap_SequenceOfSegmentOfTheSearch& operator = (const Contap_SequenceOfSegmentOfTheSearch& Other)
{
return Assign(Other);
}
Standard_EXPORT void Append (const Contap_TheSegmentOfTheSearch& T);
void Append (Contap_SequenceOfSegmentOfTheSearch& S);
Standard_EXPORT void Prepend (const Contap_TheSegmentOfTheSearch& T);
void Prepend (Contap_SequenceOfSegmentOfTheSearch& S);
void InsertBefore (const Standard_Integer Index, const Contap_TheSegmentOfTheSearch& T);
void InsertBefore (const Standard_Integer Index, Contap_SequenceOfSegmentOfTheSearch& S);
Standard_EXPORT void InsertAfter (const Standard_Integer Index, const Contap_TheSegmentOfTheSearch& T);
void InsertAfter (const Standard_Integer Index, Contap_SequenceOfSegmentOfTheSearch& S);
Standard_EXPORT const Contap_TheSegmentOfTheSearch& First() const;
Standard_EXPORT const Contap_TheSegmentOfTheSearch& Last() const;
void Split (const Standard_Integer Index, Contap_SequenceOfSegmentOfTheSearch& Sub);
Standard_EXPORT const Contap_TheSegmentOfTheSearch& Value (const Standard_Integer Index) const;
const Contap_TheSegmentOfTheSearch& operator() (const Standard_Integer Index) const
{
return Value(Index);
}
Standard_EXPORT void SetValue (const Standard_Integer Index, const Contap_TheSegmentOfTheSearch& I);
Standard_EXPORT Contap_TheSegmentOfTheSearch& ChangeValue (const Standard_Integer Index);
Contap_TheSegmentOfTheSearch& operator() (const Standard_Integer Index)
{
return ChangeValue(Index);
}
Standard_EXPORT void Remove (const Standard_Integer Index);
Standard_EXPORT void Remove (const Standard_Integer FromIndex, const Standard_Integer ToIndex);
protected:
private:
};
#define SeqItem Contap_TheSegmentOfTheSearch
#define SeqItem_hxx <Contap_TheSegmentOfTheSearch.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch)
#define TCollection_Sequence Contap_SequenceOfSegmentOfTheSearch
#define TCollection_Sequence_hxx <Contap_SequenceOfSegmentOfTheSearch.hxx>
#include <TCollection_Sequence.lxx>
#undef SeqItem
#undef SeqItem_hxx
#undef TCollection_SequenceNode
#undef TCollection_SequenceNode_hxx
#undef Handle_TCollection_SequenceNode
#undef TCollection_Sequence
#undef TCollection_Sequence_hxx
#endif // _Contap_SequenceOfSegmentOfTheSearch_HeaderFile

View File

@@ -0,0 +1,33 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_SequenceOfSegmentOfTheSearch.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_OutOfRange.hxx>
#include <Contap_TheSegmentOfTheSearch.hxx>
#include <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#define SeqItem Contap_TheSegmentOfTheSearch
#define SeqItem_hxx <Contap_TheSegmentOfTheSearch.hxx>
#define TCollection_SequenceNode Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch
#define TCollection_SequenceNode_hxx <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#define Handle_TCollection_SequenceNode Handle(Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch)
#define TCollection_Sequence Contap_SequenceOfSegmentOfTheSearch
#define TCollection_Sequence_hxx <Contap_SequenceOfSegmentOfTheSearch.hxx>
#include <TCollection_Sequence.gxx>

View File

@@ -1,233 +0,0 @@
-- Created on: 1993-06-03
-- Created by: Jacques GOUSSARD
-- Copyright (c) 1993-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class SurfFunction from Contap inherits FunctionSetWithDerivatives from math
---Purpose: This class describes the function on a parametric surface.
-- the form of the function is F(u,v) = 0 where u and v are
-- the parameteric coordinates of a point on the surface,
-- to compute the contours of the surface.
uses Vector from math,
Matrix from math,
Pnt from gp,
Vec from gp,
Dir from gp,
Dir2d from gp,
TFunction from Contap,
HSurface from Adaptor3d,
HSurfaceTool from Adaptor3d,
HContTool from Contap
raises UndefinedDerivative from StdFail
is
Create
returns SurfFunction from Contap;
Set(me: in out; S: HSurface from Adaptor3d)
is static;
Set(me: in out; Eye: Pnt from gp)
---C++: inline
is static;
Set(me: in out; Dir: Dir from gp)
---C++: inline
is static;
Set(me: in out; Dir: Dir from gp; Angle: Real from Standard)
---C++: inline
is static;
Set(me: in out; Eye: Pnt from gp; Angle: Real from Standard)
---C++: inline
is static;
Set(me: in out; Tolerance: Real from Standard)
---C++: inline
is static;
NbVariables(me)
---Purpose: This method has to return 2.
returns Integer from Standard;
NbEquations(me)
---Purpose: This method has to return 1.
returns Integer from Standard;
Value(me : in out; X : Vector from math;
F : out Vector from math)
---Purpose: The dimension of F is 1.
returns Boolean from Standard;
Derivatives(me : in out; X : Vector from math;
D : out Matrix from math)
---Purpose: The dimension of D is (1,2).
returns Boolean from Standard;
Values(me : in out; X : Vector from math;
F : out Vector from math;
D : out Matrix from math)
returns Boolean from Standard;
Root(me)
---Purpose: Root is the value of the function at the solution.
-- It is a vector of dimension 1, i-e a real.
returns Real from Standard
---C++: inline
is static;
Tolerance(me)
---Purpose: Returns the value Tol so that if Abs(Func.Root())<Tol
-- the function is considered null.
--
---C++: inline
returns Real from Standard
is static;
Point(me)
---Purpose: Returns the value of the solution point on the surface.
returns Pnt from gp
---C++: return const&
---C++: inline
is static;
IsTangent(me : in out)
returns Boolean from Standard
is static;
Direction3d(me: in out)
returns Vec from gp
---C++: return const&
---C++: inline
raises UndefinedDerivative from StdFail
is static;
Direction2d(me: in out)
returns Dir2d from gp
---C++: return const&
---C++: inline
raises UndefinedDerivative from StdFail
is static;
FunctionType(me)
returns TFunction from Contap
---C++: inline
is static;
Eye(me)
returns Pnt from gp
---C++: return const&
---C++: inline
is static;
Direction(me)
returns Dir from gp
---C++: return const&
---C++: inline
is static;
Angle(me)
returns Real from Standard
---C++: inline
is static;
Surface(me)
returns any HSurface from Adaptor3d
---C++: return const&
---C++: inline
is static;
fields
mySurf : HSurface from Adaptor3d;
myMean : Real from Standard;
myType : TFunction from Contap;
myDir : Dir from gp;
myEye : Pnt from gp;
myAng : Real from Standard;
myCosAng : Real from Standard;
tol : Real from Standard;
solpt : Pnt from gp;
valf : Real from Standard;
Usol : Real from Standard;
Vsol : Real from Standard;
Fpu : Real from Standard;
Fpv : Real from Standard;
d2d : Dir2d from gp;
d3d : Vec from gp;
tangent : Boolean from Standard;
computed : Boolean from Standard;
derived : Boolean from Standard;
end SurfFunction;

View File

@@ -16,11 +16,17 @@
// jag 940616 #define Tolpetit 1.e-16
#include <Contap_SurfFunction.ixx>
#include <Contap_SurfProps.hxx>
#include <Contap_HContTool.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <Contap_HContTool.hxx>
#include <Contap_SurfFunction.hxx>
#include <Contap_SurfProps.hxx>
#include <gp_Dir.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
#include <math_Matrix.hxx>
#include <StdFail_UndefinedDerivative.hxx>
Contap_SurfFunction::Contap_SurfFunction ():
myMean(1.),

View File

@@ -0,0 +1,152 @@
// Created on: 1993-06-03
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_SurfFunction_HeaderFile
#define _Contap_SurfFunction_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <Contap_TFunction.hxx>
#include <gp_Dir.hxx>
#include <gp_Pnt.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Vec.hxx>
#include <Standard_Boolean.hxx>
#include <math_FunctionSetWithDerivatives.hxx>
#include <Standard_Integer.hxx>
#include <math_Vector.hxx>
class Adaptor3d_HSurface;
class StdFail_UndefinedDerivative;
class gp_Pnt;
class gp_Dir;
class math_Matrix;
class gp_Vec;
class gp_Dir2d;
//! This class describes the function on a parametric surface.
//! the form of the function is F(u,v) = 0 where u and v are
//! the parameteric coordinates of a point on the surface,
//! to compute the contours of the surface.
class Contap_SurfFunction : public math_FunctionSetWithDerivatives
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Contap_SurfFunction();
Standard_EXPORT void Set (const Handle(Adaptor3d_HSurface)& S);
void Set (const gp_Pnt& Eye);
void Set (const gp_Dir& Dir);
void Set (const gp_Dir& Dir, const Standard_Real Angle);
void Set (const gp_Pnt& Eye, const Standard_Real Angle);
void Set (const Standard_Real Tolerance);
//! This method has to return 2.
Standard_EXPORT Standard_Integer NbVariables() const;
//! This method has to return 1.
Standard_EXPORT Standard_Integer NbEquations() const;
//! The dimension of F is 1.
Standard_EXPORT Standard_Boolean Value (const math_Vector& X, math_Vector& F);
//! The dimension of D is (1,2).
Standard_EXPORT Standard_Boolean Derivatives (const math_Vector& X, math_Matrix& D);
Standard_EXPORT Standard_Boolean Values (const math_Vector& X, math_Vector& F, math_Matrix& D);
//! Root is the value of the function at the solution.
//! It is a vector of dimension 1, i-e a real.
Standard_Real Root() const;
//! Returns the value Tol so that if Abs(Func.Root())<Tol
//! the function is considered null.
Standard_Real Tolerance() const;
//! Returns the value of the solution point on the surface.
const gp_Pnt& Point() const;
Standard_EXPORT Standard_Boolean IsTangent();
const gp_Vec& Direction3d();
const gp_Dir2d& Direction2d();
Contap_TFunction FunctionType() const;
const gp_Pnt& Eye() const;
const gp_Dir& Direction() const;
Standard_Real Angle() const;
const Handle(Adaptor3d_HSurface)& Surface() const;
protected:
private:
Handle(Adaptor3d_HSurface) mySurf;
Standard_Real myMean;
Contap_TFunction myType;
gp_Dir myDir;
gp_Pnt myEye;
Standard_Real myAng;
Standard_Real myCosAng;
Standard_Real tol;
gp_Pnt solpt;
Standard_Real valf;
Standard_Real Usol;
Standard_Real Vsol;
Standard_Real Fpu;
Standard_Real Fpv;
gp_Dir2d d2d;
gp_Vec d3d;
Standard_Boolean tangent;
Standard_Boolean computed;
Standard_Boolean derived;
};
#include <Contap_SurfFunction.lxx>
#endif // _Contap_SurfFunction_HeaderFile

View File

@@ -1,56 +0,0 @@
-- Created on: 1995-02-24
-- Created by: Jacques GOUSSARD
-- Copyright (c) 1995-1999 Matra Datavision
-- Copyright (c) 1999-2014 OPEN CASCADE SAS
--
-- This file is part of Open CASCADE Technology software library.
--
-- This library is free software; you can redistribute it and/or modify it under
-- the terms of the GNU Lesser General Public License version 2.1 as published
-- by the Free Software Foundation, with special exception defined in the file
-- OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-- distribution for complete text of the license and disclaimer of any warranty.
--
-- Alternatively, this file may be used under the terms of Open CASCADE
-- commercial license or contractual agreement.
class SurfProps from Contap
---Purpose: Internal tool used to compute the normal and its
-- derivatives.
uses Pnt from gp,
Vec from gp,
HSurface from Adaptor3d,
HSurfaceTool from Adaptor3d
is
Normale(myclass; S: HSurface from Adaptor3d; U,V: Real from Standard;
P: out Pnt from gp;
N: out Vec from gp);
---Purpose: Computes the point <P>, and normal vector <N> on
-- <S> at parameters U,V.
DerivAndNorm(myclass; S: HSurface from Adaptor3d; U,V: Real from Standard;
P : out Pnt from gp;
d1u,d1v: out Vec from gp;
N : out Vec from gp);
---Purpose: Computes the point <P>, and normal vector <N> on
-- <S> at parameters U,V.
NormAndDn(myclass; S: HSurface from Adaptor3d; U,V: Real from Standard;
P : out Pnt from gp;
N,Dnu,Dnv: out Vec from gp);
---Purpose: Computes the point <P>, normal vector <N>, and its
-- derivatives <Dnu> and <Dnv> on <S> at parameters U,V.
end SurfProps;

View File

@@ -14,16 +14,18 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_SurfProps.ixx>
#include <ElSLib.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <Contap_SurfProps.hxx>
#include <ElSLib.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
//=======================================================================
//function : Normale
//purpose :
//=======================================================================
void Contap_SurfProps::Normale(const Handle(Adaptor3d_HSurface)& S,
const Standard_Real U,
const Standard_Real V,

View File

@@ -0,0 +1,74 @@
// Created on: 1995-02-24
// Created by: Jacques GOUSSARD
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_SurfProps_HeaderFile
#define _Contap_SurfProps_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
class Adaptor3d_HSurface;
class gp_Pnt;
class gp_Vec;
//! Internal tool used to compute the normal and its
//! derivatives.
class Contap_SurfProps
{
public:
DEFINE_STANDARD_ALLOC
//! Computes the point <P>, and normal vector <N> on
//! <S> at parameters U,V.
Standard_EXPORT static void Normale (const Handle(Adaptor3d_HSurface)& S, const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& N);
//! Computes the point <P>, and normal vector <N> on
//! <S> at parameters U,V.
Standard_EXPORT static void DerivAndNorm (const Handle(Adaptor3d_HSurface)& S, const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& d1u, gp_Vec& d1v, gp_Vec& N);
//! Computes the point <P>, normal vector <N>, and its
//! derivatives <Dnu> and <Dnv> on <S> at parameters U,V.
Standard_EXPORT static void NormAndDn (const Handle(Adaptor3d_HSurface)& S, const Standard_Real U, const Standard_Real V, gp_Pnt& P, gp_Vec& N, gp_Vec& Dnu, gp_Vec& Dnv);
protected:
private:
};
#endif // _Contap_SurfProps_HeaderFile

View File

@@ -0,0 +1,29 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_TFunction_HeaderFile
#define _Contap_TFunction_HeaderFile
enum Contap_TFunction
{
Contap_ContourStd,
Contap_ContourPrs,
Contap_DraftStd,
Contap_DraftPrs
};
#endif // _Contap_TFunction_HeaderFile

View File

@@ -0,0 +1,151 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_TheIWLineOfTheIWalking_HeaderFile
#define _Contap_TheIWLineOfTheIWalking_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <IntSurf_SequenceOfCouple.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
#include <IntSurf_PathPoint.hxx>
#include <gp_Vec.hxx>
#include <MMgt_TShared.hxx>
#include <IntSurf_Allocator.hxx>
class IntSurf_LineOn2S;
class Standard_OutOfRange;
class Standard_DomainError;
class IntSurf_PathPoint;
class IntSurf_PntOn2S;
class gp_Vec;
class Contap_TheIWLineOfTheIWalking;
DEFINE_STANDARD_HANDLE(Contap_TheIWLineOfTheIWalking, MMgt_TShared)
class Contap_TheIWLineOfTheIWalking : public MMgt_TShared
{
public:
Standard_EXPORT Contap_TheIWLineOfTheIWalking(const IntSurf_Allocator& theAllocator = 0);
Standard_EXPORT void Reverse();
void Cut (const Standard_Integer Index);
void AddPoint (const IntSurf_PntOn2S& P);
void AddStatusFirst (const Standard_Boolean Closed, const Standard_Boolean HasFirst);
void AddStatusFirst (const Standard_Boolean Closed, const Standard_Boolean HasLast, const Standard_Integer Index, const IntSurf_PathPoint& P);
void AddStatusFirstLast (const Standard_Boolean Closed, const Standard_Boolean HasFirst, const Standard_Boolean HasLast);
void AddStatusLast (const Standard_Boolean HasLast);
void AddStatusLast (const Standard_Boolean HasLast, const Standard_Integer Index, const IntSurf_PathPoint& P);
void AddIndexPassing (const Standard_Integer Index);
void SetTangentVector (const gp_Vec& V, const Standard_Integer Index);
void SetTangencyAtBegining (const Standard_Boolean IsTangent);
void SetTangencyAtEnd (const Standard_Boolean IsTangent);
Standard_Integer NbPoints() const;
const IntSurf_PntOn2S& Value (const Standard_Integer Index) const;
const Handle(IntSurf_LineOn2S)& Line() const;
Standard_Boolean IsClosed() const;
Standard_Boolean HasFirstPoint() const;
Standard_Boolean HasLastPoint() const;
const IntSurf_PathPoint& FirstPoint() const;
Standard_Integer FirstPointIndex() const;
const IntSurf_PathPoint& LastPoint() const;
Standard_Integer LastPointIndex() const;
Standard_Integer NbPassingPoint() const;
void PassingPoint (const Standard_Integer Index, Standard_Integer& IndexLine, Standard_Integer& IndexPnts) const;
const gp_Vec& TangentVector (Standard_Integer& Index) const;
Standard_Boolean IsTangentAtBegining() const;
Standard_Boolean IsTangentAtEnd() const;
DEFINE_STANDARD_RTTI(Contap_TheIWLineOfTheIWalking,MMgt_TShared)
protected:
private:
Handle(IntSurf_LineOn2S) line;
IntSurf_SequenceOfCouple couple;
Standard_Boolean closed;
Standard_Boolean hasFirst;
Standard_Boolean hasLast;
Standard_Integer firstIndex;
Standard_Integer lastIndex;
IntSurf_PathPoint theFirstPoint;
IntSurf_PathPoint theLastPoint;
Standard_Integer indextg;
gp_Vec vcttg;
Standard_Boolean istgtbeg;
Standard_Boolean istgtend;
};
#define TheStartPoint IntSurf_PathPoint
#define TheStartPoint_hxx <IntSurf_PathPoint.hxx>
#define IntWalk_IWLine Contap_TheIWLineOfTheIWalking
#define IntWalk_IWLine_hxx <Contap_TheIWLineOfTheIWalking.hxx>
#define Handle_IntWalk_IWLine Handle(Contap_TheIWLineOfTheIWalking)
#include <IntWalk_IWLine.lxx>
#undef TheStartPoint
#undef TheStartPoint_hxx
#undef IntWalk_IWLine
#undef IntWalk_IWLine_hxx
#undef Handle_IntWalk_IWLine
#endif // _Contap_TheIWLineOfTheIWalking_HeaderFile

View File

@@ -0,0 +1,43 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_TheIWLineOfTheIWalking.hxx>
#include <Standard_Type.hxx>
#include <IntSurf_LineOn2S.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_DomainError.hxx>
#include <IntSurf_PathPoint.hxx>
#include <IntSurf_PntOn2S.hxx>
#include <gp_Vec.hxx>
#define TheStartPoint IntSurf_PathPoint
#define TheStartPoint_hxx <IntSurf_PathPoint.hxx>
#define IntWalk_IWLine Contap_TheIWLineOfTheIWalking
#define IntWalk_IWLine_hxx <Contap_TheIWLineOfTheIWalking.hxx>
#define Handle_IntWalk_IWLine Handle(Contap_TheIWLineOfTheIWalking)
#include <IntWalk_IWLine.gxx>

View File

@@ -0,0 +1,209 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_TheIWalking_HeaderFile
#define _Contap_TheIWalking_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <IntSurf_SequenceOfPathPoint.hxx>
#include <Standard_Real.hxx>
#include <math_Vector.hxx>
#include <IntWalk_VectorOfWalkingData.hxx>
#include <IntWalk_VectorOfInteger.hxx>
#include <IntSurf_PntOn2S.hxx>
#include <gp_Vec.hxx>
#include <gp_Dir2d.hxx>
#include <TColStd_SequenceOfInteger.hxx>
#include <Contap_SequenceOfIWLineOfTheIWalking.hxx>
#include <IntSurf_SequenceOfInteriorPoint.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_SequenceOfReal.hxx>
#include <IntWalk_StatusDeflection.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 Contap_SurfFunction;
class Contap_TheIWLineOfTheIWalking;
class Contap_SequenceOfIWLineOfTheIWalking;
class Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking;
class IntSurf_PntOn2S;
class Contap_TheIWalking
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Contap_TheIWalking(const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Step);
void SetTolerance (const Standard_Real Epsilon, const Standard_Real Deflection, const Standard_Real Step);
Standard_EXPORT void Perform (const IntSurf_SequenceOfPathPoint& Pnts1, const IntSurf_SequenceOfInteriorPoint& Pnts2, Contap_SurfFunction& Func, const Handle(Adaptor3d_HSurface)& S, const Standard_Boolean Reversed = Standard_False);
Standard_EXPORT void Perform (const IntSurf_SequenceOfPathPoint& Pnts1, Contap_SurfFunction& Func, const Handle(Adaptor3d_HSurface)& S, const Standard_Boolean Reversed = Standard_False);
Standard_Boolean IsDone() const;
Standard_Integer NbLines() const;
const Handle(Contap_TheIWLineOfTheIWalking)& Value (const Standard_Integer Index) const;
Standard_Integer NbSinglePnts() const;
const IntSurf_PathPoint& SinglePnt (const Standard_Integer Index) const;
protected:
Standard_EXPORT Standard_Boolean Cadrage (math_Vector& BornInf, math_Vector& BornSup, math_Vector& UVap, Standard_Real& Step, const Standard_Integer StepSign) const;
Standard_EXPORT Standard_Boolean TestArretPassage (const TColStd_SequenceOfReal& Umult, const TColStd_SequenceOfReal& Vmult, Contap_SurfFunction& Section, math_Vector& UV, Standard_Integer& Irang);
Standard_EXPORT Standard_Boolean TestArretPassage (const TColStd_SequenceOfReal& Umult, const TColStd_SequenceOfReal& Vmult, const math_Vector& UV, const Standard_Integer Index, Standard_Integer& Irang);
Standard_EXPORT Standard_Boolean TestArretAjout (Contap_SurfFunction& Section, math_Vector& UV, Standard_Integer& Irang, IntSurf_PntOn2S& PSol);
Standard_EXPORT void TestArretCadre (const TColStd_SequenceOfReal& Umult, const TColStd_SequenceOfReal& Vmult, const Handle(Contap_TheIWLineOfTheIWalking)& Line, Contap_SurfFunction& Section, math_Vector& UV, Standard_Integer& Irang);
Standard_EXPORT IntWalk_StatusDeflection TestDeflection (Contap_SurfFunction& Section, const Standard_Boolean Finished, const math_Vector& UV, const IntWalk_StatusDeflection StatusPrecedent, Standard_Integer& NbDivision, Standard_Real& Step, const Standard_Integer StepSign);
Standard_EXPORT void ComputeOpenLine (const TColStd_SequenceOfReal& Umult, const TColStd_SequenceOfReal& Vmult, const IntSurf_SequenceOfPathPoint& Pnts1, Contap_SurfFunction& Section, Standard_Boolean& Rajout);
Standard_EXPORT void OpenLine (const Standard_Integer N, const IntSurf_PntOn2S& Psol, const IntSurf_SequenceOfPathPoint& Pnts1, Contap_SurfFunction& Section, const Handle(Contap_TheIWLineOfTheIWalking)& Line);
Standard_EXPORT void ComputeCloseLine (const TColStd_SequenceOfReal& Umult, const TColStd_SequenceOfReal& Vmult, const IntSurf_SequenceOfPathPoint& Pnts1, const IntSurf_SequenceOfInteriorPoint& Pnts2, Contap_SurfFunction& Section, Standard_Boolean& Rajout);
Standard_EXPORT void AddPointInCurrentLine (const Standard_Integer N, const IntSurf_PathPoint& PathPnt, const Handle(Contap_TheIWLineOfTheIWalking)& CurrentLine) const;
Standard_EXPORT void MakeWalkingPoint (const Standard_Integer Case, const Standard_Real U, const Standard_Real V, Contap_SurfFunction& Section, IntSurf_PntOn2S& Psol);
Standard_EXPORT void Clear();
private:
Standard_Boolean done;
IntSurf_SequenceOfPathPoint seqSingle;
Standard_Real fleche;
Standard_Real pas;
math_Vector tolerance;
Standard_Real epsilon;
Standard_Boolean reversed;
IntWalk_VectorOfWalkingData wd1;
IntWalk_VectorOfWalkingData wd2;
IntWalk_VectorOfInteger nbMultiplicities;
Standard_Real Um;
Standard_Real UM;
Standard_Real Vm;
Standard_Real VM;
IntSurf_PntOn2S previousPoint;
gp_Vec previousd3d;
gp_Dir2d previousd2d;
TColStd_SequenceOfInteger seqAjout;
Contap_SequenceOfIWLineOfTheIWalking lines;
};
#define ThePointOfPath IntSurf_PathPoint
#define ThePointOfPath_hxx <IntSurf_PathPoint.hxx>
#define ThePointOfPathTool IntSurf_PathPointTool
#define ThePointOfPathTool_hxx <IntSurf_PathPointTool.hxx>
#define ThePOPIterator IntSurf_SequenceOfPathPoint
#define ThePOPIterator_hxx <IntSurf_SequenceOfPathPoint.hxx>
#define ThePointOfLoop IntSurf_InteriorPoint
#define ThePointOfLoop_hxx <IntSurf_InteriorPoint.hxx>
#define ThePointOfLoopTool IntSurf_InteriorPointTool
#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 ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define TheIWFunction Contap_SurfFunction
#define TheIWFunction_hxx <Contap_SurfFunction.hxx>
#define IntWalk_TheIWLine Contap_TheIWLineOfTheIWalking
#define IntWalk_TheIWLine_hxx <Contap_TheIWLineOfTheIWalking.hxx>
#define IntWalk_SequenceOfIWLine Contap_SequenceOfIWLineOfTheIWalking
#define IntWalk_SequenceOfIWLine_hxx <Contap_SequenceOfIWLineOfTheIWalking.hxx>
#define IntWalk_SequenceNodeOfSequenceOfIWLine Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking
#define IntWalk_SequenceNodeOfSequenceOfIWLine_hxx <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#define IntWalk_SequenceNodeOfSequenceOfIWLine Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking
#define IntWalk_SequenceNodeOfSequenceOfIWLine_hxx <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#define Handle_IntWalk_TheIWLine Handle(Contap_TheIWLineOfTheIWalking)
#define Handle_IntWalk_SequenceNodeOfSequenceOfIWLine Handle(Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking)
#define Handle_IntWalk_SequenceNodeOfSequenceOfIWLine Handle(Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking)
#define IntWalk_IWalking Contap_TheIWalking
#define IntWalk_IWalking_hxx <Contap_TheIWalking.hxx>
#include <IntWalk_IWalking.lxx>
#undef ThePointOfPath
#undef ThePointOfPath_hxx
#undef ThePointOfPathTool
#undef ThePointOfPathTool_hxx
#undef ThePOPIterator
#undef ThePOPIterator_hxx
#undef ThePointOfLoop
#undef ThePointOfLoop_hxx
#undef ThePointOfLoopTool
#undef ThePointOfLoopTool_hxx
#undef ThePOLIterator
#undef ThePOLIterator_hxx
#undef ThePSurface
#undef ThePSurface_hxx
#undef ThePSurfaceTool
#undef ThePSurfaceTool_hxx
#undef TheIWFunction
#undef TheIWFunction_hxx
#undef IntWalk_TheIWLine
#undef IntWalk_TheIWLine_hxx
#undef IntWalk_SequenceOfIWLine
#undef IntWalk_SequenceOfIWLine_hxx
#undef IntWalk_SequenceNodeOfSequenceOfIWLine
#undef IntWalk_SequenceNodeOfSequenceOfIWLine_hxx
#undef IntWalk_SequenceNodeOfSequenceOfIWLine
#undef IntWalk_SequenceNodeOfSequenceOfIWLine_hxx
#undef Handle_IntWalk_TheIWLine
#undef Handle_IntWalk_SequenceNodeOfSequenceOfIWLine
#undef Handle_IntWalk_SequenceNodeOfSequenceOfIWLine
#undef IntWalk_IWalking
#undef IntWalk_IWalking_hxx
#endif // _Contap_TheIWalking_HeaderFile

View File

@@ -0,0 +1,66 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_TheIWalking.hxx>
#include <StdFail_NotDone.hxx>
#include <Standard_OutOfRange.hxx>
#include <IntSurf_PathPoint.hxx>
#include <IntSurf_PathPointTool.hxx>
#include <IntSurf_InteriorPoint.hxx>
#include <IntSurf_InteriorPointTool.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <Contap_SurfFunction.hxx>
#include <Contap_TheIWLineOfTheIWalking.hxx>
#include <Contap_SequenceOfIWLineOfTheIWalking.hxx>
#include <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#include <IntSurf_PntOn2S.hxx>
#define ThePointOfPath IntSurf_PathPoint
#define ThePointOfPath_hxx <IntSurf_PathPoint.hxx>
#define ThePointOfPathTool IntSurf_PathPointTool
#define ThePointOfPathTool_hxx <IntSurf_PathPointTool.hxx>
#define ThePOPIterator IntSurf_SequenceOfPathPoint
#define ThePOPIterator_hxx <IntSurf_SequenceOfPathPoint.hxx>
#define ThePointOfLoop IntSurf_InteriorPoint
#define ThePointOfLoop_hxx <IntSurf_InteriorPoint.hxx>
#define ThePointOfLoopTool IntSurf_InteriorPointTool
#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 ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define TheIWFunction Contap_SurfFunction
#define TheIWFunction_hxx <Contap_SurfFunction.hxx>
#define IntWalk_TheIWLine Contap_TheIWLineOfTheIWalking
#define IntWalk_TheIWLine_hxx <Contap_TheIWLineOfTheIWalking.hxx>
#define IntWalk_SequenceOfIWLine Contap_SequenceOfIWLineOfTheIWalking
#define IntWalk_SequenceOfIWLine_hxx <Contap_SequenceOfIWLineOfTheIWalking.hxx>
#define IntWalk_SequenceNodeOfSequenceOfIWLine Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking
#define IntWalk_SequenceNodeOfSequenceOfIWLine_hxx <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#define IntWalk_SequenceNodeOfSequenceOfIWLine Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking
#define IntWalk_SequenceNodeOfSequenceOfIWLine_hxx <Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx>
#define Handle_IntWalk_TheIWLine Handle(Contap_TheIWLineOfTheIWalking)
#define Handle_IntWalk_SequenceNodeOfSequenceOfIWLine Handle(Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking)
#define Handle_IntWalk_SequenceNodeOfSequenceOfIWLine Handle(Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking)
#define IntWalk_IWalking Contap_TheIWalking
#define IntWalk_IWalking_hxx <Contap_TheIWalking.hxx>
#include <IntWalk_IWalking.gxx>

View File

@@ -0,0 +1,105 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_ThePathPointOfTheSearch_HeaderFile
#define _Contap_ThePathPointOfTheSearch_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.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 Contap_ThePathPointOfTheSearch
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Contap_ThePathPointOfTheSearch();
Standard_EXPORT Contap_ThePathPointOfTheSearch(const gp_Pnt& P, const Standard_Real Tol, const Handle(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Parameter);
Standard_EXPORT Contap_ThePathPointOfTheSearch(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(Adaptor3d_HVertex)& V, const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Parameter);
void SetValue (const gp_Pnt& P, const Standard_Real Tol, const Handle(Adaptor2d_HCurve2d)& A, const Standard_Real Parameter);
const gp_Pnt& Value() const;
Standard_Real Tolerance() const;
Standard_Boolean IsNew() const;
const Handle(Adaptor3d_HVertex)& Vertex() const;
const Handle(Adaptor2d_HCurve2d)& Arc() const;
Standard_Real Parameter() const;
protected:
private:
gp_Pnt point;
Standard_Real tol;
Standard_Boolean isnew;
Handle(Adaptor3d_HVertex) vtx;
Handle(Adaptor2d_HCurve2d) arc;
Standard_Real param;
};
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define IntStart_PathPoint Contap_ThePathPointOfTheSearch
#define IntStart_PathPoint_hxx <Contap_ThePathPointOfTheSearch.hxx>
#include <IntStart_PathPoint.lxx>
#undef TheVertex
#undef TheVertex_hxx
#undef TheArc
#undef TheArc_hxx
#undef IntStart_PathPoint
#undef IntStart_PathPoint_hxx
#endif // _Contap_ThePathPointOfTheSearch_HeaderFile

View File

@@ -0,0 +1,32 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_ThePathPointOfTheSearch.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Adaptor2d_HCurve2d.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 IntStart_PathPoint Contap_ThePathPointOfTheSearch
#define IntStart_PathPoint_hxx <Contap_ThePathPointOfTheSearch.hxx>
#include <IntStart_PathPoint.gxx>

View File

@@ -0,0 +1,168 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_TheSearch_HeaderFile
#define _Contap_TheSearch_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Contap_SequenceOfSegmentOfTheSearch.hxx>
#include <Contap_SequenceOfPathPointOfTheSearch.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
class StdFail_NotDone;
class Standard_OutOfRange;
class Standard_ConstructionError;
class Adaptor3d_HVertex;
class Adaptor2d_HCurve2d;
class Contap_HCurve2dTool;
class Contap_HContTool;
class Adaptor3d_TopolTool;
class Contap_ArcFunction;
class Contap_ThePathPointOfTheSearch;
class Contap_SequenceOfPathPointOfTheSearch;
class Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch;
class Contap_TheSegmentOfTheSearch;
class Contap_SequenceOfSegmentOfTheSearch;
class Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch;
class Contap_TheSearch
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Contap_TheSearch();
Standard_EXPORT void Perform (Contap_ArcFunction& F, const Handle(Adaptor3d_TopolTool)& Domain, const Standard_Real TolBoundary, const Standard_Real TolTangency, const Standard_Boolean RecheckOnRegularity = Standard_False);
Standard_Boolean IsDone() const;
Standard_Boolean AllArcSolution() const;
Standard_Integer NbPoints() const;
const Contap_ThePathPointOfTheSearch& Point (const Standard_Integer Index) const;
Standard_Integer NbSegments() const;
const Contap_TheSegmentOfTheSearch& Segment (const Standard_Integer Index) const;
protected:
private:
Standard_Boolean done;
Standard_Boolean all;
Contap_SequenceOfSegmentOfTheSearch sseg;
Contap_SequenceOfPathPointOfTheSearch spnt;
};
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheArcTool Contap_HCurve2dTool
#define TheArcTool_hxx <Contap_HCurve2dTool.hxx>
#define TheSOBTool Contap_HContTool
#define TheSOBTool_hxx <Contap_HContTool.hxx>
#define Handle_TheTopolTool Handle(Adaptor3d_TopolTool)
#define TheTopolTool Adaptor3d_TopolTool
#define TheTopolTool_hxx <Adaptor3d_TopolTool.hxx>
#define TheFunction Contap_ArcFunction
#define TheFunction_hxx <Contap_ArcFunction.hxx>
#define IntStart_ThePathPoint Contap_ThePathPointOfTheSearch
#define IntStart_ThePathPoint_hxx <Contap_ThePathPointOfTheSearch.hxx>
#define IntStart_SequenceOfPathPoint Contap_SequenceOfPathPointOfTheSearch
#define IntStart_SequenceOfPathPoint_hxx <Contap_SequenceOfPathPointOfTheSearch.hxx>
#define IntStart_SequenceNodeOfSequenceOfPathPoint Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch
#define IntStart_SequenceNodeOfSequenceOfPathPoint_hxx <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#define IntStart_SequenceNodeOfSequenceOfPathPoint Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch
#define IntStart_SequenceNodeOfSequenceOfPathPoint_hxx <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#define IntStart_TheSegment Contap_TheSegmentOfTheSearch
#define IntStart_TheSegment_hxx <Contap_TheSegmentOfTheSearch.hxx>
#define IntStart_SequenceOfSegment Contap_SequenceOfSegmentOfTheSearch
#define IntStart_SequenceOfSegment_hxx <Contap_SequenceOfSegmentOfTheSearch.hxx>
#define IntStart_SequenceNodeOfSequenceOfSegment Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch
#define IntStart_SequenceNodeOfSequenceOfSegment_hxx <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#define IntStart_SequenceNodeOfSequenceOfSegment Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch
#define IntStart_SequenceNodeOfSequenceOfSegment_hxx <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#define Handle_IntStart_SequenceNodeOfSequenceOfPathPoint Handle(Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch)
#define Handle_IntStart_SequenceNodeOfSequenceOfPathPoint Handle(Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch)
#define Handle_IntStart_SequenceNodeOfSequenceOfSegment Handle(Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch)
#define Handle_IntStart_SequenceNodeOfSequenceOfSegment Handle(Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch)
#define IntStart_SearchOnBoundaries Contap_TheSearch
#define IntStart_SearchOnBoundaries_hxx <Contap_TheSearch.hxx>
#include <IntStart_SearchOnBoundaries.lxx>
#undef TheVertex
#undef TheVertex_hxx
#undef TheArc
#undef TheArc_hxx
#undef TheArcTool
#undef TheArcTool_hxx
#undef TheSOBTool
#undef TheSOBTool_hxx
#undef Handle_TheTopolTool
#undef TheTopolTool
#undef TheTopolTool_hxx
#undef TheFunction
#undef TheFunction_hxx
#undef IntStart_ThePathPoint
#undef IntStart_ThePathPoint_hxx
#undef IntStart_SequenceOfPathPoint
#undef IntStart_SequenceOfPathPoint_hxx
#undef IntStart_SequenceNodeOfSequenceOfPathPoint
#undef IntStart_SequenceNodeOfSequenceOfPathPoint_hxx
#undef IntStart_SequenceNodeOfSequenceOfPathPoint
#undef IntStart_SequenceNodeOfSequenceOfPathPoint_hxx
#undef IntStart_TheSegment
#undef IntStart_TheSegment_hxx
#undef IntStart_SequenceOfSegment
#undef IntStart_SequenceOfSegment_hxx
#undef IntStart_SequenceNodeOfSequenceOfSegment
#undef IntStart_SequenceNodeOfSequenceOfSegment_hxx
#undef IntStart_SequenceNodeOfSequenceOfSegment
#undef IntStart_SequenceNodeOfSequenceOfSegment_hxx
#undef Handle_IntStart_SequenceNodeOfSequenceOfPathPoint
#undef Handle_IntStart_SequenceNodeOfSequenceOfPathPoint
#undef Handle_IntStart_SequenceNodeOfSequenceOfSegment
#undef Handle_IntStart_SequenceNodeOfSequenceOfSegment
#undef IntStart_SearchOnBoundaries
#undef IntStart_SearchOnBoundaries_hxx
#endif // _Contap_TheSearch_HeaderFile

View File

@@ -0,0 +1,112 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_TheSearchInside_HeaderFile
#define _Contap_TheSearchInside_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.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 Contap_HContTool;
class Contap_SurfFunction;
class IntSurf_InteriorPoint;
class Contap_TheSearchInside
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Contap_TheSearchInside();
Standard_EXPORT Contap_TheSearchInside(Contap_SurfFunction& F, const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& T, const Standard_Real Epsilon);
Standard_EXPORT void Perform (Contap_SurfFunction& F, const Handle(Adaptor3d_HSurface)& Surf, const Handle(Adaptor3d_TopolTool)& T, const Standard_Real Epsilon);
Standard_EXPORT void Perform (Contap_SurfFunction& F, const Handle(Adaptor3d_HSurface)& Surf, const Standard_Real UStart, const Standard_Real VStart);
Standard_Boolean IsDone() const;
Standard_Integer NbPoints() const;
const IntSurf_InteriorPoint& Value (const Standard_Integer Index) const;
protected:
private:
Standard_Boolean done;
IntSurf_SequenceOfInteriorPoint list;
};
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define Handle_TheTopolTool Handle(Adaptor3d_TopolTool)
#define TheTopolTool Adaptor3d_TopolTool
#define TheTopolTool_hxx <Adaptor3d_TopolTool.hxx>
#define TheSITool Contap_HContTool
#define TheSITool_hxx <Contap_HContTool.hxx>
#define TheFunction Contap_SurfFunction
#define TheFunction_hxx <Contap_SurfFunction.hxx>
#define IntStart_SearchInside Contap_TheSearchInside
#define IntStart_SearchInside_hxx <Contap_TheSearchInside.hxx>
#include <IntStart_SearchInside.lxx>
#undef ThePSurface
#undef ThePSurface_hxx
#undef ThePSurfaceTool
#undef ThePSurfaceTool_hxx
#undef Handle_TheTopolTool
#undef TheTopolTool
#undef TheTopolTool_hxx
#undef TheSITool
#undef TheSITool_hxx
#undef TheFunction
#undef TheFunction_hxx
#undef IntStart_SearchInside
#undef IntStart_SearchInside_hxx
#endif // _Contap_TheSearchInside_HeaderFile

View File

@@ -0,0 +1,43 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_TheSearchInside.hxx>
#include <StdFail_NotDone.hxx>
#include <Standard_OutOfRange.hxx>
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <Contap_HContTool.hxx>
#include <Contap_SurfFunction.hxx>
#include <IntSurf_InteriorPoint.hxx>
#define ThePSurface Handle(Adaptor3d_HSurface)
#define ThePSurface_hxx <Adaptor3d_HSurface.hxx>
#define ThePSurfaceTool Adaptor3d_HSurfaceTool
#define ThePSurfaceTool_hxx <Adaptor3d_HSurfaceTool.hxx>
#define Handle_TheTopolTool Handle(Adaptor3d_TopolTool)
#define TheTopolTool Adaptor3d_TopolTool
#define TheTopolTool_hxx <Adaptor3d_TopolTool.hxx>
#define TheSITool Contap_HContTool
#define TheSITool_hxx <Contap_HContTool.hxx>
#define TheFunction Contap_SurfFunction
#define TheFunction_hxx <Contap_SurfFunction.hxx>
#define IntStart_SearchInside Contap_TheSearchInside
#define IntStart_SearchInside_hxx <Contap_TheSearchInside.hxx>
#include <IntStart_SearchInside.gxx>

View File

@@ -0,0 +1,72 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_TheSearch.hxx>
#include <StdFail_NotDone.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_ConstructionError.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Contap_HCurve2dTool.hxx>
#include <Contap_HContTool.hxx>
#include <Adaptor3d_TopolTool.hxx>
#include <Contap_ArcFunction.hxx>
#include <Contap_ThePathPointOfTheSearch.hxx>
#include <Contap_SequenceOfPathPointOfTheSearch.hxx>
#include <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#include <Contap_TheSegmentOfTheSearch.hxx>
#include <Contap_SequenceOfSegmentOfTheSearch.hxx>
#include <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define TheArcTool Contap_HCurve2dTool
#define TheArcTool_hxx <Contap_HCurve2dTool.hxx>
#define TheSOBTool Contap_HContTool
#define TheSOBTool_hxx <Contap_HContTool.hxx>
#define Handle_TheTopolTool Handle(Adaptor3d_TopolTool)
#define TheTopolTool Adaptor3d_TopolTool
#define TheTopolTool_hxx <Adaptor3d_TopolTool.hxx>
#define TheFunction Contap_ArcFunction
#define TheFunction_hxx <Contap_ArcFunction.hxx>
#define IntStart_ThePathPoint Contap_ThePathPointOfTheSearch
#define IntStart_ThePathPoint_hxx <Contap_ThePathPointOfTheSearch.hxx>
#define IntStart_SequenceOfPathPoint Contap_SequenceOfPathPointOfTheSearch
#define IntStart_SequenceOfPathPoint_hxx <Contap_SequenceOfPathPointOfTheSearch.hxx>
#define IntStart_SequenceNodeOfSequenceOfPathPoint Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch
#define IntStart_SequenceNodeOfSequenceOfPathPoint_hxx <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#define IntStart_SequenceNodeOfSequenceOfPathPoint Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch
#define IntStart_SequenceNodeOfSequenceOfPathPoint_hxx <Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx>
#define IntStart_TheSegment Contap_TheSegmentOfTheSearch
#define IntStart_TheSegment_hxx <Contap_TheSegmentOfTheSearch.hxx>
#define IntStart_SequenceOfSegment Contap_SequenceOfSegmentOfTheSearch
#define IntStart_SequenceOfSegment_hxx <Contap_SequenceOfSegmentOfTheSearch.hxx>
#define IntStart_SequenceNodeOfSequenceOfSegment Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch
#define IntStart_SequenceNodeOfSequenceOfSegment_hxx <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#define IntStart_SequenceNodeOfSequenceOfSegment Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch
#define IntStart_SequenceNodeOfSequenceOfSegment_hxx <Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx>
#define Handle_IntStart_SequenceNodeOfSequenceOfPathPoint Handle(Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch)
#define Handle_IntStart_SequenceNodeOfSequenceOfPathPoint Handle(Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch)
#define Handle_IntStart_SequenceNodeOfSequenceOfSegment Handle(Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch)
#define Handle_IntStart_SequenceNodeOfSequenceOfSegment Handle(Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch)
#define IntStart_SearchOnBoundaries Contap_TheSearch
#define IntStart_SearchOnBoundaries_hxx <Contap_TheSearch.hxx>
#include <IntStart_SearchOnBoundaries.gxx>

View File

@@ -0,0 +1,101 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _Contap_TheSegmentOfTheSearch_HeaderFile
#define _Contap_TheSegmentOfTheSearch_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
#include <Contap_ThePathPointOfTheSearch.hxx>
class Adaptor2d_HCurve2d;
class Standard_DomainError;
class Adaptor3d_HVertex;
class Contap_ThePathPointOfTheSearch;
class Contap_TheSegmentOfTheSearch
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Contap_TheSegmentOfTheSearch();
void SetValue (const Handle(Adaptor2d_HCurve2d)& A);
Standard_EXPORT void SetLimitPoint (const Contap_ThePathPointOfTheSearch& V, const Standard_Boolean First);
const Handle(Adaptor2d_HCurve2d)& Curve() const;
Standard_Boolean HasFirstPoint() const;
const Contap_ThePathPointOfTheSearch& FirstPoint() const;
Standard_Boolean HasLastPoint() const;
const Contap_ThePathPointOfTheSearch& LastPoint() const;
protected:
private:
Handle(Adaptor2d_HCurve2d) arc;
Standard_Boolean hasfp;
Contap_ThePathPointOfTheSearch thefp;
Standard_Boolean haslp;
Contap_ThePathPointOfTheSearch thelp;
};
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define ThePathPoint Contap_ThePathPointOfTheSearch
#define ThePathPoint_hxx <Contap_ThePathPointOfTheSearch.hxx>
#define IntStart_Segment Contap_TheSegmentOfTheSearch
#define IntStart_Segment_hxx <Contap_TheSegmentOfTheSearch.hxx>
#include <IntStart_Segment.lxx>
#undef TheVertex
#undef TheVertex_hxx
#undef TheArc
#undef TheArc_hxx
#undef ThePathPoint
#undef ThePathPoint_hxx
#undef IntStart_Segment
#undef IntStart_Segment_hxx
#endif // _Contap_TheSegmentOfTheSearch_HeaderFile

View File

@@ -0,0 +1,34 @@
// Created on: 1993-02-05
// Created by: Jacques GOUSSARD
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <Contap_TheSegmentOfTheSearch.hxx>
#include <Adaptor2d_HCurve2d.hxx>
#include <Standard_DomainError.hxx>
#include <Adaptor3d_HVertex.hxx>
#include <Contap_ThePathPointOfTheSearch.hxx>
#define TheVertex Handle(Adaptor3d_HVertex)
#define TheVertex_hxx <Adaptor3d_HVertex.hxx>
#define TheArc Handle(Adaptor2d_HCurve2d)
#define TheArc_hxx <Adaptor2d_HCurve2d.hxx>
#define ThePathPoint Contap_ThePathPointOfTheSearch
#define ThePathPoint_hxx <Contap_ThePathPointOfTheSearch.hxx>
#define IntStart_Segment Contap_TheSegmentOfTheSearch
#define IntStart_Segment_hxx <Contap_TheSegmentOfTheSearch.hxx>
#include <IntStart_Segment.gxx>

View File

@@ -1,3 +1,54 @@
Contap_TheSequenceOfPoint.hxx
Contap_ArcFunction.cxx
Contap_ArcFunction.hxx
Contap_ArcFunction.lxx
Contap_ContAna.cxx
Contap_ContAna.hxx
Contap_ContAna.lxx
Contap_Contour.cxx
Contap_Contour.hxx
Contap_Contour.lxx
Contap_HContTool.cxx
Contap_HContTool.hxx
Contap_HCurve2dTool.cxx
Contap_HCurve2dTool.hxx
Contap_HCurve2dTool.lxx
Contap_IType.hxx
Contap_Line.cxx
Contap_Line.hxx
Contap_Line.lxx
Contap_Point.cxx
Contap_Point.hxx
Contap_Point.lxx
Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking.hxx
Contap_SequenceNodeOfSequenceOfIWLineOfTheIWalking_0.cxx
Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch.hxx
Contap_SequenceNodeOfSequenceOfPathPointOfTheSearch_0.cxx
Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch.hxx
Contap_SequenceNodeOfSequenceOfSegmentOfTheSearch_0.cxx
Contap_SequenceOfIWLineOfTheIWalking.hxx
Contap_SequenceOfIWLineOfTheIWalking_0.cxx
Contap_SequenceOfPathPointOfTheSearch.hxx
Contap_SequenceOfPathPointOfTheSearch_0.cxx
Contap_SequenceOfSegmentOfTheSearch.hxx
Contap_SequenceOfSegmentOfTheSearch_0.cxx
Contap_SurfFunction.cxx
Contap_SurfFunction.hxx
Contap_SurfFunction.lxx
Contap_SurfProps.cxx
Contap_SurfProps.hxx
Contap_TFunction.hxx
Contap_TheHSequenceOfPoint.hxx
Contap_TheIWalking.hxx
Contap_TheIWalking_0.cxx
Contap_TheIWLineOfTheIWalking.hxx
Contap_TheIWLineOfTheIWalking_0.cxx
Contap_ThePathPointOfTheSearch.hxx
Contap_ThePathPointOfTheSearch_0.cxx
Contap_TheSearch.hxx
Contap_TheSearch_0.cxx
Contap_TheSearchInside.hxx
Contap_TheSearchInside_0.cxx
Contap_TheSegmentOfTheSearch.hxx
Contap_TheSegmentOfTheSearch_0.cxx
Contap_TheSequenceOfLine.hxx
Contap_TheSequenceOfPoint.hxx