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

0024002: Overall code and build procedure refactoring -- automatic

Browse Source 
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
Download Patch File Download Diff File Expand all files Collapse all files

67
src/GeomToStep/FILES
View File

@@ -1,9 +1,72 @@
GeomToStep_MakeAxis1Placement.cxx
GeomToStep_MakeAxis1Placement.hxx
GeomToStep_MakeAxis1Placement_gen.pxx
GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve_gen.pxx
GeomToStep_MakeAxis2Placement2d.cxx
GeomToStep_MakeAxis2Placement2d.hxx
GeomToStep_MakeAxis2Placement3d.cxx
GeomToStep_MakeAxis2Placement3d.hxx
GeomToStep_MakeBoundedCurve.cxx
GeomToStep_MakeBoundedCurve.hxx
GeomToStep_MakeBoundedSurface.cxx
GeomToStep_MakeBoundedSurface.hxx
GeomToStep_MakeBSplineCurveWithKnots.cxx
GeomToStep_MakeBSplineCurveWithKnots.hxx
GeomToStep_MakeBSplineCurveWithKnots_gen.pxx
GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve.cxx
GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve.hxx
GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve_gen.pxx
GeomToStep_MakeBSplineSurfaceWithKnots.cxx
GeomToStep_MakeBSplineSurfaceWithKnots.hxx
GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface.cxx
GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx
GeomToStep_MakeCartesianPoint.cxx
GeomToStep_MakeCartesianPoint.hxx
GeomToStep_MakeCircle.cxx
GeomToStep_MakeCircle.hxx
GeomToStep_MakeCircle_gen.pxx
GeomToStep_MakeConic.cxx
GeomToStep_MakeConic.hxx
GeomToStep_MakeConicalSurface.cxx
GeomToStep_MakeConicalSurface.hxx
GeomToStep_MakeCurve.cxx
GeomToStep_MakeCurve.hxx
GeomToStep_MakeCylindricalSurface.cxx
GeomToStep_MakeCylindricalSurface.hxx
GeomToStep_MakeDirection.cxx
GeomToStep_MakeDirection.hxx
GeomToStep_MakeElementarySurface.cxx
GeomToStep_MakeElementarySurface.hxx
GeomToStep_MakeEllipse.cxx
GeomToStep_MakeEllipse.hxx
GeomToStep_MakeEllipse_gen.pxx
GeomToStep_MakeHyperbola.cxx
GeomToStep_MakeHyperbola.hxx
GeomToStep_MakeLine.cxx
GeomToStep_MakeLine.hxx
GeomToStep_MakeLine_gen.pxx
GeomToStep_MakeParabola.cxx
GeomToStep_MakeParabola.hxx
GeomToStep_MakePlane.cxx
GeomToStep_MakePlane.hxx
GeomToStep_MakePolyline.cxx
GeomToStep_MakePolyline.hxx
GeomToStep_MakePolyline_gen.pxx
GeomToStep_MakeRectangularTrimmedSurface.cxx
GeomToStep_MakeRectangularTrimmedSurface.hxx
GeomToStep_MakeSphericalSurface.cxx
GeomToStep_MakeSphericalSurface.hxx
GeomToStep_MakeSurface.cxx
GeomToStep_MakeSurface.hxx
GeomToStep_MakeSurfaceOfLinearExtrusion.cxx
GeomToStep_MakeSurfaceOfLinearExtrusion.hxx
GeomToStep_MakeSurfaceOfRevolution.cxx
GeomToStep_MakeSurfaceOfRevolution.hxx
GeomToStep_MakeSweptSurface.cxx
GeomToStep_MakeSweptSurface.hxx
GeomToStep_MakeToroidalSurface.cxx
GeomToStep_MakeToroidalSurface.hxx
GeomToStep_MakeVector.cxx
GeomToStep_MakeVector.hxx
GeomToStep_MakeVector_gen.pxx
GeomToStep_WOKSteps.edl
GeomToStep_Root.cxx
GeomToStep_Root.hxx

60
src/GeomToStep/GeomToStep.cdl
View File

@@ -1,60 +0,0 @@
-- Created on: 1993-06-11
-- Created by: Martine LANGLOIS
-- 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 GeomToStep
--- Purpose: Creation des entites geometriques du schema PmsAp2Demo3d a
-- partir des entites de Geom ou de gp.
-- Update : mise a jour pour traiter le schema StepGeom, pour demo de 94
uses gp, Geom, Geom2d, StepGeom, StdFail, TColgp
is
private deferred class Root;
class MakeCartesianPoint;
class MakeAxis1Placement;
class MakeAxis2Placement2d;
class MakeAxis2Placement3d;
class MakeDirection;
class MakeVector;
class MakeCurve;
class MakeConic;
class MakeBoundedCurve;
class MakeCircle;
class MakeEllipse;
class MakeHyperbola;
class MakeParabola;
class MakeBSplineCurveWithKnots;
class MakeBSplineCurveWithKnotsAndRationalBSplineCurve;
class MakeLine;
class MakePolyline;
class MakePlane;
class MakeSurface;
class MakeBoundedSurface;
class MakeElementarySurface;
class MakeSweptSurface;
class MakeConicalSurface;
class MakeCylindricalSurface;
class MakeRectangularTrimmedSurface;
class MakeSphericalSurface;
class MakeSurfaceOfLinearExtrusion;
class MakeSurfaceOfRevolution;
class MakeToroidalSurface;
class MakeBSplineSurfaceWithKnots;
class MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface;
end GeomToStep;

55
src/GeomToStep/GeomToStep_MakeAxis1Placement.cdl
View File

@@ -1,55 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeAxis1Placement from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Axis1Placement from Geom and Ax1 from gp, and the class
-- Axis1Placement from StepGeom which describes an
-- Axis1Placement from Prostep.
--
uses Ax1 from gp,
Ax2d from gp,
Axis1Placement from Geom,
AxisPlacement from Geom2d,
Axis1Placement from StepGeom
raises NotDone from StdFail
is
Create ( A : Ax1 from gp ) returns MakeAxis1Placement;
Create ( A : Ax2d from gp ) returns MakeAxis1Placement;
Create ( A : Axis1Placement from Geom ) returns MakeAxis1Placement;
Create ( A : AxisPlacement from Geom2d ) returns MakeAxis1Placement;
Value (me) returns Axis1Placement from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theAxis1Placement : Axis1Placement from StepGeom;
-- The solution from StepGeom
end MakeAxis1Placement;

13
src/GeomToStep/GeomToStep_MakeAxis1Placement.cxx
View File

@@ -14,24 +14,23 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeAxis1Placement.ixx>
#include <Geom2d_AxisPlacement.hxx>
#include <Geom_Axis1Placement.hxx>
#include <GeomToStep_MakeAxis1Placement.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <GeomToStep_MakeDirection.hxx>
#include <StdFail_NotDone.hxx>
#include <gp_Ax1.hxx>
#include <gp_Ax2d.hxx>
#include <Geom_Axis1Placement.hxx>
#include <Geom2d_AxisPlacement.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis1Placement.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StepGeom_Direction.hxx>
#include <GeomToStep_MakeDirection.hxx>
#include <TCollection_HAsciiString.hxx>
//=============================================================================
// Creation d' un axis1_placement de prostep a partir d' un Ax1 de gp
//=============================================================================
GeomToStep_MakeAxis1Placement::GeomToStep_MakeAxis1Placement( const gp_Ax1& A)
{
#include <GeomToStep_MakeAxis1Placement_gen.pxx>

78
src/GeomToStep/GeomToStep_MakeAxis1Placement.hxx Normal file
View File

@@ -0,0 +1,78 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeAxis1Placement_HeaderFile
#define _GeomToStep_MakeAxis1Placement_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Axis1Placement;
class StdFail_NotDone;
class gp_Ax1;
class gp_Ax2d;
class Geom_Axis1Placement;
class Geom2d_AxisPlacement;
//! This class implements the mapping between classes
//! Axis1Placement from Geom and Ax1 from gp, and the class
//! Axis1Placement from StepGeom which describes an
//! Axis1Placement from Prostep.
class GeomToStep_MakeAxis1Placement : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeAxis1Placement(const gp_Ax1& A);
Standard_EXPORT GeomToStep_MakeAxis1Placement(const gp_Ax2d& A);
Standard_EXPORT GeomToStep_MakeAxis1Placement(const Handle(Geom_Axis1Placement)& A);
Standard_EXPORT GeomToStep_MakeAxis1Placement(const Handle(Geom2d_AxisPlacement)& A);
Standard_EXPORT const Handle(StepGeom_Axis1Placement)& Value() const;
protected:
private:
Handle(StepGeom_Axis1Placement) theAxis1Placement;
};
#endif // _GeomToStep_MakeAxis1Placement_HeaderFile

51
src/GeomToStep/GeomToStep_MakeAxis2Placement2d.cdl
View File

@@ -1,51 +0,0 @@
-- Created on: 1994-08-26
-- Created by: Frederic MAUPAS
-- Copyright (c) 1994-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 MakeAxis2Placement2d from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Axis2Placement from Geom and Ax2, Ax22d from gp, and the class
-- Axis2Placement2d from StepGeom which describes an
-- axis2_placement_2d from Prostep.
uses Ax2 from gp,
Ax22d from gp,
Axis2Placement from Geom,
Axis2Placement2d from StepGeom
raises NotDone from StdFail
is
Create ( A : Ax2 from gp ) returns MakeAxis2Placement2d;
Create ( A : Ax22d from gp ) returns MakeAxis2Placement2d;
--Create ( A : Axis2Placement from Geom ) returns MakeAxis2Placement2d;
Value (me) returns Axis2Placement2d from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theAxis2Placement2d : Axis2Placement2d from StepGeom;
-- TheOP solution from StepGeom
end MakeAxis2Placement2d;

13
src/GeomToStep/GeomToStep_MakeAxis2Placement2d.cxx
View File

@@ -14,22 +14,21 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeAxis2Placement2d.ixx>
#include <StepGeom_Direction.hxx>
#include <GeomToStep_MakeDirection.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <GeomToStep_MakeAxis2Placement2d.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StdFail_NotDone.hxx>
#include <GeomToStep_MakeDirection.hxx>
#include <gp_Ax2.hxx>
#include <gp_Ax22d.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement2d.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <StepGeom_Direction.hxx>
#include <TCollection_HAsciiString.hxx>
//=============================================================================
// Creation d' un axis2_placement_2d de prostep a partir d' un Ax2 de gp
//=============================================================================
GeomToStep_MakeAxis2Placement2d::GeomToStep_MakeAxis2Placement2d
( const gp_Ax2& A)
{

72
src/GeomToStep/GeomToStep_MakeAxis2Placement2d.hxx Normal file
View File

@@ -0,0 +1,72 @@
// Created on: 1994-08-26
// Created by: Frederic MAUPAS
// Copyright (c) 1994-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 _GeomToStep_MakeAxis2Placement2d_HeaderFile
#define _GeomToStep_MakeAxis2Placement2d_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Axis2Placement2d;
class StdFail_NotDone;
class gp_Ax2;
class gp_Ax22d;
//! This class implements the mapping between classes
//! Axis2Placement from Geom and Ax2, Ax22d from gp, and the class
//! Axis2Placement2d from StepGeom which describes an
//! axis2_placement_2d from Prostep.
class GeomToStep_MakeAxis2Placement2d : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeAxis2Placement2d(const gp_Ax2& A);
Standard_EXPORT GeomToStep_MakeAxis2Placement2d(const gp_Ax22d& A);
Standard_EXPORT const Handle(StepGeom_Axis2Placement2d)& Value() const;
protected:
private:
Handle(StepGeom_Axis2Placement2d) theAxis2Placement2d;
};
#endif // _GeomToStep_MakeAxis2Placement2d_HeaderFile

57
src/GeomToStep/GeomToStep_MakeAxis2Placement3d.cdl
View File

@@ -1,57 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeAxis2Placement3d from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Axis2Placement from Geom and Ax2, Ax3 from gp, and the class
-- Axis2Placement3d from StepGeom which describes an
-- axis2_placement_3d from Prostep.
uses Ax2 from gp,
Ax3 from gp,
Trsf from gp,
Axis2Placement from Geom,
Axis2Placement3d from StepGeom
raises NotDone from StdFail
is
Create returns MakeAxis2Placement3d;
-- creates an identity (original axis)
Create ( A : Ax2 from gp ) returns MakeAxis2Placement3d;
Create ( A : Ax3 from gp ) returns MakeAxis2Placement3d;
Create ( T : Trsf from gp) returns MakeAxis2Placement3d;
Create ( A : Axis2Placement from Geom ) returns MakeAxis2Placement3d;
Value (me) returns Axis2Placement3d from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theAxis2Placement3d : Axis2Placement3d from StepGeom;
-- TheOP solution from StepGeom
end MakeAxis2Placement3d;

14
src/GeomToStep/GeomToStep_MakeAxis2Placement3d.cxx
View File

@@ -14,16 +14,18 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeAxis2Placement3d.ixx>
#include <StepGeom_Direction.hxx>
#include <GeomToStep_MakeDirection.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <Geom_Axis2Placement.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StdFail_NotDone.hxx>
#include <GeomToStep_MakeDirection.hxx>
#include <gp_Ax2.hxx>
#include <gp_Ax3.hxx>
#include <Geom_Axis2Placement.hxx>
#include <gp_Trsf.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <StepGeom_Direction.hxx>
#include <TCollection_HAsciiString.hxx>
static Handle(StepGeom_Axis2Placement3d) MakeAxis2Placement3d

80
src/GeomToStep/GeomToStep_MakeAxis2Placement3d.hxx Normal file
View File

@@ -0,0 +1,80 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeAxis2Placement3d_HeaderFile
#define _GeomToStep_MakeAxis2Placement3d_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Axis2Placement3d;
class StdFail_NotDone;
class gp_Ax2;
class gp_Ax3;
class gp_Trsf;
class Geom_Axis2Placement;
//! This class implements the mapping between classes
//! Axis2Placement from Geom and Ax2, Ax3 from gp, and the class
//! Axis2Placement3d from StepGeom which describes an
//! axis2_placement_3d from Prostep.
class GeomToStep_MakeAxis2Placement3d : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeAxis2Placement3d();
Standard_EXPORT GeomToStep_MakeAxis2Placement3d(const gp_Ax2& A);
Standard_EXPORT GeomToStep_MakeAxis2Placement3d(const gp_Ax3& A);
Standard_EXPORT GeomToStep_MakeAxis2Placement3d(const gp_Trsf& T);
Standard_EXPORT GeomToStep_MakeAxis2Placement3d(const Handle(Geom_Axis2Placement)& A);
Standard_EXPORT const Handle(StepGeom_Axis2Placement3d)& Value() const;
protected:
private:
Handle(StepGeom_Axis2Placement3d) theAxis2Placement3d;
};
#endif // _GeomToStep_MakeAxis2Placement3d_HeaderFile

55
src/GeomToStep/GeomToStep_MakeBSplineCurveWithKnots.cdl
View File

@@ -1,55 +0,0 @@
-- Created on: 1993-08-05
-- Created by: Martine LANGLOIS
-- 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 MakeBSplineCurveWithKnots from GeomToStep inherits
Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- BSplineCurve from Geom, Geom2d and the class
-- BSplineCurveWithKnots from StepGeom
-- which describes a bspline_curve_with_knots from
-- Prostep
uses
BSplineCurve from Geom,
BSplineCurve from Geom2d,
BSplineCurveWithKnots from StepGeom
raises
NotDone from StdFail
is
Create ( Bsplin : BSplineCurve from Geom ) returns
MakeBSplineCurveWithKnots;
Create ( Bsplin : BSplineCurve from Geom2d ) returns
MakeBSplineCurveWithKnots;
Value (me) returns
BSplineCurveWithKnots from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theBSplineCurveWithKnots :
BSplineCurveWithKnots from StepGeom;
-- The solution from StepGeom
end MakeBSplineCurveWithKnots;

17
src/GeomToStep/GeomToStep_MakeBSplineCurveWithKnots.cxx
View File

@@ -14,26 +14,27 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeBSplineCurveWithKnots.ixx>
#include <StdFail_NotDone.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <GeomAbs_BSplKnotDistribution.hxx>
#include <GeomToStep_MakeBSplineCurveWithKnots.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_BSplineCurveWithKnots.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StepGeom_HArray1OfCartesianPoint.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <StepGeom_KnotType.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <GeomAbs_BSplKnotDistribution.hxx>
#include <StepGeom_KnotType.hxx>
#include <TCollection_HAsciiString.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
//=============================================================================
// Creation d' une bspline_curve_with_knots de
// prostep a partir d' une BSplineCurve de Geom
//=============================================================================
GeomToStep_MakeBSplineCurveWithKnots::
GeomToStep_MakeBSplineCurveWithKnots( const
Handle(Geom_BSplineCurve)& BS )

73
src/GeomToStep/GeomToStep_MakeBSplineCurveWithKnots.hxx Normal file
View File

@@ -0,0 +1,73 @@
// Created on: 1993-08-05
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeBSplineCurveWithKnots_HeaderFile
#define _GeomToStep_MakeBSplineCurveWithKnots_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_BSplineCurveWithKnots;
class StdFail_NotDone;
class Geom_BSplineCurve;
class Geom2d_BSplineCurve;
//! This class implements the mapping between classes
//! BSplineCurve from Geom, Geom2d and the class
//! BSplineCurveWithKnots from StepGeom
//! which describes a bspline_curve_with_knots from
//! Prostep
class GeomToStep_MakeBSplineCurveWithKnots : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeBSplineCurveWithKnots(const Handle(Geom_BSplineCurve)& Bsplin);
Standard_EXPORT GeomToStep_MakeBSplineCurveWithKnots(const Handle(Geom2d_BSplineCurve)& Bsplin);
Standard_EXPORT const Handle(StepGeom_BSplineCurveWithKnots)& Value() const;
protected:
private:
Handle(StepGeom_BSplineCurveWithKnots) theBSplineCurveWithKnots;
};
#endif // _GeomToStep_MakeBSplineCurveWithKnots_HeaderFile

55
src/GeomToStep/GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve.cdl
View File

@@ -1,55 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeBSplineCurveWithKnotsAndRationalBSplineCurve from GeomToStep inherits
Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- BSplineCurve from Geom, Geom2d and the class
-- BSplineCurveWithKnotsAndRationalBSplineCurve from StepGeom
-- which describes a rational_bspline_curve_with_knots from
-- Prostep
uses
BSplineCurve from Geom,
BSplineCurve from Geom2d,
BSplineCurveWithKnotsAndRationalBSplineCurve from StepGeom
raises
NotDone from StdFail
is
Create ( Bsplin : BSplineCurve from Geom ) returns
MakeBSplineCurveWithKnotsAndRationalBSplineCurve;
Create ( Bsplin : BSplineCurve from Geom2d ) returns
MakeBSplineCurveWithKnotsAndRationalBSplineCurve;
Value (me) returns
BSplineCurveWithKnotsAndRationalBSplineCurve from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theBSplineCurveWithKnotsAndRationalBSplineCurve :
BSplineCurveWithKnotsAndRationalBSplineCurve from StepGeom;
-- The solution from StepGeom
end MakeBSplineCurveWithKnotsAndRationalBSplineCurve;

17
src/GeomToStep/GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve.cxx
View File

@@ -14,26 +14,27 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve.ixx>
#include <StdFail_NotDone.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <GeomAbs_BSplKnotDistribution.hxx>
#include <GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StepGeom_HArray1OfCartesianPoint.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <StepGeom_KnotType.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <GeomAbs_BSplKnotDistribution.hxx>
#include <StepGeom_KnotType.hxx>
#include <TCollection_HAsciiString.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
//=============================================================================
// Creation d' une bspline_curve_with_knots_and_rational_bspline_curve de
// prostep a partir d' une BSplineCurve de Geom
//=============================================================================
GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve::
GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve( const
Handle(Geom_BSplineCurve)& BS )

73
src/GeomToStep/GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve.hxx Normal file
View File

@@ -0,0 +1,73 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve_HeaderFile
#define _GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve;
class StdFail_NotDone;
class Geom_BSplineCurve;
class Geom2d_BSplineCurve;
//! This class implements the mapping between classes
//! BSplineCurve from Geom, Geom2d and the class
//! BSplineCurveWithKnotsAndRationalBSplineCurve from StepGeom
//! which describes a rational_bspline_curve_with_knots from
//! Prostep
class GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve(const Handle(Geom_BSplineCurve)& Bsplin);
Standard_EXPORT GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve(const Handle(Geom2d_BSplineCurve)& Bsplin);
Standard_EXPORT const Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)& Value() const;
protected:
private:
Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve) theBSplineCurveWithKnotsAndRationalBSplineCurve;
};
#endif // _GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve_HeaderFile

50
src/GeomToStep/GeomToStep_MakeBSplineSurfaceWithKnots.cdl
View File

@@ -1,50 +0,0 @@
-- Created on: 1993-08-05
-- Created by: Martine LANGLOIS
-- 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 MakeBSplineSurfaceWithKnots from GeomToStep
inherits Root from GeomToStep
---Purpose: This class implements the mapping between class
-- BSplineSurface from Geom and the class
-- BSplineSurfaceWithKnots from
-- StepGeom which describes a
-- bspline_Surface_with_knots from Prostep
uses BSplineSurface from Geom,
BSplineSurfaceWithKnots from StepGeom
raises NotDone from StdFail
is
Create ( Bsplin : BSplineSurface from Geom ) returns
MakeBSplineSurfaceWithKnots;
Value (me) returns
BSplineSurfaceWithKnots from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theBSplineSurfaceWithKnots :
BSplineSurfaceWithKnots from StepGeom;
-- The solution from StepGeom
end MakeBSplineSurfaceWithKnots;

16
src/GeomToStep/GeomToStep_MakeBSplineSurfaceWithKnots.cxx
View File

@@ -14,26 +14,26 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeBSplineSurfaceWithKnots.ixx>
#include <StdFail_NotDone.hxx>
#include <Geom_BSplineSurface.hxx>
#include <GeomAbs_BSplKnotDistribution.hxx>
#include <GeomToStep_MakeBSplineSurfaceWithKnots.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_BSplineSurfaceWithKnots.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StepGeom_HArray2OfCartesianPoint.hxx>
#include <StepGeom_KnotType.hxx>
#include <TColgp_Array2OfPnt.hxx>
#include <TCollection_HAsciiString.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <TColgp_Array2OfPnt.hxx>
#include <GeomAbs_BSplKnotDistribution.hxx>
#include <StepGeom_KnotType.hxx>
#include <TCollection_HAsciiString.hxx>
//=============================================================================
// Creation d' une bspline_Surface_with_knots_and_rational_bspline_Surface de
// prostep a partir d' une BSplineSurface de Geom
//=============================================================================
GeomToStep_MakeBSplineSurfaceWithKnots::
GeomToStep_MakeBSplineSurfaceWithKnots( const
Handle(Geom_BSplineSurface)& BS )

70
src/GeomToStep/GeomToStep_MakeBSplineSurfaceWithKnots.hxx Normal file
View File

@@ -0,0 +1,70 @@
// Created on: 1993-08-05
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeBSplineSurfaceWithKnots_HeaderFile
#define _GeomToStep_MakeBSplineSurfaceWithKnots_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_BSplineSurfaceWithKnots;
class StdFail_NotDone;
class Geom_BSplineSurface;
//! This class implements the mapping between class
//! BSplineSurface from Geom and the class
//! BSplineSurfaceWithKnots from
//! StepGeom which describes a
//! bspline_Surface_with_knots from Prostep
class GeomToStep_MakeBSplineSurfaceWithKnots : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeBSplineSurfaceWithKnots(const Handle(Geom_BSplineSurface)& Bsplin);
Standard_EXPORT const Handle(StepGeom_BSplineSurfaceWithKnots)& Value() const;
protected:
private:
Handle(StepGeom_BSplineSurfaceWithKnots) theBSplineSurfaceWithKnots;
};
#endif // _GeomToStep_MakeBSplineSurfaceWithKnots_HeaderFile

52
src/GeomToStep/GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface.cdl
View File

@@ -1,52 +0,0 @@
-- Created on: 1993-06-22
-- Created by: Martine LANGLOIS
-- 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.
-- .cdl
class MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface from GeomToStep
inherits Root from GeomToStep
---Purpose: This class implements the mapping between class
-- BSplineSurface from Geom and the class
-- BSplineSurfaceWithKnotsAndRationalBSplineSurface from
-- StepGeom which describes a
-- rational_bspline_Surface_with_knots from Prostep
uses BSplineSurface from Geom,
BSplineSurfaceWithKnotsAndRationalBSplineSurface from StepGeom
raises NotDone from StdFail
is
Create ( Bsplin : BSplineSurface from Geom ) returns
MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface;
Value (me) returns
BSplineSurfaceWithKnotsAndRationalBSplineSurface from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theBSplineSurfaceWithKnotsAndRationalBSplineSurface :
BSplineSurfaceWithKnotsAndRationalBSplineSurface from StepGeom;
-- The solution from StepGeom
end MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface;

15
src/GeomToStep/GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface.cxx
View File

@@ -16,26 +16,25 @@
// .cxx
#include <GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface.ixx>
#include <StdFail_NotDone.hxx>
#include <Geom_BSplineSurface.hxx>
#include <GeomAbs_BSplKnotDistribution.hxx>
#include <GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StepGeom_HArray2OfCartesianPoint.hxx>
#include <StepGeom_KnotType.hxx>
#include <TColgp_Array2OfPnt.hxx>
#include <TCollection_HAsciiString.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <TColgp_Array2OfPnt.hxx>
#include <GeomAbs_BSplKnotDistribution.hxx>
#include <StepGeom_KnotType.hxx>
#include <TCollection_HAsciiString.hxx>
//=============================================================================
// Creation d' une bspline_Surface_with_knots_and_rational_bspline_Surface de
// prostep a partir d' une BSplineSurface de Geom
//=============================================================================
GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface::
GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface( const
Handle(Geom_BSplineSurface)& BS )

70
src/GeomToStep/GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx Normal file
View File

@@ -0,0 +1,70 @@
// Created on: 1993-06-22
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface_HeaderFile
#define _GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface;
class StdFail_NotDone;
class Geom_BSplineSurface;
//! This class implements the mapping between class
//! BSplineSurface from Geom and the class
//! BSplineSurfaceWithKnotsAndRationalBSplineSurface from
//! StepGeom which describes a
//! rational_bspline_Surface_with_knots from Prostep
class GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface(const Handle(Geom_BSplineSurface)& Bsplin);
Standard_EXPORT const Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface)& Value() const;
protected:
private:
Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) theBSplineSurfaceWithKnotsAndRationalBSplineSurface;
};
#endif // _GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface_HeaderFile

50
src/GeomToStep/GeomToStep_MakeBoundedCurve.cdl
View File

@@ -1,50 +0,0 @@
-- Created on: 1993-06-21
-- Created by: Martine LANGLOIS
-- 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 MakeBoundedCurve from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- BoundedCurve from Geom, Geom2d and the class BoundedCurve from
-- StepGeom which describes a BoundedCurve from prostep.
-- As BoundedCurve is an abstract BoundedCurve this class
-- is an access to the sub-class required.
uses BoundedCurve from Geom,
BoundedCurve from Geom2d,
BoundedCurve from StepGeom
raises NotDone from StdFail
is
Create ( C : BoundedCurve from Geom ) returns MakeBoundedCurve;
Create ( C : BoundedCurve from Geom2d ) returns MakeBoundedCurve;
Value (me) returns BoundedCurve from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theBoundedCurve : BoundedCurve from StepGeom;
-- The solution from StepGeom
end MakeBoundedCurve;

21
src/GeomToStep/GeomToStep_MakeBoundedCurve.cxx
View File

@@ -14,25 +14,26 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeBoundedCurve.ixx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_BoundedCurve.hxx>
#include <GeomToStep_MakeBoundedCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2d_BezierCurve.hxx>
#include <GeomConvert.hxx>
#include <Geom2d_BoundedCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <Geom2dConvert.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BoundedCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <GeomConvert.hxx>
#include <GeomToStep_MakeBoundedCurve.hxx>
#include <GeomToStep_MakeBSplineCurveWithKnots.hxx>
#include <GeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_BoundedCurve.hxx>
#include <StepGeom_BSplineCurveWithKnots.hxx>
#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
//=============================================================================
// Creation d' une BoundedCurve de prostep a partir d' une BoundedCurve de Geom
//=============================================================================
GeomToStep_MakeBoundedCurve::GeomToStep_MakeBoundedCurve ( const Handle(Geom_BoundedCurve)& C)
{
done = Standard_True;

73
src/GeomToStep/GeomToStep_MakeBoundedCurve.hxx Normal file
View File

@@ -0,0 +1,73 @@
// Created on: 1993-06-21
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeBoundedCurve_HeaderFile
#define _GeomToStep_MakeBoundedCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_BoundedCurve;
class StdFail_NotDone;
class Geom_BoundedCurve;
class Geom2d_BoundedCurve;
//! This class implements the mapping between classes
//! BoundedCurve from Geom, Geom2d and the class BoundedCurve from
//! StepGeom which describes a BoundedCurve from prostep.
//! As BoundedCurve is an abstract BoundedCurve this class
//! is an access to the sub-class required.
class GeomToStep_MakeBoundedCurve : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeBoundedCurve(const Handle(Geom_BoundedCurve)& C);
Standard_EXPORT GeomToStep_MakeBoundedCurve(const Handle(Geom2d_BoundedCurve)& C);
Standard_EXPORT const Handle(StepGeom_BoundedCurve)& Value() const;
protected:
private:
Handle(StepGeom_BoundedCurve) theBoundedCurve;
};
#endif // _GeomToStep_MakeBoundedCurve_HeaderFile

47
src/GeomToStep/GeomToStep_MakeBoundedSurface.cdl
View File

@@ -1,47 +0,0 @@
-- Created on: 1993-06-22
-- Created by: Martine LANGLOIS
-- 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 MakeBoundedSurface from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- BoundedSurface from Geom and the class BoundedSurface from
-- StepGeom which describes a BoundedSurface from prostep.
-- As BoundedSurface is an abstract BoundedSurface this class
-- is an access to the sub-class required.
uses BoundedSurface from Geom,
BoundedSurface from StepGeom
raises NotDone from StdFail
is
Create ( C : BoundedSurface from Geom ) returns MakeBoundedSurface;
Value (me) returns BoundedSurface from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theBoundedSurface : BoundedSurface from StepGeom;
-- The solution from StepGeom
end MakeBoundedSurface;

18
src/GeomToStep/GeomToStep_MakeBoundedSurface.cxx
View File

@@ -14,26 +14,26 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeBoundedSurface.ixx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_BoundedSurface.hxx>
#include <StepGeom_BSplineSurfaceWithKnots.hxx>
#include <StepGeom_RectangularTrimmedSurface.hxx>
#include <StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
#include <GeomToStep_MakeBoundedSurface.hxx>
#include <Geom_BezierSurface.hxx>
#include <Geom_BoundedSurface.hxx>
#include <Geom_BSplineSurface.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_BezierSurface.hxx>
#include <GeomConvert.hxx>
#include <GeomToStep_MakeBoundedSurface.hxx>
#include <GeomToStep_MakeBSplineSurfaceWithKnots.hxx>
#include <GeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
#include <GeomToStep_MakeRectangularTrimmedSurface.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_BoundedSurface.hxx>
#include <StepGeom_BSplineSurfaceWithKnots.hxx>
#include <StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
#include <StepGeom_RectangularTrimmedSurface.hxx>
//=============================================================================
// Creation d' une BoundedSurface de prostep a partir d' une BoundedSurface
// de Geom
//=============================================================================
GeomToStep_MakeBoundedSurface::GeomToStep_MakeBoundedSurface
( const Handle(Geom_BoundedSurface)& S)
{

70
src/GeomToStep/GeomToStep_MakeBoundedSurface.hxx Normal file
View File

@@ -0,0 +1,70 @@
// Created on: 1993-06-22
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeBoundedSurface_HeaderFile
#define _GeomToStep_MakeBoundedSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_BoundedSurface;
class StdFail_NotDone;
class Geom_BoundedSurface;
//! This class implements the mapping between classes
//! BoundedSurface from Geom and the class BoundedSurface from
//! StepGeom which describes a BoundedSurface from prostep.
//! As BoundedSurface is an abstract BoundedSurface this class
//! is an access to the sub-class required.
class GeomToStep_MakeBoundedSurface : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeBoundedSurface(const Handle(Geom_BoundedSurface)& C);
Standard_EXPORT const Handle(StepGeom_BoundedSurface)& Value() const;
protected:
private:
Handle(StepGeom_BoundedSurface) theBoundedSurface;
};
#endif // _GeomToStep_MakeBoundedSurface_HeaderFile

54
src/GeomToStep/GeomToStep_MakeCartesianPoint.cdl
View File

@@ -1,54 +0,0 @@
-- Created on: 1993-06-11
-- Created by: Martine LANGLOIS
-- 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 MakeCartesianPoint from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- CartesianPoint from Geom and Pnt from gp, and the class
-- CartesianPoint from StepGeom which describes a point from
-- Prostep.
uses Pnt from gp,
Pnt2d from gp,
CartesianPoint from Geom,
CartesianPoint from Geom2d,
CartesianPoint from StepGeom
raises NotDone from StdFail
is
Create ( P : Pnt from gp ) returns MakeCartesianPoint;
Create ( P : Pnt2d from gp ) returns MakeCartesianPoint;
Create ( P : CartesianPoint from Geom ) returns MakeCartesianPoint;
Create ( P : CartesianPoint from Geom2d ) returns MakeCartesianPoint;
Value (me) returns CartesianPoint from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theCartesianPoint : CartesianPoint from StepGeom;
-- The solution from StepGeom
end MakeCartesianPoint;

12
src/GeomToStep/GeomToStep_MakeCartesianPoint.cxx
View File

@@ -14,21 +14,21 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeCartesianPoint.ixx>
#include <StdFail_NotDone.hxx>
#include <Geom2d_CartesianPoint.hxx>
#include <Geom_CartesianPoint.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <Geom_CartesianPoint.hxx>
#include <Geom2d_CartesianPoint.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TCollection_HAsciiString.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <UnitsMethods.hxx>
//=============================================================================
// Creation d' un cartesian_point de prostep a partir d' un point3d de gp
//=============================================================================
GeomToStep_MakeCartesianPoint::GeomToStep_MakeCartesianPoint( const gp_Pnt& P)
{
Handle(StepGeom_CartesianPoint) Pstep = new StepGeom_CartesianPoint;

78
src/GeomToStep/GeomToStep_MakeCartesianPoint.hxx Normal file
View File

@@ -0,0 +1,78 @@
// Created on: 1993-06-11
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeCartesianPoint_HeaderFile
#define _GeomToStep_MakeCartesianPoint_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_CartesianPoint;
class StdFail_NotDone;
class gp_Pnt;
class gp_Pnt2d;
class Geom_CartesianPoint;
class Geom2d_CartesianPoint;
//! This class implements the mapping between classes
//! CartesianPoint from Geom and Pnt from gp, and the class
//! CartesianPoint from StepGeom which describes a point from
//! Prostep.
class GeomToStep_MakeCartesianPoint : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeCartesianPoint(const gp_Pnt& P);
Standard_EXPORT GeomToStep_MakeCartesianPoint(const gp_Pnt2d& P);
Standard_EXPORT GeomToStep_MakeCartesianPoint(const Handle(Geom_CartesianPoint)& P);
Standard_EXPORT GeomToStep_MakeCartesianPoint(const Handle(Geom2d_CartesianPoint)& P);
Standard_EXPORT const Handle(StepGeom_CartesianPoint)& Value() const;
protected:
private:
Handle(StepGeom_CartesianPoint) theCartesianPoint;
};
#endif // _GeomToStep_MakeCartesianPoint_HeaderFile

52
src/GeomToStep/GeomToStep_MakeCircle.cdl
View File

@@ -1,52 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeCircle from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Circle from Geom, and Circ from gp, and the class
-- Circle from StepGeom which describes a circle from
-- Prostep.
uses Circ from gp,
Circ2d from gp,
Circle from Geom,
Circle from Geom2d,
Circle from StepGeom
raises NotDone from StdFail
is
Create ( C : Circ from gp ) returns MakeCircle;
Create ( C : Circle from Geom ) returns MakeCircle;
Create ( C : Circle from Geom2d ) returns MakeCircle;
Value (me) returns Circle from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theCircle : Circle from StepGeom;
-- The solution from StepGeom
end MakeCircle;

13
src/GeomToStep/GeomToStep_MakeCircle.cxx
View File

@@ -14,23 +14,24 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeCircle.ixx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom_Circle.hxx>
#include <GeomToStep_MakeAxis2Placement2d.hxx>
#include <StdFail_NotDone.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakeCircle.hxx>
#include <gp_Circ.hxx>
#include <gp_Circ2d.hxx>
#include <Geom_Circle.hxx>
#include <StepGeom_Circle.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement2d.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_Circle.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
//=============================================================================
// Creation d' un cercle de prostep a partir d' un cercle 3d de gp
//=============================================================================
GeomToStep_MakeCircle::GeomToStep_MakeCircle( const gp_Circ& C)
{
#include <GeomToStep_MakeCircle_gen.pxx>

75
src/GeomToStep/GeomToStep_MakeCircle.hxx Normal file
View File

@@ -0,0 +1,75 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeCircle_HeaderFile
#define _GeomToStep_MakeCircle_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Circle;
class StdFail_NotDone;
class gp_Circ;
class Geom_Circle;
class Geom2d_Circle;
//! This class implements the mapping between classes
//! Circle from Geom, and Circ from gp, and the class
//! Circle from StepGeom which describes a circle from
//! Prostep.
class GeomToStep_MakeCircle : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeCircle(const gp_Circ& C);
Standard_EXPORT GeomToStep_MakeCircle(const Handle(Geom_Circle)& C);
Standard_EXPORT GeomToStep_MakeCircle(const Handle(Geom2d_Circle)& C);
Standard_EXPORT const Handle(StepGeom_Circle)& Value() const;
protected:
private:
Handle(StepGeom_Circle) theCircle;
};
#endif // _GeomToStep_MakeCircle_HeaderFile

49
src/GeomToStep/GeomToStep_MakeConic.cdl
View File

@@ -1,49 +0,0 @@
-- Created on: 1993-06-21
-- Created by: Martine LANGLOIS
-- 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 MakeConic from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Conic from Geom and the class Conic from StepGeom
-- which describes a Conic from prostep. As Conic is an abstract
-- Conic this class is an access to the sub-class required.
uses Conic from Geom,
Conic from Geom2d,
Conic from StepGeom
raises NotDone from StdFail
is
Create ( C : Conic from Geom ) returns MakeConic;
Create ( C : Conic from Geom2d ) returns MakeConic;
Value (me) returns Conic from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theConic : Conic from StepGeom;
-- The solution from StepGeom
end MakeConic;

26
src/GeomToStep/GeomToStep_MakeConic.cxx
View File

@@ -14,30 +14,32 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeConic.ixx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Circle.hxx>
#include <StepGeom_Ellipse.hxx>
#include <StepGeom_Hyperbola.hxx>
#include <StepGeom_Parabola.hxx>
#include <GeomToStep_MakeConic.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Ellipse.hxx>
#include <Geom_Hyperbola.hxx>
#include <Geom_Parabola.hxx>
#include <Geom2d_Circle.hxx>
#include <Geom2d_Conic.hxx>
#include <Geom2d_Ellipse.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom2d_Parabola.hxx>
#include <Geom_Circle.hxx>
#include <Geom_Conic.hxx>
#include <Geom_Ellipse.hxx>
#include <Geom_Hyperbola.hxx>
#include <Geom_Parabola.hxx>
#include <GeomToStep_MakeCircle.hxx>
#include <GeomToStep_MakeConic.hxx>
#include <GeomToStep_MakeEllipse.hxx>
#include <GeomToStep_MakeHyperbola.hxx>
#include <GeomToStep_MakeParabola.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Circle.hxx>
#include <StepGeom_Conic.hxx>
#include <StepGeom_Ellipse.hxx>
#include <StepGeom_Hyperbola.hxx>
#include <StepGeom_Parabola.hxx>
//=============================================================================
// Creation d' une Conic de prostep a partir d' une Conic de Geom
//=============================================================================
GeomToStep_MakeConic::GeomToStep_MakeConic ( const Handle(Geom_Conic)& C)
{
done = Standard_True;

72
src/GeomToStep/GeomToStep_MakeConic.hxx Normal file
View File

@@ -0,0 +1,72 @@
// Created on: 1993-06-21
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeConic_HeaderFile
#define _GeomToStep_MakeConic_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Conic;
class StdFail_NotDone;
class Geom_Conic;
class Geom2d_Conic;
//! This class implements the mapping between classes
//! Conic from Geom and the class Conic from StepGeom
//! which describes a Conic from prostep. As Conic is an abstract
//! Conic this class is an access to the sub-class required.
class GeomToStep_MakeConic : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeConic(const Handle(Geom_Conic)& C);
Standard_EXPORT GeomToStep_MakeConic(const Handle(Geom2d_Conic)& C);
Standard_EXPORT const Handle(StepGeom_Conic)& Value() const;
protected:
private:
Handle(StepGeom_Conic) theConic;
};
#endif // _GeomToStep_MakeConic_HeaderFile

47
src/GeomToStep/GeomToStep_MakeConicalSurface.cdl
View File

@@ -1,47 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeConicalSurface from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between class
-- ConicalSurface from Geom and the class
-- ConicalSurface from StepGeom which describes a
-- conical_surface from Prostep
uses ConicalSurface from Geom,
ConicalSurface from StepGeom
raises NotDone from StdFail
is
Create ( CSurf : ConicalSurface from Geom ) returns MakeConicalSurface;
Value (me) returns ConicalSurface from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theConicalSurface : ConicalSurface from StepGeom;
-- The solution from StepGeom
end MakeConicalSurface;

13
src/GeomToStep/GeomToStep_MakeConicalSurface.cxx
View File

@@ -14,22 +14,21 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeConicalSurface.ixx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <StdFail_NotDone.hxx>
#include <Geom_ConicalSurface.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakeConicalSurface.hxx>
#include <Standard_DomainError.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_ConicalSurface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Standard_DomainError.hxx>
#include <UnitsMethods.hxx>
//=============================================================================
// Creation d' une conical_surface de prostep a partir d' une ConicalSurface
// de Geom
//=============================================================================
GeomToStep_MakeConicalSurface::GeomToStep_MakeConicalSurface
( const Handle(Geom_ConicalSurface)& CS )

69
src/GeomToStep/GeomToStep_MakeConicalSurface.hxx Normal file
View File

@@ -0,0 +1,69 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeConicalSurface_HeaderFile
#define _GeomToStep_MakeConicalSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_ConicalSurface;
class StdFail_NotDone;
class Geom_ConicalSurface;
//! This class implements the mapping between class
//! ConicalSurface from Geom and the class
//! ConicalSurface from StepGeom which describes a
//! conical_surface from Prostep
class GeomToStep_MakeConicalSurface : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeConicalSurface(const Handle(Geom_ConicalSurface)& CSurf);
Standard_EXPORT const Handle(StepGeom_ConicalSurface)& Value() const;
protected:
private:
Handle(StepGeom_ConicalSurface) theConicalSurface;
};
#endif // _GeomToStep_MakeConicalSurface_HeaderFile

49
src/GeomToStep/GeomToStep_MakeCurve.cdl
View File

@@ -1,49 +0,0 @@
-- Created on: 1993-06-21
-- Created by: Martine LANGLOIS
-- 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 MakeCurve from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Curve from Geom and the class Curve from StepGeom which
-- describes a Curve from prostep. As Curve is an
-- abstract curve this class an access to the sub-class required.
uses Curve from Geom,
Curve from Geom2d,
Curve from StepGeom
raises NotDone from StdFail
is
Create ( C : Curve from Geom ) returns MakeCurve;
Create ( C : Curve from Geom2d ) returns MakeCurve;
Value (me) returns Curve from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theCurve : Curve from StepGeom;
-- The solution from StepGeom
end MakeCurve;

46
src/GeomToStep/GeomToStep_MakeCurve.cxx
View File

@@ -14,38 +14,38 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeCurve.ixx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Conic.hxx>
#include <StepGeom_Line.hxx>
#include <StepGeom_BoundedCurve.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <GeomToStep_MakeCurve.hxx>
#include <Geom_Line.hxx>
#include <Geom2d_Line.hxx>
#include <GeomToStep_MakeLine.hxx>
#include <Geom_Conic.hxx>
#include <Geom2d_Conic.hxx>
#include <GeomToStep_MakeConic.hxx>
#include <Geom_BoundedCurve.hxx>
#include <Geom2d_BoundedCurve.hxx>
#include <Geom2d_BSplineCurve.hxx>
#include <GeomToStep_MakeBoundedCurve.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom2dConvert.hxx>
#include <Geom2d_Circle.hxx>
#include <gp_Circ2d.hxx>
#include <Geom2d_Conic.hxx>
#include <Geom2d_Curve.hxx>
#include <Geom2d_Ellipse.hxx>
#include <Geom2d_Line.hxx>
#include <Geom2dConvert.hxx>
#include <Geom_BezierCurve.hxx>
#include <Geom_BoundedCurve.hxx>
#include <Geom_BSplineCurve.hxx>
#include <Geom_Conic.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Line.hxx>
#include <Geom_TrimmedCurve.hxx>
#include <GeomToStep_MakeBoundedCurve.hxx>
#include <GeomToStep_MakeConic.hxx>
#include <GeomToStep_MakeCurve.hxx>
#include <GeomToStep_MakeLine.hxx>
#include <gp_Circ2d.hxx>
#include <gp_Elips2d.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_BoundedCurve.hxx>
#include <StepGeom_Conic.hxx>
#include <StepGeom_Curve.hxx>
#include <StepGeom_Line.hxx>
//=============================================================================
// Creation d' une Curve de prostep a partir d' une Curve de Geom
//=============================================================================
GeomToStep_MakeCurve::GeomToStep_MakeCurve ( const Handle(Geom_Curve)& C)
{
done = Standard_True;

72
src/GeomToStep/GeomToStep_MakeCurve.hxx Normal file
View File

@@ -0,0 +1,72 @@
// Created on: 1993-06-21
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeCurve_HeaderFile
#define _GeomToStep_MakeCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Curve;
class StdFail_NotDone;
class Geom_Curve;
class Geom2d_Curve;
//! This class implements the mapping between classes
//! Curve from Geom and the class Curve from StepGeom which
//! describes a Curve from prostep. As Curve is an
//! abstract curve this class an access to the sub-class required.
class GeomToStep_MakeCurve : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeCurve(const Handle(Geom_Curve)& C);
Standard_EXPORT GeomToStep_MakeCurve(const Handle(Geom2d_Curve)& C);
Standard_EXPORT const Handle(StepGeom_Curve)& Value() const;
protected:
private:
Handle(StepGeom_Curve) theCurve;
};
#endif // _GeomToStep_MakeCurve_HeaderFile

45
src/GeomToStep/GeomToStep_MakeCylindricalSurface.cdl
View File

@@ -1,45 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeCylindricalSurface from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between class
-- CylindricalSurface from Geom and the class
-- CylindricalSurface from StepGeom which describes a
-- cylindrical_surface from Prostep
uses CylindricalSurface from Geom,
CylindricalSurface from StepGeom
raises NotDone from StdFail
is
Create ( CSurf : CylindricalSurface from Geom ) returns MakeCylindricalSurface;
Value (me) returns CylindricalSurface from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theCylindricalSurface : CylindricalSurface from StepGeom;
-- The solution from StepGeom
end MakeCylindricalSurface;

10
src/GeomToStep/GeomToStep_MakeCylindricalSurface.cxx
View File

@@ -14,11 +14,12 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeCylindricalSurface.ixx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <StdFail_NotDone.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakeCylindricalSurface.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_CylindricalSurface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
@@ -27,7 +28,6 @@
// Creation d' une conical_surface de prostep a partir d' une
// CylindricalSurface de Geom
//=============================================================================
GeomToStep_MakeCylindricalSurface::GeomToStep_MakeCylindricalSurface
( const Handle(Geom_CylindricalSurface)& CS )

69
src/GeomToStep/GeomToStep_MakeCylindricalSurface.hxx Normal file
View File

@@ -0,0 +1,69 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeCylindricalSurface_HeaderFile
#define _GeomToStep_MakeCylindricalSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_CylindricalSurface;
class StdFail_NotDone;
class Geom_CylindricalSurface;
//! This class implements the mapping between class
//! CylindricalSurface from Geom and the class
//! CylindricalSurface from StepGeom which describes a
//! cylindrical_surface from Prostep
class GeomToStep_MakeCylindricalSurface : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeCylindricalSurface(const Handle(Geom_CylindricalSurface)& CSurf);
Standard_EXPORT const Handle(StepGeom_CylindricalSurface)& Value() const;
protected:
private:
Handle(StepGeom_CylindricalSurface) theCylindricalSurface;
};
#endif // _GeomToStep_MakeCylindricalSurface_HeaderFile

54
src/GeomToStep/GeomToStep_MakeDirection.cdl
View File

@@ -1,54 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeDirection from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Direction from Geom, Geom2d and Dir, Dir2d from gp, and the
-- class Direction from StepGeom which describes a direction
-- from Prostep.
uses Dir from gp,
Dir2d from gp,
Direction from Geom,
Direction from Geom2d,
Direction from StepGeom
raises NotDone from StdFail
is
Create ( D : Dir from gp ) returns MakeDirection;
Create ( D : Dir2d from gp ) returns MakeDirection;
Create ( D : Direction from Geom ) returns MakeDirection;
Create ( D : Direction from Geom2d ) returns MakeDirection;
Value (me) returns Direction from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theDirection : Direction from StepGeom;
-- The solution from StepGeom
end MakeDirection;

12
src/GeomToStep/GeomToStep_MakeDirection.cxx
View File

@@ -14,20 +14,20 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeDirection.ixx>
#include <StdFail_NotDone.hxx>
#include <Geom2d_Direction.hxx>
#include <Geom_Direction.hxx>
#include <GeomToStep_MakeDirection.hxx>
#include <gp_Dir.hxx>
#include <gp_Dir2d.hxx>
#include <Geom_Direction.hxx>
#include <Geom2d_Direction.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Direction.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TCollection_HAsciiString.hxx>
#include <TColStd_HArray1OfReal.hxx>
//=============================================================================
// Creation d' une direction de prostep a partir d' une Dir de gp
//=============================================================================
GeomToStep_MakeDirection::GeomToStep_MakeDirection( const gp_Dir& D)
{
Handle(StepGeom_Direction) Dir = new StepGeom_Direction;

78
src/GeomToStep/GeomToStep_MakeDirection.hxx Normal file
View File

@@ -0,0 +1,78 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeDirection_HeaderFile
#define _GeomToStep_MakeDirection_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Direction;
class StdFail_NotDone;
class gp_Dir;
class gp_Dir2d;
class Geom_Direction;
class Geom2d_Direction;
//! This class implements the mapping between classes
//! Direction from Geom, Geom2d and Dir, Dir2d from gp, and the
//! class Direction from StepGeom which describes a direction
//! from Prostep.
class GeomToStep_MakeDirection : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeDirection(const gp_Dir& D);
Standard_EXPORT GeomToStep_MakeDirection(const gp_Dir2d& D);
Standard_EXPORT GeomToStep_MakeDirection(const Handle(Geom_Direction)& D);
Standard_EXPORT GeomToStep_MakeDirection(const Handle(Geom2d_Direction)& D);
Standard_EXPORT const Handle(StepGeom_Direction)& Value() const;
protected:
private:
Handle(StepGeom_Direction) theDirection;
};
#endif // _GeomToStep_MakeDirection_HeaderFile

47
src/GeomToStep/GeomToStep_MakeElementarySurface.cdl
View File

@@ -1,47 +0,0 @@
-- Created on: 1993-06-22
-- Created by: Martine LANGLOIS
-- 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 MakeElementarySurface from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- ElementarySurface from Geom and the class ElementarySurface
-- from StepGeom which describes a ElementarySurface from
-- prostep. As ElementarySurface is an abstract Surface this
-- class is an access to the sub-class required.
uses ElementarySurface from Geom,
ElementarySurface from StepGeom
raises NotDone from StdFail
is
Create ( S : ElementarySurface from Geom ) returns MakeElementarySurface;
Value (me) returns ElementarySurface from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theElementarySurface : ElementarySurface from StepGeom;
-- The solution from StepGeom
end MakeElementarySurface;

28
src/GeomToStep/GeomToStep_MakeElementarySurface.cxx
View File

@@ -14,31 +14,31 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeElementarySurface.ixx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_ElementarySurface.hxx>
#include <StepGeom_CylindricalSurface.hxx>
#include <StepGeom_ConicalSurface.hxx>
#include <StepGeom_SphericalSurface.hxx>
#include <StepGeom_ToroidalSurface.hxx>
#include <StepGeom_Plane.hxx>
#include <GeomToStep_MakeElementarySurface.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_ConicalSurface.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_ElementarySurface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <Geom_Plane.hxx>
#include <GeomToStep_MakeCylindricalSurface.hxx>
#include <GeomToStep_MakeConicalSurface.hxx>
#include <GeomToStep_MakeCylindricalSurface.hxx>
#include <GeomToStep_MakeElementarySurface.hxx>
#include <GeomToStep_MakePlane.hxx>
#include <GeomToStep_MakeSphericalSurface.hxx>
#include <GeomToStep_MakeToroidalSurface.hxx>
#include <GeomToStep_MakePlane.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_ConicalSurface.hxx>
#include <StepGeom_CylindricalSurface.hxx>
#include <StepGeom_ElementarySurface.hxx>
#include <StepGeom_Plane.hxx>
#include <StepGeom_SphericalSurface.hxx>
#include <StepGeom_ToroidalSurface.hxx>
//=============================================================================
// Creation d' une ElementarySurface de prostep a partir d' une
// ElementarySurface de Geom
//=============================================================================
GeomToStep_MakeElementarySurface::GeomToStep_MakeElementarySurface
( const Handle(Geom_ElementarySurface)& S)
{

70
src/GeomToStep/GeomToStep_MakeElementarySurface.hxx Normal file
View File

@@ -0,0 +1,70 @@
// Created on: 1993-06-22
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeElementarySurface_HeaderFile
#define _GeomToStep_MakeElementarySurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_ElementarySurface;
class StdFail_NotDone;
class Geom_ElementarySurface;
//! This class implements the mapping between classes
//! ElementarySurface from Geom and the class ElementarySurface
//! from StepGeom which describes a ElementarySurface from
//! prostep. As ElementarySurface is an abstract Surface this
//! class is an access to the sub-class required.
class GeomToStep_MakeElementarySurface : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeElementarySurface(const Handle(Geom_ElementarySurface)& S);
Standard_EXPORT const Handle(StepGeom_ElementarySurface)& Value() const;
protected:
private:
Handle(StepGeom_ElementarySurface) theElementarySurface;
};
#endif // _GeomToStep_MakeElementarySurface_HeaderFile

52
src/GeomToStep/GeomToStep_MakeEllipse.cdl
View File

@@ -1,52 +0,0 @@
-- Created on: 1994-09-02
-- Created by: Frederic MAUPAS
-- Copyright (c) 1994-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 MakeEllipse from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Ellipse from Geom, and Circ from gp, and the class
-- Ellipse from StepGeom which describes a Ellipse from
-- Prostep.
uses Elips from gp,
Elips2d from gp,
Ellipse from Geom,
Ellipse from Geom2d,
Ellipse from StepGeom
raises NotDone from StdFail
is
Create ( C : Elips from gp ) returns MakeEllipse;
Create ( C : Ellipse from Geom ) returns MakeEllipse;
Create ( C : Ellipse from Geom2d ) returns MakeEllipse;
Value (me) returns Ellipse from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theEllipse : Ellipse from StepGeom;
-- The solution from StepGeom
end MakeEllipse;

14
src/GeomToStep/GeomToStep_MakeEllipse.cxx
View File

@@ -14,22 +14,24 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeEllipse.ixx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakeAxis2Placement2d.hxx>
#include <StdFail_NotDone.hxx>
#include <Geom2d_Ellipse.hxx>
#include <Geom_Ellipse.hxx>
#include <GeomToStep_MakeAxis2Placement2d.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakeEllipse.hxx>
#include <gp_Elips.hxx>
#include <gp_Elips2d.hxx>
#include <StepGeom_Ellipse.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement2d.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_Ellipse.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
//=============================================================================
// Creation d'une ellipse de prostep a partir d'une ellipse 3d de gp
//=============================================================================
GeomToStep_MakeEllipse::GeomToStep_MakeEllipse( const gp_Elips& E)
{
#include <GeomToStep_MakeEllipse_gen.pxx>

75
src/GeomToStep/GeomToStep_MakeEllipse.hxx Normal file
View File

@@ -0,0 +1,75 @@
// Created on: 1994-09-02
// Created by: Frederic MAUPAS
// Copyright (c) 1994-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 _GeomToStep_MakeEllipse_HeaderFile
#define _GeomToStep_MakeEllipse_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Ellipse;
class StdFail_NotDone;
class gp_Elips;
class Geom_Ellipse;
class Geom2d_Ellipse;
//! This class implements the mapping between classes
//! Ellipse from Geom, and Circ from gp, and the class
//! Ellipse from StepGeom which describes a Ellipse from
//! Prostep.
class GeomToStep_MakeEllipse : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeEllipse(const gp_Elips& C);
Standard_EXPORT GeomToStep_MakeEllipse(const Handle(Geom_Ellipse)& C);
Standard_EXPORT GeomToStep_MakeEllipse(const Handle(Geom2d_Ellipse)& C);
Standard_EXPORT const Handle(StepGeom_Ellipse)& Value() const;
protected:
private:
Handle(StepGeom_Ellipse) theEllipse;
};
#endif // _GeomToStep_MakeEllipse_HeaderFile

48
src/GeomToStep/GeomToStep_MakeHyperbola.cdl
View File

@@ -1,48 +0,0 @@
-- Created on: 1995-05-04
-- Created by: Dieter THIEMANN
-- 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 MakeHyperbola from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between the class
-- Hyperbola from Geom and the class Hyperbola from
-- StepGeom which describes a Hyperbola from ProSTEP
uses Hyperbola from Geom,
Hyperbola from Geom2d,
Hyperbola from StepGeom
raises NotDone from StdFail
is
Create ( C : Hyperbola from Geom2d) returns MakeHyperbola;
Create ( C : Hyperbola from Geom) returns MakeHyperbola;
Value (me) returns Hyperbola from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theHyperbola : Hyperbola from StepGeom;
-- The solution from StepGeom
end MakeHyperbola;

15
src/GeomToStep/GeomToStep_MakeHyperbola.cxx
View File

@@ -11,26 +11,25 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeHyperbola.ixx>
#include <StepGeom_Hyperbola.hxx>
#include <StepGeom_Axis2Placement2d.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <gp_Hypr.hxx>
#include <gp_Hypr2d.hxx>
#include <Geom2d_Hyperbola.hxx>
#include <Geom_Hyperbola.hxx>
#include <GeomToStep_MakeAxis2Placement2d.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakeHyperbola.hxx>
#include <gp_Hypr.hxx>
#include <gp_Hypr2d.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement2d.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_Hyperbola.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
//=============================================================================
// Creation d'une hyperbola de prostep a partir d'une hyperbola de
// Geom2d
//=============================================================================
GeomToStep_MakeHyperbola::GeomToStep_MakeHyperbola(const Handle(Geom2d_Hyperbola)& C)
{
gp_Hypr2d gpHyp;

71
src/GeomToStep/GeomToStep_MakeHyperbola.hxx Normal file
View File

@@ -0,0 +1,71 @@
// Created on: 1995-05-04
// Created by: Dieter THIEMANN
// 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 _GeomToStep_MakeHyperbola_HeaderFile
#define _GeomToStep_MakeHyperbola_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Hyperbola;
class StdFail_NotDone;
class Geom2d_Hyperbola;
class Geom_Hyperbola;
//! This class implements the mapping between the class
//! Hyperbola from Geom and the class Hyperbola from
//! StepGeom which describes a Hyperbola from ProSTEP
class GeomToStep_MakeHyperbola : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeHyperbola(const Handle(Geom2d_Hyperbola)& C);
Standard_EXPORT GeomToStep_MakeHyperbola(const Handle(Geom_Hyperbola)& C);
Standard_EXPORT const Handle(StepGeom_Hyperbola)& Value() const;
protected:
private:
Handle(StepGeom_Hyperbola) theHyperbola;
};
#endif // _GeomToStep_MakeHyperbola_HeaderFile

54
src/GeomToStep/GeomToStep_MakeLine.cdl
View File

@@ -1,54 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeLine from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Line from Geom and Lin from gp, and the class
-- Line from StepGeom which describes a line from
-- Prostep.
uses Lin from gp,
Lin2d from gp,
Line from Geom,
Line from Geom2d,
Line from StepGeom
raises NotDone from StdFail
is
Create ( L : Lin from gp ) returns MakeLine;
Create ( L : Lin2d from gp ) returns MakeLine;
Create ( C : Line from Geom ) returns MakeLine;
Create ( C : Line from Geom2d ) returns MakeLine;
Value (me) returns Line from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theLine : Line from StepGeom;
-- The solution from StepGeom
end MakeLine;

22
src/GeomToStep/GeomToStep_MakeLine.cxx
View File

@@ -14,23 +14,25 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeLine.ixx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Line.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <StepGeom_Vector.hxx>
#include <Geom2d_Line.hxx>
#include <Geom_Line.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <GeomToStep_MakeLine.hxx>
#include <GeomToStep_MakeVector.hxx>
#include <gp_Lin.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Vec.hxx>
#include <gp_Vec2d.hxx>
#include <GeomToStep_MakeLine.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <GeomToStep_MakeVector.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <StepGeom_Line.hxx>
#include <StepGeom_Vector.hxx>
#include <TCollection_HAsciiString.hxx>
//=============================================================================
// Creation d' une line de prostep a partir d' une Lin de gp
//=============================================================================
GeomToStep_MakeLine::GeomToStep_MakeLine( const gp_Lin& L)
{
#define Vec_gen gp_Vec

78
src/GeomToStep/GeomToStep_MakeLine.hxx Normal file
View File

@@ -0,0 +1,78 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeLine_HeaderFile
#define _GeomToStep_MakeLine_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Line;
class StdFail_NotDone;
class gp_Lin;
class gp_Lin2d;
class Geom_Line;
class Geom2d_Line;
//! This class implements the mapping between classes
//! Line from Geom and Lin from gp, and the class
//! Line from StepGeom which describes a line from
//! Prostep.
class GeomToStep_MakeLine : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeLine(const gp_Lin& L);
Standard_EXPORT GeomToStep_MakeLine(const gp_Lin2d& L);
Standard_EXPORT GeomToStep_MakeLine(const Handle(Geom_Line)& C);
Standard_EXPORT GeomToStep_MakeLine(const Handle(Geom2d_Line)& C);
Standard_EXPORT const Handle(StepGeom_Line)& Value() const;
protected:
private:
Handle(StepGeom_Line) theLine;
};
#endif // _GeomToStep_MakeLine_HeaderFile

48
src/GeomToStep/GeomToStep_MakeParabola.cdl
View File

@@ -1,48 +0,0 @@
-- Created on: 1995-05-04
-- Created by: Dieter THIEMANN
-- 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 MakeParabola from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between the class
-- Parabola from Geom and the class Parabola from
-- StepGeom which describes a Parabola from ProSTEP
uses Parabola from Geom,
Parabola from Geom2d,
Parabola from StepGeom
raises NotDone from StdFail
is
Create ( C : Parabola from Geom2d) returns MakeParabola;
Create ( C : Parabola from Geom) returns MakeParabola;
Value (me) returns Parabola from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theParabola : Parabola from StepGeom;
-- The solution from StepGeom
end MakeParabola;

15
src/GeomToStep/GeomToStep_MakeParabola.cxx
View File

@@ -11,26 +11,25 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeParabola.ixx>
#include <StepGeom_Parabola.hxx>
#include <StepGeom_Axis2Placement2d.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <gp_Parab.hxx>
#include <gp_Parab2d.hxx>
#include <Geom2d_Parabola.hxx>
#include <Geom_Parabola.hxx>
#include <GeomToStep_MakeAxis2Placement2d.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakeParabola.hxx>
#include <gp_Parab.hxx>
#include <gp_Parab2d.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement2d.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_Parabola.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
//=============================================================================
// Creation d'une Parabola de prostep a partir d'une Parabola de
// Geom2d
//=============================================================================
GeomToStep_MakeParabola::GeomToStep_MakeParabola(const Handle(Geom2d_Parabola)& C)
{
gp_Parab2d gpPar;

71
src/GeomToStep/GeomToStep_MakeParabola.hxx Normal file
View File

@@ -0,0 +1,71 @@
// Created on: 1995-05-04
// Created by: Dieter THIEMANN
// 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 _GeomToStep_MakeParabola_HeaderFile
#define _GeomToStep_MakeParabola_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Parabola;
class StdFail_NotDone;
class Geom2d_Parabola;
class Geom_Parabola;
//! This class implements the mapping between the class
//! Parabola from Geom and the class Parabola from
//! StepGeom which describes a Parabola from ProSTEP
class GeomToStep_MakeParabola : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeParabola(const Handle(Geom2d_Parabola)& C);
Standard_EXPORT GeomToStep_MakeParabola(const Handle(Geom_Parabola)& C);
Standard_EXPORT const Handle(StepGeom_Parabola)& Value() const;
protected:
private:
Handle(StepGeom_Parabola) theParabola;
};
#endif // _GeomToStep_MakeParabola_HeaderFile

48
src/GeomToStep/GeomToStep_MakePlane.cdl
View File

@@ -1,48 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakePlane from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Plane from Geom and Pln from gp, and the class
-- Plane from StepGeom which describes a plane from
-- Prostep.
uses Pln from gp,
Plane from Geom,
Plane from StepGeom
raises NotDone from StdFail
is
Create ( P : Pln from gp ) returns MakePlane;
Create ( P : Plane from Geom ) returns MakePlane;
Value (me) returns Plane from StepGeom
raises NotDone
is static;
---C++: return const&
fields
thePlane : Plane from StepGeom;
-- The solution from StepGeom
end MakePlane;

14
src/GeomToStep/GeomToStep_MakePlane.cxx
View File

@@ -14,20 +14,20 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakePlane.ixx>
#include <GeomToStep_MakePlane.hxx>
#include <StdFail_NotDone.hxx>
#include <gp_Dir.hxx>
#include <Geom_Plane.hxx>
#include <StepGeom_Plane.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakePlane.hxx>
#include <gp_Dir.hxx>
#include <gp_Pln.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_Plane.hxx>
#include <TCollection_HAsciiString.hxx>
//=============================================================================
// Creation d' un plane de prostep a partir d' un Pln de gp
//=============================================================================
GeomToStep_MakePlane::GeomToStep_MakePlane( const gp_Pln& P)
{
Handle(StepGeom_Plane) Plan = new StepGeom_Plane;

72
src/GeomToStep/GeomToStep_MakePlane.hxx Normal file
View File

@@ -0,0 +1,72 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakePlane_HeaderFile
#define _GeomToStep_MakePlane_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Plane;
class StdFail_NotDone;
class gp_Pln;
class Geom_Plane;
//! This class implements the mapping between classes
//! Plane from Geom and Pln from gp, and the class
//! Plane from StepGeom which describes a plane from
//! Prostep.
class GeomToStep_MakePlane : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakePlane(const gp_Pln& P);
Standard_EXPORT GeomToStep_MakePlane(const Handle(Geom_Plane)& P);
Standard_EXPORT const Handle(StepGeom_Plane)& Value() const;
protected:
private:
Handle(StepGeom_Plane) thePlane;
};
#endif // _GeomToStep_MakePlane_HeaderFile

46
src/GeomToStep/GeomToStep_MakePolyline.cdl
View File

@@ -1,46 +0,0 @@
-- Created on: 1993-07-12
-- Created by: Martine LANGLOIS
-- 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 MakePolyline from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between an Array1 of points
-- from gp and a Polyline from StepGeom.
uses Array1OfPnt from TColgp,
Array1OfPnt2d from TColgp,
Polyline from StepGeom
raises NotDone from StdFail
is
Create ( P : Array1OfPnt from TColgp ) returns MakePolyline;
Create ( P : Array1OfPnt2d from TColgp ) returns MakePolyline;
Value (me) returns Polyline from StepGeom
raises NotDone
is static;
---C++: return const&
fields
thePolyline : Polyline from StepGeom;
-- The solution from StepGeom
end MakePolyline;

14
src/GeomToStep/GeomToStep_MakePolyline.cxx
View File

@@ -14,21 +14,21 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakePolyline.ixx>
#include <StdFail_NotDone.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <GeomToStep_MakePolyline.hxx>
#include <gp_Pnt.hxx>
#include <gp_Pnt2d.hxx>
#include <StepGeom_Polyline.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_HArray1OfCartesianPoint.hxx>
#include <GeomToStep_MakeCartesianPoint.hxx>
#include <StepGeom_Polyline.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
#include <TCollection_HAsciiString.hxx>
//=============================================================================
// Creation d' une polyline Step a partir d' une Array1OfPnt
//=============================================================================
GeomToStep_MakePolyline::GeomToStep_MakePolyline( const TColgp_Array1OfPnt& P)
{
gp_Pnt P1;

70
src/GeomToStep/GeomToStep_MakePolyline.hxx Normal file
View File

@@ -0,0 +1,70 @@
// Created on: 1993-07-12
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakePolyline_HeaderFile
#define _GeomToStep_MakePolyline_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
class StepGeom_Polyline;
class StdFail_NotDone;
//! This class implements the mapping between an Array1 of points
//! from gp and a Polyline from StepGeom.
class GeomToStep_MakePolyline : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakePolyline(const TColgp_Array1OfPnt& P);
Standard_EXPORT GeomToStep_MakePolyline(const TColgp_Array1OfPnt2d& P);
Standard_EXPORT const Handle(StepGeom_Polyline)& Value() const;
protected:
private:
Handle(StepGeom_Polyline) thePolyline;
};
#endif // _GeomToStep_MakePolyline_HeaderFile

50
src/GeomToStep/GeomToStep_MakeRectangularTrimmedSurface.cdl
View File

@@ -1,50 +0,0 @@
-- Created on: 1996-01-25
-- Created by: Frederic MAUPAS
-- Copyright (c) 1996-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 MakeRectangularTrimmedSurface from GeomToStep
inherits Root from GeomToStep
---Purpose: This class implements the mapping between class
-- RectangularTrimmedSurface from Geom and the class
-- RectangularTrimmedSurface from
-- StepGeom which describes a
-- rectangular_trimmed_surface from ISO-IS 10303-42
uses RectangularTrimmedSurface from Geom,
RectangularTrimmedSurface from StepGeom
raises NotDone from StdFail
is
Create ( RTSurf : RectangularTrimmedSurface from Geom ) returns
MakeRectangularTrimmedSurface;
Value (me) returns
RectangularTrimmedSurface from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theRectangularTrimmedSurface :
RectangularTrimmedSurface from StepGeom;
-- The solution from StepGeom
end MakeRectangularTrimmedSurface;

20
src/GeomToStep/GeomToStep_MakeRectangularTrimmedSurface.cxx
View File

@@ -14,26 +14,26 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeRectangularTrimmedSurface.ixx>
#include <StdFail_NotDone.hxx>
#include <GeomToStep_MakeSurface.hxx>
#include <StepGeom_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_ConicalSurface.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_RectangularTrimmedSurface.hxx>
#include <Geom_SphericalSurface.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <GeomToStep_MakeRectangularTrimmedSurface.hxx>
#include <GeomToStep_MakeSurface.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_RectangularTrimmedSurface.hxx>
#include <StepGeom_Surface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
#include <Geom_Plane.hxx>
//=============================================================================
// Creation d' une rectangular_trimmed_surface de STEP
// a partir d' une RectangularTrimmedSurface de Geom
//=============================================================================
GeomToStep_MakeRectangularTrimmedSurface::
GeomToStep_MakeRectangularTrimmedSurface( const
Handle(Geom_RectangularTrimmedSurface)& RTSurf )

70
src/GeomToStep/GeomToStep_MakeRectangularTrimmedSurface.hxx Normal file
View File

@@ -0,0 +1,70 @@
// Created on: 1996-01-25
// Created by: Frederic MAUPAS
// Copyright (c) 1996-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 _GeomToStep_MakeRectangularTrimmedSurface_HeaderFile
#define _GeomToStep_MakeRectangularTrimmedSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_RectangularTrimmedSurface;
class StdFail_NotDone;
class Geom_RectangularTrimmedSurface;
//! This class implements the mapping between class
//! RectangularTrimmedSurface from Geom and the class
//! RectangularTrimmedSurface from
//! StepGeom which describes a
//! rectangular_trimmed_surface from ISO-IS 10303-42
class GeomToStep_MakeRectangularTrimmedSurface : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeRectangularTrimmedSurface(const Handle(Geom_RectangularTrimmedSurface)& RTSurf);
Standard_EXPORT const Handle(StepGeom_RectangularTrimmedSurface)& Value() const;
protected:
private:
Handle(StepGeom_RectangularTrimmedSurface) theRectangularTrimmedSurface;
};
#endif // _GeomToStep_MakeRectangularTrimmedSurface_HeaderFile

47
src/GeomToStep/GeomToStep_MakeSphericalSurface.cdl
View File

@@ -1,47 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeSphericalSurface from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between class
-- SphericalSurface from Geom and the class
-- SphericalSurface from StepGeom which describes a
-- spherical_surface from Prostep
uses SphericalSurface from Geom,
SphericalSurface from StepGeom
raises NotDone from StdFail
is
Create ( CSurf : SphericalSurface from Geom ) returns MakeSphericalSurface;
Value (me) returns SphericalSurface from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theSphericalSurface : SphericalSurface from StepGeom;
-- The solution from StepGeom
end MakeSphericalSurface;

10
src/GeomToStep/GeomToStep_MakeSphericalSurface.cxx
View File

@@ -14,11 +14,12 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeSphericalSurface.ixx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StdFail_NotDone.hxx>
#include <Geom_SphericalSurface.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakeSphericalSurface.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_SphericalSurface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
@@ -27,7 +28,6 @@
// Creation d' une conical_surface de prostep a partir d' une SphericalSurface
// de Geom
//=============================================================================
GeomToStep_MakeSphericalSurface::GeomToStep_MakeSphericalSurface
( const Handle(Geom_SphericalSurface)& S )

69
src/GeomToStep/GeomToStep_MakeSphericalSurface.hxx Normal file
View File

@@ -0,0 +1,69 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeSphericalSurface_HeaderFile
#define _GeomToStep_MakeSphericalSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_SphericalSurface;
class StdFail_NotDone;
class Geom_SphericalSurface;
//! This class implements the mapping between class
//! SphericalSurface from Geom and the class
//! SphericalSurface from StepGeom which describes a
//! spherical_surface from Prostep
class GeomToStep_MakeSphericalSurface : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeSphericalSurface(const Handle(Geom_SphericalSurface)& CSurf);
Standard_EXPORT const Handle(StepGeom_SphericalSurface)& Value() const;
protected:
private:
Handle(StepGeom_SphericalSurface) theSphericalSurface;
};
#endif // _GeomToStep_MakeSphericalSurface_HeaderFile

46
src/GeomToStep/GeomToStep_MakeSurface.cdl
View File

@@ -1,46 +0,0 @@
-- Created on: 1993-06-22
-- Created by: Martine LANGLOIS
-- 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 MakeSurface from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Surface from Geom and the class Surface from StepGeom which
-- describes a Surface from prostep. As Surface is an abstract
-- Surface this class is an access to the sub-class required.
uses Surface from Geom,
Surface from StepGeom
raises NotDone from StdFail
is
Create ( C : Surface from Geom ) returns MakeSurface;
Value (me) returns Surface from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theSurface : Surface from StepGeom;
-- The solution from StepGeom
end MakeSurface;

27
src/GeomToStep/GeomToStep_MakeSurface.cxx
View File

@@ -14,28 +14,29 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeSurface.ixx>
#include <Geom_BoundedSurface.hxx>
#include <Geom_ElementarySurface.hxx>
#include <Geom_OffsetSurface.hxx>
#include <Geom_Surface.hxx>
#include <Geom_SweptSurface.hxx>
#include <GeomToStep_MakeBoundedSurface.hxx>
#include <GeomToStep_MakeElementarySurface.hxx>
#include <GeomToStep_MakeSurface.hxx>
#include <GeomToStep_MakeSweptSurface.hxx>
#include <StdFail_NotDone.hxx>
#include <StepData_Logical.hxx>
#include <StepGeom_BoundedSurface.hxx>
#include <StepGeom_ElementarySurface.hxx>
#include <StepGeom_SweptSurface.hxx>
#include <GeomToStep_MakeSurface.hxx>
#include <Geom_BoundedSurface.hxx>
#include <GeomToStep_MakeBoundedSurface.hxx>
#include <Geom_ElementarySurface.hxx>
#include <GeomToStep_MakeElementarySurface.hxx>
#include <Geom_SweptSurface.hxx>
#include <GeomToStep_MakeSweptSurface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <Geom_OffsetSurface.hxx>
#include <StepGeom_OffsetSurface.hxx>
#include <StepData_Logical.hxx>
#include <StepGeom_Surface.hxx>
#include <StepGeom_SweptSurface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
//=============================================================================
// Creation d' une Surface de prostep a partir d' une Surface de Geom
//=============================================================================
GeomToStep_MakeSurface::GeomToStep_MakeSurface ( const Handle(Geom_Surface)& S)
{
done = Standard_True;

69
src/GeomToStep/GeomToStep_MakeSurface.hxx Normal file
View File

@@ -0,0 +1,69 @@
// Created on: 1993-06-22
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeSurface_HeaderFile
#define _GeomToStep_MakeSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Surface;
class StdFail_NotDone;
class Geom_Surface;
//! This class implements the mapping between classes
//! Surface from Geom and the class Surface from StepGeom which
//! describes a Surface from prostep. As Surface is an abstract
//! Surface this class is an access to the sub-class required.
class GeomToStep_MakeSurface : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeSurface(const Handle(Geom_Surface)& C);
Standard_EXPORT const Handle(StepGeom_Surface)& Value() const;
protected:
private:
Handle(StepGeom_Surface) theSurface;
};
#endif // _GeomToStep_MakeSurface_HeaderFile

46
src/GeomToStep/GeomToStep_MakeSurfaceOfLinearExtrusion.cdl
View File

@@ -1,46 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeSurfaceOfLinearExtrusion from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between class
-- SurfaceOfLinearExtrusion from Geom and the class
-- SurfaceOfLinearExtrusion from StepGeom which describes a
-- surface_of_linear_extrusion from Prostep
uses SurfaceOfLinearExtrusion from Geom,
SurfaceOfLinearExtrusion from StepGeom
raises NotDone from StdFail
is
Create ( CSurf : SurfaceOfLinearExtrusion from Geom ) returns
MakeSurfaceOfLinearExtrusion;
Value (me) returns SurfaceOfLinearExtrusion from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theSurfaceOfLinearExtrusion : SurfaceOfLinearExtrusion from StepGeom;
-- The solution from StepGeom
end MakeSurfaceOfLinearExtrusion;

12
src/GeomToStep/GeomToStep_MakeSurfaceOfLinearExtrusion.cxx
View File

@@ -14,14 +14,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeSurfaceOfLinearExtrusion.ixx>
#include <GeomToStep_MakeVector.hxx>
#include <GeomToStep_MakeCurve.hxx>
#include <StdFail_NotDone.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <GeomToStep_MakeCurve.hxx>
#include <GeomToStep_MakeSurfaceOfLinearExtrusion.hxx>
#include <GeomToStep_MakeVector.hxx>
#include <gp_Vec.hxx>
#include <StepGeom_SurfaceOfLinearExtrusion.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Curve.hxx>
#include <StepGeom_SurfaceOfLinearExtrusion.hxx>
#include <StepGeom_Vector.hxx>
#include <TCollection_HAsciiString.hxx>
@@ -29,7 +30,6 @@
// Creation d' une surface_of_linear_extrusion de prostep a partir d' une
// SurfaceOfLinearExtrusion de Geom
//=============================================================================
GeomToStep_MakeSurfaceOfLinearExtrusion::GeomToStep_MakeSurfaceOfLinearExtrusion
( const Handle(Geom_SurfaceOfLinearExtrusion)& S )

69
src/GeomToStep/GeomToStep_MakeSurfaceOfLinearExtrusion.hxx Normal file
View File

@@ -0,0 +1,69 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeSurfaceOfLinearExtrusion_HeaderFile
#define _GeomToStep_MakeSurfaceOfLinearExtrusion_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_SurfaceOfLinearExtrusion;
class StdFail_NotDone;
class Geom_SurfaceOfLinearExtrusion;
//! This class implements the mapping between class
//! SurfaceOfLinearExtrusion from Geom and the class
//! SurfaceOfLinearExtrusion from StepGeom which describes a
//! surface_of_linear_extrusion from Prostep
class GeomToStep_MakeSurfaceOfLinearExtrusion : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeSurfaceOfLinearExtrusion(const Handle(Geom_SurfaceOfLinearExtrusion)& CSurf);
Standard_EXPORT const Handle(StepGeom_SurfaceOfLinearExtrusion)& Value() const;
protected:
private:
Handle(StepGeom_SurfaceOfLinearExtrusion) theSurfaceOfLinearExtrusion;
};
#endif // _GeomToStep_MakeSurfaceOfLinearExtrusion_HeaderFile

46
src/GeomToStep/GeomToStep_MakeSurfaceOfRevolution.cdl
View File

@@ -1,46 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeSurfaceOfRevolution from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between class
-- SurfaceOfRevolution from Geom and the class
-- SurfaceOfRevolution from StepGeom which describes a
-- surface_of_revolution from Prostep
uses SurfaceOfRevolution from Geom,
SurfaceOfRevolution from StepGeom
raises NotDone from StdFail
is
Create ( RevSurf : SurfaceOfRevolution from Geom ) returns
MakeSurfaceOfRevolution;
Value (me) returns SurfaceOfRevolution from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theSurfaceOfRevolution : SurfaceOfRevolution from StepGeom;
-- The solution from StepGeom
end MakeSurfaceOfRevolution;

10
src/GeomToStep/GeomToStep_MakeSurfaceOfRevolution.cxx
View File

@@ -14,14 +14,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeSurfaceOfRevolution.ixx>
#include <Geom_SurfaceOfRevolution.hxx>
#include <GeomToStep_MakeAxis1Placement.hxx>
#include <GeomToStep_MakeCurve.hxx>
#include <GeomToStep_MakeSurfaceOfRevolution.hxx>
#include <gp_Ax1.hxx>
#include <StepGeom_Curve.hxx>
#include <StepGeom_Axis1Placement.hxx>
#include <StdFail_NotDone.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
#include <StepGeom_Axis1Placement.hxx>
#include <StepGeom_Curve.hxx>
#include <StepGeom_SurfaceOfRevolution.hxx>
#include <TCollection_HAsciiString.hxx>
@@ -29,7 +30,6 @@
// Creation d' une surface_of_revolution de prostep a partir d' une
// SurfaceOfRevolution de Geom
//=============================================================================
GeomToStep_MakeSurfaceOfRevolution::GeomToStep_MakeSurfaceOfRevolution
( const Handle(Geom_SurfaceOfRevolution)& S )

69
src/GeomToStep/GeomToStep_MakeSurfaceOfRevolution.hxx Normal file
View File

@@ -0,0 +1,69 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeSurfaceOfRevolution_HeaderFile
#define _GeomToStep_MakeSurfaceOfRevolution_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_SurfaceOfRevolution;
class StdFail_NotDone;
class Geom_SurfaceOfRevolution;
//! This class implements the mapping between class
//! SurfaceOfRevolution from Geom and the class
//! SurfaceOfRevolution from StepGeom which describes a
//! surface_of_revolution from Prostep
class GeomToStep_MakeSurfaceOfRevolution : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeSurfaceOfRevolution(const Handle(Geom_SurfaceOfRevolution)& RevSurf);
Standard_EXPORT const Handle(StepGeom_SurfaceOfRevolution)& Value() const;
protected:
private:
Handle(StepGeom_SurfaceOfRevolution) theSurfaceOfRevolution;
};
#endif // _GeomToStep_MakeSurfaceOfRevolution_HeaderFile

47
src/GeomToStep/GeomToStep_MakeSweptSurface.cdl
View File

@@ -1,47 +0,0 @@
-- Created on: 1993-06-22
-- Created by: Martine LANGLOIS
-- 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 MakeSweptSurface from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- SweptSurface from Geom and the class SweptSurface from
-- StepGeom which describes a SweptSurface from prostep.
-- As SweptSurface is an abstract SweptSurface this class
-- is an access to the sub-class required.
uses SweptSurface from Geom,
SweptSurface from StepGeom
raises NotDone from StdFail
is
Create ( S : SweptSurface from Geom ) returns MakeSweptSurface;
Value (me) returns SweptSurface from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theSweptSurface : SweptSurface from StepGeom;
-- The solution from StepGeom
end MakeSweptSurface;

14
src/GeomToStep/GeomToStep_MakeSweptSurface.cxx
View File

@@ -14,23 +14,23 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeSweptSurface.ixx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_SweptSurface.hxx>
#include <StepGeom_SurfaceOfLinearExtrusion.hxx>
#include <StepGeom_SurfaceOfRevolution.hxx>
#include <GeomToStep_MakeSweptSurface.hxx>
#include <Geom_SurfaceOfLinearExtrusion.hxx>
#include <Geom_SurfaceOfRevolution.hxx>
#include <Geom_SweptSurface.hxx>
#include <GeomToStep_MakeSurfaceOfLinearExtrusion.hxx>
#include <GeomToStep_MakeSurfaceOfRevolution.hxx>
#include <GeomToStep_MakeSweptSurface.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_SurfaceOfLinearExtrusion.hxx>
#include <StepGeom_SurfaceOfRevolution.hxx>
#include <StepGeom_SweptSurface.hxx>
#include <TCollection_HAsciiString.hxx>
//=============================================================================
// Creation d' une SweptSurface de prostep a partir d' une
// SweptSurface de Geom
//=============================================================================
GeomToStep_MakeSweptSurface::GeomToStep_MakeSweptSurface
( const Handle(Geom_SweptSurface)& S)
{

70
src/GeomToStep/GeomToStep_MakeSweptSurface.hxx Normal file
View File

@@ -0,0 +1,70 @@
// Created on: 1993-06-22
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeSweptSurface_HeaderFile
#define _GeomToStep_MakeSweptSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_SweptSurface;
class StdFail_NotDone;
class Geom_SweptSurface;
//! This class implements the mapping between classes
//! SweptSurface from Geom and the class SweptSurface from
//! StepGeom which describes a SweptSurface from prostep.
//! As SweptSurface is an abstract SweptSurface this class
//! is an access to the sub-class required.
class GeomToStep_MakeSweptSurface : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeSweptSurface(const Handle(Geom_SweptSurface)& S);
Standard_EXPORT const Handle(StepGeom_SweptSurface)& Value() const;
protected:
private:
Handle(StepGeom_SweptSurface) theSweptSurface;
};
#endif // _GeomToStep_MakeSweptSurface_HeaderFile

46
src/GeomToStep/GeomToStep_MakeToroidalSurface.cdl
View File

@@ -1,46 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeToroidalSurface from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between class
-- ToroidalSurface from Geom and the class
-- ToroidalSurface from StepGeom which describes a
-- toroidal_surface from Prostep
uses ToroidalSurface from Geom,
ToroidalSurface from StepGeom
raises NotDone from StdFail
is
Create ( TorSurf : ToroidalSurface from Geom ) returns MakeToroidalSurface;
Value (me) returns ToroidalSurface from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theToroidalSurface : ToroidalSurface from StepGeom;
-- The solution from StepGeom
end MakeToroidalSurface;

8
src/GeomToStep/GeomToStep_MakeToroidalSurface.cxx
View File

@@ -14,10 +14,11 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeToroidalSurface.ixx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <StdFail_NotDone.hxx>
#include <Geom_ToroidalSurface.hxx>
#include <GeomToStep_MakeAxis2Placement3d.hxx>
#include <GeomToStep_MakeToroidalSurface.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_ToroidalSurface.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
@@ -26,7 +27,6 @@
// Creation d' une toroidal_surface de prostep a partir d' une ToroidalSurface
// de Geom
//=============================================================================
GeomToStep_MakeToroidalSurface::GeomToStep_MakeToroidalSurface
( const Handle(Geom_ToroidalSurface)& S )

69
src/GeomToStep/GeomToStep_MakeToroidalSurface.hxx Normal file
View File

@@ -0,0 +1,69 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeToroidalSurface_HeaderFile
#define _GeomToStep_MakeToroidalSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_ToroidalSurface;
class StdFail_NotDone;
class Geom_ToroidalSurface;
//! This class implements the mapping between class
//! ToroidalSurface from Geom and the class
//! ToroidalSurface from StepGeom which describes a
//! toroidal_surface from Prostep
class GeomToStep_MakeToroidalSurface : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeToroidalSurface(const Handle(Geom_ToroidalSurface)& TorSurf);
Standard_EXPORT const Handle(StepGeom_ToroidalSurface)& Value() const;
protected:
private:
Handle(StepGeom_ToroidalSurface) theToroidalSurface;
};
#endif // _GeomToStep_MakeToroidalSurface_HeaderFile

54
src/GeomToStep/GeomToStep_MakeVector.cdl
View File

@@ -1,54 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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 MakeVector from GeomToStep inherits Root from GeomToStep
---Purpose: This class implements the mapping between classes
-- Vector from Geom, Geom2d and Vec, Vec2d from gp, and the class
-- Vector from StepGeom which describes a Vector from
-- Prostep.
uses Vec from gp,
Vec2d from gp,
Vector from Geom,
Vector from Geom2d,
Vector from StepGeom
raises NotDone from StdFail
is
Create ( V : Vec from gp ) returns MakeVector;
Create ( V : Vec2d from gp ) returns MakeVector;
Create ( V : Vector from Geom ) returns MakeVector;
Create ( V : Vector from Geom2d ) returns MakeVector;
Value (me) returns Vector from StepGeom
raises NotDone
is static;
---C++: return const&
fields
theVector : Vector from StepGeom;
-- The solution from StepGeom
end MakeVector;

12
src/GeomToStep/GeomToStep_MakeVector.cxx
View File

@@ -14,21 +14,23 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_MakeVector.ixx>
#include <StdFail_NotDone.hxx>
#include <Geom2d_Vector.hxx>
#include <Geom_Vector.hxx>
#include <GeomToStep_MakeDirection.hxx>
#include <GeomToStep_MakeVector.hxx>
#include <gp_Dir.hxx>
#include <gp_Dir2d.hxx>
#include <gp_Vec.hxx>
#include <Geom_Vector.hxx>
#include <gp_Vec2d.hxx>
#include <StdFail_NotDone.hxx>
#include <StepGeom_Vector.hxx>
#include <GeomToStep_MakeDirection.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
//=============================================================================
// Creation d' un vector de prostep a partir d' un Vec de gp
//=============================================================================
GeomToStep_MakeVector::GeomToStep_MakeVector( const gp_Vec& V)
{
gp_Dir D = gp_Dir(V);

78
src/GeomToStep/GeomToStep_MakeVector.hxx Normal file
View File

@@ -0,0 +1,78 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_MakeVector_HeaderFile
#define _GeomToStep_MakeVector_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <GeomToStep_Root.hxx>
class StepGeom_Vector;
class StdFail_NotDone;
class gp_Vec;
class gp_Vec2d;
class Geom_Vector;
class Geom2d_Vector;
//! This class implements the mapping between classes
//! Vector from Geom, Geom2d and Vec, Vec2d from gp, and the class
//! Vector from StepGeom which describes a Vector from
//! Prostep.
class GeomToStep_MakeVector : public GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT GeomToStep_MakeVector(const gp_Vec& V);
Standard_EXPORT GeomToStep_MakeVector(const gp_Vec2d& V);
Standard_EXPORT GeomToStep_MakeVector(const Handle(Geom_Vector)& V);
Standard_EXPORT GeomToStep_MakeVector(const Handle(Geom2d_Vector)& V);
Standard_EXPORT const Handle(StepGeom_Vector)& Value() const;
protected:
private:
Handle(StepGeom_Vector) theVector;
};
#endif // _GeomToStep_MakeVector_HeaderFile

33
src/GeomToStep/GeomToStep_Root.cdl
View File

@@ -1,33 +0,0 @@
-- Created on: 1993-06-14
-- Created by: Martine LANGLOIS
-- 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.
private deferred class Root from GeomToStep
---Purpose : This class implements the common services for
-- all classes of GeomToStep which report error.
is
IsDone(me) returns Boolean
is static;
fields
done : Boolean is protected;
--Equal True if everything is ok, False otherwise.
end Root;

3
src/GeomToStep/GeomToStep_Root.cxx
View File

@@ -14,7 +14,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <GeomToStep_Root.ixx>
#include <GeomToStep_Root.hxx>
Standard_Boolean GeomToStep_Root::IsDone () const
{

62
src/GeomToStep/GeomToStep_Root.hxx Normal file
View File

@@ -0,0 +1,62 @@
// Created on: 1993-06-14
// Created by: Martine LANGLOIS
// 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 _GeomToStep_Root_HeaderFile
#define _GeomToStep_Root_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Boolean.hxx>
//! This class implements the common services for
//! all classes of GeomToStep which report error.
class GeomToStep_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT Standard_Boolean IsDone() const;
protected:
Standard_Boolean done;
private:
};
#endif // _GeomToStep_Root_HeaderFile

16
src/GeomToStep/GeomToStep_WOKSteps.edl
View File

@@ -1,16 +0,0 @@
-- 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.
@set %WOKSteps_UseSourceInclude = "yes";