0024023: Revamp the OCCT Handle -- StepToGeom
authorabv <abv@opencascade.com>
Fri, 3 Jul 2015 08:24:43 +0000 (11:24 +0300)
committerabv <abv@opencascade.com>
Sun, 12 Jul 2015 09:30:39 +0000 (12:30 +0300)
StepToGeom package refactored to avoid C-style casts of handles to derived types.

Instead of 45 classes, each defining single static method, it now defines 45 static methods in the main package class.
Results of conversion are returned in normal way rather than via function parameter.

Conflicts:
src/StepToGeom/StepToGeom_MakeSurfaceOfRevolution.cxx

109 files changed:
src/QABugs/QABugs_19.cxx [changed mode: 0755->0644]
src/STEPControl/STEPControl_ActorRead.cxx
src/StepToGeom/FILES
src/StepToGeom/StepToGeom.cxx [new file with mode: 0644]
src/StepToGeom/StepToGeom.hxx [new file with mode: 0644]
src/StepToGeom/StepToGeom_MakeAxis1Placement.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeAxis1Placement.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeAxis2Placement.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeAxis2Placement.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeAxisPlacement.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeAxisPlacement.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeBSplineCurve.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeBSplineCurve.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeBSplineCurve.pxx
src/StepToGeom/StepToGeom_MakeBSplineCurve2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeBSplineCurve2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeBSplineSurface.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeBSplineSurface.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeBoundedCurve.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeBoundedCurve.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeBoundedCurve2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeBoundedCurve2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeBoundedSurface.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeBoundedSurface.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeCartesianPoint.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeCartesianPoint.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeCartesianPoint2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeCartesianPoint2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeCircle.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeCircle.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeCircle2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeCircle2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeConic.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeConic.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeConic2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeConic2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeConicalSurface.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeConicalSurface.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeCurve.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeCurve.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeCurve2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeCurve2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeCylindricalSurface.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeCylindricalSurface.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeDirection.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeDirection.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeDirection2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeDirection2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeElementarySurface.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeElementarySurface.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeEllipse.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeEllipse.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeEllipse2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeEllipse2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeHyperbola.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeHyperbola.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeHyperbola2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeHyperbola2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeLine.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeLine.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeLine2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeLine2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeParabola.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeParabola.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeParabola2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeParabola2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakePlane.cxx [deleted file]
src/StepToGeom/StepToGeom_MakePlane.hxx [deleted file]
src/StepToGeom/StepToGeom_MakePolyline.cxx [deleted file]
src/StepToGeom/StepToGeom_MakePolyline.hxx [deleted file]
src/StepToGeom/StepToGeom_MakePolyline2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakePolyline2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeRectangularTrimmedSurface.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeRectangularTrimmedSurface.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeSphericalSurface.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeSphericalSurface.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeSurface.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeSurface.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeSurfaceOfLinearExtrusion.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeSurfaceOfLinearExtrusion.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeSurfaceOfRevolution.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeSurfaceOfRevolution.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeSweptSurface.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeSweptSurface.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeToroidalSurface.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeToroidalSurface.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeTransformation2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeTransformation2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeTransformation3d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeTransformation3d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeTrimmedCurve.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeTrimmedCurve.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeTrimmedCurve2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeTrimmedCurve2d.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeVectorWithMagnitude.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeVectorWithMagnitude.hxx [deleted file]
src/StepToGeom/StepToGeom_MakeVectorWithMagnitude2d.cxx [deleted file]
src/StepToGeom/StepToGeom_MakeVectorWithMagnitude2d.hxx [deleted file]
src/StepToGeom/StepToGeom_Root.cxx [deleted file]
src/StepToGeom/StepToGeom_Root.hxx [deleted file]
src/StepToTopoDS/StepToTopoDS_Builder.cxx
src/StepToTopoDS/StepToTopoDS_MakeTransformed.cxx
src/StepToTopoDS/StepToTopoDS_TranslateCompositeCurve.cxx
src/StepToTopoDS/StepToTopoDS_TranslateCurveBoundedSurface.cxx
src/StepToTopoDS/StepToTopoDS_TranslateEdge.cxx
src/StepToTopoDS/StepToTopoDS_TranslateEdgeLoop.cxx
src/StepToTopoDS/StepToTopoDS_TranslateFace.cxx
src/StepToTopoDS/StepToTopoDS_TranslatePolyLoop.cxx
src/StepToTopoDS/StepToTopoDS_TranslateVertex.cxx

old mode 100755 (executable)
new mode 100644 (file)
index dd14e10..2c856b9
@@ -381,12 +381,12 @@ static Standard_Address GeomConvertTest (Standard_Address data)
   GeomConvert_ApproxSurface aGAS (info->surf, 1e-4, GeomAbs_C1, GeomAbs_C1, 9, 9, 100, 1);
   if (!aGAS.IsDone()) {
     cout << "Error: ApproxSurface is not done!" << endl;
-    return Standard_False;
+    return 0;
   }
   const Handle(Geom_BSplineSurface)& aBSurf = aGAS.Surface();
   if (aBSurf.IsNull()) {
     cout << "Error: BSplineSurface is not created!" << endl;
-    return Standard_False;
+    return 0;
   }
   cout << "Number of UPoles:" << aBSurf->NbUPoles();
   if (aBSurf->NbUPoles() == info->nbupoles)
index 3afe546..e7558c8 100644 (file)
@@ -86,8 +86,7 @@
 #include <StepShape_ShapeDefinitionRepresentation.hxx>
 #include <StepShape_ShapeRepresentation.hxx>
 #include <StepShape_ShellBasedSurfaceModel.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeTransformation3d.hxx>
+#include <StepToGeom.hxx>
 #include <StepToTopoDS_Builder.hxx>
 #include <StepToTopoDS_DataMapOfTRI.hxx>
 #include <StepToTopoDS_MakeTransformed.hxx>
@@ -1327,7 +1326,7 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Han
       Handle(StepGeom_CartesianTransformationOperator3d) CartOp =
         Handle(StepGeom_CartesianTransformationOperator3d)::DownCast(mapit->MappingTarget());
       if ( ! CartOp.IsNull() ) {
-        ok = StepToGeom_MakeTransformation3d::Convert( CartOp, Trsf );
+        ok = StepToGeom::MakeTransformation3d (CartOp, Trsf);
       }
       else {
         Handle(StepGeom_Axis2Placement3d) Origin = 
@@ -1658,11 +1657,9 @@ Standard_Boolean STEPControl_ActorRead::ComputeTransformation (const Handle(Step
   // translate axis_placements taking units into account 
   Handle(StepRepr_Representation) oldSRContext = mySRContext;
   if ( OrigContext  != oldSRContext ) PrepareUnits(OrigContext,TP);
-  Handle(Geom_Axis2Placement) theOrig;
-  StepToGeom_MakeAxis2Placement::Convert(org,theOrig);
+  Handle(Geom_Axis2Placement) theOrig = StepToGeom::MakeAxis2Placement (org);
   if ( TargContext  != OrigContext  ) PrepareUnits(TargContext,TP);
-  Handle(Geom_Axis2Placement) theTarg;
-  StepToGeom_MakeAxis2Placement::Convert(trg,theTarg);
+  Handle(Geom_Axis2Placement) theTarg = StepToGeom::MakeAxis2Placement (trg);
   if ( oldSRContext != TargContext  ) PrepareUnits(oldSRContext,TP);
 
   gp_Ax3 ax3Orig(theOrig->Ax2());
@@ -1697,7 +1694,7 @@ Standard_Boolean STEPControl_ActorRead::ComputeSRRWT (const Handle(StepRepr_Repr
     // reset units (by Rep2 - ?)
     Handle(StepRepr_Representation) oldSRContext = mySRContext;
     if ( SRR->Rep2() != oldSRContext ) PrepareUnits(SRR->Rep2(),TP);
-    StepToGeom_MakeTransformation3d::Convert( CartOp, Trsf );
+    StepToGeom::MakeTransformation3d (CartOp, Trsf);
     if ( SRR->Rep2() != oldSRContext ) PrepareUnits(oldSRContext,TP);
     return Trsf.Form() != gp_Identity;
   }
index 81d9d1e..7a57bb0 100755 (executable)
@@ -1,95 +1,3 @@
-StepToGeom_MakeAxis1Placement.cxx
-StepToGeom_MakeAxis1Placement.hxx
-StepToGeom_MakeAxis2Placement.cxx
-StepToGeom_MakeAxis2Placement.hxx
-StepToGeom_MakeAxisPlacement.cxx
-StepToGeom_MakeAxisPlacement.hxx
-StepToGeom_MakeBoundedCurve.cxx
-StepToGeom_MakeBoundedCurve.hxx
-StepToGeom_MakeBoundedCurve2d.cxx
-StepToGeom_MakeBoundedCurve2d.hxx
-StepToGeom_MakeBoundedSurface.cxx
-StepToGeom_MakeBoundedSurface.hxx
-StepToGeom_MakeBSplineCurve.cxx
-StepToGeom_MakeBSplineCurve.hxx
+StepToGeom.cxx
+StepToGeom.hxx
 StepToGeom_MakeBSplineCurve.pxx
-StepToGeom_MakeBSplineCurve2d.cxx
-StepToGeom_MakeBSplineCurve2d.hxx
-StepToGeom_MakeBSplineSurface.cxx
-StepToGeom_MakeBSplineSurface.hxx
-StepToGeom_MakeCartesianPoint.cxx
-StepToGeom_MakeCartesianPoint.hxx
-StepToGeom_MakeCartesianPoint2d.cxx
-StepToGeom_MakeCartesianPoint2d.hxx
-StepToGeom_MakeCircle.cxx
-StepToGeom_MakeCircle.hxx
-StepToGeom_MakeCircle2d.cxx
-StepToGeom_MakeCircle2d.hxx
-StepToGeom_MakeConic.cxx
-StepToGeom_MakeConic.hxx
-StepToGeom_MakeConic2d.cxx
-StepToGeom_MakeConic2d.hxx
-StepToGeom_MakeConicalSurface.cxx
-StepToGeom_MakeConicalSurface.hxx
-StepToGeom_MakeCurve.cxx
-StepToGeom_MakeCurve.hxx
-StepToGeom_MakeCurve2d.cxx
-StepToGeom_MakeCurve2d.hxx
-StepToGeom_MakeCylindricalSurface.cxx
-StepToGeom_MakeCylindricalSurface.hxx
-StepToGeom_MakeDirection.cxx
-StepToGeom_MakeDirection.hxx
-StepToGeom_MakeDirection2d.cxx
-StepToGeom_MakeDirection2d.hxx
-StepToGeom_MakeElementarySurface.cxx
-StepToGeom_MakeElementarySurface.hxx
-StepToGeom_MakeEllipse.cxx
-StepToGeom_MakeEllipse.hxx
-StepToGeom_MakeEllipse2d.cxx
-StepToGeom_MakeEllipse2d.hxx
-StepToGeom_MakeHyperbola.cxx
-StepToGeom_MakeHyperbola.hxx
-StepToGeom_MakeHyperbola2d.cxx
-StepToGeom_MakeHyperbola2d.hxx
-StepToGeom_MakeLine.cxx
-StepToGeom_MakeLine.hxx
-StepToGeom_MakeLine2d.cxx
-StepToGeom_MakeLine2d.hxx
-StepToGeom_MakeParabola.cxx
-StepToGeom_MakeParabola.hxx
-StepToGeom_MakeParabola2d.cxx
-StepToGeom_MakeParabola2d.hxx
-StepToGeom_MakePlane.cxx
-StepToGeom_MakePlane.hxx
-StepToGeom_MakePolyline.cxx
-StepToGeom_MakePolyline.hxx
-StepToGeom_MakePolyline2d.cxx
-StepToGeom_MakePolyline2d.hxx
-StepToGeom_MakeRectangularTrimmedSurface.cxx
-StepToGeom_MakeRectangularTrimmedSurface.hxx
-StepToGeom_MakeSphericalSurface.cxx
-StepToGeom_MakeSphericalSurface.hxx
-StepToGeom_MakeSurface.cxx
-StepToGeom_MakeSurface.hxx
-StepToGeom_MakeSurfaceOfLinearExtrusion.cxx
-StepToGeom_MakeSurfaceOfLinearExtrusion.hxx
-StepToGeom_MakeSurfaceOfRevolution.cxx
-StepToGeom_MakeSurfaceOfRevolution.hxx
-StepToGeom_MakeSweptSurface.cxx
-StepToGeom_MakeSweptSurface.hxx
-StepToGeom_MakeToroidalSurface.cxx
-StepToGeom_MakeToroidalSurface.hxx
-StepToGeom_MakeTransformation2d.cxx
-StepToGeom_MakeTransformation2d.hxx
-StepToGeom_MakeTransformation3d.cxx
-StepToGeom_MakeTransformation3d.hxx
-StepToGeom_MakeTrimmedCurve.cxx
-StepToGeom_MakeTrimmedCurve.hxx
-StepToGeom_MakeTrimmedCurve2d.cxx
-StepToGeom_MakeTrimmedCurve2d.hxx
-StepToGeom_MakeVectorWithMagnitude.cxx
-StepToGeom_MakeVectorWithMagnitude.hxx
-StepToGeom_MakeVectorWithMagnitude2d.cxx
-StepToGeom_MakeVectorWithMagnitude2d.hxx
-StepToGeom_Root.cxx
-StepToGeom_Root.hxx
diff --git a/src/StepToGeom/StepToGeom.cxx b/src/StepToGeom/StepToGeom.cxx
new file mode 100644 (file)
index 0000000..e2a98a2
--- /dev/null
@@ -0,0 +1,2042 @@
+// Created on: 1993-06-15
+// 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.
+
+#include <StepToGeom.hxx>
+
+#include <BRep_Tool.hxx>
+#include <BRepBuilderAPI_MakeFace.hxx>
+#include <ElCLib.hxx>
+
+#include <Geom_Axis1Placement.hxx>
+#include <Geom_Axis2Placement.hxx>
+#include <Geom_BoundedCurve.hxx>
+#include <Geom_BoundedSurface.hxx>
+#include <Geom_BSplineCurve.hxx>
+#include <Geom_BSplineSurface.hxx>
+#include <Geom_CartesianPoint.hxx>
+#include <Geom_Circle.hxx>
+#include <Geom_Conic.hxx>
+#include <Geom_ConicalSurface.hxx>
+#include <Geom_Curve.hxx>
+#include <Geom_CylindricalSurface.hxx>
+#include <Geom_Direction.hxx>
+#include <Geom_ElementarySurface.hxx>
+#include <Geom_Ellipse.hxx>
+#include <Geom_Hyperbola.hxx>
+#include <Geom_Line.hxx>
+#include <Geom_OffsetCurve.hxx>
+#include <Geom_OffsetSurface.hxx>
+#include <Geom_Parabola.hxx>
+#include <Geom_Plane.hxx>
+#include <Geom_RectangularTrimmedSurface.hxx>
+#include <Geom_SphericalSurface.hxx>
+#include <Geom_Surface.hxx>
+#include <Geom_SurfaceOfLinearExtrusion.hxx>
+#include <Geom_SurfaceOfRevolution.hxx>
+#include <Geom_SweptSurface.hxx>
+#include <Geom_ToroidalSurface.hxx>
+#include <Geom_TrimmedCurve.hxx>
+#include <Geom_VectorWithMagnitude.hxx>
+
+#include <Geom2d_AxisPlacement.hxx>
+#include <Geom2d_BoundedCurve.hxx>
+#include <Geom2d_BSplineCurve.hxx>
+#include <Geom2d_CartesianPoint.hxx>
+#include <Geom2d_Circle.hxx>
+#include <Geom2d_Conic.hxx>
+#include <Geom2d_Curve.hxx>
+#include <Geom2d_Direction.hxx>
+#include <Geom2d_Ellipse.hxx>
+#include <Geom2d_Hyperbola.hxx>
+#include <Geom2d_Line.hxx>
+#include <Geom2d_Parabola.hxx>
+#include <Geom2d_TrimmedCurve.hxx>
+#include <Geom2d_VectorWithMagnitude.hxx>
+#include <Geom2dConvert.hxx>
+
+#include <gp_Trsf.hxx>
+#include <gp_Trsf2d.hxx>
+#include <gp_Lin.hxx>
+#include <gp_Lin2d.hxx>
+
+#include <ShapeAlgo.hxx>
+#include <ShapeAlgo_AlgoContainer.hxx>
+#include <ShapeAnalysis_Curve.hxx>
+
+#include <StepGeom_Axis1Placement.hxx>
+#include <StepGeom_Axis2Placement2d.hxx>
+#include <StepGeom_Axis2Placement3d.hxx>
+#include <StepGeom_BoundedCurve.hxx>
+#include <StepGeom_BoundedSurface.hxx>
+#include <StepGeom_BSplineCurve.hxx>
+#include <StepGeom_CartesianPoint.hxx>
+#include <StepGeom_Direction.hxx>
+
+#include <Standard_ErrorHandler.hxx>
+#include <Standard_Failure.hxx>
+
+#include <StepGeom_BezierCurve.hxx>
+#include <StepGeom_BezierSurface.hxx>
+#include <StepGeom_BSplineSurface.hxx>
+#include <StepGeom_BSplineCurveWithKnots.hxx>
+#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
+#include <StepGeom_BSplineSurfaceWithKnots.hxx>
+#include <StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
+#include <StepGeom_Circle.hxx>
+#include <StepGeom_Conic.hxx>
+#include <StepGeom_ConicalSurface.hxx>
+#include <StepGeom_Curve.hxx>
+#include <StepGeom_CurveReplica.hxx>
+#include <StepGeom_CylindricalSurface.hxx>
+#include <StepGeom_ElementarySurface.hxx>
+#include <StepGeom_Ellipse.hxx>
+#include <StepGeom_Hyperbola.hxx>
+#include <StepGeom_Line.hxx>
+#include <StepGeom_OffsetCurve3d.hxx>
+#include <StepGeom_OffsetSurface.hxx>
+#include <StepGeom_Parabola.hxx>
+#include <StepGeom_Plane.hxx>
+#include <StepGeom_Polyline.hxx>
+#include <StepGeom_QuasiUniformCurve.hxx>
+#include <StepGeom_QuasiUniformCurveAndRationalBSplineCurve.hxx>
+#include <StepGeom_QuasiUniformSurface.hxx>
+#include <StepGeom_QuasiUniformSurfaceAndRationalBSplineSurface.hxx>
+#include <StepGeom_RectangularTrimmedSurface.hxx>
+#include <StepGeom_SphericalSurface.hxx>
+#include <StepGeom_Surface.hxx>
+#include <StepGeom_SurfaceCurve.hxx>
+#include <StepGeom_SurfaceOfLinearExtrusion.hxx>
+#include <StepGeom_SurfaceOfRevolution.hxx>
+#include <StepGeom_SurfaceReplica.hxx>
+#include <StepGeom_SweptSurface.hxx>
+#include <StepGeom_ToroidalSurface.hxx>
+#include <StepGeom_CartesianTransformationOperator2d.hxx>
+#include <StepGeom_CartesianTransformationOperator3d.hxx>
+#include <StepGeom_TrimmedCurve.hxx>
+#include <StepGeom_UniformCurve.hxx>
+#include <StepGeom_UniformCurveAndRationalBSplineCurve.hxx>
+#include <StepGeom_UniformSurface.hxx>
+#include <StepGeom_UniformSurfaceAndRationalBSplineSurface.hxx>
+#include <StepGeom_Vector.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Face.hxx>
+
+#include <UnitsMethods.hxx>
+
+//=============================================================================
+// Creation d' un Ax1Placement de Geom a partir d' un axis1_placement de Step
+//=============================================================================
+
+Handle(Geom_Axis1Placement) StepToGeom::MakeAxis1Placement (const Handle(StepGeom_Axis1Placement)& SA)
+{
+  Handle(Geom_CartesianPoint) P = MakeCartesianPoint (SA->Location());
+  if (! P.IsNull())
+  {
+    // sln 22.10.2001. CTS23496: If problems with creation of axis direction occur default direction is used
+    gp_Dir D(0.,0.,1.);
+    if (SA->HasAxis())
+    {
+      Handle(Geom_Direction) D1 = MakeDirection (SA->Axis());
+      if (! D1.IsNull())
+        D = D1->Dir();
+    }
+    return new Geom_Axis1Placement(P->Pnt(),D);
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Axis2Placement de Geom a partir d' un axis2_placement_3d de Step
+//=============================================================================
+
+Handle(Geom_Axis2Placement) StepToGeom::MakeAxis2Placement (const Handle(StepGeom_Axis2Placement3d)& SA)
+{
+  Handle(Geom_CartesianPoint) P = MakeCartesianPoint (SA->Location());
+  if (! P.IsNull())
+  {
+    const gp_Pnt Pgp = P->Pnt();
+
+    // sln 22.10.2001. CTS23496: If problems with creation of direction occur default direction is used (MakeLine(...) function)
+    gp_Dir Ngp(0.,0.,1.);
+    if (SA->HasAxis())
+    {
+      Handle(Geom_Direction) D = MakeDirection (SA->Axis());
+      if (! D.IsNull())
+        Ngp = D->Dir();
+    }
+
+    gp_Ax2 gpAx2;
+    Standard_Boolean isDefaultDirectionUsed = Standard_True;
+    if (SA->HasRefDirection())
+    {
+      Handle(Geom_Direction) D = MakeDirection (SA->RefDirection());
+      if (! D.IsNull())
+      {
+        const gp_Dir Vxgp = D->Dir();
+        if (!Ngp.IsParallel(Vxgp,Precision::Angular()))
+        {
+          gpAx2 = gp_Ax2(Pgp, Ngp, Vxgp);
+          isDefaultDirectionUsed = Standard_False;
+        }
+      }
+    }
+    if(isDefaultDirectionUsed)
+      gpAx2 = gp_Ax2(Pgp, Ngp);
+
+    return new Geom_Axis2Placement(gpAx2);
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un AxisPlacement de Geom2d a partir d' un axis2_placement_3d de Step
+//=============================================================================
+
+Handle(Geom2d_AxisPlacement) StepToGeom::MakeAxisPlacement (const Handle(StepGeom_Axis2Placement2d)& SA)
+{
+  Handle(Geom2d_CartesianPoint) P = MakeCartesianPoint2d (SA->Location());
+  if (! P.IsNull())
+  {
+    // sln 23.10.2001. CTS23496: If problems with creation of direction occur default direction is used
+    gp_Dir2d Vxgp(1.,0.);
+    if (SA->HasRefDirection()) {
+      Handle(Geom2d_Direction) Vx = MakeDirection2d (SA->RefDirection());
+      if (! Vx.IsNull())
+        Vxgp = Vx->Dir2d();
+    }
+
+    return new Geom2d_AxisPlacement(P->Pnt2d(),Vxgp);
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une BoundedCurve de Geom a partir d' une BoundedCurve de Step
+//=============================================================================
+
+Handle(Geom_BoundedCurve) StepToGeom::MakeBoundedCurve (const Handle(StepGeom_BoundedCurve)& SC)
+{
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)))
+  {
+    return MakeBSplineCurve (Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_BSplineCurveWithKnots)))
+  {
+    return MakeBSplineCurve (Handle(StepGeom_BSplineCurveWithKnots)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_TrimmedCurve)))
+  {
+    return MakeTrimmedCurve (Handle(StepGeom_TrimmedCurve)::DownCast(SC));
+  }
+
+  // STEP BezierCurve, UniformCurve and QuasiUniformCurve are transformed into
+  // STEP BSplineCurve before being mapped onto CAS.CADE/SF
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_BezierCurve)))
+  {
+    const Handle(StepGeom_BezierCurve) BzC = Handle(StepGeom_BezierCurve)::DownCast(SC);
+    Standard_Integer aDegree = BzC->Degree();
+    if (aDegree < 1 || aDegree > Geom_BSplineCurve::MaxDegree())
+      return 0;
+    const Handle(StepGeom_BSplineCurveWithKnots) BSPL = new StepGeom_BSplineCurveWithKnots;
+    BSPL->SetDegree(aDegree);
+    BSPL->SetControlPointsList(BzC->ControlPointsList());
+    BSPL->SetCurveForm(BzC->CurveForm());
+    BSPL->SetClosedCurve(BzC->ClosedCurve());
+    BSPL->SetSelfIntersect(BzC->SelfIntersect());
+    // Compute Knots and KnotsMultiplicity
+    const Handle(TColStd_HArray1OfInteger) Kmult = new TColStd_HArray1OfInteger(1,2);
+    const Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(1,2);
+    Kmult->SetValue(1, BzC->Degree() + 1);
+    Kmult->SetValue(2, BzC->Degree() + 1);
+    Knots->SetValue(1, 0.);
+    Knots->SetValue(2, 1.);
+    BSPL->SetKnotMultiplicities(Kmult);
+    BSPL->SetKnots(Knots);
+
+    return MakeBSplineCurve (BSPL);
+  }
+
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_UniformCurve)))
+  {
+    const Handle(StepGeom_UniformCurve) UC = Handle(StepGeom_UniformCurve)::DownCast(SC);
+    Standard_Integer aDegree = UC->Degree();
+    if (aDegree < 1 || aDegree > Geom_BSplineCurve::MaxDegree())
+      return 0;
+    const Handle(StepGeom_BSplineCurveWithKnots) BSPL = new StepGeom_BSplineCurveWithKnots;
+    BSPL->SetDegree(aDegree);
+    BSPL->SetControlPointsList(UC->ControlPointsList());
+    BSPL->SetCurveForm(UC->CurveForm());
+    BSPL->SetClosedCurve(UC->ClosedCurve());
+    BSPL->SetSelfIntersect(UC->SelfIntersect());
+
+    // Compute Knots and KnotsMultiplicity
+    const Standard_Integer nbK = BSPL->NbControlPointsList() + BSPL->Degree() + 1;
+    const Handle(TColStd_HArray1OfInteger) Kmult = new TColStd_HArray1OfInteger(1,nbK);
+    const Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(1,nbK);
+    for (Standard_Integer iUC = 1 ; iUC <= nbK ; iUC ++) {
+      Kmult->SetValue(iUC, 1);
+      Knots->SetValue(iUC, iUC - 1.);
+    }
+    BSPL->SetKnotMultiplicities(Kmult);
+    BSPL->SetKnots(Knots);
+
+    return MakeBSplineCurve (BSPL);
+  }
+
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_QuasiUniformCurve)))
+  {
+    const Handle(StepGeom_QuasiUniformCurve) QUC =
+      Handle(StepGeom_QuasiUniformCurve)::DownCast(SC);
+    Standard_Integer aDegree = QUC->Degree();
+    if (aDegree < 1 || aDegree > Geom_BSplineCurve::MaxDegree())
+      return 0;
+    const Handle(StepGeom_BSplineCurveWithKnots) BSPL = new StepGeom_BSplineCurveWithKnots;
+    BSPL->SetDegree(aDegree);
+    BSPL->SetControlPointsList(QUC->ControlPointsList());
+    BSPL->SetCurveForm(QUC->CurveForm());
+    BSPL->SetClosedCurve(QUC->ClosedCurve());
+    BSPL->SetSelfIntersect(QUC->SelfIntersect());
+
+    // Compute Knots and KnotsMultiplicity
+    const Standard_Integer nbK = BSPL->NbControlPointsList() - BSPL->Degree() + 1;
+    const Handle(TColStd_HArray1OfInteger) Kmult = new TColStd_HArray1OfInteger(1,nbK);
+    const Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(1,nbK);
+    for (Standard_Integer iQUC = 1 ; iQUC <= nbK ; iQUC ++) {
+      Kmult->SetValue(iQUC, 1);
+      Knots->SetValue(iQUC, iQUC - 1.);
+    }
+    Kmult->SetValue(1, BSPL->Degree() + 1);
+    Kmult->SetValue(nbK, BSPL->Degree() + 1);
+    BSPL->SetKnotMultiplicities(Kmult);
+    BSPL->SetKnots(Knots);
+
+    return MakeBSplineCurve (BSPL);
+  }
+
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_UniformCurveAndRationalBSplineCurve)))
+  {
+    const Handle(StepGeom_UniformCurveAndRationalBSplineCurve) RUC =
+      Handle(StepGeom_UniformCurveAndRationalBSplineCurve)::DownCast(SC);
+    Standard_Integer aDegree = RUC->Degree();
+    if (aDegree < 1 || aDegree > Geom_BSplineCurve::MaxDegree())
+      return 0;
+    const Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve) RBSPL =
+      new StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve;
+
+    // Compute Knots and KnotsMultiplicity
+    const Standard_Integer nbK = RUC->NbControlPointsList() + aDegree + 1;
+    const Handle(TColStd_HArray1OfInteger) Kmult = new TColStd_HArray1OfInteger(1,nbK);
+    const Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(1,nbK);
+    for (Standard_Integer iUC = 1 ; iUC <= nbK ; iUC ++) {
+      Kmult->SetValue(iUC, 1);
+      Knots->SetValue(iUC, iUC - 1.);
+    }
+
+    // Initialize the BSplineCurveWithKnotsAndRationalBSplineCurve
+    RBSPL->Init(RUC->Name(), aDegree, RUC->ControlPointsList(), RUC->CurveForm(),
+               RUC->ClosedCurve(), RUC->SelfIntersect(), Kmult, Knots, StepGeom_ktUnspecified,
+               RUC->WeightsData());
+
+    return MakeBSplineCurve (RBSPL);
+  }
+
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_QuasiUniformCurveAndRationalBSplineCurve)))
+  {
+    const Handle(StepGeom_QuasiUniformCurveAndRationalBSplineCurve) RQUC =
+      Handle(StepGeom_QuasiUniformCurveAndRationalBSplineCurve)::DownCast(SC);
+    Standard_Integer aDegree = RQUC->Degree();
+    if (aDegree < 1 || aDegree > Geom_BSplineCurve::MaxDegree())
+      return 0;
+    const Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve) RBSPL =
+      new StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve;
+
+    // Compute Knots and KnotsMultiplicity
+    const Standard_Integer nbK = RQUC->NbControlPointsList() - aDegree + 1;
+    const Handle(TColStd_HArray1OfInteger) Kmult = new TColStd_HArray1OfInteger(1,nbK);
+    const Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(1,nbK);
+    for (Standard_Integer iRQUC = 1 ; iRQUC <= nbK ; iRQUC ++) {
+      Kmult->SetValue(iRQUC, 1);
+      Knots->SetValue(iRQUC, iRQUC - 1.);
+    }
+    Kmult->SetValue(1, aDegree + 1);
+    Kmult->SetValue(nbK, aDegree + 1);
+    // Initialize the BSplineCurveWithKnotsAndRationalBSplineCurve
+    RBSPL->Init(RQUC->Name(), aDegree, RQUC->ControlPointsList(), RQUC->CurveForm(),
+               RQUC->ClosedCurve(), RQUC->SelfIntersect(), Kmult, Knots, StepGeom_ktUnspecified,
+               RQUC->WeightsData());
+
+    return MakeBSplineCurve (RBSPL);
+  }
+
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Polyline)))
+  { //:n6 abv 15 Feb 99
+    return MakePolyline (Handle(StepGeom_Polyline)::DownCast (SC));
+  }
+
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une BoundedCurve de Geom a partir d' une BoundedCurve de Step
+//=============================================================================
+
+Handle(Geom2d_BoundedCurve) StepToGeom::MakeBoundedCurve2d (const Handle(StepGeom_BoundedCurve)& SC)
+{
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)))
+  {
+    return MakeBSplineCurve2d (Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_BSplineCurveWithKnots)))
+  {
+    return MakeBSplineCurve2d (Handle(StepGeom_BSplineCurveWithKnots)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_TrimmedCurve)))
+  {
+    return MakeTrimmedCurve2d (Handle(StepGeom_TrimmedCurve)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Polyline)))
+  { //:n6 abv 15 Feb 99
+    return MakePolyline2d (Handle(StepGeom_Polyline)::DownCast(SC));
+  }
+  return Handle(Geom2d_BoundedCurve)();
+}
+
+//=============================================================================
+// Creation d' une BoundedSurface de Geom a partir d' une BoundedSurface de Step
+//=============================================================================
+
+Handle(Geom_BoundedSurface) StepToGeom::MakeBoundedSurface (const Handle(StepGeom_BoundedSurface)& SS)
+{
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface)))
+  {
+    return MakeBSplineSurface (Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface)::DownCast(SS));
+  }
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_BSplineSurfaceWithKnots)))
+  {
+    return MakeBSplineSurface (Handle(StepGeom_BSplineSurfaceWithKnots)::DownCast(SS));
+  }
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_RectangularTrimmedSurface)))
+  {
+    return MakeRectangularTrimmedSurface (Handle(StepGeom_RectangularTrimmedSurface)::DownCast(SS));
+  }
+
+  // STEP BezierSurface, UniformSurface and QuasiUniformSurface are transformed
+  // into STEP BSplineSurface before being mapped onto CAS.CADE/SF
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_BezierSurface))) {
+    const Handle(StepGeom_BezierSurface) BzS = Handle(StepGeom_BezierSurface)::DownCast(SS);
+    const Handle(StepGeom_BSplineSurfaceWithKnots) BSPL = new StepGeom_BSplineSurfaceWithKnots;
+    BSPL->SetUDegree(BzS->UDegree());
+    BSPL->SetVDegree(BzS->VDegree());
+    BSPL->SetControlPointsList(BzS->ControlPointsList());
+    BSPL->SetSurfaceForm(BzS->SurfaceForm());
+    BSPL->SetUClosed(BzS->UClosed());
+    BSPL->SetVClosed(BzS->VClosed());
+    BSPL->SetSelfIntersect(BzS->SelfIntersect());
+
+    // Compute Knots and KnotsMultiplicity
+    const Handle(TColStd_HArray1OfInteger) UKmult = new TColStd_HArray1OfInteger(1,2);
+    const Handle(TColStd_HArray1OfInteger) VKmult = new TColStd_HArray1OfInteger(1,2);
+    const Handle(TColStd_HArray1OfReal) UKnots = new TColStd_HArray1OfReal(1,2);
+    const Handle(TColStd_HArray1OfReal) VKnots = new TColStd_HArray1OfReal(1,2);
+    UKmult->SetValue(1, BzS->UDegree() + 1);
+    UKmult->SetValue(2, BzS->UDegree() + 1);
+    VKmult->SetValue(1, BzS->VDegree() + 1);
+    VKmult->SetValue(2, BzS->VDegree() + 1);
+    UKnots->SetValue(1, 0.);
+    UKnots->SetValue(2, 1.);
+    VKnots->SetValue(1, 0.);
+    VKnots->SetValue(2, 1.);
+    BSPL->SetUMultiplicities(UKmult);
+    BSPL->SetVMultiplicities(VKmult);
+    BSPL->SetUKnots(UKnots);
+    BSPL->SetVKnots(VKnots);
+
+    return MakeBSplineSurface (BSPL);
+  }
+
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_UniformSurface)))
+  {
+    const Handle(StepGeom_UniformSurface) US = Handle(StepGeom_UniformSurface)::DownCast(SS);
+    const Handle(StepGeom_BSplineSurfaceWithKnots) BSPL = new StepGeom_BSplineSurfaceWithKnots;
+    BSPL->SetUDegree(US->UDegree());
+    BSPL->SetVDegree(US->VDegree());
+    BSPL->SetControlPointsList(US->ControlPointsList());
+    BSPL->SetSurfaceForm(US->SurfaceForm());
+    BSPL->SetUClosed(US->UClosed());
+    BSPL->SetVClosed(US->VClosed());
+    BSPL->SetSelfIntersect(US->SelfIntersect());
+
+    // Compute Knots and KnotsMultiplicity for U Direction
+    const Standard_Integer nbKU = BSPL->NbControlPointsListI() + BSPL->UDegree() + 1;
+    const Handle(TColStd_HArray1OfInteger) UKmult = new TColStd_HArray1OfInteger(1,nbKU);
+    const Handle(TColStd_HArray1OfReal) UKnots = new TColStd_HArray1OfReal(1,nbKU);
+    for (Standard_Integer iU = 1 ; iU <= nbKU ; iU ++) {
+      UKmult->SetValue(iU, 1);
+      UKnots->SetValue(iU, iU - 1.);
+    }
+    BSPL->SetUMultiplicities(UKmult);
+    BSPL->SetUKnots(UKnots);
+
+    // Compute Knots and KnotsMultiplicity for V Direction
+    const Standard_Integer nbKV = BSPL->NbControlPointsListJ() + BSPL->VDegree() + 1;
+    const Handle(TColStd_HArray1OfInteger) VKmult = new TColStd_HArray1OfInteger(1,nbKV);
+    const Handle(TColStd_HArray1OfReal) VKnots = new TColStd_HArray1OfReal(1,nbKV);
+    for (Standard_Integer iV = 1 ; iV <= nbKV ; iV ++) {
+      VKmult->SetValue(iV, 1);
+      VKnots->SetValue(iV, iV - 1.);
+    }
+    BSPL->SetVMultiplicities(VKmult);
+    BSPL->SetVKnots(VKnots);
+
+    return MakeBSplineSurface (BSPL);
+  }
+
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_QuasiUniformSurface)))
+  {
+    const Handle(StepGeom_QuasiUniformSurface) QUS =
+      Handle(StepGeom_QuasiUniformSurface)::DownCast(SS);
+    const Handle(StepGeom_BSplineSurfaceWithKnots) BSPL = new StepGeom_BSplineSurfaceWithKnots;
+    BSPL->SetUDegree(QUS->UDegree());
+    BSPL->SetVDegree(QUS->VDegree());
+    BSPL->SetControlPointsList(QUS->ControlPointsList());
+    BSPL->SetSurfaceForm(QUS->SurfaceForm());
+    BSPL->SetUClosed(QUS->UClosed());
+    BSPL->SetVClosed(QUS->VClosed());
+    BSPL->SetSelfIntersect(QUS->SelfIntersect());
+
+    // Compute Knots and KnotsMultiplicity for U Direction
+    const Standard_Integer nbKU = BSPL->NbControlPointsListI() - BSPL->UDegree() + 1;
+    const Handle(TColStd_HArray1OfInteger) UKmult = new TColStd_HArray1OfInteger(1,nbKU);
+    const Handle(TColStd_HArray1OfReal) UKnots = new TColStd_HArray1OfReal(1,nbKU);
+    for (Standard_Integer iU = 1 ; iU <= nbKU ; iU ++) {
+      UKmult->SetValue(iU, 1);
+      UKnots->SetValue(iU, iU - 1.);
+    }
+    UKmult->SetValue(1, BSPL->UDegree() + 1);
+    UKmult->SetValue(nbKU, BSPL->UDegree() + 1);
+    BSPL->SetUMultiplicities(UKmult);
+    BSPL->SetUKnots(UKnots);
+
+    // Compute Knots and KnotsMultiplicity for V Direction
+    const Standard_Integer nbKV = BSPL->NbControlPointsListJ() - BSPL->VDegree() + 1;
+    const Handle(TColStd_HArray1OfInteger) VKmult = new TColStd_HArray1OfInteger(1,nbKV);
+    const Handle(TColStd_HArray1OfReal) VKnots = new TColStd_HArray1OfReal(1,nbKV);
+    for (Standard_Integer iV = 1 ; iV <= nbKV ; iV ++) {
+      VKmult->SetValue(iV, 1);
+      VKnots->SetValue(iV, iV - 1.);
+    }
+    VKmult->SetValue(1, BSPL->VDegree() + 1);
+    VKmult->SetValue(nbKV, BSPL->VDegree() + 1);
+    BSPL->SetVMultiplicities(VKmult);
+    BSPL->SetVKnots(VKnots);
+
+    return MakeBSplineSurface (BSPL);
+  }
+
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_UniformSurfaceAndRationalBSplineSurface)))
+  {
+    const Handle(StepGeom_UniformSurfaceAndRationalBSplineSurface) RUS =
+      Handle(StepGeom_UniformSurfaceAndRationalBSplineSurface)::DownCast(SS);
+    const Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) RBSPL =
+      new StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface;
+
+    // Compute Knots and KnotsMultiplicity for U Direction
+    const Standard_Integer nbKU = RUS->NbControlPointsListI() + RUS->UDegree() + 1;
+    const Handle(TColStd_HArray1OfInteger) UKmult = new TColStd_HArray1OfInteger(1,nbKU);
+    const Handle(TColStd_HArray1OfReal) UKnots = new TColStd_HArray1OfReal(1,nbKU);
+    for (Standard_Integer iU = 1 ; iU <= nbKU ; iU ++) {
+      UKmult->SetValue(iU, 1);
+      UKnots->SetValue(iU, iU - 1.);
+    }
+
+    // Compute Knots and KnotsMultiplicity for V Direction
+    const Standard_Integer nbKV = RUS->NbControlPointsListJ() + RUS->VDegree() + 1;
+    const Handle(TColStd_HArray1OfInteger) VKmult = new TColStd_HArray1OfInteger(1,nbKV);
+    const Handle(TColStd_HArray1OfReal) VKnots = new TColStd_HArray1OfReal(1,nbKV);
+    for (Standard_Integer iV = 1 ; iV <= nbKV ; iV ++) {
+      VKmult->SetValue(iV, 1);
+      VKnots->SetValue(iV, iV - 1.);
+    }
+
+    // Initialize the BSplineSurfaceWithKnotsAndRationalBSplineSurface
+    RBSPL->Init(RUS->Name(), RUS->UDegree(), RUS->VDegree(),
+               RUS->ControlPointsList(), RUS->SurfaceForm(),
+               RUS->UClosed(), RUS->VClosed(), RUS->SelfIntersect(),
+               UKmult, VKmult, UKnots, VKnots, StepGeom_ktUnspecified,
+               RUS->WeightsData());
+
+    return MakeBSplineSurface (RBSPL);
+  }
+
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_QuasiUniformSurfaceAndRationalBSplineSurface)))
+  {
+    const Handle(StepGeom_QuasiUniformSurfaceAndRationalBSplineSurface) RQUS =
+      Handle(StepGeom_QuasiUniformSurfaceAndRationalBSplineSurface)::DownCast(SS);
+    const Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) RBSPL =
+      new StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface;
+
+    // Compute Knots and KnotsMultiplicity for U Direction
+    const Standard_Integer nbKU = RQUS->NbControlPointsListI() - RQUS->UDegree() + 1;
+    const Handle(TColStd_HArray1OfInteger) UKmult = new TColStd_HArray1OfInteger(1,nbKU);
+    const Handle(TColStd_HArray1OfReal) UKnots = new TColStd_HArray1OfReal(1,nbKU);
+    for (Standard_Integer iU = 1 ; iU <= nbKU ; iU ++) {
+      UKmult->SetValue(iU, 1);
+      UKnots->SetValue(iU, iU - 1.);
+    }
+    UKmult->SetValue(1, RQUS->UDegree() + 1);
+    UKmult->SetValue(nbKU, RQUS->UDegree() + 1);
+
+    // Compute Knots and KnotsMultiplicity for V Direction
+    const Standard_Integer nbKV = RQUS->NbControlPointsListJ() - RQUS->VDegree() + 1;
+    const Handle(TColStd_HArray1OfInteger) VKmult = new TColStd_HArray1OfInteger(1,nbKV);
+    const Handle(TColStd_HArray1OfReal) VKnots = new TColStd_HArray1OfReal(1,nbKV);
+    for (Standard_Integer iV = 1 ; iV <= nbKV ; iV ++) {
+      VKmult->SetValue(iV, 1);
+      VKnots->SetValue(iV, iV - 1.);
+    }
+    VKmult->SetValue(1, RQUS->VDegree() + 1);
+    VKmult->SetValue(nbKV, RQUS->VDegree() + 1);
+
+    // Initialize the BSplineSurfaceWithKnotsAndRationalBSplineSurface
+    RBSPL->Init(RQUS->Name(), RQUS->UDegree(), RQUS->VDegree(), RQUS->ControlPointsList(),
+               RQUS->SurfaceForm(), RQUS->UClosed(), RQUS->VClosed(),
+               RQUS->SelfIntersect(), UKmult, VKmult, UKnots, VKnots, StepGeom_ktUnspecified,
+               RQUS->WeightsData());
+    return MakeBSplineSurface (RBSPL);
+  }
+
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une BSplineCurve de Geom a partir d' une BSplineCurve de Step
+//=============================================================================
+
+Handle(Geom_BSplineCurve) StepToGeom::MakeBSplineCurve (const Handle(StepGeom_BSplineCurve)& SC)
+{
+#define Array1OfPnt_gen                  TColgp_Array1OfPnt
+#define Pnt_gen                          gp_Pnt
+#define Pnt_fonc                         Pnt
+#define CartesianPoint_gen               Handle(Geom_CartesianPoint)
+#define MakeCartesianPoint_gen MakeCartesianPoint
+#define BSplineCurve_gen                 Geom_BSplineCurve
+#define BSplineCurve_retour              Handle(Geom_BSplineCurve)
+#define MakeBSplineCurve_gen   MakeBSplineCurve
+#include "StepToGeom_MakeBSplineCurve.pxx"
+#undef Array1OfPnt_gen
+#undef Pnt_gen
+#undef Pnt_fonc
+#undef CartesianPoint_gen
+#undef MakeCartesianPoint_gen
+#undef BSplineCurve_gen
+#undef MakeBSplineCurve_gen
+#undef BSplineCurve_retour
+}
+
+//=============================================================================
+// Creation d' une BSplineCurve de Geom2d a partir d' une
+// BSplineCurveWithKnotsAndRationalBSplineCurve de Step
+//=============================================================================
+
+Handle(Geom2d_BSplineCurve) StepToGeom::MakeBSplineCurve2d (const Handle(StepGeom_BSplineCurve)& SC)
+{
+#define Array1OfPnt_gen                  TColgp_Array1OfPnt2d
+#define Pnt_gen                          gp_Pnt2d
+#define CartesianPoint_gen               Handle(Geom2d_CartesianPoint)
+#define MakeCartesianPoint_gen MakeCartesianPoint2d
+#define Pnt_fonc                         Pnt2d
+#define BSplineCurve_gen                 Geom2d_BSplineCurve
+#define BSplineCurve_retour              Handle(Geom2d_BSplineCurve)
+#define MakeBSplineCurve_gen   MakeBSplineCurve2d
+#include "StepToGeom_MakeBSplineCurve.pxx"
+#undef Array1OfPnt_gen
+#undef Pnt_gen
+#undef CartesianPoint_gen
+#undef MakeCartesianPoint_gen
+#undef Pnt_fonc
+#undef BSplineCurve_gen
+#undef MakeBSplineCurve_gen
+#undef BSplineCurve_retour
+}
+
+//=============================================================================
+// Creation d' une BSplineSurface de Geom a partir d' une
+// BSplineSurface de Step
+//=============================================================================
+
+Handle(Geom_BSplineSurface) StepToGeom::MakeBSplineSurface (const Handle(StepGeom_BSplineSurface)& SS)
+{
+  Standard_Integer                    i, j;
+  Handle(StepGeom_BSplineSurfaceWithKnots) BS;
+  Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) BSR;
+
+  if (SS->
+      IsKind(STANDARD_TYPE(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface))) {
+    BSR =
+      Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface)
+       ::DownCast(SS);
+    BS =
+      Handle(StepGeom_BSplineSurfaceWithKnots)
+       ::DownCast(BSR->BSplineSurfaceWithKnots());
+  }
+  else
+    BS = Handle(StepGeom_BSplineSurfaceWithKnots)::DownCast(SS);
+
+  const Standard_Integer UDeg = BS->UDegree();
+  const Standard_Integer VDeg = BS->VDegree();
+  const Standard_Integer NUPoles = BS->NbControlPointsListI();
+  const Standard_Integer NVPoles = BS->NbControlPointsListJ();
+  const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList = BS->ControlPointsList();
+  TColgp_Array2OfPnt Poles(1,NUPoles,1,NVPoles);
+  for (i=1; i<=NUPoles; i++) {
+    for (j=1; j<=NVPoles; j++) {
+      Handle(Geom_CartesianPoint) P = MakeCartesianPoint (aControlPointsList->Value(i,j));
+      if (! P.IsNull())
+        Poles.SetValue(i,j,P->Pnt());
+      else
+        return 0;
+    }
+  }
+  const Standard_Integer NUKnots = BS->NbUMultiplicities();
+  const Handle(TColStd_HArray1OfInteger)& aUMultiplicities = BS->UMultiplicities();
+  const Handle(TColStd_HArray1OfReal)& aUKnots = BS->UKnots();
+
+  // count number of unique uknots
+  Standard_Real lastKnot = RealFirst();
+  Standard_Integer NUKnotsUnique = 0;
+  for (i=1; i<=NUKnots; i++) {
+    if (aUKnots->Value(i) - lastKnot > Epsilon (Abs(lastKnot))) {
+      NUKnotsUnique++;
+      lastKnot = aUKnots->Value(i);
+    }
+  }
+
+  // set umultiplicities and uknots
+  TColStd_Array1OfInteger UMult(1,NUKnotsUnique);
+  TColStd_Array1OfReal KUn(1,NUKnotsUnique);
+  Standard_Integer pos = 1;
+  lastKnot = aUKnots->Value(1);
+  KUn.SetValue(1, aUKnots->Value(1));
+  UMult.SetValue(1, aUMultiplicities->Value(1));
+  for (i=2; i<=NUKnots; i++) {
+    if (aUKnots->Value(i) - lastKnot > Epsilon (Abs(lastKnot))) {
+      pos++;
+      KUn.SetValue(pos, aUKnots->Value(i));
+      UMult.SetValue(pos, aUMultiplicities->Value(i));
+      lastKnot = aUKnots->Value(i);
+    }
+    else {
+      // Knot not unique, increase multiplicity
+      Standard_Integer curMult = UMult.Value(pos);
+      UMult.SetValue(pos, curMult + aUMultiplicities->Value(i));
+    }
+  }
+  const Standard_Integer NVKnots = BS->NbVMultiplicities();
+  const Handle(TColStd_HArray1OfInteger)& aVMultiplicities = BS->VMultiplicities();
+  const Handle(TColStd_HArray1OfReal)& aVKnots = BS->VKnots();
+
+  // count number of unique vknots
+  lastKnot = RealFirst();
+  Standard_Integer NVKnotsUnique = 0;
+  for (i=1; i<=NVKnots; i++) {
+    if (aVKnots->Value(i) - lastKnot > Epsilon (Abs(lastKnot))) {
+      NVKnotsUnique++;
+      lastKnot = aVKnots->Value(i);
+    }
+  }
+
+  // set vmultiplicities and vknots
+  TColStd_Array1OfInteger VMult(1,NVKnotsUnique);
+  TColStd_Array1OfReal KVn(1,NVKnotsUnique);
+  pos = 1;
+  lastKnot = aVKnots->Value(1);
+  KVn.SetValue(1, aVKnots->Value(1));
+  VMult.SetValue(1, aVMultiplicities->Value(1));
+  for (i=2; i<=NVKnots; i++) {
+    if (aVKnots->Value(i) - lastKnot > Epsilon (Abs(lastKnot))) {
+      pos++;
+      KVn.SetValue(pos, aVKnots->Value(i));
+      VMult.SetValue(pos, aVMultiplicities->Value(i));
+      lastKnot = aVKnots->Value(i);
+    }
+    else {
+      // Knot not unique, increase multiplicity
+      Standard_Integer curMult = VMult.Value(pos);
+      VMult.SetValue(pos, curMult + aVMultiplicities->Value(i));
+    }
+  }
+
+  // --- Does the Surface Descriptor LOOKS like a U and/or V Periodic ---
+  // --- Descriptor ? ---
+
+  // --- U Periodic ? ---
+
+  Standard_Integer SumMult = 0;
+  for (i=1; i<=NUKnotsUnique; i++) {
+    SumMult += UMult.Value(i);
+  }
+
+  Standard_Boolean shouldBeUPeriodic = Standard_False;
+  if (SumMult == (NUPoles + UDeg + 1)) {
+    //shouldBeUPeriodic = Standard_False;
+  }
+  else if ((UMult.Value(1) ==
+           UMult.Value(NUKnotsUnique)) &&
+          ((SumMult - UMult.Value(1))== NUPoles)) {
+    shouldBeUPeriodic = Standard_True;
+  }
+
+  // --- V Periodic ? ---
+
+  SumMult = 0;
+  for (i=1; i<=NVKnotsUnique; i++) {
+    SumMult += VMult.Value(i);
+  }
+
+  Standard_Boolean shouldBeVPeriodic = Standard_False;
+  if (SumMult == (NVPoles + VDeg + 1)) {
+    //shouldBeVPeriodic = Standard_False;
+  }
+  else if ((VMult.Value(1) ==
+           VMult.Value(NVKnotsUnique)) &&
+          ((SumMult - VMult.Value(1)) == NVPoles)) {
+    shouldBeVPeriodic = Standard_True;
+  }
+
+  Handle(Geom_BSplineSurface) CS;
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface))) {
+    const Handle(TColStd_HArray2OfReal)& aWeight = BSR->WeightsData();
+    TColStd_Array2OfReal W(1,NUPoles,1,NVPoles);
+    for (i=1; i<=NUPoles; i++) {
+      for (j=1; j<=NVPoles; j++) {
+        W.SetValue(i,j,aWeight->Value(i,j));
+      }
+    }
+    CS = new Geom_BSplineSurface(Poles, W, KUn, KVn, UMult,
+                                 VMult, UDeg, VDeg,
+                                 shouldBeUPeriodic,
+                                 shouldBeVPeriodic);
+  }
+  else
+    CS = new Geom_BSplineSurface(Poles, KUn, KVn, UMult,
+                                 VMult, UDeg, VDeg,
+                                 shouldBeUPeriodic,
+                                 shouldBeVPeriodic);
+  return CS;
+}
+
+//=============================================================================
+// Creation d' un CartesianPoint de Geom a partir d' un CartesianPoint de Step
+//=============================================================================
+
+Handle(Geom_CartesianPoint) StepToGeom::MakeCartesianPoint (const Handle(StepGeom_CartesianPoint)& SP)
+{
+  if (SP->NbCoordinates() == 3)
+  {
+    const Standard_Real LF = UnitsMethods::LengthFactor();
+    const Standard_Real X = SP->CoordinatesValue(1) * LF;
+    const Standard_Real Y = SP->CoordinatesValue(2) * LF;
+    const Standard_Real Z = SP->CoordinatesValue(3) * LF;
+    return new Geom_CartesianPoint(X, Y, Z);
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un CartesianPoint de Geom2d a partir d' un CartesianPoint de
+// Step
+//=============================================================================
+
+Handle(Geom2d_CartesianPoint) StepToGeom::MakeCartesianPoint2d (const Handle(StepGeom_CartesianPoint)& SP)
+{
+  if (SP->NbCoordinates() == 2)
+  {
+    const Standard_Real X = SP->CoordinatesValue(1);
+    const Standard_Real Y = SP->CoordinatesValue(2);
+    return new Geom2d_CartesianPoint(X, Y);
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Circle de Geom a partir d' un Circle de Step
+//=============================================================================
+
+Handle(Geom_Circle) StepToGeom::MakeCircle (const Handle(StepGeom_Circle)& SC)
+{
+  const StepGeom_Axis2Placement AxisSelect = SC->Position();
+  if (AxisSelect.CaseNum(AxisSelect.Value()) == 2)
+  {
+    Handle(Geom_Axis2Placement) A =
+      MakeAxis2Placement (Handle(StepGeom_Axis2Placement3d)::DownCast(AxisSelect.Value()));
+    if (! A.IsNull())
+    {
+      return new Geom_Circle(A->Ax2(),SC->Radius() * UnitsMethods::LengthFactor());
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Circle de Geom2d a partir d' un Circle de Step
+//=============================================================================
+
+Handle(Geom2d_Circle) StepToGeom::MakeCircle2d (const Handle(StepGeom_Circle)& SC)
+{
+  const StepGeom_Axis2Placement AxisSelect = SC->Position();
+  if (AxisSelect.CaseNum(AxisSelect.Value()) == 1) {
+    Handle(Geom2d_AxisPlacement) A1 =
+      MakeAxisPlacement (Handle(StepGeom_Axis2Placement2d)::DownCast(AxisSelect.Value()));
+    if (! A1.IsNull())
+    {
+      return new Geom2d_Circle (A1->Ax2d(), SC->Radius());
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une Conic de Geom a partir d' une Conic de Step
+//=============================================================================
+
+Handle(Geom_Conic) StepToGeom::MakeConic (const Handle(StepGeom_Conic)& SC)
+{
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Circle))) {
+    return MakeCircle (Handle(StepGeom_Circle)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Ellipse))) {
+    return MakeEllipse (Handle(StepGeom_Ellipse)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Hyperbola))) {
+    return MakeHyperbola (Handle(StepGeom_Hyperbola)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Parabola))) {
+    return MakeParabola (Handle(StepGeom_Parabola)::DownCast(SC));
+  }
+  // Attention : Other conic shall be implemented !
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une Conic de Geom2d a partir d' une Conic de Step
+//=============================================================================
+
+Handle(Geom2d_Conic) StepToGeom::MakeConic2d (const Handle(StepGeom_Conic)& SC)
+{
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Circle))) {
+    return MakeCircle2d (Handle(StepGeom_Circle)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Ellipse))) {
+    return MakeEllipse2d (Handle(StepGeom_Ellipse)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Hyperbola))) {
+    return MakeHyperbola2d (Handle(StepGeom_Hyperbola)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Parabola))) {
+    return MakeParabola2d (Handle(StepGeom_Parabola)::DownCast(SC));
+  }
+  // Attention : Other conic shall be implemented !
+  return Handle(Geom2d_Conic)();
+}
+
+//=============================================================================
+// Creation d' une ConicalSurface de Geom a partir d' une ConicalSurface de
+// Step
+//=============================================================================
+
+Handle(Geom_ConicalSurface) StepToGeom::MakeConicalSurface (const Handle(StepGeom_ConicalSurface)& SS)
+{
+  Handle(Geom_Axis2Placement) A = MakeAxis2Placement (SS->Position());
+  if (! A.IsNull())
+  {
+    const Standard_Real R = SS->Radius() * UnitsMethods::LengthFactor();
+    const Standard_Real Ang = SS->SemiAngle() * UnitsMethods::PlaneAngleFactor();
+    //#2(K3-3) rln 12/02/98 ProSTEP ct_turbine-A.stp entity #518, #3571 (gp::Resolution() is too little)
+    return new Geom_ConicalSurface(A->Ax2(), Max(Ang, Precision::Angular()), R);
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une Curve de Geom a partir d' une Curve de Step
+//=============================================================================
+
+Handle(Geom_Curve) StepToGeom::MakeCurve (const Handle(StepGeom_Curve)& SC)
+{
+  if (SC.IsNull()){
+    return Handle(Geom_Curve)();
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Line))) {
+    return MakeLine (Handle(StepGeom_Line)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_TrimmedCurve))) {
+    return MakeTrimmedCurve (Handle(StepGeom_TrimmedCurve)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Conic))) {
+    return MakeConic (Handle(StepGeom_Conic)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_BoundedCurve))) {
+    return MakeBoundedCurve (Handle(StepGeom_BoundedCurve)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_CurveReplica))) { //:n7 abv 16 Feb 99
+    const Handle(StepGeom_CurveReplica) CR = Handle(StepGeom_CurveReplica)::DownCast(SC);
+    const Handle(StepGeom_Curve) PC = CR->ParentCurve();
+    const Handle(StepGeom_CartesianTransformationOperator3d) T =
+      Handle(StepGeom_CartesianTransformationOperator3d)::DownCast(CR->Transformation());
+    // protect against cyclic references and wrong type of cartop
+    if ( !T.IsNull() && PC != SC )
+    {
+      Handle(Geom_Curve) C1 = MakeCurve (PC);
+      if (! C1.IsNull())
+      {
+        gp_Trsf T1;
+        if (MakeTransformation3d(T,T1))
+        {
+          C1->Transform ( T1 );
+          return C1;
+        }
+      }
+    }
+  }
+  else if (SC->IsKind(STANDARD_TYPE(StepGeom_OffsetCurve3d))) { //:o2 abv 17 Feb 99
+    const Handle(StepGeom_OffsetCurve3d) OC = Handle(StepGeom_OffsetCurve3d)::DownCast(SC);
+    const Handle(StepGeom_Curve) BC = OC->BasisCurve();
+    if ( BC != SC ) { // protect against loop
+      Handle(Geom_Curve) C1 = MakeCurve (BC);
+      if (! C1.IsNull())
+      {
+        Handle(Geom_Direction) RD = MakeDirection(OC->RefDirection());
+        if (! RD.IsNull())
+        {
+          return new Geom_OffsetCurve ( C1, -OC->Distance(), RD->Dir() );
+        }
+      }
+    }
+  }
+  else if (SC->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve))) { //:o5 abv 17 Feb 99
+    const Handle(StepGeom_SurfaceCurve) SurfC = Handle(StepGeom_SurfaceCurve)::DownCast(SC);
+    return MakeCurve (SurfC->Curve3d());
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une Curve de Geom2d a partir d' une Curve de Step
+//=============================================================================
+
+Handle(Geom2d_Curve) StepToGeom::MakeCurve2d (const Handle(StepGeom_Curve)& SC)
+{
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Line))) {
+    return MakeLine2d (Handle(StepGeom_Line)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_Conic))) {
+    return MakeConic2d (Handle(StepGeom_Conic)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_BoundedCurve))) {
+    return MakeBoundedCurve2d (Handle(StepGeom_BoundedCurve)::DownCast(SC));
+  }
+  if (SC->IsKind(STANDARD_TYPE(StepGeom_CurveReplica))) { //:n7 abv 16 Feb 99
+    const Handle(StepGeom_CurveReplica) CR = Handle(StepGeom_CurveReplica)::DownCast(SC);
+    const Handle(StepGeom_Curve) PC = CR->ParentCurve();
+    const Handle(StepGeom_CartesianTransformationOperator2d) T =
+      Handle(StepGeom_CartesianTransformationOperator2d)::DownCast(CR->Transformation());
+    // protect against cyclic references and wrong type of cartop
+    if ( !T.IsNull() && PC != SC )
+    {
+      Handle(Geom2d_Curve) C1 = MakeCurve2d (PC);
+      if (! C1.IsNull())
+      {
+        gp_Trsf2d T1;
+        if (MakeTransformation2d(T,T1))
+        {
+          C1->Transform ( T1 );
+          return C1;
+        }
+      }
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une CylindricalSurface de Geom a partir d' une
+// CylindricalSurface de Step
+//=============================================================================
+
+Handle(Geom_CylindricalSurface) StepToGeom::MakeCylindricalSurface (const Handle(StepGeom_CylindricalSurface)& SS)
+{
+  Handle(Geom_Axis2Placement) A = MakeAxis2Placement(SS->Position());
+  if (! A.IsNull())
+  {
+    return new Geom_CylindricalSurface(A->Ax2(), SS->Radius() * UnitsMethods::LengthFactor());
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Direction de Geom a partir d' un Direction de Step
+//=============================================================================
+
+Handle(Geom_Direction) StepToGeom::MakeDirection (const Handle(StepGeom_Direction)& SD)
+{
+  if (SD->NbDirectionRatios() >= 3)
+  {
+    const Standard_Real X = SD->DirectionRatiosValue(1);
+    const Standard_Real Y = SD->DirectionRatiosValue(2);
+    const Standard_Real Z = SD->DirectionRatiosValue(3);
+    // sln 22.10.2001. CTS23496: Direction is not created if it has null magnitude
+    if (gp_XYZ(X, Y, Z).SquareModulus() > gp::Resolution()*gp::Resolution())
+    {
+      return new Geom_Direction(X, Y, Z);
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Direction de Geom2d a partir d' un Direction de Step
+//=============================================================================
+
+Handle(Geom2d_Direction) StepToGeom::MakeDirection2d (const Handle(StepGeom_Direction)& SD)
+{
+  if (SD->NbDirectionRatios() >= 2)
+  {
+    const Standard_Real X = SD->DirectionRatiosValue(1);
+    const Standard_Real Y = SD->DirectionRatiosValue(2);
+    // sln 23.10.2001. CTS23496: Direction is not created if it has null magnitude
+    if(gp_XY(X,Y).SquareModulus() > gp::Resolution()*gp::Resolution())
+    {
+      return  new Geom2d_Direction(X, Y);
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une ElementarySurface de Geom a partir d' une
+// ElementarySurface de Step
+//=============================================================================
+
+Handle(Geom_ElementarySurface) StepToGeom::MakeElementarySurface (const Handle(StepGeom_ElementarySurface)& SS)
+{
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_Plane))) {
+    return MakePlane (Handle(StepGeom_Plane)::DownCast(SS));
+  }
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_CylindricalSurface))) {
+    return MakeCylindricalSurface (Handle(StepGeom_CylindricalSurface)::DownCast(SS));
+  }
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_ConicalSurface))) {
+    return MakeConicalSurface (Handle(StepGeom_ConicalSurface)::DownCast(SS));
+  }
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_SphericalSurface))) {
+    return MakeSphericalSurface (Handle(StepGeom_SphericalSurface)::DownCast(SS));
+  }
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_ToroidalSurface))) {
+    return MakeToroidalSurface (Handle(StepGeom_ToroidalSurface)::DownCast(SS));
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Ellipse de Geom a partir d' un Ellipse de Step
+//=============================================================================
+
+Handle(Geom_Ellipse) StepToGeom::MakeEllipse (const Handle(StepGeom_Ellipse)& SC)
+{
+  const StepGeom_Axis2Placement AxisSelect = SC->Position();
+  if (AxisSelect.CaseNum(AxisSelect.Value()) == 2) {
+    Handle(Geom_Axis2Placement) A1 = MakeAxis2Placement (Handle(StepGeom_Axis2Placement3d)::DownCast(AxisSelect.Value()));
+    if (! A1.IsNull())
+    {
+      gp_Ax2 A( A1->Ax2() );
+      const Standard_Real LF = UnitsMethods::LengthFactor();
+      const Standard_Real majorR = SC->SemiAxis1() * LF;
+      const Standard_Real minorR = SC->SemiAxis2() * LF;
+      if ( majorR - minorR >= 0. ) { //:o9 abv 19 Feb 99
+        return new Geom_Ellipse(A, majorR, minorR);
+      }
+      //:o9 abv 19 Feb 99
+      else {
+        A.SetXDirection ( A.XDirection() ^ A.Direction() );
+        return new Geom_Ellipse(A, minorR, majorR);
+      }
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Ellipse de Geom2d a partir d' un Ellipse de Step
+//=============================================================================
+
+Handle(Geom2d_Ellipse) StepToGeom::MakeEllipse2d (const Handle(StepGeom_Ellipse)& SC)
+{
+  const StepGeom_Axis2Placement AxisSelect = SC->Position();
+  if (AxisSelect.CaseNum(AxisSelect.Value()) == 1) {
+    Handle(Geom2d_AxisPlacement) A1 = MakeAxisPlacement (Handle(StepGeom_Axis2Placement2d)::DownCast(AxisSelect.Value()));
+    if (! A1.IsNull())
+    {
+      gp_Ax22d A( A1->Ax2d() );
+      const Standard_Real majorR = SC->SemiAxis1();
+      const Standard_Real minorR = SC->SemiAxis2();
+      if ( majorR - minorR >= 0. ) { //:o9 abv 19 Feb 99: bm4_id_punch_b.stp #678: protection
+        return new Geom2d_Ellipse(A, majorR, minorR);
+      }
+      else {
+        const gp_Dir2d X = A.XDirection();
+        A.SetXDirection ( gp_Dir2d ( X.X(), -X.Y() ) );
+        return new Geom2d_Ellipse(A, minorR, majorR);
+      }
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Hyperbola de Geom a partir d' un Hyperbola de Step
+//=============================================================================
+
+Handle(Geom_Hyperbola) StepToGeom::MakeHyperbola (const Handle(StepGeom_Hyperbola)& SC)
+{
+  const StepGeom_Axis2Placement AxisSelect = SC->Position();
+  if (AxisSelect.CaseNum(AxisSelect.Value()) == 2)
+  {
+    Handle(Geom_Axis2Placement) A1 = MakeAxis2Placement (Handle(StepGeom_Axis2Placement3d)::DownCast(AxisSelect.Value()));
+    if (! A1.IsNull())
+    {
+      const gp_Ax2 A( A1->Ax2() );
+      const Standard_Real LF = UnitsMethods::LengthFactor();
+      return new Geom_Hyperbola(A, SC->SemiAxis() * LF, SC->SemiImagAxis() * LF);
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Hyperbola de Geom2d a partir d' un Hyperbola de Step
+//=============================================================================
+
+Handle(Geom2d_Hyperbola) StepToGeom::MakeHyperbola2d (const Handle(StepGeom_Hyperbola)& SC)
+{
+  const StepGeom_Axis2Placement AxisSelect = SC->Position();
+  if (AxisSelect.CaseNum(AxisSelect.Value()) == 1)
+  {
+    Handle(Geom2d_AxisPlacement) A1 = MakeAxisPlacement (Handle(StepGeom_Axis2Placement2d)::DownCast(AxisSelect.Value()));
+    if (! A1.IsNull())
+    {
+      const gp_Ax22d A( A1->Ax2d() );
+      return new Geom2d_Hyperbola(A, SC->SemiAxis(), SC->SemiImagAxis());
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une Line de Geom a partir d' une Line de Step
+//=============================================================================
+
+Handle(Geom_Line) StepToGeom::MakeLine (const Handle(StepGeom_Line)& SC)
+{
+  Handle(Geom_CartesianPoint) P = MakeCartesianPoint(SC->Pnt());
+  if (! P.IsNull())
+  {
+    // sln 22.10.2001. CTS23496: Line is not created if direction have not been succesfully created
+    Handle(Geom_VectorWithMagnitude) D = MakeVectorWithMagnitude (SC->Dir());
+    if (! D.IsNull())
+    {
+      if( D->Vec().SquareMagnitude() < Precision::Confusion() * Precision::Confusion())
+        return 0;
+      const gp_Dir V(D->Vec());
+      return new Geom_Line(P->Pnt(), V);
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une Line de Geom2d a partir d' une Line de Step
+//=============================================================================
+
+Handle(Geom2d_Line) StepToGeom::MakeLine2d (const Handle(StepGeom_Line)& SC)
+{
+  Handle(Geom2d_CartesianPoint) P = MakeCartesianPoint2d(SC->Pnt());
+  if (! P.IsNull())
+  {
+    // sln 23.10.2001. CTS23496: Line is not created if direction have not been succesfully created
+    Handle(Geom2d_VectorWithMagnitude) D = MakeVectorWithMagnitude2d (SC->Dir());
+    if (! D.IsNull())
+    {
+      const gp_Dir2d D1(D->Vec2d());
+      return new Geom2d_Line(P->Pnt2d(), D1);
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Parabola de Geom a partir d' un Parabola de Step
+//=============================================================================
+
+Handle(Geom_Parabola) StepToGeom::MakeParabola (const Handle(StepGeom_Parabola)& SC)
+{
+  const StepGeom_Axis2Placement AxisSelect = SC->Position();
+  if (AxisSelect.CaseNum(AxisSelect.Value()) == 2)
+  {
+    Handle(Geom_Axis2Placement) A = MakeAxis2Placement (Handle(StepGeom_Axis2Placement3d)::DownCast(AxisSelect.Value()));
+    if (! A.IsNull())
+    {
+      return new Geom_Parabola(A->Ax2(), SC->FocalDist() * UnitsMethods::LengthFactor());
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Parabola de Geom2d a partir d' un Parabola de Step
+//=============================================================================
+
+Handle(Geom2d_Parabola) StepToGeom::MakeParabola2d (const Handle(StepGeom_Parabola)& SC)
+{
+  const StepGeom_Axis2Placement AxisSelect = SC->Position();
+  if (AxisSelect.CaseNum(AxisSelect.Value()) == 1) {
+    Handle(Geom2d_AxisPlacement) A1 = MakeAxisPlacement (Handle(StepGeom_Axis2Placement2d)::DownCast(AxisSelect.Value()));
+    if (! A1.IsNull())
+    {
+      const gp_Ax22d A( A1->Ax2d() );
+      return new Geom2d_Parabola(A, SC->FocalDist());
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un Plane de Geom a partir d' un plane de Step
+//=============================================================================
+
+Handle(Geom_Plane) StepToGeom::MakePlane (const Handle(StepGeom_Plane)& SP)
+{
+  Handle(Geom_Axis2Placement) A = MakeAxis2Placement (SP->Position());
+  if (! A.IsNull())
+  {
+    return new Geom_Plane(A->Ax2());
+  }
+  return 0;
+}
+
+//=======================================================================
+//function : MakePolyline
+//purpose  :
+//=======================================================================
+
+Handle(Geom_BSplineCurve) StepToGeom::MakePolyline (const Handle(StepGeom_Polyline)& SPL)
+{
+  if (SPL.IsNull())
+    return Handle(Geom_BSplineCurve)();
+
+  const Standard_Integer nbp = SPL->NbPoints();
+  if (nbp > 1)
+  {
+    TColgp_Array1OfPnt Poles ( 1, nbp );
+    TColStd_Array1OfReal Knots ( 1, nbp );
+    TColStd_Array1OfInteger Mults ( 1, nbp );
+
+    for ( Standard_Integer i=1; i <= nbp; i++ )
+    {
+      Handle(Geom_CartesianPoint) P = MakeCartesianPoint (SPL->PointsValue(i));
+      if (! P.IsNull())
+        Poles.SetValue ( i, P->Pnt() );
+      else
+        return 0;
+      Knots.SetValue ( i, Standard_Real(i-1) );
+      Mults.SetValue ( i, 1 );
+    }
+    Mults.SetValue ( 1, 2 );
+    Mults.SetValue ( nbp, 2 );
+
+    return new Geom_BSplineCurve ( Poles, Knots, Mults, 1 );
+  }
+  return 0;
+}
+
+//=======================================================================
+//function : MakePolyline2d
+//purpose  :
+//=======================================================================
+
+Handle(Geom2d_BSplineCurve) StepToGeom::MakePolyline2d (const Handle(StepGeom_Polyline)& SPL)
+{
+  if (SPL.IsNull())
+    return Handle(Geom2d_BSplineCurve)();
+
+  const Standard_Integer nbp = SPL->NbPoints();
+  if (nbp > 1)
+  {
+    TColgp_Array1OfPnt2d Poles ( 1, nbp );
+    TColStd_Array1OfReal Knots ( 1, nbp );
+    TColStd_Array1OfInteger Mults ( 1, nbp );
+
+    for ( Standard_Integer i=1; i <= nbp; i++ )
+    {
+    Handle(Geom2d_CartesianPoint) P = MakeCartesianPoint2d (SPL->PointsValue(i));
+      if (! P.IsNull())
+        Poles.SetValue ( i, P->Pnt2d() );
+      else
+        return 0;
+      Knots.SetValue ( i, Standard_Real(i-1) );
+      Mults.SetValue ( i, 1 );
+    }
+    Mults.SetValue ( 1, 2 );
+    Mults.SetValue ( nbp, 2 );
+
+    return new Geom2d_BSplineCurve ( Poles, Knots, Mults, 1 );
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une RectangularTrimmedSurface de Geom a partir d' une
+// RectangularTrimmedSurface de Step
+//=============================================================================
+
+Handle(Geom_RectangularTrimmedSurface) StepToGeom::MakeRectangularTrimmedSurface (const Handle(StepGeom_RectangularTrimmedSurface)& SS)
+{
+  Handle(Geom_Surface) theBasis = MakeSurface (SS->BasisSurface());
+  if (! theBasis.IsNull())
+  {
+    // -----------------------------------------
+    // Modification of the Trimming Parameters ?
+    // -----------------------------------------
+
+    Standard_Real uFact = 1.;
+    Standard_Real vFact = 1.;
+    const Standard_Real LengthFact  = UnitsMethods::LengthFactor();
+    const Standard_Real AngleFact   = UnitsMethods::PlaneAngleFactor(); // abv 30.06.00 trj4_k1_geo-tc-214.stp #1477: PI/180.;
+
+    if (theBasis->IsKind(STANDARD_TYPE(Geom_SphericalSurface)) ||
+        theBasis->IsKind(STANDARD_TYPE(Geom_ToroidalSurface))) {
+      uFact = vFact = AngleFact;
+    }
+    else if (theBasis->IsKind(STANDARD_TYPE(Geom_CylindricalSurface))) {
+      uFact = AngleFact;
+      vFact = LengthFact;
+    }
+    else if ( theBasis->IsKind(STANDARD_TYPE(Geom_SurfaceOfRevolution))) {
+      uFact = AngleFact;
+    }
+    else if (theBasis->IsKind(STANDARD_TYPE(Geom_ConicalSurface))) {
+      const Handle(Geom_ConicalSurface) conicS = Handle(Geom_ConicalSurface)::DownCast(theBasis);
+      uFact = AngleFact;
+      vFact = LengthFact / Cos(conicS->SemiAngle());
+    }
+    else if (theBasis->IsKind(STANDARD_TYPE(Geom_Plane))) {
+      uFact = vFact = LengthFact;
+    }
+
+    const Standard_Real U1 = SS->U1() * uFact;
+    const Standard_Real U2 = SS->U2() * uFact;
+    const Standard_Real V1 = SS->V1() * vFact;
+    const Standard_Real V2 = SS->V2() * vFact;
+
+    return new Geom_RectangularTrimmedSurface(theBasis, U1, U2, V1, V2, SS->Usense(), SS->Vsense());
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une SphericalSurface de Geom a partir d' une
+// SphericalSurface de Step
+//=============================================================================
+
+Handle(Geom_SphericalSurface) StepToGeom::MakeSphericalSurface (const Handle(StepGeom_SphericalSurface)& SS)
+{
+  Handle(Geom_Axis2Placement) A = MakeAxis2Placement (SS->Position());
+  if (! A.IsNull())
+  {
+    return new Geom_SphericalSurface(A->Ax2(), SS->Radius() * UnitsMethods::LengthFactor());
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une Surface de Geom a partir d' une Surface de Step
+//=============================================================================
+
+Handle(Geom_Surface) StepToGeom::MakeSurface (const Handle(StepGeom_Surface)& SS)
+{
+   // sln 01.10.2001 BUC61003. If entry shell is NULL do nothing
+  if(SS.IsNull()) {
+    return Handle(Geom_Surface)();
+  }
+
+  try {
+    OCC_CATCH_SIGNALS
+    if (SS->IsKind(STANDARD_TYPE(StepGeom_BoundedSurface))) {
+      return MakeBoundedSurface (Handle(StepGeom_BoundedSurface)::DownCast(SS));
+    }
+    if (SS->IsKind(STANDARD_TYPE(StepGeom_ElementarySurface))) {
+      const Handle(StepGeom_ElementarySurface) S1 = Handle(StepGeom_ElementarySurface)::DownCast(SS);
+      if(S1->Position().IsNull())
+        return Handle(Geom_Surface)();
+
+      return MakeElementarySurface (S1);
+    }
+    if (SS->IsKind(STANDARD_TYPE(StepGeom_SweptSurface))) {
+      return MakeSweptSurface (Handle(StepGeom_SweptSurface)::DownCast(SS));
+    }
+    if (SS->IsKind(STANDARD_TYPE(StepGeom_OffsetSurface))) { //:d4 abv 12 Mar 98
+      const Handle(StepGeom_OffsetSurface) OS = Handle(StepGeom_OffsetSurface)::DownCast(SS);
+
+      Handle(Geom_Surface) aBasisSurface = MakeSurface (OS->BasisSurface());
+      if (! aBasisSurface.IsNull())
+      {
+        // sln 03.10.01. BUC61003. creation of  offset surface is corrected
+        const Standard_Real anOffset = OS->Distance() * UnitsMethods::LengthFactor();
+        if (aBasisSurface->Continuity() == GeomAbs_C0)
+        {
+          const BRepBuilderAPI_MakeFace aBFace(aBasisSurface, Precision::Confusion());
+          if (aBFace.IsDone())
+          {
+            const TopoDS_Shape aResult = ShapeAlgo::AlgoContainer()->C0ShapeToC1Shape(aBFace.Face(), Abs(anOffset));
+            if (aResult.ShapeType() == TopAbs_FACE)
+            {
+              aBasisSurface = BRep_Tool::Surface(TopoDS::Face(aResult));
+            }
+          }
+        }
+        if(aBasisSurface->Continuity() != GeomAbs_C0)
+        {
+          return new Geom_OffsetSurface ( aBasisSurface, anOffset );
+        }
+      }
+    }
+    else if (SS->IsKind(STANDARD_TYPE(StepGeom_SurfaceReplica))) { //:n7 abv 16 Feb 99
+      const Handle(StepGeom_SurfaceReplica) SR = Handle(StepGeom_SurfaceReplica)::DownCast(SS);
+      const Handle(StepGeom_Surface) PS = SR->ParentSurface();
+      const Handle(StepGeom_CartesianTransformationOperator3d) T =
+        Handle(StepGeom_CartesianTransformationOperator3d)::DownCast(SR->Transformation());
+      // protect against cyclic references and wrong type of cartop
+      if ( !T.IsNull() && PS != SS ) {
+        Handle(Geom_Surface) S1 = MakeSurface (PS);
+        if (! S1.IsNull())
+        {
+          gp_Trsf T1;
+          if (MakeTransformation3d(T,T1))
+          {
+            S1->Transform ( T1 );
+            return S1;
+          }
+        }
+      }
+    }
+  }
+  catch(Standard_Failure) {
+//   ShapeTool_DB ?
+#ifdef OCCT_DEBUG //:s5
+    cout<<"Warning: MakeSurface: Exception:";
+    Standard_Failure::Caught()->Print(cout); cout << endl;
+#endif
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une SurfaceOfLinearExtrusion de Geom a partir d' une
+// SurfaceOfLinearExtrusion de Step
+//=============================================================================
+
+Handle(Geom_SurfaceOfLinearExtrusion) StepToGeom::MakeSurfaceOfLinearExtrusion (const Handle(StepGeom_SurfaceOfLinearExtrusion)& SS)
+{
+  Handle(Geom_Curve) C = MakeCurve (SS->SweptCurve());
+  if (! C.IsNull())
+  {
+    // sln 23.10.2001. CTS23496: Surface is not created if extrusion axis have not been succesfully created
+    Handle(Geom_VectorWithMagnitude) V = MakeVectorWithMagnitude (SS->ExtrusionAxis());
+    if (! V.IsNull())
+    {
+      const gp_Dir D(V->Vec());
+      Handle(Geom_Line) aLine = Handle(Geom_Line)::DownCast(C);
+      if (!aLine.IsNull() && aLine->Lin().Direction().IsParallel(D, Precision::Angular()))
+        return Handle(Geom_SurfaceOfLinearExtrusion)();
+      return new Geom_SurfaceOfLinearExtrusion(C,D);
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une SurfaceOfRevolution de Geom a partir d' une
+// SurfaceOfRevolution de Step
+//=============================================================================
+
+Handle(Geom_SurfaceOfRevolution) StepToGeom::MakeSurfaceOfRevolution (const Handle(StepGeom_SurfaceOfRevolution)& SS)
+{
+  Handle(Geom_Curve) C = MakeCurve (SS->SweptCurve());
+  if (! C.IsNull())
+  {
+    Handle(Geom_Axis1Placement) A1 = MakeAxis1Placement (SS->AxisPosition());
+    if (! A1.IsNull())
+    {
+      const gp_Ax1 A( A1->Ax1() );
+      //skl for OCC952 (one bad case revolution of circle)
+      if ( C->IsKind(STANDARD_TYPE(Geom_Circle)) || C->IsKind(STANDARD_TYPE(Geom_Ellipse)) )
+      {
+        const Handle(Geom_Conic) conic = Handle(Geom_Conic)::DownCast(C);
+        const gp_Pnt pc = conic->Location();
+        const gp_Lin rl (A);
+        if (rl.Distance(pc) < Precision::Confusion()) { //pc lies on A2
+          const gp_Dir dirline = A.Direction();
+          const gp_Dir norm = conic->Axis().Direction();
+          const gp_Dir xAxis = conic->XAxis().Direction();
+          //checking A2 lies on plane of circle
+          if( dirline.IsNormal(norm,Precision::Angular()) && (dirline.IsParallel(xAxis,Precision::Angular()) || C->IsKind(STANDARD_TYPE(Geom_Circle)))) {
+            //change parametrization for trimming
+            gp_Ax2 axnew(pc,norm,dirline.Reversed());
+            conic->SetPosition(axnew);
+            C = new Geom_TrimmedCurve(conic, 0., M_PI);
+          }
+        }
+      }
+      return new Geom_SurfaceOfRevolution(C, A);
+    }
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' une SweptSurface de prostep a partir d' une
+// SweptSurface de Geom
+//=============================================================================
+
+Handle(Geom_SweptSurface) StepToGeom::MakeSweptSurface (const Handle(StepGeom_SweptSurface)& SS)
+{
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_SurfaceOfLinearExtrusion))) {
+    return MakeSurfaceOfLinearExtrusion (Handle(StepGeom_SurfaceOfLinearExtrusion)::DownCast(SS));
+  }
+  if (SS->IsKind(STANDARD_TYPE(StepGeom_SurfaceOfRevolution))) {
+    return MakeSurfaceOfRevolution (Handle(StepGeom_SurfaceOfRevolution)::DownCast(SS));
+  }
+  return Handle(Geom_SweptSurface)();
+}
+
+//=============================================================================
+// Creation d' une ToroidalSurface de Geom a partir d' une
+// ToroidalSurface de Step
+//=============================================================================
+
+Handle(Geom_ToroidalSurface) StepToGeom::MakeToroidalSurface (const Handle(StepGeom_ToroidalSurface)& SS)
+{
+  Handle(Geom_Axis2Placement) A = MakeAxis2Placement (SS->Position());
+  if (! A.IsNull())
+  {
+    const Standard_Real LF = UnitsMethods::LengthFactor();
+    return new Geom_ToroidalSurface(A->Ax2(), Abs(SS->MajorRadius() * LF), Abs(SS->MinorRadius() * LF));
+  }
+  return 0;
+}
+
+//=======================================================================
+//function : MakeTransformation2d
+//purpose  :
+//=======================================================================
+Standard_Boolean StepToGeom::MakeTransformation2d (const Handle(StepGeom_CartesianTransformationOperator2d)& SCTO, gp_Trsf2d& CT)
+{
+  //  NB : on ne s interesse ici qu au deplacement rigide
+  Handle(Geom2d_CartesianPoint) CP = MakeCartesianPoint2d (SCTO->LocalOrigin());
+  if (! CP.IsNull())
+  {
+    gp_Dir2d D1(1.,0.);
+    // sln 23.10.2001. CTS23496: If problems with creation of direction occur default direction is used
+    const Handle(StepGeom_Direction) A = SCTO->Axis1();
+    if (!A.IsNull())
+    {
+      Handle(Geom2d_Direction) D = MakeDirection2d (A);
+      if (! D.IsNull())
+        D1 = D->Dir2d();
+    }
+    const gp_Ax2d result(CP->Pnt2d(),D1);
+    CT.SetTransformation(result);
+    CT = CT.Inverted();
+    return Standard_True;
+  }
+  return Standard_False;
+}
+
+//=======================================================================
+//function : MakeTransformation3d
+//purpose  :
+//=======================================================================
+
+Standard_Boolean StepToGeom::MakeTransformation3d (const Handle(StepGeom_CartesianTransformationOperator3d)& SCTO, gp_Trsf& CT)
+{
+  Handle(Geom_CartesianPoint) CP = MakeCartesianPoint (SCTO->LocalOrigin());
+  if (! CP.IsNull())
+  {
+    const gp_Pnt Pgp = CP->Pnt();
+
+    // sln 23.10.2001. CTS23496: If problems with creation of direction occur default direction is used
+    gp_Dir D1(1.,0.,0.);
+    const Handle(StepGeom_Direction) A1 = SCTO->Axis1();
+    if (!A1.IsNull()) {
+      Handle(Geom_Direction) D = MakeDirection (A1);
+      if (! D.IsNull())
+        D1 = D->Dir();
+    }
+
+    gp_Dir D2(0.,1.,0.);
+    const Handle(StepGeom_Direction) A2 = SCTO->Axis2();
+    if (!A2.IsNull()) {
+      Handle(Geom_Direction) D = MakeDirection (A2);
+      if (! D.IsNull())
+        D2 = D->Dir();
+    }
+
+    Standard_Boolean isDefaultDirectionUsed = Standard_True;
+    gp_Dir D3;
+    const Handle(StepGeom_Direction) A3 = SCTO->Axis3();
+    if (!A3.IsNull()) {
+      Handle(Geom_Direction) D = MakeDirection (A3);
+      if (! D.IsNull())
+      {
+        D3 = D->Dir();
+        isDefaultDirectionUsed = Standard_False;
+      }
+    }
+    if(isDefaultDirectionUsed)
+      D3 = D1.Crossed(D2);
+
+    const gp_Ax3 result(Pgp,D3,D1);
+    CT.SetTransformation(result);
+    CT = CT.Inverted(); //:n8 abv 16 Feb 99: tr8_as2_db.stp: reverse for accordance with LV tool
+    return Standard_True;
+  }
+  return Standard_False;
+}
+
+// ----------------------------------------------------------------
+// ExtractParameter
+// ----------------------------------------------------------------
+//:o6 abv 18 Feb 99: parameter Factor added
+//:p3 abv 23 Feb 99: parameter Shift added
+static Standard_Boolean  ExtractParameter
+(const Handle(Geom_Curve) &  aGeomCurve,
+ const Handle(StepGeom_HArray1OfTrimmingSelect) & TS,
+ const Standard_Integer nbSel,
+ const Standard_Integer MasterRep,
+ const Standard_Real Factor,
+ const Standard_Real Shift,
+ Standard_Real & aParam)
+{
+  Handle(StepGeom_CartesianPoint) aPoint;
+  Standard_Integer i;
+//:S4136  Standard_Real precBrep = BRepAPI::Precision();
+  for ( i = 1 ; i <= nbSel ; i++) {
+    StepGeom_TrimmingSelect theSel = TS->Value(i);
+    if (MasterRep == 2 && theSel.CaseMember() > 0) {
+      aParam = Shift + Factor * theSel.ParameterValue();
+      return Standard_True;
+    }
+    else if (MasterRep == 1 && theSel.CaseNumber() > 0) {
+      aPoint = theSel.CartesianPoint();
+      Handle(Geom_CartesianPoint) theGeomPnt = StepToGeom::MakeCartesianPoint (aPoint);
+      gp_Pnt thegpPnt = theGeomPnt->Pnt();
+
+      //:S4136: use advanced algorithm
+      ShapeAnalysis_Curve sac;
+      gp_Pnt p;
+      sac.Project ( aGeomCurve, thegpPnt, Precision::Confusion(), p, aParam );
+/* //:S4136
+      //Trim == natural boundary ?
+      if(aGeomCurve->IsKind(STANDARD_TYPE(Geom_BoundedCurve))) {
+       Standard_Real frstPar = aGeomCurve->FirstParameter();
+       Standard_Real lstPar = aGeomCurve->LastParameter();
+       gp_Pnt frstPnt = aGeomCurve->Value(frstPar);
+       gp_Pnt lstPnt = aGeomCurve->Value(lstPar);
+       if(frstPnt.IsEqual(thegpPnt,precBrep)) {
+         aParam = frstPar;
+         return Standard_True;
+       }
+       if(lstPnt.IsEqual(thegpPnt,precBrep)) {
+         aParam = lstPar;
+         return Standard_True;
+       }
+      }
+      // Project Point On Curve
+      GeomAPI_ProjectPointOnCurve PPOC(thegpPnt, aGeomCurve);
+      if (PPOC.NbPoints() == 0) {
+       return Standard_False;
+      }
+      aParam = PPOC.LowerDistanceParameter();
+*/
+      return Standard_True;
+    }
+  }
+// if the MasterRepresentation is unspecified:
+// if a ParameterValue exists, it is prefered
+
+  for ( i = 1 ; i <= nbSel ; i++) {
+    StepGeom_TrimmingSelect theSel = TS->Value(i);
+    if (theSel.CaseMember() > 0) {
+      aParam = Shift + Factor * theSel.ParameterValue();
+
+      return Standard_True;
+    }
+  }
+// if no ParameterValue exists, it is created from the CartesianPointValue
+
+  for ( i = 1 ; i <= nbSel ; i++) {
+    StepGeom_TrimmingSelect theSel = TS->Value(i);
+    if (theSel.CaseNumber() > 0) {
+      aPoint = theSel.CartesianPoint();
+      Handle(Geom_CartesianPoint) theGeomPnt = StepToGeom::MakeCartesianPoint (aPoint);
+      gp_Pnt thegpPnt = theGeomPnt->Pnt();
+      // Project Point On Curve
+      ShapeAnalysis_Curve sac;
+      gp_Pnt p;
+      sac.Project ( aGeomCurve, thegpPnt, Precision::Confusion(), p, aParam );
+/*
+      GeomAPI_ProjectPointOnCurve PPOC(thegpPnt, aGeomCurve);
+      if (PPOC.NbPoints() == 0) {
+       return Standard_False;
+      }
+      aParam = PPOC.LowerDistanceParameter();
+*/
+      return Standard_True;
+    }
+  }
+  return Standard_False;  // I suppose
+}
+
+
+//=============================================================================
+// Creation d' une Trimmed Curve de Geom a partir d' une Trimmed Curve de Step
+//=============================================================================
+
+Handle(Geom_TrimmedCurve) StepToGeom::MakeTrimmedCurve (const Handle(StepGeom_TrimmedCurve)& SC)
+{
+  const Handle(StepGeom_Curve) theSTEPCurve = SC->BasisCurve();
+  Handle(Geom_Curve) theCurve = MakeCurve (theSTEPCurve);
+  if (theCurve.IsNull())
+    return Handle(Geom_TrimmedCurve)();
+
+  const Handle(StepGeom_HArray1OfTrimmingSelect)& theTrimSel1 = SC->Trim1();
+  const Handle(StepGeom_HArray1OfTrimmingSelect)& theTrimSel2 = SC->Trim2();
+  const Standard_Integer nbSel1 = SC->NbTrim1();
+  const Standard_Integer nbSel2 = SC->NbTrim2();
+
+  Standard_Integer MasterRep;
+  switch (SC->MasterRepresentation())
+  {
+    case StepGeom_tpCartesian: MasterRep = 1; break;
+    case StepGeom_tpParameter: MasterRep = 2; break;
+    default: MasterRep = 0;
+  }
+
+  //gka 18.02.04 analysis for case when MasterRep = .Unspecified
+  //and parameters are specified as CARTESIAN_POINT
+  Standard_Boolean isPoint = Standard_False;
+  if(MasterRep == 0 || (MasterRep == 2 && nbSel1 >1 && nbSel2 > 1)) {
+    Standard_Integer ii;
+    for(ii = 1; ii <= nbSel1; ii++)
+    {
+      if (!(theTrimSel1->Value(ii).CartesianPoint().IsNull()))
+      {
+        for(ii = 1; ii <= nbSel2; ii++)
+        {
+          if (!(theTrimSel2->Value(ii).CartesianPoint().IsNull()))
+          {
+            isPoint = Standard_True;
+            break;
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  //:o6 abv 18 Feb 99: computation of factor moved
+  Standard_Real fact = 1., shift = 0.;
+  if (theSTEPCurve->IsKind(STANDARD_TYPE(StepGeom_Line))) {
+    const Handle(StepGeom_Line) theLine =
+      Handle(StepGeom_Line)::DownCast(theSTEPCurve);
+    fact = theLine->Dir()->Magnitude() * UnitsMethods::LengthFactor();
+  }
+  else if (theSTEPCurve->IsKind(STANDARD_TYPE(StepGeom_Circle)) ||
+           theSTEPCurve->IsKind(STANDARD_TYPE(StepGeom_Ellipse))) {
+//    if (trim1 > 2.1*M_PI || trim2 > 2.1*M_PI) fact = M_PI / 180.;
+    fact = UnitsMethods::PlaneAngleFactor();
+    //:p3 abv 23 Feb 99: shift on pi/2 on ellipse with R1 < R2
+    const Handle(StepGeom_Ellipse) ellipse = Handle(StepGeom_Ellipse)::DownCast(theSTEPCurve);
+    if ( !ellipse.IsNull() && ellipse->SemiAxis1() - ellipse->SemiAxis2() < 0. )
+      shift = 0.5 * M_PI;
+
+    // skl 04.02.2002 for OCC133: we can not make TrimmedCurve if
+    // there is no X-direction in StepGeom_Axis2Placement3d
+    const Handle(StepGeom_Conic) conic = Handle(StepGeom_Conic)::DownCast(theSTEPCurve);
+    // CKY 6-FEB-2004 for Airbus-MedialAxis :
+    // this restriction does not apply for trimming by POINTS
+    if(!conic.IsNull() && MasterRep != 1) {
+      const StepGeom_Axis2Placement a2p = conic->Position();
+      if(a2p.CaseNum(a2p.Value())==2) {
+        if( !a2p.Axis2Placement3d()->HasRefDirection() ) {
+          ////gka 18.02.04 analysis for case when MasterRep = .Unspecified
+          //and parameters are specified as CARTESIAN_POINT
+          if(isPoint /*&& !MasterRep*/)
+            MasterRep =1;
+          else {
+            if ( SC->SenseAgreement() )
+              return new Geom_TrimmedCurve(theCurve, 0., 2.*M_PI, Standard_True);
+            else
+              return new Geom_TrimmedCurve(theCurve, 2.*M_PI, 0., Standard_False);
+          }
+        }
+      }
+    }
+  }
+
+  Standard_Real trim1 = 0.;
+  Standard_Real trim2 = 0.;
+  Handle(StepGeom_CartesianPoint) TrimCP1, TrimCP2;
+  const Standard_Boolean FoundParam1 = ExtractParameter(theCurve, theTrimSel1, nbSel1, MasterRep, fact, shift, trim1);
+  const Standard_Boolean FoundParam2 = ExtractParameter(theCurve, theTrimSel2, nbSel2, MasterRep, fact, shift, trim2);
+
+  if (FoundParam1 && FoundParam2) {
+    const Standard_Real cf = theCurve->FirstParameter();
+    const Standard_Real cl = theCurve->LastParameter();
+    //: abv 09.04.99: S4136: bm2_ug_t4-B.stp #70610: protect against OutOfRange
+    if ( !theCurve->IsPeriodic() ) {
+      if ( trim1 < cf ) trim1 = cf;
+      else if ( trim1 > cl ) trim1 = cl;
+      if ( trim2 < cf ) trim2 = cf;
+      else if ( trim2 > cl ) trim2 = cl;
+    }
+    if (Abs(trim1 - trim2) < Precision::PConfusion()) {
+      if (theCurve->IsPeriodic()) {
+        ElCLib::AdjustPeriodic(cf,cl,Precision::PConfusion(),trim1,trim2);
+      }
+      else if (theCurve->IsClosed()) {
+        if (Abs(trim1 - cf) < Precision::PConfusion()) {
+          trim2 += cl;
+        }
+        else {
+          trim1 -= cl;
+        }
+      }
+      else {
+        return 0;
+      }
+    }
+//  CKY 16-DEC-1997 : USA60035 le texte de Part42 parle de degres
+//    mais des systemes ecrivent en radians. Exploiter UnitsMethods
+//:o6    trim1 = trim1 * fact;
+//:o6    trim2 = trim2 * fact;
+    if ( SC->SenseAgreement() )
+      return new Geom_TrimmedCurve(theCurve, trim1, trim2, Standard_True);
+    else //:abv 29.09.00 PRO20362: reverse parameters in case of reversed curve
+      return new Geom_TrimmedCurve(theCurve, trim2, trim1, Standard_False);
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d'une Trimmed Curve de Geom2d a partir d' une Trimmed Curve de Step
+//=============================================================================
+// Shall be completed to treat trimming with points
+
+Handle(Geom2d_BSplineCurve) StepToGeom::MakeTrimmedCurve2d (const Handle(StepGeom_TrimmedCurve)& SC)
+{
+  const Handle(StepGeom_Curve) BasisCurve = SC->BasisCurve();
+  Handle(Geom2d_Curve) theGeomBasis = MakeCurve2d (BasisCurve);
+  if (theGeomBasis.IsNull())
+    return Handle(Geom2d_BSplineCurve)();
+
+  if (theGeomBasis->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))) {
+    return Handle(Geom2d_BSplineCurve)::DownCast(theGeomBasis);
+  }
+
+  const Handle(StepGeom_HArray1OfTrimmingSelect)& theTrimSel1 = SC->Trim1();
+  const Handle(StepGeom_HArray1OfTrimmingSelect)& theTrimSel2 = SC->Trim2();
+  const Standard_Integer nbSel1 = SC->NbTrim1();
+  const Standard_Integer nbSel2 = SC->NbTrim2();
+  if ((nbSel1 == 1) && (nbSel2 == 1) &&
+      (theTrimSel1->Value(1).CaseMember() > 0) &&
+      (theTrimSel2->Value(1).CaseMember() > 0))
+  {
+    const Standard_Real u1 = theTrimSel1->Value(1).ParameterValue();
+    const Standard_Real u2 = theTrimSel2->Value(1).ParameterValue();
+    Standard_Real fact = 1., shift = 0.;
+
+    if (BasisCurve->IsKind(STANDARD_TYPE(StepGeom_Line))) {
+      const Handle(StepGeom_Line) theLine = Handle(StepGeom_Line)::DownCast(BasisCurve);
+      fact = theLine->Dir()->Magnitude();
+    }
+    else if (BasisCurve->IsKind(STANDARD_TYPE(StepGeom_Circle)) ||
+             BasisCurve->IsKind(STANDARD_TYPE(StepGeom_Ellipse))) {
+//      if (u1 > 2.1*M_PI || u2 > 2.1*M_PI) fact = M_PI / 180.;
+      fact = UnitsMethods::PlaneAngleFactor();
+      //:p3 abv 23 Feb 99: shift on pi/2 on ellipse with R1 < R2
+      const Handle(StepGeom_Ellipse) ellipse = Handle(StepGeom_Ellipse)::DownCast(BasisCurve);
+      if ( !ellipse.IsNull() && ellipse->SemiAxis1() - ellipse->SemiAxis2() < 0. )
+        shift = 0.5 * M_PI;
+    }
+    else if (BasisCurve->IsKind(STANDARD_TYPE(StepGeom_Parabola)) ||
+             BasisCurve->IsKind(STANDARD_TYPE(StepGeom_Hyperbola))) {
+      // LATER !!!
+    }
+//    CKY 16-DEC-1997 : USA60035 le texte de Part42 parle de degres
+//      mais des systemes ecrivent en radians. Exploiter UnitsMethods
+
+    const Standard_Real newU1 = shift + u1 * fact;
+    const Standard_Real newU2 = shift + u2 * fact;
+
+    const Handle(Geom2d_TrimmedCurve) theTrimmed =
+      new Geom2d_TrimmedCurve(theGeomBasis, newU1, newU2, SC->SenseAgreement());
+    return Geom2dConvert::CurveToBSplineCurve(theTrimmed);
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un VectorWithMagnitude de Geom a partir d' un Vector de Step
+//=============================================================================
+
+Handle(Geom_VectorWithMagnitude) StepToGeom::MakeVectorWithMagnitude (const Handle(StepGeom_Vector)& SV)
+{
+  // sln 22.10.2001. CTS23496: Vector is not created if direction have not been succesfully created
+  Handle(Geom_Direction) D = MakeDirection (SV->Orientation());
+  if (! D.IsNull())
+  {
+    const gp_Vec V(D->Dir().XYZ() * SV->Magnitude() * UnitsMethods::LengthFactor());
+    return new Geom_VectorWithMagnitude(V);
+  }
+  return 0;
+}
+
+//=============================================================================
+// Creation d' un VectorWithMagnitude de Geom2d a partir d' un Vector de Step
+//=============================================================================
+
+Handle(Geom2d_VectorWithMagnitude) StepToGeom::MakeVectorWithMagnitude2d (const Handle(StepGeom_Vector)& SV)
+{
+  // sln 23.10.2001. CTS23496: Vector is not created if direction have not been succesfully created (MakeVectorWithMagnitude2d(...) function)
+  Handle(Geom2d_Direction) D = MakeDirection2d (SV->Orientation());
+  if (! D.IsNull())
+  {
+    const gp_Vec2d V(D->Dir2d().XY() * SV->Magnitude());
+    return new Geom2d_VectorWithMagnitude(V);
+  }
+  return 0;
+}
diff --git a/src/StepToGeom/StepToGeom.hxx b/src/StepToGeom/StepToGeom.hxx
new file mode 100644 (file)
index 0000000..d95d975
--- /dev/null
@@ -0,0 +1,160 @@
+// 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 _StepToGeom_HeaderFile
+#define _StepToGeom_HeaderFile
+
+#include <Standard.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+
+class Geom_Axis1Placement;
+class Geom_Axis2Placement;
+class Geom_BoundedCurve;
+class Geom_BoundedSurface;
+class Geom_BSplineCurve;
+class Geom_BSplineSurface;
+class Geom_CartesianPoint;
+class Geom_Circle;
+class Geom_Conic;
+class Geom_ConicalSurface;
+class Geom_Curve;
+class Geom_CylindricalSurface;
+class Geom_Direction;
+class Geom_ElementarySurface;
+class Geom_Ellipse;
+class Geom_Hyperbola;
+class Geom_Line;
+class Geom_Parabola;
+class Geom_Plane;
+class Geom_RectangularTrimmedSurface;
+class Geom_SphericalSurface;
+class Geom_Surface;
+class Geom_SurfaceOfLinearExtrusion;
+class Geom_SurfaceOfRevolution;
+class Geom_SweptSurface;
+class Geom_ToroidalSurface;
+class Geom_TrimmedCurve;
+class Geom_VectorWithMagnitude;
+
+class Geom2d_AxisPlacement;
+class Geom2d_BoundedCurve;
+class Geom2d_BSplineCurve;
+class Geom2d_CartesianPoint;
+class Geom2d_Circle;
+class Geom2d_Conic;
+class Geom2d_Curve;
+class Geom2d_Direction;
+class Geom2d_Ellipse;
+class Geom2d_Hyperbola;
+class Geom2d_Line;
+class Geom2d_Parabola;
+class Geom2d_VectorWithMagnitude;
+
+class gp_Trsf;
+class gp_Trsf2d;
+
+class StepGeom_Axis1Placement;
+class StepGeom_Axis2Placement2d;
+class StepGeom_Axis2Placement3d;
+class StepGeom_BoundedCurve;
+class StepGeom_BoundedSurface;
+class StepGeom_BSplineCurve;
+class StepGeom_CartesianPoint;
+class StepGeom_Direction;
+
+class StepGeom_BSplineSurface;
+class StepGeom_Circle;
+class StepGeom_Conic;
+class StepGeom_ConicalSurface;
+class StepGeom_Curve;
+class StepGeom_CylindricalSurface;
+class StepGeom_ElementarySurface;
+class StepGeom_Ellipse;
+class StepGeom_Hyperbola;
+class StepGeom_Line;
+class StepGeom_Parabola;
+class StepGeom_Plane;
+class StepGeom_Polyline;
+class StepGeom_RectangularTrimmedSurface;
+class StepGeom_SphericalSurface;
+class StepGeom_Surface;
+class StepGeom_SurfaceOfLinearExtrusion;
+class StepGeom_SurfaceOfRevolution;
+class StepGeom_SweptSurface;
+class StepGeom_ToroidalSurface;
+class StepGeom_CartesianTransformationOperator2d;
+class StepGeom_CartesianTransformationOperator3d;
+class StepGeom_TrimmedCurve;
+class StepGeom_Vector;
+
+//! This class provides static methods to convert STEP geometric entities to OCCT.
+//! The methods returning handles will return null handle in case of error.
+//! The methods returning boolean will return True if succeeded and False if error.
+
+class StepToGeom
+{
+public:
+
+  Standard_EXPORT static Handle(Geom_Axis1Placement) MakeAxis1Placement (const Handle(StepGeom_Axis1Placement)& SA);
+  Standard_EXPORT static Handle(Geom_Axis2Placement) MakeAxis2Placement (const Handle(StepGeom_Axis2Placement3d)& SA);
+  Standard_EXPORT static Handle(Geom2d_AxisPlacement) MakeAxisPlacement (const Handle(StepGeom_Axis2Placement2d)& SA);
+  Standard_EXPORT static Handle(Geom_BoundedCurve) MakeBoundedCurve (const Handle(StepGeom_BoundedCurve)& SC);
+  Standard_EXPORT static Handle(Geom2d_BoundedCurve) MakeBoundedCurve2d (const Handle(StepGeom_BoundedCurve)& SC);
+  Standard_EXPORT static Handle(Geom_BoundedSurface) MakeBoundedSurface (const Handle(StepGeom_BoundedSurface)& SS);
+  Standard_EXPORT static Handle(Geom_BSplineCurve) MakeBSplineCurve (const Handle(StepGeom_BSplineCurve)& SC);
+  Standard_EXPORT static Handle(Geom2d_BSplineCurve) MakeBSplineCurve2d (const Handle(StepGeom_BSplineCurve)& SC);
+  Standard_EXPORT static Handle(Geom_BSplineSurface) MakeBSplineSurface (const Handle(StepGeom_BSplineSurface)& SS);
+  Standard_EXPORT static Handle(Geom_CartesianPoint) MakeCartesianPoint (const Handle(StepGeom_CartesianPoint)& SP);
+  Standard_EXPORT static Handle(Geom2d_CartesianPoint) MakeCartesianPoint2d (const Handle(StepGeom_CartesianPoint)& SP);
+  Standard_EXPORT static Handle(Geom_Circle) MakeCircle (const Handle(StepGeom_Circle)& SC);
+  Standard_EXPORT static Handle(Geom2d_Circle) MakeCircle2d (const Handle(StepGeom_Circle)& SC);
+  Standard_EXPORT static Handle(Geom_Conic) MakeConic (const Handle(StepGeom_Conic)& SC);
+  Standard_EXPORT static Handle(Geom2d_Conic) MakeConic2d (const Handle(StepGeom_Conic)& SC);
+  Standard_EXPORT static Handle(Geom_ConicalSurface) MakeConicalSurface (const Handle(StepGeom_ConicalSurface)& SS);
+  Standard_EXPORT static Handle(Geom_Curve) MakeCurve (const Handle(StepGeom_Curve)& SC);
+  Standard_EXPORT static Handle(Geom2d_Curve) MakeCurve2d (const Handle(StepGeom_Curve)& SC);
+  Standard_EXPORT static Handle(Geom_CylindricalSurface) MakeCylindricalSurface (const Handle(StepGeom_CylindricalSurface)& SS);
+  Standard_EXPORT static Handle(Geom_Direction) MakeDirection (const Handle(StepGeom_Direction)& SD);
+  Standard_EXPORT static Handle(Geom2d_Direction) MakeDirection2d (const Handle(StepGeom_Direction)& SD);
+  Standard_EXPORT static Handle(Geom_ElementarySurface) MakeElementarySurface (const Handle(StepGeom_ElementarySurface)& SS);
+  Standard_EXPORT static Handle(Geom_Ellipse) MakeEllipse (const Handle(StepGeom_Ellipse)& SC);
+  Standard_EXPORT static Handle(Geom2d_Ellipse) MakeEllipse2d (const Handle(StepGeom_Ellipse)& SC);
+  Standard_EXPORT static Handle(Geom_Hyperbola) MakeHyperbola (const Handle(StepGeom_Hyperbola)& SC);
+  Standard_EXPORT static Handle(Geom2d_Hyperbola) MakeHyperbola2d (const Handle(StepGeom_Hyperbola)& SC);
+  Standard_EXPORT static Handle(Geom_Line) MakeLine (const Handle(StepGeom_Line)& SC);
+  Standard_EXPORT static Handle(Geom2d_Line) MakeLine2d (const Handle(StepGeom_Line)& SC);
+  Standard_EXPORT static Handle(Geom_Parabola) MakeParabola (const Handle(StepGeom_Parabola)& SC);
+  Standard_EXPORT static Handle(Geom2d_Parabola) MakeParabola2d (const Handle(StepGeom_Parabola)& SC);
+  Standard_EXPORT static Handle(Geom_Plane) MakePlane (const Handle(StepGeom_Plane)& SP);
+  Standard_EXPORT static Handle(Geom_BSplineCurve) MakePolyline (const Handle(StepGeom_Polyline)& SPL);
+  Standard_EXPORT static Handle(Geom2d_BSplineCurve) MakePolyline2d (const Handle(StepGeom_Polyline)& SPL);
+  Standard_EXPORT static Handle(Geom_RectangularTrimmedSurface) MakeRectangularTrimmedSurface (const Handle(StepGeom_RectangularTrimmedSurface)& SS);
+  Standard_EXPORT static Handle(Geom_SphericalSurface) MakeSphericalSurface (const Handle(StepGeom_SphericalSurface)& SS);
+  Standard_EXPORT static Handle(Geom_Surface) MakeSurface (const Handle(StepGeom_Surface)& SS);
+  Standard_EXPORT static Handle(Geom_SurfaceOfLinearExtrusion) MakeSurfaceOfLinearExtrusion (const Handle(StepGeom_SurfaceOfLinearExtrusion)& SS);
+  Standard_EXPORT static Handle(Geom_SurfaceOfRevolution) MakeSurfaceOfRevolution (const Handle(StepGeom_SurfaceOfRevolution)& SS);
+  Standard_EXPORT static Handle(Geom_SweptSurface) MakeSweptSurface (const Handle(StepGeom_SweptSurface)& SS);
+  Standard_EXPORT static Handle(Geom_ToroidalSurface) MakeToroidalSurface (const Handle(StepGeom_ToroidalSurface)& SS);
+  Standard_EXPORT static Standard_Boolean MakeTransformation2d (const Handle(StepGeom_CartesianTransformationOperator2d)& SCTO, gp_Trsf2d& CT);
+  Standard_EXPORT static Standard_Boolean MakeTransformation3d (const Handle(StepGeom_CartesianTransformationOperator3d)& SCTO, gp_Trsf& CT);
+  Standard_EXPORT static Handle(Geom_TrimmedCurve) MakeTrimmedCurve (const Handle(StepGeom_TrimmedCurve)& SC);
+  Standard_EXPORT static Handle(Geom2d_BSplineCurve) MakeTrimmedCurve2d (const Handle(StepGeom_TrimmedCurve)& SC);
+  Standard_EXPORT static Handle(Geom_VectorWithMagnitude) MakeVectorWithMagnitude (const Handle(StepGeom_Vector)& SV);
+  Standard_EXPORT static Handle(Geom2d_VectorWithMagnitude) MakeVectorWithMagnitude2d (const Handle(StepGeom_Vector)& SV);
+};
+
+#endif // _StepToGeom_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeAxis1Placement.cxx b/src/StepToGeom/StepToGeom_MakeAxis1Placement.cxx
deleted file mode 100644 (file)
index c040272..0000000
+++ /dev/null
@@ -1,51 +0,0 @@
-// Created on: 1993-06-15
-// 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.
-
-// sln 22.10.2001. CTS23496: If problems with creation of axis's direction occur default direction is used (StepToGeom_MakeAxis1Placement(...) function)
-
-#include <Geom_Axis1Placement.hxx>
-#include <Geom_CartesianPoint.hxx>
-#include <Geom_Direction.hxx>
-#include <gp_Dir.hxx>
-#include <gp_Pnt.hxx>
-#include <StepGeom_Axis1Placement.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_Direction.hxx>
-#include <StepToGeom_MakeAxis1Placement.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <StepToGeom_MakeDirection.hxx>
-
-//=============================================================================
-// Creation d' un Ax1Placement de Geom a partir d' un axis1_placement de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeAxis1Placement::Convert (const Handle(StepGeom_Axis1Placement)& SA, Handle(Geom_Axis1Placement)& CA)
-{
-  Handle(Geom_CartesianPoint) P;
-  if (StepToGeom_MakeCartesianPoint::Convert(SA->Location(),P))
-  {
-    // sln 22.10.2001. CTS23496: If problems with creation of axis direction occur default direction is used
-    gp_Dir D(0.,0.,1.);
-    if (SA->HasAxis())
-    {
-      Handle(Geom_Direction) D1;
-      if (StepToGeom_MakeDirection::Convert(SA->Axis(),D1))
-        D = D1->Dir();
-    }
-    CA = new Geom_Axis1Placement(P->Pnt(),D);
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeAxis1Placement.hxx b/src/StepToGeom/StepToGeom_MakeAxis1Placement.hxx
deleted file mode 100644 (file)
index a12f11f..0000000
+++ /dev/null
@@ -1,63 +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.
-
-#ifndef _StepToGeom_MakeAxis1Placement_HeaderFile
-#define _StepToGeom_MakeAxis1Placement_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Axis1Placement;
-class Geom_Axis1Placement;
-
-
-//! This class implements the mapping between classes
-//! Axis1Placement from Step and Axis1Placement from Geom
-class StepToGeom_MakeAxis1Placement 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Axis1Placement)& SA, Handle(Geom_Axis1Placement)& CA);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeAxis1Placement_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeAxis2Placement.cxx b/src/StepToGeom/StepToGeom_MakeAxis2Placement.cxx
deleted file mode 100644 (file)
index 459f159..0000000
+++ /dev/null
@@ -1,72 +0,0 @@
-// Created on: 1993-07-01
-// 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.
-
-// sln 22.10.2001. CTS23496: If problems with creation of direction occur default direction is used (StepToGeom_MakeAxis2Placement(...) function)
-
-#include <Geom_Axis2Placement.hxx>
-#include <Geom_CartesianPoint.hxx>
-#include <Geom_Direction.hxx>
-#include <gp_Ax2.hxx>
-#include <gp_Dir.hxx>
-#include <gp_Pnt.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <StepToGeom_MakeDirection.hxx>
-
-//=============================================================================
-// Creation d' un Axis2Placement de Geom a partir d' un axis2_placement_3d
-// de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeAxis2Placement::Convert (const Handle(StepGeom_Axis2Placement3d)& SA, Handle(Geom_Axis2Placement)& CA)
-{
-  Handle(Geom_CartesianPoint) P;
-  if (StepToGeom_MakeCartesianPoint::Convert(SA->Location(),P))
-  {
-    const gp_Pnt Pgp = P->Pnt();
-  
-    // sln 22.10.2001. CTS23496: If problems with creation of direction occur default direction is used (StepToGeom_MakeLine(...) function)
-    gp_Dir Ngp(0.,0.,1.);
-    if (SA->HasAxis())
-    {
-      Handle(Geom_Direction) D;
-      if (StepToGeom_MakeDirection::Convert(SA->Axis(),D))
-        Ngp = D->Dir();
-    }
-  
-    gp_Ax2 gpAx2;
-    Standard_Boolean isDefaultDirectionUsed = Standard_True;
-    if (SA->HasRefDirection())
-    {
-      Handle(Geom_Direction) D;
-      if (StepToGeom_MakeDirection::Convert(SA->RefDirection(),D))
-      {
-        const gp_Dir Vxgp = D->Dir();
-        if (!Ngp.IsParallel(Vxgp,Precision::Angular()))
-        {
-          gpAx2 = gp_Ax2(Pgp, Ngp, Vxgp);
-          isDefaultDirectionUsed = Standard_False;
-        }
-      }
-    }
-    if(isDefaultDirectionUsed)
-      gpAx2 = gp_Ax2(Pgp, Ngp);
-
-    CA = new Geom_Axis2Placement(gpAx2);
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeAxis2Placement.hxx b/src/StepToGeom/StepToGeom_MakeAxis2Placement.hxx
deleted file mode 100644 (file)
index cac35c2..0000000
+++ /dev/null
@@ -1,63 +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.
-
-#ifndef _StepToGeom_MakeAxis2Placement_HeaderFile
-#define _StepToGeom_MakeAxis2Placement_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Axis2Placement3d;
-class Geom_Axis2Placement;
-
-
-//! This class implements the mapping between classes
-//! Axis2Placement from Step and Axis2Placement from Geom
-class StepToGeom_MakeAxis2Placement 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Axis2Placement3d)& SA, Handle(Geom_Axis2Placement)& CA);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeAxis2Placement_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeAxisPlacement.cxx b/src/StepToGeom/StepToGeom_MakeAxisPlacement.cxx
deleted file mode 100644 (file)
index 7726597..0000000
+++ /dev/null
@@ -1,52 +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.
-
-// sln 23.10.2001. CTS23496: If problems with creation of direction occur default direction is used
-
-#include <Geom2d_AxisPlacement.hxx>
-#include <Geom2d_CartesianPoint.hxx>
-#include <Geom2d_Direction.hxx>
-#include <gp_Dir2d.hxx>
-#include <gp_Pnt2d.hxx>
-#include <StepGeom_Axis2Placement2d.hxx>
-#include <StepToGeom_MakeAxisPlacement.hxx>
-#include <StepToGeom_MakeCartesianPoint2d.hxx>
-#include <StepToGeom_MakeDirection2d.hxx>
-
-//=============================================================================
-// Creation d' un AxisPlacement de Geom2d a partir d' un axis2_placement_3d
-// de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeAxisPlacement::Convert
-  (const Handle(StepGeom_Axis2Placement2d)& SA,
-   Handle(Geom2d_AxisPlacement)& CA)
-{
-  Handle(Geom2d_CartesianPoint) P;
-  if (StepToGeom_MakeCartesianPoint2d::Convert(SA->Location(),P))
-  {
-    // sln 23.10.2001. CTS23496: If problems with creation of direction occur default direction is used
-    gp_Dir2d Vxgp(1.,0.);
-    if (SA->HasRefDirection()) {
-      Handle(Geom2d_Direction) Vx;
-      if (StepToGeom_MakeDirection2d::Convert(SA->RefDirection(),Vx))
-        Vxgp = Vx->Dir2d();
-    }
-
-    CA = new Geom2d_AxisPlacement(P->Pnt2d(),Vxgp);
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeAxisPlacement.hxx b/src/StepToGeom/StepToGeom_MakeAxisPlacement.hxx
deleted file mode 100644 (file)
index 50c6f09..0000000
+++ /dev/null
@@ -1,63 +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.
-
-#ifndef _StepToGeom_MakeAxisPlacement_HeaderFile
-#define _StepToGeom_MakeAxisPlacement_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Axis2Placement2d;
-class Geom2d_AxisPlacement;
-
-
-//! This class implements the mapping between classes
-//! Axis2Placement2d from Step and AxisPlacement from Geom2d
-class StepToGeom_MakeAxisPlacement 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Axis2Placement2d)& SA, Handle(Geom2d_AxisPlacement)& CA);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeAxisPlacement_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeBSplineCurve.cxx b/src/StepToGeom/StepToGeom_MakeBSplineCurve.cxx
deleted file mode 100644 (file)
index 663777a..0000000
+++ /dev/null
@@ -1,59 +0,0 @@
-// Created on: 1993-07-01
-// 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.
-
-
-#include <Geom_BSplineCurve.hxx>
-#include <Geom_CartesianPoint.hxx>
-#include <gp_Pnt.hxx>
-#include <StepGeom_BSplineCurve.hxx>
-#include <StepGeom_BSplineCurveWithKnots.hxx>
-#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_HArray1OfCartesianPoint.hxx>
-#include <StepToGeom_MakeBSplineCurve.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <TColgp_Array1OfPnt.hxx>
-#include <TColStd_Array1OfInteger.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <TColStd_HArray1OfInteger.hxx>
-#include <TColStd_HArray1OfReal.hxx>
-
-//=============================================================================
-// Creation d' une BSplineCurve de Geom a partir d' une BSplineCurve de Step
-//=============================================================================
-#define Array1OfPnt_gen                  TColgp_Array1OfPnt
-#define Pnt_gen                          gp_Pnt
-#define Pnt_fonc                         Pnt
-#define CartesianPoint_gen               Handle(Geom_CartesianPoint)
-#define StepToGeom_MakeCartesianPoint_gen StepToGeom_MakeCartesianPoint
-#define BSplineCurve_gen                 Geom_BSplineCurve
-#define BSplineCurve_retour              Handle(Geom_BSplineCurve)
-#define StepToGeom_MakeBSplineCurve_gen   StepToGeom_MakeBSplineCurve
-
-Standard_Boolean StepToGeom_MakeBSplineCurve::Convert
-    (const Handle(StepGeom_BSplineCurve)& SC,
-     Handle(Geom_BSplineCurve)& CC)
-  
-#include <StepToGeom_MakeBSplineCurve.pxx>
-
-#undef Array1OfPnt_gen
-#undef Pnt_gen
-#undef Pnt_fonc
-#undef CartesianPoint_gen
-#undef StepToGeom_MakeCartesianPoint_gen
-#undef BSplineCurve_gen
-#undef StepToGeom_MakeBSplineCurve_gen
-#undef BSplineCurve_retour
diff --git a/src/StepToGeom/StepToGeom_MakeBSplineCurve.hxx b/src/StepToGeom/StepToGeom_MakeBSplineCurve.hxx
deleted file mode 100644 (file)
index 5b89618..0000000
+++ /dev/null
@@ -1,63 +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.
-
-#ifndef _StepToGeom_MakeBSplineCurve_HeaderFile
-#define _StepToGeom_MakeBSplineCurve_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_BSplineCurve;
-class Geom_BSplineCurve;
-
-
-//! This class implements the mapping between all classes of
-//! BSplineCurve from StepGeom and BSplineCurve from Geom
-class StepToGeom_MakeBSplineCurve 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_BSplineCurve)& SC, Handle(Geom_BSplineCurve)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeBSplineCurve_HeaderFile
index ee5f6ad..9692b4e 100644 (file)
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
-{
   Handle(StepGeom_BSplineCurveWithKnots)   BSCW;
   Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve) BSCWR;
 
   if (SC->IsKind(STANDARD_TYPE(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve))) {
-    BSCWR = 
-      Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)
-       ::DownCast(SC);
-    BSCW = 
-      Handle(StepGeom_BSplineCurveWithKnots)
-       ::DownCast(BSCWR->BSplineCurveWithKnots());
+    BSCWR = Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)::DownCast(SC);
+    BSCW = Handle(StepGeom_BSplineCurveWithKnots)::DownCast(BSCWR->BSplineCurveWithKnots());
   }
   else
     BSCW = Handle(StepGeom_BSplineCurveWithKnots)::DownCast(SC);
   const Handle(StepGeom_HArray1OfCartesianPoint)& aControlPointsList = BSCW->ControlPointsList();
   Standard_Integer aSumMulDiff = aFMulDiff + aLMulDiff;
   Array1OfPnt_gen Poles(1,NbPoles - aSumMulDiff);
-  CartesianPoint_gen P;
   
   for (i = 1 + aFMulDiff; i<= NbPoles - aLMulDiff; ++i)
   {
-    if (StepToGeom_MakeCartesianPoint_gen::Convert(aControlPointsList->Value(i),P))
+    CartesianPoint_gen P = MakeCartesianPoint_gen (aControlPointsList->Value(i));
+    if (! P.IsNull())
       Poles.SetValue(i - aFMulDiff,P->Pnt_fonc());
     else
-      return Standard_False;
+      return 0;
   }
   
   // --- Does the Curve descriptor LOOKS like a periodic descriptor ? ---
     shouldBePeriodic = Standard_False;
     //cout << "Strange BSpline Curve Descriptor" << endl;
   }
-  
+
+  BSplineCurve_retour CC;
   if (SC->IsKind(STANDARD_TYPE(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve))) {
     const Handle(TColStd_HArray1OfReal)& aWeight = BSCWR->WeightsData();
     TColStd_Array1OfReal W(1,NbPoles);
   if ( SC->ClosedCurve() && CC->Degree() >1 && CC->IsClosed() ) {
     CC->SetPeriodic();
   }
-  return Standard_True;
-}
+  return CC;
diff --git a/src/StepToGeom/StepToGeom_MakeBSplineCurve2d.cxx b/src/StepToGeom/StepToGeom_MakeBSplineCurve2d.cxx
deleted file mode 100644 (file)
index f11a219..0000000
+++ /dev/null
@@ -1,60 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-
-#include <Geom2d_BSplineCurve.hxx>
-#include <Geom2d_CartesianPoint.hxx>
-#include <gp_Pnt2d.hxx>
-#include <StepGeom_BSplineCurve.hxx>
-#include <StepGeom_BSplineCurveWithKnots.hxx>
-#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_HArray1OfCartesianPoint.hxx>
-#include <StepToGeom_MakeBSplineCurve2d.hxx>
-#include <StepToGeom_MakeCartesianPoint2d.hxx>
-#include <TColgp_Array1OfPnt2d.hxx>
-#include <TColStd_Array1OfInteger.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <TColStd_HArray1OfInteger.hxx>
-#include <TColStd_HArray1OfReal.hxx>
-
-//=============================================================================
-// Creation d' une BSplineCurve de Geom2d a partir d' une
-// BSplineCurveWithKnotsAndRationalBSplineCurve de Step
-//=============================================================================
-#define Array1OfPnt_gen                  TColgp_Array1OfPnt2d
-#define Pnt_gen                          gp_Pnt2d
-#define CartesianPoint_gen               Handle(Geom2d_CartesianPoint)
-#define StepToGeom_MakeCartesianPoint_gen StepToGeom_MakeCartesianPoint2d
-#define Pnt_fonc                         Pnt2d
-#define BSplineCurve_gen                 Geom2d_BSplineCurve
-#define BSplineCurve_retour              Handle(Geom2d_BSplineCurve)
-#define StepToGeom_MakeBSplineCurve_gen   StepToGeom_MakeBSplineCurve2d
-
-Standard_Boolean StepToGeom_MakeBSplineCurve2d::Convert
-    (const Handle(StepGeom_BSplineCurve)& SC,
-     Handle(Geom2d_BSplineCurve)& CC)
-
-#include <StepToGeom_MakeBSplineCurve.pxx>
-
-#undef Array1OfPnt_gen
-#undef Pnt_gen
-#undef CartesianPoint_gen
-#undef StepToGeom_MakeCartesianPoint_gen
-#undef Pnt_fonc
-#undef BSplineCurve_gen
-#undef StepToGeom_MakeBSplineCurve_gen
-#undef BSplineCurve_retour
diff --git a/src/StepToGeom/StepToGeom_MakeBSplineCurve2d.hxx b/src/StepToGeom/StepToGeom_MakeBSplineCurve2d.hxx
deleted file mode 100644 (file)
index 3d6277e..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-// Created on: 1993-07-06
-// 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 _StepToGeom_MakeBSplineCurve2d_HeaderFile
-#define _StepToGeom_MakeBSplineCurve2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_BSplineCurve;
-class Geom2d_BSplineCurve;
-
-
-//! This class implements the mapping between classes
-//! BSplineCurve from StepGeom and BSplineCurve from Geom2d
-class StepToGeom_MakeBSplineCurve2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_BSplineCurve)& SC, Handle(Geom2d_BSplineCurve)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeBSplineCurve2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeBSplineSurface.cxx b/src/StepToGeom/StepToGeom_MakeBSplineSurface.cxx
deleted file mode 100644 (file)
index 50f4f17..0000000
+++ /dev/null
@@ -1,199 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-
-#include <Geom_BSplineSurface.hxx>
-#include <Geom_CartesianPoint.hxx>
-#include <gp_Pnt.hxx>
-#include <StepGeom_BSplineSurface.hxx>
-#include <StepGeom_BSplineSurfaceWithKnots.hxx>
-#include <StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_HArray2OfCartesianPoint.hxx>
-#include <StepToGeom_MakeBSplineSurface.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <TColgp_Array2OfPnt.hxx>
-#include <TColStd_Array1OfInteger.hxx>
-#include <TColStd_Array1OfReal.hxx>
-#include <TColStd_HArray1OfInteger.hxx>
-#include <TColStd_HArray1OfReal.hxx>
-#include <TColStd_HArray2OfReal.hxx>
-
-//=============================================================================
-// Creation d' une BSplineSurface de Geom a partir d' une
-// BSplineSurface de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeBSplineSurface::Convert
-    (const Handle(StepGeom_BSplineSurface)& SS,
-     Handle(Geom_BSplineSurface)& CS)
-{
-  Standard_Integer                    i, j;
-  Handle(StepGeom_BSplineSurfaceWithKnots) BS;
-  Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) BSR;
-
-  if (SS->
-      IsKind(STANDARD_TYPE(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface))) {
-    BSR = 
-      Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface)
-       ::DownCast(SS);
-    BS = 
-      Handle(StepGeom_BSplineSurfaceWithKnots)
-       ::DownCast(BSR->BSplineSurfaceWithKnots());
-  }
-  else
-    BS = Handle(StepGeom_BSplineSurfaceWithKnots)::DownCast(SS);
-
-  const Standard_Integer UDeg = BS->UDegree();
-  const Standard_Integer VDeg = BS->VDegree();
-  const Standard_Integer NUPoles = BS->NbControlPointsListI();
-  const Standard_Integer NVPoles = BS->NbControlPointsListJ();
-  const Handle(StepGeom_HArray2OfCartesianPoint)& aControlPointsList = BS->ControlPointsList();
-  Handle(Geom_CartesianPoint) P;
-  TColgp_Array2OfPnt Poles(1,NUPoles,1,NVPoles);
-  for (i=1; i<=NUPoles; i++) {
-    for (j=1; j<=NVPoles; j++) {
-      if (StepToGeom_MakeCartesianPoint::Convert(aControlPointsList->Value(i,j),P))
-        Poles.SetValue(i,j,P->Pnt());
-         else
-        return Standard_False;
-    }
-  }
-  const Standard_Integer NUKnots = BS->NbUMultiplicities();
-  const Handle(TColStd_HArray1OfInteger)& aUMultiplicities = BS->UMultiplicities();
-  const Handle(TColStd_HArray1OfReal)& aUKnots = BS->UKnots();
-  
-  // count number of unique uknots
-  Standard_Real lastKnot = RealFirst();
-  Standard_Integer NUKnotsUnique = 0;
-  for (i=1; i<=NUKnots; i++) {
-    if (aUKnots->Value(i) - lastKnot > Epsilon (Abs(lastKnot))) {
-      NUKnotsUnique++;
-      lastKnot = aUKnots->Value(i);
-    }
-  }
-
-  // set umultiplicities and uknots
-  TColStd_Array1OfInteger UMult(1,NUKnotsUnique);
-  TColStd_Array1OfReal KUn(1,NUKnotsUnique);
-  Standard_Integer pos = 1;
-  lastKnot = aUKnots->Value(1);
-  KUn.SetValue(1, aUKnots->Value(1));
-  UMult.SetValue(1, aUMultiplicities->Value(1));
-  for (i=2; i<=NUKnots; i++) {
-    if (aUKnots->Value(i) - lastKnot > Epsilon (Abs(lastKnot))) {
-      pos++;
-      KUn.SetValue(pos, aUKnots->Value(i));
-      UMult.SetValue(pos, aUMultiplicities->Value(i));
-      lastKnot = aUKnots->Value(i);
-    }
-    else {
-      // Knot not unique, increase multiplicity
-      Standard_Integer curMult = UMult.Value(pos);
-      UMult.SetValue(pos, curMult + aUMultiplicities->Value(i));
-    }
-  }
-  const Standard_Integer NVKnots = BS->NbVMultiplicities();
-  const Handle(TColStd_HArray1OfInteger)& aVMultiplicities = BS->VMultiplicities();
-  const Handle(TColStd_HArray1OfReal)& aVKnots = BS->VKnots();
-  
-  // count number of unique vknots
-  lastKnot = RealFirst();
-  Standard_Integer NVKnotsUnique = 0;
-  for (i=1; i<=NVKnots; i++) {
-    if (aVKnots->Value(i) - lastKnot > Epsilon (Abs(lastKnot))) {
-      NVKnotsUnique++;
-      lastKnot = aVKnots->Value(i);
-    }
-  }
-  
-  // set vmultiplicities and vknots
-  TColStd_Array1OfInteger VMult(1,NVKnotsUnique);
-  TColStd_Array1OfReal KVn(1,NVKnotsUnique);
-  pos = 1;
-  lastKnot = aVKnots->Value(1);
-  KVn.SetValue(1, aVKnots->Value(1));
-  VMult.SetValue(1, aVMultiplicities->Value(1));
-  for (i=2; i<=NVKnots; i++) {
-    if (aVKnots->Value(i) - lastKnot > Epsilon (Abs(lastKnot))) {
-      pos++;
-      KVn.SetValue(pos, aVKnots->Value(i));
-      VMult.SetValue(pos, aVMultiplicities->Value(i));
-      lastKnot = aVKnots->Value(i);
-    }
-    else {
-      // Knot not unique, increase multiplicity
-      Standard_Integer curMult = VMult.Value(pos);
-      VMult.SetValue(pos, curMult + aVMultiplicities->Value(i));
-    }
-  }
-  
-  // --- Does the Surface Descriptor LOOKS like a U and/or V Periodic ---
-  // --- Descriptor ? ---
-  
-  // --- U Periodic ? ---
-  
-  Standard_Integer SumMult = 0;
-  for (i=1; i<=NUKnotsUnique; i++) {
-    SumMult += UMult.Value(i);
-  }
-  
-  Standard_Boolean shouldBeUPeriodic = Standard_False;
-  if (SumMult == (NUPoles + UDeg + 1)) {
-    //shouldBeUPeriodic = Standard_False;
-  }
-  else if ((UMult.Value(1) == 
-           UMult.Value(NUKnotsUnique)) &&
-          ((SumMult - UMult.Value(1))== NUPoles)) {
-    shouldBeUPeriodic = Standard_True;
-  }
-  
-  // --- V Periodic ? ---
-  
-  SumMult = 0;
-  for (i=1; i<=NVKnotsUnique; i++) {
-    SumMult += VMult.Value(i);
-  }
-  
-  Standard_Boolean shouldBeVPeriodic = Standard_False;
-  if (SumMult == (NVPoles + VDeg + 1)) {
-    //shouldBeVPeriodic = Standard_False;
-  }
-  else if ((VMult.Value(1) == 
-           VMult.Value(NVKnotsUnique)) &&
-          ((SumMult - VMult.Value(1)) == NVPoles)) {
-    shouldBeVPeriodic = Standard_True;
-  }
-  
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface))) {
-    const Handle(TColStd_HArray2OfReal)& aWeight = BSR->WeightsData();
-    TColStd_Array2OfReal W(1,NUPoles,1,NVPoles);
-    for (i=1; i<=NUPoles; i++) {
-      for (j=1; j<=NVPoles; j++) {
-        W.SetValue(i,j,aWeight->Value(i,j));
-      }
-    }
-    CS = new Geom_BSplineSurface(Poles, W, KUn, KVn, UMult,
-                                 VMult, UDeg, VDeg,
-                                 shouldBeUPeriodic,
-                                 shouldBeVPeriodic);
-  }
-  else
-    CS = new Geom_BSplineSurface(Poles, KUn, KVn, UMult,
-                                 VMult, UDeg, VDeg,
-                                 shouldBeUPeriodic,
-                                 shouldBeVPeriodic);
-  return Standard_True;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeBSplineSurface.hxx b/src/StepToGeom/StepToGeom_MakeBSplineSurface.hxx
deleted file mode 100644 (file)
index 9fb0306..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeBSplineSurface_HeaderFile
-#define _StepToGeom_MakeBSplineSurface_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_BSplineSurface;
-class Geom_BSplineSurface;
-
-
-//! This class implements the mapping between classes
-//! BSplineSurface from StepGeom
-//! and class BSplineSurface from Geom
-class StepToGeom_MakeBSplineSurface 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_BSplineSurface)& SS, Handle(Geom_BSplineSurface)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeBSplineSurface_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeBoundedCurve.cxx b/src/StepToGeom/StepToGeom_MakeBoundedCurve.cxx
deleted file mode 100644 (file)
index 6883ebc..0000000
+++ /dev/null
@@ -1,185 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-//:n6 abv 15.02.99: S4132: adding translation of polyline
-//:p0 abv 19.02.99: management of 'done' flag improved; trimmed_curve treated
-
-#include <Geom_BSplineCurve.hxx>
-#include <Geom_TrimmedCurve.hxx>
-#include <StepGeom_BezierCurve.hxx>
-#include <StepGeom_BoundedCurve.hxx>
-#include <StepGeom_BSplineCurveWithKnots.hxx>
-#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
-#include <StepGeom_KnotType.hxx>
-#include <StepGeom_Polyline.hxx>
-#include <StepGeom_QuasiUniformCurve.hxx>
-#include <StepGeom_QuasiUniformCurveAndRationalBSplineCurve.hxx>
-#include <StepGeom_TrimmedCurve.hxx>
-#include <StepGeom_UniformCurve.hxx>
-#include <StepGeom_UniformCurveAndRationalBSplineCurve.hxx>
-#include <StepToGeom_MakeBoundedCurve.hxx>
-#include <StepToGeom_MakeBSplineCurve.hxx>
-#include <StepToGeom_MakePolyline.hxx>
-#include <StepToGeom_MakeTrimmedCurve.hxx>
-#include <TColStd_HArray1OfInteger.hxx>
-#include <TColStd_HArray1OfReal.hxx>
-
-//=============================================================================
-// Creation d' une BoundedCurve de Geom a partir d' une BoundedCurve de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeBoundedCurve::Convert
-    (const Handle(StepGeom_BoundedCurve)& SC,
-     Handle(Geom_BoundedCurve)& CC)
-{
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve))) {
-    const Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)
-      Bspli = Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)::DownCast(SC);
-       return StepToGeom_MakeBSplineCurve::Convert(Bspli,Handle(Geom_BSplineCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_BSplineCurveWithKnots))) {
-    const Handle(StepGeom_BSplineCurveWithKnots)
-      Bspli = Handle(StepGeom_BSplineCurveWithKnots)::DownCast(SC);
-       return StepToGeom_MakeBSplineCurve::Convert(Bspli,Handle(Geom_BSplineCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_TrimmedCurve))) {
-    const Handle(StepGeom_TrimmedCurve) L = Handle(StepGeom_TrimmedCurve)::DownCast(SC);
-       return StepToGeom_MakeTrimmedCurve::Convert(L,Handle(Geom_TrimmedCurve)::DownCast (CC));
-  }
-  // STEP BezierCurve, UniformCurve and QuasiUniformCurve are transformed into
-  // STEP BSplineCurve before being mapped onto CAS.CADE/SF
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_BezierCurve))) {
-    const Handle(StepGeom_BezierCurve) BzC = Handle(StepGeom_BezierCurve)::DownCast(SC);
-    Standard_Integer aDegree = BzC->Degree();
-    if (aDegree < 1 || aDegree > Geom_BSplineCurve::MaxDegree())
-      return Standard_False;
-    const Handle(StepGeom_BSplineCurveWithKnots) BSPL = new StepGeom_BSplineCurveWithKnots;
-    BSPL->SetDegree(aDegree);
-    BSPL->SetControlPointsList(BzC->ControlPointsList());
-    BSPL->SetCurveForm(BzC->CurveForm());
-    BSPL->SetClosedCurve(BzC->ClosedCurve());
-    BSPL->SetSelfIntersect(BzC->SelfIntersect());
-    // Compute Knots and KnotsMultiplicity
-    const Handle(TColStd_HArray1OfInteger) Kmult = new TColStd_HArray1OfInteger(1,2);
-    const Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(1,2);
-    Kmult->SetValue(1, BzC->Degree() + 1);
-    Kmult->SetValue(2, BzC->Degree() + 1);
-    Knots->SetValue(1, 0.);
-    Knots->SetValue(2, 1.);
-    BSPL->SetKnotMultiplicities(Kmult);
-    BSPL->SetKnots(Knots);
-       return StepToGeom_MakeBSplineCurve::Convert(BSPL,Handle(Geom_BSplineCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_UniformCurve))) {
-    const Handle(StepGeom_UniformCurve) UC = Handle(StepGeom_UniformCurve)::DownCast(SC);
-    Standard_Integer aDegree = UC->Degree();
-    if (aDegree < 1 || aDegree > Geom_BSplineCurve::MaxDegree())
-      return Standard_False;
-    const Handle(StepGeom_BSplineCurveWithKnots) BSPL = new StepGeom_BSplineCurveWithKnots;
-    BSPL->SetDegree(aDegree);
-    BSPL->SetControlPointsList(UC->ControlPointsList());
-    BSPL->SetCurveForm(UC->CurveForm());
-    BSPL->SetClosedCurve(UC->ClosedCurve());
-    BSPL->SetSelfIntersect(UC->SelfIntersect());
-    // Compute Knots and KnotsMultiplicity
-    const Standard_Integer nbK = BSPL->NbControlPointsList() + BSPL->Degree() + 1;
-    const Handle(TColStd_HArray1OfInteger) Kmult = new TColStd_HArray1OfInteger(1,nbK);
-    const Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(1,nbK);
-    for (Standard_Integer iUC = 1 ; iUC <= nbK ; iUC ++) {
-      Kmult->SetValue(iUC, 1);
-      Knots->SetValue(iUC, iUC - 1.);
-    }
-    BSPL->SetKnotMultiplicities(Kmult);
-    BSPL->SetKnots(Knots);
-       return StepToGeom_MakeBSplineCurve::Convert(BSPL,Handle(Geom_BSplineCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_QuasiUniformCurve))) {
-    const Handle(StepGeom_QuasiUniformCurve) QUC = 
-      Handle(StepGeom_QuasiUniformCurve)::DownCast(SC);
-    Standard_Integer aDegree = QUC->Degree();
-    if (aDegree < 1 || aDegree > Geom_BSplineCurve::MaxDegree())
-      return Standard_False;
-    const Handle(StepGeom_BSplineCurveWithKnots) BSPL = new StepGeom_BSplineCurveWithKnots;
-    BSPL->SetDegree(aDegree);
-    BSPL->SetControlPointsList(QUC->ControlPointsList());
-    BSPL->SetCurveForm(QUC->CurveForm());
-    BSPL->SetClosedCurve(QUC->ClosedCurve());
-    BSPL->SetSelfIntersect(QUC->SelfIntersect());
-    // Compute Knots and KnotsMultiplicity
-    const Standard_Integer nbK = BSPL->NbControlPointsList() - BSPL->Degree() + 1;
-    const Handle(TColStd_HArray1OfInteger) Kmult = new TColStd_HArray1OfInteger(1,nbK);
-    const Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(1,nbK);
-    for (Standard_Integer iQUC = 1 ; iQUC <= nbK ; iQUC ++) {
-      Kmult->SetValue(iQUC, 1);
-      Knots->SetValue(iQUC, iQUC - 1.);
-    }
-    Kmult->SetValue(1, BSPL->Degree() + 1);
-    Kmult->SetValue(nbK, BSPL->Degree() + 1);
-    BSPL->SetKnotMultiplicities(Kmult);
-    BSPL->SetKnots(Knots);
-       return StepToGeom_MakeBSplineCurve::Convert(BSPL,Handle(Geom_BSplineCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_UniformCurveAndRationalBSplineCurve))) {
-    const Handle(StepGeom_UniformCurveAndRationalBSplineCurve) RUC = 
-      Handle(StepGeom_UniformCurveAndRationalBSplineCurve)::DownCast(SC);
-    Standard_Integer aDegree = RUC->Degree();
-    if (aDegree < 1 || aDegree > Geom_BSplineCurve::MaxDegree())
-      return Standard_False;
-    const Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve) RBSPL = 
-      new StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve;
-    // Compute Knots and KnotsMultiplicity
-    const Standard_Integer nbK = RUC->NbControlPointsList() + aDegree + 1;
-    const Handle(TColStd_HArray1OfInteger) Kmult = new TColStd_HArray1OfInteger(1,nbK);
-    const Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(1,nbK);
-    for (Standard_Integer iUC = 1 ; iUC <= nbK ; iUC ++) {
-      Kmult->SetValue(iUC, 1);
-      Knots->SetValue(iUC, iUC - 1.);
-    }
-    // Initialize the BSplineCurveWithKnotsAndRationalBSplineCurve
-    RBSPL->Init(RUC->Name(), aDegree, RUC->ControlPointsList(), RUC->CurveForm(),
-               RUC->ClosedCurve(), RUC->SelfIntersect(), Kmult, Knots, StepGeom_ktUnspecified,
-               RUC->WeightsData());
-       return StepToGeom_MakeBSplineCurve::Convert(RBSPL,Handle(Geom_BSplineCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_QuasiUniformCurveAndRationalBSplineCurve))) {
-    const Handle(StepGeom_QuasiUniformCurveAndRationalBSplineCurve) RQUC = 
-      Handle(StepGeom_QuasiUniformCurveAndRationalBSplineCurve)::DownCast(SC);
-    Standard_Integer aDegree = RQUC->Degree();
-    if (aDegree < 1 || aDegree > Geom_BSplineCurve::MaxDegree())
-      return Standard_False;
-    const Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve) RBSPL = 
-      new StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve;
-    // Compute Knots and KnotsMultiplicity
-    const Standard_Integer nbK = RQUC->NbControlPointsList() - aDegree + 1;
-    const Handle(TColStd_HArray1OfInteger) Kmult = new TColStd_HArray1OfInteger(1,nbK);
-    const Handle(TColStd_HArray1OfReal) Knots = new TColStd_HArray1OfReal(1,nbK);
-    for (Standard_Integer iRQUC = 1 ; iRQUC <= nbK ; iRQUC ++) {
-      Kmult->SetValue(iRQUC, 1);
-      Knots->SetValue(iRQUC, iRQUC - 1.);
-    }
-    Kmult->SetValue(1, aDegree + 1);
-    Kmult->SetValue(nbK, aDegree + 1);
-    // Initialize the BSplineCurveWithKnotsAndRationalBSplineCurve
-    RBSPL->Init(RQUC->Name(), aDegree, RQUC->ControlPointsList(), RQUC->CurveForm(),
-               RQUC->ClosedCurve(), RQUC->SelfIntersect(), Kmult, Knots, StepGeom_ktUnspecified,
-               RQUC->WeightsData());
-       return StepToGeom_MakeBSplineCurve::Convert(RBSPL,Handle(Geom_BSplineCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Polyline))) { //:n6 abv 15 Feb 99
-    const Handle(StepGeom_Polyline) PL = Handle(StepGeom_Polyline)::DownCast (SC);
-    return StepToGeom_MakePolyline::Convert(PL,Handle(Geom_BSplineCurve)::DownCast (CC));
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeBoundedCurve.hxx b/src/StepToGeom/StepToGeom_MakeBoundedCurve.hxx
deleted file mode 100644 (file)
index dfa0050..0000000
+++ /dev/null
@@ -1,67 +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.
-
-#ifndef _StepToGeom_MakeBoundedCurve_HeaderFile
-#define _StepToGeom_MakeBoundedCurve_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_BoundedCurve;
-class Geom_BoundedCurve;
-
-
-//! This class implements the mapping between classes
-//! BoundedCurve from
-//! StepGeom which describes a BoundedCurve from
-//! prostep and BoundedCurve from  Geom.
-//! As BoundedCurve is an abstract BoundedCurve this class
-//! is an access to the sub-class required.
-class StepToGeom_MakeBoundedCurve 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_BoundedCurve)& SC, Handle(Geom_BoundedCurve)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeBoundedCurve_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeBoundedCurve2d.cxx b/src/StepToGeom/StepToGeom_MakeBoundedCurve2d.cxx
deleted file mode 100644 (file)
index 7fd3969..0000000
+++ /dev/null
@@ -1,55 +0,0 @@
-// Created on: 1993-08-04
-// 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.
-
-//:n6 abv 15.02.99: S4132: adding translation of polyline
-//:p0 abv 19.02.99: management of 'done' flag improved
-
-#include <Geom2d_BSplineCurve.hxx>
-#include <StepGeom_BoundedCurve.hxx>
-#include <StepGeom_BSplineCurveWithKnots.hxx>
-#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
-#include <StepGeom_Polyline.hxx>
-#include <StepGeom_TrimmedCurve.hxx>
-#include <StepToGeom_MakeBoundedCurve2d.hxx>
-#include <StepToGeom_MakeBSplineCurve2d.hxx>
-#include <StepToGeom_MakePolyline2d.hxx>
-#include <StepToGeom_MakeTrimmedCurve2d.hxx>
-
-//=============================================================================
-// Creation d' une BoundedCurve de Geom a partir d' une BoundedCurve de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeBoundedCurve2d::Convert (const Handle(StepGeom_BoundedCurve)& SC, Handle(Geom2d_BoundedCurve)& CC)
-{
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve))) {
-    const Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)
-      Bspli = Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)::DownCast(SC);
-       return StepToGeom_MakeBSplineCurve2d::Convert(Bspli,Handle(Geom2d_BSplineCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_BSplineCurveWithKnots))) {
-    const Handle(StepGeom_BSplineCurveWithKnots)
-      Bspli = Handle(StepGeom_BSplineCurveWithKnots)::DownCast(SC);
-       return StepToGeom_MakeBSplineCurve2d::Convert(Bspli,Handle(Geom2d_BSplineCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_TrimmedCurve))) {
-    const Handle(StepGeom_TrimmedCurve) TC = Handle(StepGeom_TrimmedCurve)::DownCast(SC);
-       return StepToGeom_MakeTrimmedCurve2d::Convert(TC,Handle(Geom2d_BSplineCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Polyline))) { //:n6 abv 15 Feb 99
-    const Handle(StepGeom_Polyline) PL = Handle(StepGeom_Polyline)::DownCast(SC);
-       return StepToGeom_MakePolyline2d::Convert(PL,Handle(Geom2d_BSplineCurve)::DownCast (CC));
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeBoundedCurve2d.hxx b/src/StepToGeom/StepToGeom_MakeBoundedCurve2d.hxx
deleted file mode 100644 (file)
index c7dd715..0000000
+++ /dev/null
@@ -1,67 +0,0 @@
-// Created on: 1993-08-04
-// 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 _StepToGeom_MakeBoundedCurve2d_HeaderFile
-#define _StepToGeom_MakeBoundedCurve2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_BoundedCurve;
-class Geom2d_BoundedCurve;
-
-
-//! This class implements the mapping between classes
-//! BoundedCurve from
-//! StepGeom which describes a BoundedCurve from
-//! prostep and BoundedCurve from  Geom2d.
-//! As BoundedCurve is an abstract BoundedCurve this class
-//! is an access to the sub-class required.
-class StepToGeom_MakeBoundedCurve2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_BoundedCurve)& SC, Handle(Geom2d_BoundedCurve)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeBoundedCurve2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeBoundedSurface.cxx b/src/StepToGeom/StepToGeom_MakeBoundedSurface.cxx
deleted file mode 100644 (file)
index 0fc13ed..0000000
+++ /dev/null
@@ -1,240 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-//:p0 abv 19.02.99: management of 'done' flag improved
-//:j7 abv 05.04.99: S4136: ass-tol2.stp #9861: avoid using CheckSurfaceClosure
-//    rln 02.06.99 removing #include <StepToGeom_CheckSurfaceClosure.hxx>
-
-#include <Geom_BSplineSurface.hxx>
-#include <Geom_RectangularTrimmedSurface.hxx>
-#include <StepGeom_BezierSurface.hxx>
-#include <StepGeom_BoundedSurface.hxx>
-#include <StepGeom_BSplineSurfaceWithKnots.hxx>
-#include <StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
-#include <StepGeom_KnotType.hxx>
-#include <StepGeom_QuasiUniformSurface.hxx>
-#include <StepGeom_QuasiUniformSurfaceAndRationalBSplineSurface.hxx>
-#include <StepGeom_RectangularTrimmedSurface.hxx>
-#include <StepGeom_UniformSurface.hxx>
-#include <StepGeom_UniformSurfaceAndRationalBSplineSurface.hxx>
-#include <StepToGeom_MakeBoundedSurface.hxx>
-#include <StepToGeom_MakeBSplineSurface.hxx>
-#include <StepToGeom_MakeRectangularTrimmedSurface.hxx>
-#include <TColStd_HArray1OfInteger.hxx>
-#include <TColStd_HArray1OfReal.hxx>
-
-//rln 02.06.99 #include <StepToGeom_CheckSurfaceClosure.hxx>
-//=============================================================================
-// Creation d' une BoundedSurface de Geom a partir d' une BoundedSurface
-// de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeBoundedSurface::Convert (const Handle(StepGeom_BoundedSurface)& SS, Handle(Geom_BoundedSurface)& CS)
-{
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface))) { 
-    const Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) BS =
-      Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface)::DownCast(SS);
-       return StepToGeom_MakeBSplineSurface::Convert(BS,Handle(Geom_BSplineSurface)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_BSplineSurfaceWithKnots))) {
-    const Handle(StepGeom_BSplineSurfaceWithKnots) BS
-      = Handle(StepGeom_BSplineSurfaceWithKnots)::DownCast(SS);
-       return StepToGeom_MakeBSplineSurface::Convert(BS,Handle(Geom_BSplineSurface)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_RectangularTrimmedSurface))) {
-    const Handle(StepGeom_RectangularTrimmedSurface) Sur = 
-      Handle(StepGeom_RectangularTrimmedSurface)::DownCast(SS);
-    return StepToGeom_MakeRectangularTrimmedSurface::Convert(Sur,Handle(Geom_RectangularTrimmedSurface)::DownCast (CS));
-  }
-  // STEP BezierSurface, UniformSurface and QuasiUniformSurface are transformed
-  // into STEP BSplineSurface before being mapped onto CAS.CADE/SF
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_BezierSurface))) {
-    const Handle(StepGeom_BezierSurface) BzS = Handle(StepGeom_BezierSurface)::DownCast(SS);
-    const Handle(StepGeom_BSplineSurfaceWithKnots) BSPL = new StepGeom_BSplineSurfaceWithKnots;
-    BSPL->SetUDegree(BzS->UDegree());
-    BSPL->SetVDegree(BzS->VDegree());
-    BSPL->SetControlPointsList(BzS->ControlPointsList());
-    BSPL->SetSurfaceForm(BzS->SurfaceForm());
-    BSPL->SetUClosed(BzS->UClosed());
-    BSPL->SetVClosed(BzS->VClosed());
-    BSPL->SetSelfIntersect(BzS->SelfIntersect());
-    // Compute Knots and KnotsMultiplicity
-    const Handle(TColStd_HArray1OfInteger) UKmult = new TColStd_HArray1OfInteger(1,2);
-    const Handle(TColStd_HArray1OfInteger) VKmult = new TColStd_HArray1OfInteger(1,2);
-    const Handle(TColStd_HArray1OfReal) UKnots = new TColStd_HArray1OfReal(1,2);
-    const Handle(TColStd_HArray1OfReal) VKnots = new TColStd_HArray1OfReal(1,2);
-    UKmult->SetValue(1, BzS->UDegree() + 1);
-    UKmult->SetValue(2, BzS->UDegree() + 1);
-    VKmult->SetValue(1, BzS->VDegree() + 1);
-    VKmult->SetValue(2, BzS->VDegree() + 1);
-    UKnots->SetValue(1, 0.);
-    UKnots->SetValue(2, 1.);
-    VKnots->SetValue(1, 0.);
-    VKnots->SetValue(2, 1.);
-    BSPL->SetUMultiplicities(UKmult);
-    BSPL->SetVMultiplicities(VKmult);
-    BSPL->SetUKnots(UKnots);
-    BSPL->SetVKnots(VKnots);
-       return StepToGeom_MakeBSplineSurface::Convert(BSPL,Handle(Geom_BSplineSurface)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_UniformSurface))) {
-    const Handle(StepGeom_UniformSurface) US = Handle(StepGeom_UniformSurface)::DownCast(SS);
-    const Handle(StepGeom_BSplineSurfaceWithKnots) BSPL = new StepGeom_BSplineSurfaceWithKnots;
-    BSPL->SetUDegree(US->UDegree());
-    BSPL->SetVDegree(US->VDegree());
-    BSPL->SetControlPointsList(US->ControlPointsList());
-    BSPL->SetSurfaceForm(US->SurfaceForm());
-    BSPL->SetUClosed(US->UClosed());
-    BSPL->SetVClosed(US->VClosed());
-    BSPL->SetSelfIntersect(US->SelfIntersect());
-    // Compute Knots and KnotsMultiplicity for U Direction
-    const Standard_Integer nbKU = BSPL->NbControlPointsListI() + BSPL->UDegree() + 1;
-    const Handle(TColStd_HArray1OfInteger) UKmult = new TColStd_HArray1OfInteger(1,nbKU);
-    const Handle(TColStd_HArray1OfReal) UKnots = new TColStd_HArray1OfReal(1,nbKU);
-    for (Standard_Integer iU = 1 ; iU <= nbKU ; iU ++) {
-      UKmult->SetValue(iU, 1);
-      UKnots->SetValue(iU, iU - 1.);
-    }
-    BSPL->SetUMultiplicities(UKmult);
-    BSPL->SetUKnots(UKnots);
-    // Compute Knots and KnotsMultiplicity for V Direction
-    const Standard_Integer nbKV = BSPL->NbControlPointsListJ() + BSPL->VDegree() + 1;
-    const Handle(TColStd_HArray1OfInteger) VKmult = new TColStd_HArray1OfInteger(1,nbKV);
-    const Handle(TColStd_HArray1OfReal) VKnots = new TColStd_HArray1OfReal(1,nbKV);
-    for (Standard_Integer iV = 1 ; iV <= nbKV ; iV ++) {
-      VKmult->SetValue(iV, 1);
-      VKnots->SetValue(iV, iV - 1.);
-    }
-    BSPL->SetVMultiplicities(VKmult);
-    BSPL->SetVKnots(VKnots);
-       return StepToGeom_MakeBSplineSurface::Convert(BSPL,Handle(Geom_BSplineSurface)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_QuasiUniformSurface))) {
-    const Handle(StepGeom_QuasiUniformSurface) QUS = 
-      Handle(StepGeom_QuasiUniformSurface)::DownCast(SS);
-    const Handle(StepGeom_BSplineSurfaceWithKnots) BSPL = new StepGeom_BSplineSurfaceWithKnots;
-    BSPL->SetUDegree(QUS->UDegree());
-    BSPL->SetVDegree(QUS->VDegree());
-    BSPL->SetControlPointsList(QUS->ControlPointsList());
-    BSPL->SetSurfaceForm(QUS->SurfaceForm());
-    BSPL->SetUClosed(QUS->UClosed());
-    BSPL->SetVClosed(QUS->VClosed());
-    BSPL->SetSelfIntersect(QUS->SelfIntersect());
-    // Compute Knots and KnotsMultiplicity for U Direction
-    const Standard_Integer nbKU = BSPL->NbControlPointsListI() - BSPL->UDegree() + 1;
-    const Handle(TColStd_HArray1OfInteger) UKmult = new TColStd_HArray1OfInteger(1,nbKU);
-    const Handle(TColStd_HArray1OfReal) UKnots = new TColStd_HArray1OfReal(1,nbKU);
-    for (Standard_Integer iU = 1 ; iU <= nbKU ; iU ++) {
-      UKmult->SetValue(iU, 1);
-      UKnots->SetValue(iU, iU - 1.);
-    }
-    UKmult->SetValue(1, BSPL->UDegree() + 1);
-    UKmult->SetValue(nbKU, BSPL->UDegree() + 1);
-    BSPL->SetUMultiplicities(UKmult);
-    BSPL->SetUKnots(UKnots);
-    // Compute Knots and KnotsMultiplicity for V Direction
-    const Standard_Integer nbKV = BSPL->NbControlPointsListJ() - BSPL->VDegree() + 1;
-    const Handle(TColStd_HArray1OfInteger) VKmult = new TColStd_HArray1OfInteger(1,nbKV);
-    const Handle(TColStd_HArray1OfReal) VKnots = new TColStd_HArray1OfReal(1,nbKV);
-    for (Standard_Integer iV = 1 ; iV <= nbKV ; iV ++) {
-      VKmult->SetValue(iV, 1);
-      VKnots->SetValue(iV, iV - 1.);
-    }
-    VKmult->SetValue(1, BSPL->VDegree() + 1);
-    VKmult->SetValue(nbKV, BSPL->VDegree() + 1);
-    BSPL->SetVMultiplicities(VKmult);
-    BSPL->SetVKnots(VKnots);
-       return StepToGeom_MakeBSplineSurface::Convert(BSPL,Handle(Geom_BSplineSurface)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_UniformSurfaceAndRationalBSplineSurface))) {
-    const Handle(StepGeom_UniformSurfaceAndRationalBSplineSurface) RUS = 
-      Handle(StepGeom_UniformSurfaceAndRationalBSplineSurface)::DownCast(SS);
-    const Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) RBSPL = 
-      new StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface;
-    // Compute Knots and KnotsMultiplicity for U Direction
-    const Standard_Integer nbKU = RUS->NbControlPointsListI() + RUS->UDegree() + 1;
-    const Handle(TColStd_HArray1OfInteger) UKmult = new TColStd_HArray1OfInteger(1,nbKU);
-    const Handle(TColStd_HArray1OfReal) UKnots = new TColStd_HArray1OfReal(1,nbKU);
-    for (Standard_Integer iU = 1 ; iU <= nbKU ; iU ++) {
-      UKmult->SetValue(iU, 1);
-      UKnots->SetValue(iU, iU - 1.);
-    }
-    // Compute Knots and KnotsMultiplicity for V Direction
-    const Standard_Integer nbKV = RUS->NbControlPointsListJ() + RUS->VDegree() + 1;
-    const Handle(TColStd_HArray1OfInteger) VKmult = new TColStd_HArray1OfInteger(1,nbKV);
-    const Handle(TColStd_HArray1OfReal) VKnots = new TColStd_HArray1OfReal(1,nbKV);
-    for (Standard_Integer iV = 1 ; iV <= nbKV ; iV ++) {
-      VKmult->SetValue(iV, 1);
-      VKnots->SetValue(iV, iV - 1.);
-    }
-    // Initialize the BSplineSurfaceWithKnotsAndRationalBSplineSurface
-    RBSPL->Init(RUS->Name(), RUS->UDegree(), RUS->VDegree(), 
-               RUS->ControlPointsList(), RUS->SurfaceForm(),
-               RUS->UClosed(), RUS->VClosed(), RUS->SelfIntersect(), 
-               UKmult, VKmult, UKnots, VKnots, StepGeom_ktUnspecified,
-               RUS->WeightsData());
-       return StepToGeom_MakeBSplineSurface::Convert(RBSPL,Handle(Geom_BSplineSurface)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_QuasiUniformSurfaceAndRationalBSplineSurface))) {
-    const Handle(StepGeom_QuasiUniformSurfaceAndRationalBSplineSurface) RQUS = 
-      Handle(StepGeom_QuasiUniformSurfaceAndRationalBSplineSurface)::DownCast(SS);
-    const Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) RBSPL = 
-      new StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface;
-    // Compute Knots and KnotsMultiplicity for U Direction
-    const Standard_Integer nbKU = RQUS->NbControlPointsListI() - RQUS->UDegree() + 1;
-    const Handle(TColStd_HArray1OfInteger) UKmult = new TColStd_HArray1OfInteger(1,nbKU);
-    const Handle(TColStd_HArray1OfReal) UKnots = new TColStd_HArray1OfReal(1,nbKU);
-    for (Standard_Integer iU = 1 ; iU <= nbKU ; iU ++) {
-      UKmult->SetValue(iU, 1);
-      UKnots->SetValue(iU, iU - 1.);
-    }
-    UKmult->SetValue(1, RQUS->UDegree() + 1);
-    UKmult->SetValue(nbKU, RQUS->UDegree() + 1);
-    // Compute Knots and KnotsMultiplicity for V Direction
-    const Standard_Integer nbKV = RQUS->NbControlPointsListJ() - RQUS->VDegree() + 1;
-    const Handle(TColStd_HArray1OfInteger) VKmult = new TColStd_HArray1OfInteger(1,nbKV);
-    const Handle(TColStd_HArray1OfReal) VKnots = new TColStd_HArray1OfReal(1,nbKV);
-    for (Standard_Integer iV = 1 ; iV <= nbKV ; iV ++) {
-      VKmult->SetValue(iV, 1);
-      VKnots->SetValue(iV, iV - 1.);
-    }
-    VKmult->SetValue(1, RQUS->VDegree() + 1);
-    VKmult->SetValue(nbKV, RQUS->VDegree() + 1);
-    // Initialize the BSplineSurfaceWithKnotsAndRationalBSplineSurface
-    RBSPL->Init(RQUS->Name(), RQUS->UDegree(), RQUS->VDegree(), RQUS->ControlPointsList(), 
-               RQUS->SurfaceForm(), RQUS->UClosed(), RQUS->VClosed(), 
-               RQUS->SelfIntersect(), UKmult, VKmult, UKnots, VKnots, StepGeom_ktUnspecified,
-               RQUS->WeightsData());
-       return StepToGeom_MakeBSplineSurface::Convert(RBSPL,Handle(Geom_BSplineSurface)::DownCast (CS));
-  }
-/* //:S4136: ass-tol2.stp #9861
-  // UPDATE FMA 15-03-96
-  // For BSplineSurface, the surface could be U and/or VClosed within the 
-  // file tolerance. In this case, the closure flag is enforced
-  
-  if (done && //:i6
-      theBoundedSurface->IsKind(STANDARD_TYPE(Geom_BSplineSurface))) {
-
-    Handle(Geom_BSplineSurface) theBSP = 
-      Handle(Geom_BSplineSurface)::DownCast(theBoundedSurface);
-    if (!theBSP->IsURational() &&
-       !theBSP->IsVRational()) {
-      StepToGeom_CheckSurfaceClosure CheckClose(theBSP);
-      theBoundedSurface = CheckClose.Surface();
-    }
-  }
-*/  
-  return Standard_False;
-}       
diff --git a/src/StepToGeom/StepToGeom_MakeBoundedSurface.hxx b/src/StepToGeom/StepToGeom_MakeBoundedSurface.hxx
deleted file mode 100644 (file)
index a55ab20..0000000
+++ /dev/null
@@ -1,67 +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.
-
-#ifndef _StepToGeom_MakeBoundedSurface_HeaderFile
-#define _StepToGeom_MakeBoundedSurface_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_BoundedSurface;
-class Geom_BoundedSurface;
-
-
-//! This class implements the mapping between classes
-//! BoundedSurface from
-//! StepGeom which describes a BoundedSurface from
-//! prostep and the class BoundedSurface from Geom.
-//! As BoundedSurface is an abstract BoundedSurface this class
-//! is an access to the sub-class required.
-class StepToGeom_MakeBoundedSurface 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_BoundedSurface)& SS, Handle(Geom_BoundedSurface)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeBoundedSurface_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeCartesianPoint.cxx b/src/StepToGeom/StepToGeom_MakeCartesianPoint.cxx
deleted file mode 100644 (file)
index f8b2c44..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-
-#include <Geom_CartesianPoint.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d' un CartesianPoint de Geom a partir d' un CartesianPoint de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeCartesianPoint::Convert
-  (const Handle(StepGeom_CartesianPoint)& SP,
-   Handle(Geom_CartesianPoint)& CP)
-{
-  if (SP->NbCoordinates() == 3)
-  {
-    const Standard_Real LF = UnitsMethods::LengthFactor();
-    const Standard_Real X = SP->CoordinatesValue(1) * LF;
-    const Standard_Real Y = SP->CoordinatesValue(2) * LF;
-    const Standard_Real Z = SP->CoordinatesValue(3) * LF;
-    CP = new Geom_CartesianPoint(X, Y, Z);
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeCartesianPoint.hxx b/src/StepToGeom/StepToGeom_MakeCartesianPoint.hxx
deleted file mode 100644 (file)
index 7bd19bf..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeCartesianPoint_HeaderFile
-#define _StepToGeom_MakeCartesianPoint_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_CartesianPoint;
-class Geom_CartesianPoint;
-
-
-//! This class implements the mapping between classes
-//! CartesianPoint from StepGeom which describes a point from
-//! Prostep and CartesianPoint from Geom.
-class StepToGeom_MakeCartesianPoint 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_CartesianPoint)& SP, Handle(Geom_CartesianPoint)& CP);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeCartesianPoint_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeCartesianPoint2d.cxx b/src/StepToGeom/StepToGeom_MakeCartesianPoint2d.cxx
deleted file mode 100644 (file)
index 24bcd7e..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-
-#include <Geom2d_CartesianPoint.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepToGeom_MakeCartesianPoint2d.hxx>
-
-//=============================================================================
-// Creation d' un CartesianPoint de Geom2d a partir d' un CartesianPoint de
-// Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeCartesianPoint2d::Convert
-  (const Handle(StepGeom_CartesianPoint)& SP,
-   Handle(Geom2d_CartesianPoint)& CP)
-{
-  if (SP->NbCoordinates() == 2)
-  {
-    const Standard_Real X = SP->CoordinatesValue(1);
-    const Standard_Real Y = SP->CoordinatesValue(2);
-    CP = new Geom2d_CartesianPoint(X, Y);
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeCartesianPoint2d.hxx b/src/StepToGeom/StepToGeom_MakeCartesianPoint2d.hxx
deleted file mode 100644 (file)
index b8833d9..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1993-07-06
-// 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 _StepToGeom_MakeCartesianPoint2d_HeaderFile
-#define _StepToGeom_MakeCartesianPoint2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_CartesianPoint;
-class Geom2d_CartesianPoint;
-
-
-//! This class implements the mapping between classes
-//! CartesianPoint from StepGeom which describes a point from
-//! Prostep and CartesianPoint from Geom2d.
-class StepToGeom_MakeCartesianPoint2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_CartesianPoint)& SP, Handle(Geom2d_CartesianPoint)& CP);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeCartesianPoint2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeCircle.cxx b/src/StepToGeom/StepToGeom_MakeCircle.cxx
deleted file mode 100644 (file)
index be38a22..0000000
+++ /dev/null
@@ -1,46 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-
-#include <Geom_Axis2Placement.hxx>
-#include <Geom_Circle.hxx>
-#include <gp_Ax2.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepGeom_Circle.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeCircle.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d' un Circle de Geom a partir d' un Circle de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeCircle::Convert
-    (const Handle(StepGeom_Circle)& SC,
-     Handle(Geom_Circle)& CC)
-{
-  const StepGeom_Axis2Placement AxisSelect = SC->Position();
-  if (AxisSelect.CaseNum(AxisSelect.Value()) == 2)
-  {
-    Handle(Geom_Axis2Placement) A;
-    if (StepToGeom_MakeAxis2Placement::Convert 
-          (Handle(StepGeom_Axis2Placement3d)::DownCast(AxisSelect.Value()),A))
-    {
-      CC = new Geom_Circle(A->Ax2(),SC->Radius() * UnitsMethods::LengthFactor());
-      return Standard_True;
-       }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeCircle.hxx b/src/StepToGeom/StepToGeom_MakeCircle.hxx
deleted file mode 100644 (file)
index 366b6bc..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeCircle_HeaderFile
-#define _StepToGeom_MakeCircle_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Circle;
-class Geom_Circle;
-
-
-//! This class implements the mapping between classes
-//! Circle from StepGeom which describes a circle from
-//! Prostep and Circle from Geom.
-class StepToGeom_MakeCircle 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Circle)& SC, Handle(Geom_Circle)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeCircle_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeCircle2d.cxx b/src/StepToGeom/StepToGeom_MakeCircle2d.cxx
deleted file mode 100644 (file)
index e3198cb..0000000
+++ /dev/null
@@ -1,46 +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.
-
-
-#include <Geom2d_AxisPlacement.hxx>
-#include <Geom2d_Circle.hxx>
-#include <gp_Ax2.hxx>
-#include <gp_Ax22d.hxx>
-#include <StepGeom_Axis2Placement2d.hxx>
-#include <StepGeom_Circle.hxx>
-#include <StepToGeom_MakeAxisPlacement.hxx>
-#include <StepToGeom_MakeCircle2d.hxx>
-
-//=============================================================================
-// Creation d' un Circle de Geom2d a partir d' un Circle de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeCircle2d::Convert
-    (const Handle(StepGeom_Circle)& SC,
-     Handle(Geom2d_Circle)& CC)
-{
-  const StepGeom_Axis2Placement AxisSelect = SC->Position();
-  if (AxisSelect.CaseNum(AxisSelect.Value()) == 1) {
-    Handle(Geom2d_AxisPlacement) A1;
-    if (StepToGeom_MakeAxisPlacement::Convert
-          (Handle(StepGeom_Axis2Placement2d)::DownCast(AxisSelect.Value()),A1))
-    {
-      const gp_Ax22d A( A1->Ax2d() );
-      CC = new Geom2d_Circle(A, SC->Radius());
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeCircle2d.hxx b/src/StepToGeom/StepToGeom_MakeCircle2d.hxx
deleted file mode 100644 (file)
index 34ef33e..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeCircle2d_HeaderFile
-#define _StepToGeom_MakeCircle2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Circle;
-class Geom2d_Circle;
-
-
-//! This class implements the mapping between classes
-//! Circle from StepGeom which describes a circle from
-//! Prostep and Circle from Geom2d.
-class StepToGeom_MakeCircle2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Circle)& SC, Handle(Geom2d_Circle)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeCircle2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeConic.cxx b/src/StepToGeom/StepToGeom_MakeConic.cxx
deleted file mode 100644 (file)
index 7aea651..0000000
+++ /dev/null
@@ -1,59 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-//:p0 abv 19.02.99: management of 'done' flag improved
-
-#include <Geom_Circle.hxx>
-#include <Geom_Ellipse.hxx>
-#include <Geom_Hyperbola.hxx>
-#include <Geom_Parabola.hxx>
-#include <StepGeom_Circle.hxx>
-#include <StepGeom_Conic.hxx>
-#include <StepGeom_Ellipse.hxx>
-#include <StepGeom_Hyperbola.hxx>
-#include <StepGeom_Parabola.hxx>
-#include <StepToGeom_MakeCircle.hxx>
-#include <StepToGeom_MakeConic.hxx>
-#include <StepToGeom_MakeEllipse.hxx>
-#include <StepToGeom_MakeHyperbola.hxx>
-#include <StepToGeom_MakeParabola.hxx>
-
-//=============================================================================
-// Creation d' une Conic de Geom a partir d' une Conic de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeConic::Convert
-    (const Handle(StepGeom_Conic)& SC,
-     Handle(Geom_Conic)& CC)
-{
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Circle))) {
-    const Handle(StepGeom_Circle) Cir = Handle(StepGeom_Circle)::DownCast(SC);
-       return StepToGeom_MakeCircle::Convert(Cir,Handle(Geom_Circle)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Ellipse))) {
-    const Handle(StepGeom_Ellipse) Ell = Handle(StepGeom_Ellipse)::DownCast(SC);
-       return StepToGeom_MakeEllipse::Convert(Ell,Handle(Geom_Ellipse)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Hyperbola))) {
-    const Handle(StepGeom_Hyperbola) Hyp = Handle(StepGeom_Hyperbola)::DownCast(SC);
-       return StepToGeom_MakeHyperbola::Convert(Hyp,Handle(Geom_Hyperbola)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Parabola))) {
-    const Handle(StepGeom_Parabola) Par = Handle(StepGeom_Parabola)::DownCast(SC);
-       return StepToGeom_MakeParabola::Convert(Par,Handle(Geom_Parabola)::DownCast (CC));
-  }
-  // Attention : Other conic shall be implemented !
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeConic.hxx b/src/StepToGeom/StepToGeom_MakeConic.hxx
deleted file mode 100644 (file)
index 427ad23..0000000
+++ /dev/null
@@ -1,66 +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.
-
-#ifndef _StepToGeom_MakeConic_HeaderFile
-#define _StepToGeom_MakeConic_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Conic;
-class Geom_Conic;
-
-
-//! This class implements the mapping between classes
-//! Conic from StepGeom
-//! which describes a Conic from prostep and Conic from Geom .
-//! As Conic is an abstract class
-//! this class is an access to the sub-class required.
-class StepToGeom_MakeConic 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Conic)& SC, Handle(Geom_Conic)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeConic_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeConic2d.cxx b/src/StepToGeom/StepToGeom_MakeConic2d.cxx
deleted file mode 100644 (file)
index 607ea53..0000000
+++ /dev/null
@@ -1,59 +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.
-
-//:p0 abv 19.02.99: management of 'done' flag improved
-
-#include <Geom2d_Circle.hxx>
-#include <Geom2d_Ellipse.hxx>
-#include <Geom2d_Hyperbola.hxx>
-#include <Geom2d_Parabola.hxx>
-#include <StepGeom_Circle.hxx>
-#include <StepGeom_Conic.hxx>
-#include <StepGeom_Ellipse.hxx>
-#include <StepGeom_Hyperbola.hxx>
-#include <StepGeom_Parabola.hxx>
-#include <StepToGeom_MakeCircle2d.hxx>
-#include <StepToGeom_MakeConic2d.hxx>
-#include <StepToGeom_MakeEllipse2d.hxx>
-#include <StepToGeom_MakeHyperbola2d.hxx>
-#include <StepToGeom_MakeParabola2d.hxx>
-
-//=============================================================================
-// Creation d' une Conic de Geom2d a partir d' une Conic de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeConic2d::Convert
-    (const Handle(StepGeom_Conic)& SC,
-     Handle(Geom2d_Conic)& CC)
-{
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Circle))) {
-    const Handle(StepGeom_Circle) Cir = Handle(StepGeom_Circle)::DownCast(SC);
-       return StepToGeom_MakeCircle2d::Convert(Cir,Handle(Geom2d_Circle)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Ellipse))) {
-    const Handle(StepGeom_Ellipse) Ell = Handle(StepGeom_Ellipse)::DownCast(SC);
-       return StepToGeom_MakeEllipse2d::Convert(Ell,Handle(Geom2d_Ellipse)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Hyperbola))) {
-    const Handle(StepGeom_Hyperbola) Hyp = Handle(StepGeom_Hyperbola)::DownCast(SC);
-       return StepToGeom_MakeHyperbola2d::Convert(Hyp,Handle(Geom2d_Hyperbola)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Parabola))) {
-    const Handle(StepGeom_Parabola) Par = Handle(StepGeom_Parabola)::DownCast(SC);
-       return StepToGeom_MakeParabola2d::Convert(Par,Handle(Geom2d_Parabola)::DownCast (CC));
-  }
-  // Attention : Other conic shall be implemented !
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeConic2d.hxx b/src/StepToGeom/StepToGeom_MakeConic2d.hxx
deleted file mode 100644 (file)
index 435c623..0000000
+++ /dev/null
@@ -1,66 +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.
-
-#ifndef _StepToGeom_MakeConic2d_HeaderFile
-#define _StepToGeom_MakeConic2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Conic;
-class Geom2d_Conic;
-
-
-//! This class implements the mapping between classes
-//! Conic from StepGeom
-//! which describes a Conic from prostep and Conic from Geom2d.
-//! As Conic is an abstract class
-//! this class is an access to the sub-class required.
-class StepToGeom_MakeConic2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Conic)& SC, Handle(Geom2d_Conic)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeConic2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeConicalSurface.cxx b/src/StepToGeom/StepToGeom_MakeConicalSurface.cxx
deleted file mode 100644 (file)
index 9cd2ec4..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-
-#include <Geom_Axis2Placement.hxx>
-#include <Geom_ConicalSurface.hxx>
-#include <gp_Ax2.hxx>
-#include <Precision.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepGeom_ConicalSurface.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeConicalSurface.hxx>
-#include <UnitsMethods.hxx>
-
-//#2(K3-3) rln
-//=============================================================================
-// Creation d' une ConicalSurface de Geom a partir d' une ConicalSurface de
-// Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeConicalSurface::Convert (const Handle(StepGeom_ConicalSurface)& SS, Handle(Geom_ConicalSurface)& CS)
-{
-  Handle(Geom_Axis2Placement) A;
-  if (StepToGeom_MakeAxis2Placement::Convert(SS->Position(),A))
-  {
-    const Standard_Real R = SS->Radius() * UnitsMethods::LengthFactor();
-    const Standard_Real Ang = SS->SemiAngle() * UnitsMethods::PlaneAngleFactor();
-    //#2(K3-3) rln 12/02/98 ProSTEP ct_turbine-A.stp entity #518, #3571 (gp::Resolution() is too little)
-    CS = new Geom_ConicalSurface(A->Ax2(), Max(Ang, Precision::Angular()), R);
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeConicalSurface.hxx b/src/StepToGeom/StepToGeom_MakeConicalSurface.hxx
deleted file mode 100644 (file)
index a4d1fec..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeConicalSurface_HeaderFile
-#define _StepToGeom_MakeConicalSurface_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_ConicalSurface;
-class Geom_ConicalSurface;
-
-
-//! This class implements the mapping between class
-//! ConicalSurface from StepGeom which describes a
-//! conical_surface from Prostep and ConicalSurface from Geom
-class StepToGeom_MakeConicalSurface 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_ConicalSurface)& SS, Handle(Geom_ConicalSurface)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeConicalSurface_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeCurve.cxx b/src/StepToGeom/StepToGeom_MakeCurve.cxx
deleted file mode 100644 (file)
index 02ff776..0000000
+++ /dev/null
@@ -1,110 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-//:n7 abv 16.02.99: S4132: adding translation of curve_replica
-//:o2 abv 17.02.99: S4132: adding translation of offset_curve_3d
-//:o5 abv 17.02.99: bm4_sd_seal_c.stp #58720: translate surface_curve (3d only)
-//:p0 abv 19.02.99: management of 'done' flag improved
-
-#include <Geom_Conic.hxx>
-#include <Geom_Direction.hxx>
-#include <Geom_Line.hxx>
-#include <Geom_OffsetCurve.hxx>
-#include <Geom_TrimmedCurve.hxx>
-#include <StepGeom_BoundedCurve.hxx>
-#include <StepGeom_CartesianTransformationOperator3d.hxx>
-#include <StepGeom_Conic.hxx>
-#include <StepGeom_Curve.hxx>
-#include <StepGeom_CurveReplica.hxx>
-#include <StepGeom_Line.hxx>
-#include <StepGeom_OffsetCurve3d.hxx>
-#include <StepGeom_SurfaceCurve.hxx>
-#include <StepGeom_TrimmedCurve.hxx>
-#include <StepToGeom_MakeBoundedCurve.hxx>
-#include <StepToGeom_MakeConic.hxx>
-#include <StepToGeom_MakeCurve.hxx>
-#include <StepToGeom_MakeDirection.hxx>
-#include <StepToGeom_MakeLine.hxx>
-#include <StepToGeom_MakeTransformation3d.hxx>
-#include <StepToGeom_MakeTrimmedCurve.hxx>
-
-//=============================================================================
-// Creation d' une Curve de Geom a partir d' une Curve de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeCurve::Convert (const Handle(StepGeom_Curve)& SC, Handle(Geom_Curve)& CC)
-{
-  if (SC.IsNull()){
-    return Standard_False;
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Line))) {
-    const Handle(StepGeom_Line) L = Handle(StepGeom_Line)::DownCast(SC);
-    return StepToGeom_MakeLine::Convert(L,Handle(Geom_Line)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_TrimmedCurve))) {
-    const Handle(StepGeom_TrimmedCurve) TC = Handle(StepGeom_TrimmedCurve)::DownCast(SC);
-    return StepToGeom_MakeTrimmedCurve::Convert(TC,Handle(Geom_TrimmedCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Conic))) {
-    const Handle(StepGeom_Conic) CO = Handle(StepGeom_Conic)::DownCast(SC);
-    return StepToGeom_MakeConic::Convert(CO,Handle(Geom_Conic)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_BoundedCurve))) {
-    const Handle(StepGeom_BoundedCurve) BC = Handle(StepGeom_BoundedCurve)::DownCast(SC);
-    return StepToGeom_MakeBoundedCurve::Convert(BC,Handle(Geom_BoundedCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_CurveReplica))) { //:n7 abv 16 Feb 99
-    const Handle(StepGeom_CurveReplica) CR = Handle(StepGeom_CurveReplica)::DownCast(SC);
-    const Handle(StepGeom_Curve) PC = CR->ParentCurve();
-    const Handle(StepGeom_CartesianTransformationOperator3d) T = 
-      Handle(StepGeom_CartesianTransformationOperator3d)::DownCast(CR->Transformation());
-    // protect against cyclic references and wrong type of cartop
-    if ( !T.IsNull() && PC != SC )
-    {
-      Handle(Geom_Curve) C1;
-      if (StepToGeom_MakeCurve::Convert(PC,C1))
-      {
-        gp_Trsf T1;
-               if (StepToGeom_MakeTransformation3d::Convert(T,T1))
-        {
-          C1->Transform ( T1 );
-          CC = C1;
-          return Standard_True;
-        }
-      }
-    }
-  }
-  else if (SC->IsKind(STANDARD_TYPE(StepGeom_OffsetCurve3d))) { //:o2 abv 17 Feb 99
-    const Handle(StepGeom_OffsetCurve3d) OC = Handle(StepGeom_OffsetCurve3d)::DownCast(SC);
-    const Handle(StepGeom_Curve) BC = OC->BasisCurve();
-    if ( BC != SC ) { // protect against loop
-      Handle(Geom_Curve) C1;
-      if (StepToGeom_MakeCurve::Convert(BC,C1))
-      {
-        Handle(Geom_Direction) RD;
-        if (StepToGeom_MakeDirection::Convert(OC->RefDirection(),RD))
-        {
-          CC = new Geom_OffsetCurve ( C1, -OC->Distance(), RD->Dir() );
-          return Standard_True;
-        }
-      }
-    }
-  }
-  else if (SC->IsKind(STANDARD_TYPE(StepGeom_SurfaceCurve))) { //:o5 abv 17 Feb 99
-    const Handle(StepGeom_SurfaceCurve) SurfC = Handle(StepGeom_SurfaceCurve)::DownCast(SC);
-    return StepToGeom_MakeCurve::Convert(SurfC->Curve3d(),CC);
-  }
-  return Standard_False;
-}       
diff --git a/src/StepToGeom/StepToGeom_MakeCurve.hxx b/src/StepToGeom/StepToGeom_MakeCurve.hxx
deleted file mode 100644 (file)
index da65292..0000000
+++ /dev/null
@@ -1,66 +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.
-
-#ifndef _StepToGeom_MakeCurve_HeaderFile
-#define _StepToGeom_MakeCurve_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Curve;
-class Geom_Curve;
-
-
-//! This class implements the mapping between classes
-//! class Curve from StepGeom which
-//! describes a Curve from prostep and Curve from Geom.
-//! As Curve is an abstract class
-//! this class an access to the sub-class required.
-class StepToGeom_MakeCurve 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Curve)& SC, Handle(Geom_Curve)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeCurve_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeCurve2d.cxx b/src/StepToGeom/StepToGeom_MakeCurve2d.cxx
deleted file mode 100644 (file)
index afd82eb..0000000
+++ /dev/null
@@ -1,79 +0,0 @@
-// Created on: 1993-08-04
-// 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.
-
-//:n7 abv 15.02.99: S4132: adding translation of curve_replica
-//:p0 abv 19.02.99: management of 'done' flag improved
-
-#include <Geom2d_BSplineCurve.hxx>
-#include <Geom2d_Conic.hxx>
-#include <Geom2d_Line.hxx>
-#include <Geom2d_TrimmedCurve.hxx>
-#include <Geom2dConvert.hxx>
-#include <gp_Trsf2d.hxx>
-#include <StepGeom_BoundedCurve.hxx>
-#include <StepGeom_CartesianTransformationOperator2d.hxx>
-#include <StepGeom_Conic.hxx>
-#include <StepGeom_Curve.hxx>
-#include <StepGeom_CurveReplica.hxx>
-#include <StepGeom_HArray1OfTrimmingSelect.hxx>
-#include <StepGeom_Line.hxx>
-#include <StepGeom_TrimmedCurve.hxx>
-#include <StepToGeom_MakeBoundedCurve2d.hxx>
-#include <StepToGeom_MakeConic2d.hxx>
-#include <StepToGeom_MakeCurve2d.hxx>
-#include <StepToGeom_MakeLine2d.hxx>
-#include <StepToGeom_MakeTransformation2d.hxx>
-
-//=============================================================================
-// Creation d' une Curve de Geom2d a partir d' une Curve de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeCurve2d::Convert (const Handle(StepGeom_Curve)& SC, Handle(Geom2d_Curve)& CC)
-{
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Line))) {
-    const Handle(StepGeom_Line) L = Handle(StepGeom_Line)::DownCast(SC);
-       return StepToGeom_MakeLine2d::Convert(L,Handle(Geom2d_Line)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_Conic))) {
-    const Handle(StepGeom_Conic) L = Handle(StepGeom_Conic)::DownCast(SC);
-       return StepToGeom_MakeConic2d::Convert(L,Handle(Geom2d_Conic)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_BoundedCurve))) {
-    const Handle(StepGeom_BoundedCurve) L = Handle(StepGeom_BoundedCurve)::DownCast(SC);
-       return StepToGeom_MakeBoundedCurve2d::Convert(L,Handle(Geom2d_BoundedCurve)::DownCast (CC));
-  }
-  if (SC->IsKind(STANDARD_TYPE(StepGeom_CurveReplica))) { //:n7 abv 16 Feb 99
-    const Handle(StepGeom_CurveReplica) CR = Handle(StepGeom_CurveReplica)::DownCast(SC);
-    const Handle(StepGeom_Curve) PC = CR->ParentCurve();
-    const Handle(StepGeom_CartesianTransformationOperator2d) T =
-      Handle(StepGeom_CartesianTransformationOperator2d)::DownCast(CR->Transformation());
-    // protect against cyclic references and wrong type of cartop
-    if ( !T.IsNull() && PC != SC )
-    {
-      Handle(Geom2d_Curve) C1;
-      if (StepToGeom_MakeCurve2d::Convert(PC,C1))
-      {
-        gp_Trsf2d T1;
-        if (StepToGeom_MakeTransformation2d::Convert(T,T1))
-        {
-          C1->Transform ( T1 );
-          CC = C1;
-          return Standard_True;
-               }
-      }
-    }
-  }
-  return Standard_False;
-}       
diff --git a/src/StepToGeom/StepToGeom_MakeCurve2d.hxx b/src/StepToGeom/StepToGeom_MakeCurve2d.hxx
deleted file mode 100644 (file)
index 42a7d42..0000000
+++ /dev/null
@@ -1,66 +0,0 @@
-// Created on: 1993-08-04
-// 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 _StepToGeom_MakeCurve2d_HeaderFile
-#define _StepToGeom_MakeCurve2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Curve;
-class Geom2d_Curve;
-
-
-//! This class implements the mapping between
-//! class Curve from StepGeom which
-//! describes a Curve from prostep and Curve from Geom2d.
-//! As Curve is an abstract class
-//! this class an access to the sub-class required.
-class StepToGeom_MakeCurve2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Curve)& SC, Handle(Geom2d_Curve)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeCurve2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeCylindricalSurface.cxx b/src/StepToGeom/StepToGeom_MakeCylindricalSurface.cxx
deleted file mode 100644 (file)
index 43edcaa..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-
-#include <Geom_Axis2Placement.hxx>
-#include <Geom_CylindricalSurface.hxx>
-#include <gp_Ax2.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepGeom_CylindricalSurface.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeCylindricalSurface.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d' une CylindricalSurface de Geom a partir d' une 
-// CylindricalSurface de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeCylindricalSurface::Convert (const Handle(StepGeom_CylindricalSurface)& SS, Handle(Geom_CylindricalSurface)& CS)
-{
-  Handle(Geom_Axis2Placement) A;
-  if (StepToGeom_MakeAxis2Placement::Convert(SS->Position(),A))
-  {
-    CS = new Geom_CylindricalSurface(A->Ax2(), SS->Radius() * UnitsMethods::LengthFactor());
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeCylindricalSurface.hxx b/src/StepToGeom/StepToGeom_MakeCylindricalSurface.hxx
deleted file mode 100644 (file)
index 57bda37..0000000
+++ /dev/null
@@ -1,65 +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.
-
-#ifndef _StepToGeom_MakeCylindricalSurface_HeaderFile
-#define _StepToGeom_MakeCylindricalSurface_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_CylindricalSurface;
-class Geom_CylindricalSurface;
-
-
-//! This class implements the mapping between class
-//! CylindricalSurface from StepGeom which describes a
-//! cylindrical_surface from Prostep and CylindricalSurface
-//! from Geom
-class StepToGeom_MakeCylindricalSurface 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_CylindricalSurface)& SS, Handle(Geom_CylindricalSurface)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeCylindricalSurface_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeDirection.cxx b/src/StepToGeom/StepToGeom_MakeDirection.cxx
deleted file mode 100644 (file)
index 47f5338..0000000
+++ /dev/null
@@ -1,41 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-// sln 22.10.2001. CTS23496: Direction is not created if it has null magnitude (StepToGeom_MakeDirection(...) function)
-
-#include <Geom_Direction.hxx>
-#include <StepGeom_Direction.hxx>
-#include <StepToGeom_MakeDirection.hxx>
-
-//=============================================================================
-// Creation d' un Direction de Geom a partir d' un Direction de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeDirection::Convert (const Handle(StepGeom_Direction)& SD, Handle(Geom_Direction)& CD)
-{
-  if (SD->NbDirectionRatios() >= 3)
-  {
-    const Standard_Real X = SD->DirectionRatiosValue(1);
-    const Standard_Real Y = SD->DirectionRatiosValue(2);
-    const Standard_Real Z = SD->DirectionRatiosValue(3);
-    // sln 22.10.2001. CTS23496: Direction is not created if it has null magnitude
-    if (gp_XYZ(X, Y, Z).SquareModulus() > gp::Resolution()*gp::Resolution())
-    {
-      CD = new Geom_Direction(X, Y, Z);
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeDirection.hxx b/src/StepToGeom/StepToGeom_MakeDirection.hxx
deleted file mode 100644 (file)
index 0f6e1ab..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeDirection_HeaderFile
-#define _StepToGeom_MakeDirection_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Direction;
-class Geom_Direction;
-
-
-//! This class implements the mapping between classes
-//! Direction from StepGeom which describes a direction
-//! from Prostep and Direction from Geom.
-class StepToGeom_MakeDirection 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Direction)& SD, Handle(Geom_Direction)& CD);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeDirection_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeDirection2d.cxx b/src/StepToGeom/StepToGeom_MakeDirection2d.cxx
deleted file mode 100644 (file)
index 8c247d2..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-// Created on: 1993-08-04
-// 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.
-
-// sln 23.10.2001. CTS23496: Direction is not created if it has null magnitude (StepToGeom_MakeDirection2d(...) function)
-
-#include <Geom2d_Direction.hxx>
-#include <StepGeom_Direction.hxx>
-#include <StepToGeom_MakeDirection2d.hxx>
-
-//=============================================================================
-// Creation d' un Direction de Geom2d a partir d' un Direction de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeDirection2d::Convert (const Handle(StepGeom_Direction)& SD, Handle(Geom2d_Direction)& CD)
-{
-  if (SD->NbDirectionRatios() >= 2)
-  {
-    const Standard_Real X = SD->DirectionRatiosValue(1);
-    const Standard_Real Y = SD->DirectionRatiosValue(2);
-    // sln 23.10.2001. CTS23496: Direction is not created if it has null magnitude
-    if(gp_XY(X,Y).SquareModulus() > gp::Resolution()*gp::Resolution())
-    {
-      CD = new Geom2d_Direction(X, Y);
-      return Standard_True;
-    }
-  }
-  return Standard_False;   
-}
diff --git a/src/StepToGeom/StepToGeom_MakeDirection2d.hxx b/src/StepToGeom/StepToGeom_MakeDirection2d.hxx
deleted file mode 100644 (file)
index 664a1fd..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1993-08-04
-// 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 _StepToGeom_MakeDirection2d_HeaderFile
-#define _StepToGeom_MakeDirection2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Direction;
-class Geom2d_Direction;
-
-
-//! This class implements the mapping between classes
-//! Direction from StepGeom which describes a direction
-//! from Prostep and Direction from Geom2d.
-class StepToGeom_MakeDirection2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Direction)& SD, Handle(Geom2d_Direction)& CD);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeDirection2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeElementarySurface.cxx b/src/StepToGeom/StepToGeom_MakeElementarySurface.cxx
deleted file mode 100644 (file)
index b65d659..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-//:p0 abv 19.02.99: management of 'done' flag improved
-
-#include <Geom_ConicalSurface.hxx>
-#include <Geom_CylindricalSurface.hxx>
-#include <Geom_Plane.hxx>
-#include <Geom_SphericalSurface.hxx>
-#include <Geom_ToroidalSurface.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>
-#include <StepToGeom_MakeConicalSurface.hxx>
-#include <StepToGeom_MakeCylindricalSurface.hxx>
-#include <StepToGeom_MakeElementarySurface.hxx>
-#include <StepToGeom_MakePlane.hxx>
-#include <StepToGeom_MakeSphericalSurface.hxx>
-#include <StepToGeom_MakeToroidalSurface.hxx>
-
-//=============================================================================
-// Creation d' une ElementarySurface de Geom a partir d' une 
-// ElementarySurface de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeElementarySurface::Convert (const Handle(StepGeom_ElementarySurface)& SS, Handle(Geom_ElementarySurface)& CS)
-{
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_Plane))) {
-    const Handle(StepGeom_Plane) Sur = Handle(StepGeom_Plane)::DownCast(SS);
-       return StepToGeom_MakePlane::Convert(Sur,Handle(Geom_Plane)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_CylindricalSurface))) {
-    const Handle(StepGeom_CylindricalSurface) Sur = Handle(StepGeom_CylindricalSurface)::DownCast(SS);
-    return StepToGeom_MakeCylindricalSurface::Convert(Sur,Handle(Geom_CylindricalSurface)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_ConicalSurface))) {
-    const Handle(StepGeom_ConicalSurface) Sur = Handle(StepGeom_ConicalSurface)::DownCast(SS);
-       return StepToGeom_MakeConicalSurface::Convert(Sur,Handle(Geom_ConicalSurface)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_SphericalSurface))) {
-    const Handle(StepGeom_SphericalSurface) Sur = Handle(StepGeom_SphericalSurface)::DownCast(SS);
-    return StepToGeom_MakeSphericalSurface::Convert(Sur,Handle(Geom_SphericalSurface)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_ToroidalSurface))) {
-    const Handle(StepGeom_ToroidalSurface) Sur = Handle(StepGeom_ToroidalSurface)::DownCast(SS);
-    return StepToGeom_MakeToroidalSurface::Convert(Sur,Handle(Geom_ToroidalSurface)::DownCast (CS));
-  }
-  return Standard_False;
-}       
diff --git a/src/StepToGeom/StepToGeom_MakeElementarySurface.hxx b/src/StepToGeom/StepToGeom_MakeElementarySurface.hxx
deleted file mode 100644 (file)
index c2bb00e..0000000
+++ /dev/null
@@ -1,66 +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.
-
-#ifndef _StepToGeom_MakeElementarySurface_HeaderFile
-#define _StepToGeom_MakeElementarySurface_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_ElementarySurface;
-class Geom_ElementarySurface;
-
-
-//! This class implements the mapping between classes
-//! ElementarySurface from StepGeom which describes
-//! a ElementarySurface from Step and ElementarySurface from
-//! Geom. As ElementarySurface is an abstract Surface this
-//! class is an access to the sub-class required.
-class StepToGeom_MakeElementarySurface 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_ElementarySurface)& SS, Handle(Geom_ElementarySurface)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeElementarySurface_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeEllipse.cxx b/src/StepToGeom/StepToGeom_MakeEllipse.cxx
deleted file mode 100644 (file)
index bc24676..0000000
+++ /dev/null
@@ -1,58 +0,0 @@
-// Created on: 1994-09-01
-// 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.
-
-//:o9 abv 19.02.99: bm4_id_punch_b.stp #678: treatment of ellipse with minR > maxR
-//                  NOTE: parametrisation of resulting ellipse shifted on pi/2
-
-#include <Geom_Axis2Placement.hxx>
-#include <Geom_Ellipse.hxx>
-#include <gp_Ax2.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepGeom_Ellipse.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeEllipse.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d' un Ellipse de Geom a partir d' un Ellipse de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeEllipse::Convert
-    (const Handle(StepGeom_Ellipse)& SC,
-     Handle(Geom_Ellipse)& CC)
-{
-  const StepGeom_Axis2Placement AxisSelect = SC->Position();
-  if (AxisSelect.CaseNum(AxisSelect.Value()) == 2) {
-    Handle(Geom_Axis2Placement) A1;
-    if (StepToGeom_MakeAxis2Placement::Convert
-          (Handle(StepGeom_Axis2Placement3d)::DownCast(AxisSelect.Value()),A1))
-    {
-      gp_Ax2 A( A1->Ax2() );
-      const Standard_Real LF = UnitsMethods::LengthFactor();
-      const Standard_Real majorR = SC->SemiAxis1() * LF;
-      const Standard_Real minorR = SC->SemiAxis2() * LF;
-      if ( majorR - minorR >= 0. ) { //:o9 abv 19 Feb 99
-        CC = new Geom_Ellipse(A, majorR, minorR);
-      }
-      //:o9 abv 19 Feb 99
-      else {
-        A.SetXDirection ( A.XDirection() ^ A.Direction() );
-        CC = new Geom_Ellipse(A, minorR, majorR);
-      }
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeEllipse.hxx b/src/StepToGeom/StepToGeom_MakeEllipse.hxx
deleted file mode 100644 (file)
index 457a391..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1994-09-01
-// 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 _StepToGeom_MakeEllipse_HeaderFile
-#define _StepToGeom_MakeEllipse_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Ellipse;
-class Geom_Ellipse;
-
-
-//! This class implements the mapping between classes
-//! Ellipse from StepGeom which describes a Ellipse from
-//! Prostep and Ellipse from Geom.
-class StepToGeom_MakeEllipse 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Ellipse)& SC, Handle(Geom_Ellipse)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeEllipse_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeEllipse2d.cxx b/src/StepToGeom/StepToGeom_MakeEllipse2d.cxx
deleted file mode 100644 (file)
index 102ddca..0000000
+++ /dev/null
@@ -1,57 +0,0 @@
-// Created on: 1994-09-01
-// 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.
-
-//:o9 abv 19.02.99: bm4_id_punch_b.stp #678: treatment of minR > maxR
-//                  NOTE: parametrisation of resulting ellipse shifted on pi/2
-
-#include <Geom2d_AxisPlacement.hxx>
-#include <Geom2d_Ellipse.hxx>
-#include <gp_Ax2.hxx>
-#include <gp_Ax22d.hxx>
-#include <StepGeom_Axis2Placement2d.hxx>
-#include <StepGeom_Ellipse.hxx>
-#include <StepToGeom_MakeAxisPlacement.hxx>
-#include <StepToGeom_MakeEllipse2d.hxx>
-
-//=============================================================================
-// Creation d' un Ellipse de Geom2d a partir d' un Ellipse de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeEllipse2d::Convert
-    (const Handle(StepGeom_Ellipse)& SC,
-     Handle(Geom2d_Ellipse)& CC)
-{
-  const StepGeom_Axis2Placement AxisSelect = SC->Position();
-  if (AxisSelect.CaseNum(AxisSelect.Value()) == 1) {
-    Handle(Geom2d_AxisPlacement) A1;
-    if (StepToGeom_MakeAxisPlacement::Convert
-          (Handle(StepGeom_Axis2Placement2d)::DownCast(AxisSelect.Value()),A1))
-    {
-      gp_Ax22d A( A1->Ax2d() );
-      const Standard_Real majorR = SC->SemiAxis1();
-      const Standard_Real minorR = SC->SemiAxis2();
-      if ( majorR - minorR >= 0. ) { //:o9 abv 19 Feb 99: bm4_id_punch_b.stp #678: protection
-        CC = new Geom2d_Ellipse(A, majorR, minorR);
-      }
-      else {
-        const gp_Dir2d X = A.XDirection();
-        A.SetXDirection ( gp_Dir2d ( X.X(), -X.Y() ) );
-        CC = new Geom2d_Ellipse(A, minorR, majorR);
-      }
-      return Standard_True;
-       }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeEllipse2d.hxx b/src/StepToGeom/StepToGeom_MakeEllipse2d.hxx
deleted file mode 100644 (file)
index 8f71b1e..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1994-09-01
-// 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 _StepToGeom_MakeEllipse2d_HeaderFile
-#define _StepToGeom_MakeEllipse2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Ellipse;
-class Geom2d_Ellipse;
-
-
-//! This class implements the mapping between classes
-//! Ellipse from StepGeom which describes a Ellipse from
-//! Prostep and Ellipse from Geom2d.
-class StepToGeom_MakeEllipse2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Ellipse)& SC, Handle(Geom2d_Ellipse)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeEllipse2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeHyperbola.cxx b/src/StepToGeom/StepToGeom_MakeHyperbola.cxx
deleted file mode 100644 (file)
index 6be1a67..0000000
+++ /dev/null
@@ -1,48 +0,0 @@
-// Created on: 1994-09-08
-// 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.
-
-
-#include <Geom_Axis2Placement.hxx>
-#include <Geom_Hyperbola.hxx>
-#include <gp_Ax2.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepGeom_Hyperbola.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeHyperbola.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d' un Hyperbola de Geom a partir d' un Hyperbola de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeHyperbola::Convert
-    (const Handle(StepGeom_Hyperbola)& SC,
-     Handle(Geom_Hyperbola)& CC)
-{
-  const StepGeom_Axis2Placement AxisSelect = SC->Position();
-  if (AxisSelect.CaseNum(AxisSelect.Value()) == 2)
-  {
-    Handle(Geom_Axis2Placement) A1;
-    if (StepToGeom_MakeAxis2Placement::Convert
-          (Handle(StepGeom_Axis2Placement3d)::DownCast(AxisSelect.Value()),A1))
-    {
-      const gp_Ax2 A( A1->Ax2() );
-      const Standard_Real LF = UnitsMethods::LengthFactor();
-      CC = new Geom_Hyperbola(A, SC->SemiAxis() * LF, SC->SemiImagAxis() * LF);
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeHyperbola.hxx b/src/StepToGeom/StepToGeom_MakeHyperbola.hxx
deleted file mode 100644 (file)
index 12043a6..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1994-09-08
-// 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 _StepToGeom_MakeHyperbola_HeaderFile
-#define _StepToGeom_MakeHyperbola_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Hyperbola;
-class Geom_Hyperbola;
-
-
-//! This class implements the mapping between classes
-//! Hyperbola from StepGeom which describes a Hyperbola from
-//! Prostep and Hyperbola from Geom.
-class StepToGeom_MakeHyperbola 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Hyperbola)& SC, Handle(Geom_Hyperbola)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeHyperbola_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeHyperbola2d.cxx b/src/StepToGeom/StepToGeom_MakeHyperbola2d.cxx
deleted file mode 100644 (file)
index 2462c42..0000000
+++ /dev/null
@@ -1,46 +0,0 @@
-// Created on: 1994-09-01
-// 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.
-
-
-#include <Geom2d_AxisPlacement.hxx>
-#include <Geom2d_Hyperbola.hxx>
-#include <gp_Ax2.hxx>
-#include <gp_Ax22d.hxx>
-#include <StepGeom_Axis2Placement2d.hxx>
-#include <StepGeom_Hyperbola.hxx>
-#include <StepToGeom_MakeAxisPlacement.hxx>
-#include <StepToGeom_MakeHyperbola2d.hxx>
-
-//=============================================================================
-// Creation d' un Hyperbola de Geom2d a partir d' un Hyperbola de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeHyperbola2d::Convert
-    (const Handle(StepGeom_Hyperbola)& SC,
-     Handle(Geom2d_Hyperbola)& CC)
-{
-  const StepGeom_Axis2Placement AxisSelect = SC->Position();
-  if (AxisSelect.CaseNum(AxisSelect.Value()) == 1) {
-    Handle(Geom2d_AxisPlacement) A1;
-    if (StepToGeom_MakeAxisPlacement::Convert
-          (Handle(StepGeom_Axis2Placement2d)::DownCast(AxisSelect.Value()),A1))
-    {
-      const gp_Ax22d A( A1->Ax2d() );
-      CC = new Geom2d_Hyperbola(A, SC->SemiAxis(), SC->SemiImagAxis());
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeHyperbola2d.hxx b/src/StepToGeom/StepToGeom_MakeHyperbola2d.hxx
deleted file mode 100644 (file)
index f194de5..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1995-05-09
-// 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 _StepToGeom_MakeHyperbola2d_HeaderFile
-#define _StepToGeom_MakeHyperbola2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Hyperbola;
-class Geom2d_Hyperbola;
-
-
-//! This class implements the mapping between classes
-//! Hyperbola from StepGeom which describes a Hyperbola from
-//! Prostep and Hyperbola from Geom2d.
-class StepToGeom_MakeHyperbola2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Hyperbola)& SC, Handle(Geom2d_Hyperbola)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeHyperbola2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeLine.cxx b/src/StepToGeom/StepToGeom_MakeLine.cxx
deleted file mode 100644 (file)
index 9b61264..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-// sln 22.10.2001. CTS23496: Line is not created if direction have not been succesfully created (StepToGeom_MakeLine(...) function)
-
-#include <Geom_CartesianPoint.hxx>
-#include <Geom_Line.hxx>
-#include <Geom_VectorWithMagnitude.hxx>
-#include <gp_Dir.hxx>
-#include <gp_Pnt.hxx>
-#include <gp_Vec.hxx>
-#include <Precision.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_Line.hxx>
-#include <StepGeom_Vector.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <StepToGeom_MakeLine.hxx>
-#include <StepToGeom_MakeVectorWithMagnitude.hxx>
-
-//=============================================================================
-// Creation d' une Line de Geom a partir d' une Line de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeLine::Convert (const Handle(StepGeom_Line)& SC, Handle(Geom_Line)& CC)
-{
-  Handle(Geom_CartesianPoint) P;
-  if (StepToGeom_MakeCartesianPoint::Convert(SC->Pnt(),P))
-  {
-    // sln 22.10.2001. CTS23496: Line is not created if direction have not been succesfully created 
-    Handle(Geom_VectorWithMagnitude) D;
-    if (StepToGeom_MakeVectorWithMagnitude::Convert(SC->Dir(),D))
-    {
-      if( D->Vec().SquareMagnitude() < Precision::Confusion() * Precision::Confusion())
-        return Standard_False;
-      const gp_Dir V(D->Vec());
-      CC = new Geom_Line(P->Pnt(), V);
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeLine.hxx b/src/StepToGeom/StepToGeom_MakeLine.hxx
deleted file mode 100644 (file)
index 42dce72..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeLine_HeaderFile
-#define _StepToGeom_MakeLine_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Line;
-class Geom_Line;
-
-
-//! This class implements the mapping between classes
-//! Line from StepGeom which describes a line from
-//! Prostep and Line from Geom.
-class StepToGeom_MakeLine 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Line)& SC, Handle(Geom_Line)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeLine_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeLine2d.cxx b/src/StepToGeom/StepToGeom_MakeLine2d.cxx
deleted file mode 100644 (file)
index 2d76ffd..0000000
+++ /dev/null
@@ -1,51 +0,0 @@
-// Created on: 1993-08-04
-// 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.
-
-// sln 23.10.2001. CTS23496: Line is not created if direction have not been succesfully created (StepToGeom_MakeLine2d(...) function)
-
-#include <Geom2d_CartesianPoint.hxx>
-#include <Geom2d_Line.hxx>
-#include <Geom2d_Vector.hxx>
-#include <Geom2d_VectorWithMagnitude.hxx>
-#include <gp_Dir2d.hxx>
-#include <gp_Pnt2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_Line.hxx>
-#include <StepGeom_Vector.hxx>
-#include <StepToGeom_MakeCartesianPoint2d.hxx>
-#include <StepToGeom_MakeLine2d.hxx>
-#include <StepToGeom_MakeVectorWithMagnitude2d.hxx>
-
-//=============================================================================
-// Creation d' une Line de Geom2d a partir d' une Line de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeLine2d::Convert (const Handle(StepGeom_Line)& SC, Handle(Geom2d_Line)& CC)
-{
-  Handle(Geom2d_CartesianPoint) P;
-  if (StepToGeom_MakeCartesianPoint2d::Convert(SC->Pnt(),P))
-  {
-    // sln 23.10.2001. CTS23496: Line is not created if direction have not been succesfully created
-    Handle(Geom2d_VectorWithMagnitude) D;
-    if (StepToGeom_MakeVectorWithMagnitude2d::Convert(SC->Dir(),D))
-    {
-      const gp_Dir2d D1(D->Vec2d());
-      CC = new Geom2d_Line(P->Pnt2d(), D1);
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeLine2d.hxx b/src/StepToGeom/StepToGeom_MakeLine2d.hxx
deleted file mode 100644 (file)
index d85079f..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1993-08-04
-// 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 _StepToGeom_MakeLine2d_HeaderFile
-#define _StepToGeom_MakeLine2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Line;
-class Geom2d_Line;
-
-
-//! This class implements the mapping between classes
-//! Line from StepGeom which describes a line from
-//! Prostep and Line from Geom2d.
-class StepToGeom_MakeLine2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Line)& SC, Handle(Geom2d_Line)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeLine2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeParabola.cxx b/src/StepToGeom/StepToGeom_MakeParabola.cxx
deleted file mode 100644 (file)
index f4200f8..0000000
+++ /dev/null
@@ -1,46 +0,0 @@
-// Created on: 1994-09-08
-// 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.
-
-
-#include <Geom_Axis2Placement.hxx>
-#include <Geom_Parabola.hxx>
-#include <gp_Ax2.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepGeom_Parabola.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeParabola.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d' un Parabola de Geom a partir d' un Parabola de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeParabola::Convert
-    (const Handle(StepGeom_Parabola)& SC,
-     Handle(Geom_Parabola)& CC)
-{
-  const StepGeom_Axis2Placement AxisSelect = SC->Position();
-  if (AxisSelect.CaseNum(AxisSelect.Value()) == 2)
-  {
-    Handle(Geom_Axis2Placement) A;
-    if (StepToGeom_MakeAxis2Placement::Convert
-          (Handle(StepGeom_Axis2Placement3d)::DownCast(AxisSelect.Value()),A))
-       {
-      CC = new Geom_Parabola(A->Ax2(), SC->FocalDist() * UnitsMethods::LengthFactor());
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeParabola.hxx b/src/StepToGeom/StepToGeom_MakeParabola.hxx
deleted file mode 100644 (file)
index c814314..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1994-09-08
-// 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 _StepToGeom_MakeParabola_HeaderFile
-#define _StepToGeom_MakeParabola_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Parabola;
-class Geom_Parabola;
-
-
-//! This class implements the mapping between classes
-//! Parabola from StepGeom which describes a Parabola from
-//! Prostep and Parabola from Geom.
-class StepToGeom_MakeParabola 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Parabola)& SC, Handle(Geom_Parabola)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeParabola_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeParabola2d.cxx b/src/StepToGeom/StepToGeom_MakeParabola2d.cxx
deleted file mode 100644 (file)
index 5da0edf..0000000
+++ /dev/null
@@ -1,46 +0,0 @@
-// Created on: 1994-09-01
-// 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.
-
-
-#include <Geom2d_AxisPlacement.hxx>
-#include <Geom2d_Parabola.hxx>
-#include <gp_Ax2.hxx>
-#include <gp_Ax22d.hxx>
-#include <StepGeom_Axis2Placement2d.hxx>
-#include <StepGeom_Parabola.hxx>
-#include <StepToGeom_MakeAxisPlacement.hxx>
-#include <StepToGeom_MakeParabola2d.hxx>
-
-//=============================================================================
-// Creation d' un Parabola de Geom2d a partir d' un Parabola de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeParabola2d::Convert
-    (const Handle(StepGeom_Parabola)& SC,
-     Handle(Geom2d_Parabola)& CC)
-{
-  const StepGeom_Axis2Placement AxisSelect = SC->Position();
-  if (AxisSelect.CaseNum(AxisSelect.Value()) == 1) {
-    Handle(Geom2d_AxisPlacement) A1;
-    if (StepToGeom_MakeAxisPlacement::Convert
-          (Handle(StepGeom_Axis2Placement2d)::DownCast(AxisSelect.Value()),A1))
-    {
-      const gp_Ax22d A( A1->Ax2d() );
-      CC = new Geom2d_Parabola(A, SC->FocalDist());
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeParabola2d.hxx b/src/StepToGeom/StepToGeom_MakeParabola2d.hxx
deleted file mode 100644 (file)
index 6ac0c0c..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1995-05-09
-// 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 _StepToGeom_MakeParabola2d_HeaderFile
-#define _StepToGeom_MakeParabola2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Parabola;
-class Geom2d_Parabola;
-
-
-//! This class implements the mapping between classes
-//! Parabola from StepGeom which describes a Parabola from
-//! Prostep and Parabola from Geom2d.
-class StepToGeom_MakeParabola2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Parabola)& SC, Handle(Geom2d_Parabola)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeParabola2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakePlane.cxx b/src/StepToGeom/StepToGeom_MakePlane.cxx
deleted file mode 100644 (file)
index 24139e3..0000000
+++ /dev/null
@@ -1,38 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-
-#include <Geom_Axis2Placement.hxx>
-#include <Geom_Plane.hxx>
-#include <gp_Ax2.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepGeom_Plane.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakePlane.hxx>
-
-//=============================================================================
-// Creation d' un Plane de Geom a partir d' un plane de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakePlane::Convert (const Handle(StepGeom_Plane)& SP, Handle(Geom_Plane)& CP)
-{
-  Handle(Geom_Axis2Placement) A;
-  if (StepToGeom_MakeAxis2Placement::Convert(SP->Position(),A))
-  {
-    CP = new Geom_Plane(A->Ax2());
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakePlane.hxx b/src/StepToGeom/StepToGeom_MakePlane.hxx
deleted file mode 100644 (file)
index 635cf27..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakePlane_HeaderFile
-#define _StepToGeom_MakePlane_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Plane;
-class Geom_Plane;
-
-
-//! This class implements the mapping between classes
-//! Plane from StepGeom which describes a plane from
-//! Prostep and Plane form Geom.
-class StepToGeom_MakePlane 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Plane)& SP, Handle(Geom_Plane)& CP);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakePlane_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakePolyline.cxx b/src/StepToGeom/StepToGeom_MakePolyline.cxx
deleted file mode 100644 (file)
index 8689087..0000000
+++ /dev/null
@@ -1,61 +0,0 @@
-// Created on: 1999-02-15
-// Created by: Andrey BETENEV
-// Copyright (c) 1999-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-
-#include <Geom_BSplineCurve.hxx>
-#include <Geom_CartesianPoint.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_Polyline.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <StepToGeom_MakePolyline.hxx>
-#include <TColgp_Array1OfPnt.hxx>
-#include <TColStd_Array1OfInteger.hxx>
-#include <TColStd_Array1OfReal.hxx>
-
-//=======================================================================
-//function : StepToGeom_MakePolyline
-//purpose  : 
-//=======================================================================
-Standard_Boolean StepToGeom_MakePolyline::Convert (const Handle(StepGeom_Polyline)& SPL, Handle(Geom_BSplineCurve)& CC)
-{
-  if (SPL.IsNull())
-    return Standard_False;
-
-  const Standard_Integer nbp = SPL->NbPoints();
-  if (nbp > 1)
-  {
-    TColgp_Array1OfPnt Poles ( 1, nbp );
-    TColStd_Array1OfReal Knots ( 1, nbp );
-    TColStd_Array1OfInteger Mults ( 1, nbp );
-
-    Handle(Geom_CartesianPoint) P;
-    for ( Standard_Integer i=1; i <= nbp; i++ )
-    {
-      if (StepToGeom_MakeCartesianPoint::Convert(SPL->PointsValue(i),P))
-        Poles.SetValue ( i, P->Pnt() );
-         else
-        return Standard_False;
-      Knots.SetValue ( i, Standard_Real(i-1) );
-      Mults.SetValue ( i, 1 );
-    }
-    Mults.SetValue ( 1, 2 );
-    Mults.SetValue ( nbp, 2 );
-
-    CC = new Geom_BSplineCurve ( Poles, Knots, Mults, 1 );
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakePolyline.hxx b/src/StepToGeom/StepToGeom_MakePolyline.hxx
deleted file mode 100644 (file)
index 888ef1c..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1999-02-15
-// Created by: Andrey BETENEV
-// Copyright (c) 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 _StepToGeom_MakePolyline_HeaderFile
-#define _StepToGeom_MakePolyline_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <StepToGeom_Root.hxx>
-#include <Standard_Boolean.hxx>
-class StepGeom_Polyline;
-class Geom_BSplineCurve;
-
-
-//! Translates polyline entity into Geom_BSpline
-//! In case if polyline has more than 2 points bspline will be C0
-class StepToGeom_MakePolyline  : public StepToGeom_Root
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Polyline)& SPL, Handle(Geom_BSplineCurve)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakePolyline_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakePolyline2d.cxx b/src/StepToGeom/StepToGeom_MakePolyline2d.cxx
deleted file mode 100644 (file)
index 29cbc7c..0000000
+++ /dev/null
@@ -1,61 +0,0 @@
-// Created on: 1999-02-15
-// Created by: Andrey BETENEV
-// Copyright (c) 1999-1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-
-#include <Geom2d_BSplineCurve.hxx>
-#include <Geom2d_CartesianPoint.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_Polyline.hxx>
-#include <StepToGeom_MakeCartesianPoint2d.hxx>
-#include <StepToGeom_MakePolyline2d.hxx>
-#include <TColgp_Array1OfPnt2d.hxx>
-#include <TColStd_Array1OfInteger.hxx>
-#include <TColStd_Array1OfReal.hxx>
-
-//=======================================================================
-//function : StepToGeom_MakePolyline2d
-//purpose  : 
-//=======================================================================
-Standard_Boolean StepToGeom_MakePolyline2d::Convert (const Handle(StepGeom_Polyline)& SPL, Handle(Geom2d_BSplineCurve)& CC)
-{
-  if (SPL.IsNull())
-    return Standard_False;
-
-  const Standard_Integer nbp = SPL->NbPoints();
-  if (nbp > 1)
-  {
-    TColgp_Array1OfPnt2d Poles ( 1, nbp );
-    TColStd_Array1OfReal Knots ( 1, nbp );
-    TColStd_Array1OfInteger Mults ( 1, nbp );
-
-    Handle(Geom2d_CartesianPoint) P;
-    for ( Standard_Integer i=1; i <= nbp; i++ )
-    {
-      if (StepToGeom_MakeCartesianPoint2d::Convert(SPL->PointsValue(i),P))
-        Poles.SetValue ( i, P->Pnt2d() );
-      else
-        return Standard_False;
-      Knots.SetValue ( i, Standard_Real(i-1) );
-      Mults.SetValue ( i, 1 );
-    }
-    Mults.SetValue ( 1, 2 );
-    Mults.SetValue ( nbp, 2 );
-
-    CC = new Geom2d_BSplineCurve ( Poles, Knots, Mults, 1 );
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakePolyline2d.hxx b/src/StepToGeom/StepToGeom_MakePolyline2d.hxx
deleted file mode 100644 (file)
index 31aef2b..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-// Created on: 1999-02-15
-// Created by: Andrey BETENEV
-// Copyright (c) 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 _StepToGeom_MakePolyline2d_HeaderFile
-#define _StepToGeom_MakePolyline2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Polyline;
-class Geom2d_BSplineCurve;
-
-
-//! Translates Polyline entity into Geom2d_BSpline
-//! In case if Polyline has more than 2 points bspline will be C0
-class StepToGeom_MakePolyline2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Polyline)& SPL, Handle(Geom2d_BSplineCurve)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakePolyline2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeRectangularTrimmedSurface.cxx b/src/StepToGeom/StepToGeom_MakeRectangularTrimmedSurface.cxx
deleted file mode 100644 (file)
index c816de2..0000000
+++ /dev/null
@@ -1,78 +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.
-
-
-#include <Geom_ConicalSurface.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 <StepGeom_RectangularTrimmedSurface.hxx>
-#include <StepToGeom_MakeRectangularTrimmedSurface.hxx>
-#include <StepToGeom_MakeSurface.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d' une RectangularTrimmedSurface de Geom a partir d' une
-// RectangularTrimmedSurface de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeRectangularTrimmedSurface::Convert (const Handle(StepGeom_RectangularTrimmedSurface)& SS,
-                                                                    Handle(Geom_RectangularTrimmedSurface)& CS)
-{
-  Handle(Geom_Surface) theBasis;
-  if (StepToGeom_MakeSurface::Convert(SS->BasisSurface(),theBasis))
-  {
-    // -----------------------------------------
-    // Modification of the Trimming Parameters ?
-    // -----------------------------------------
-  
-    Standard_Real uFact = 1.;
-    Standard_Real vFact = 1.;
-    const Standard_Real LengthFact  = UnitsMethods::LengthFactor();
-    const Standard_Real AngleFact   = UnitsMethods::PlaneAngleFactor(); // abv 30.06.00 trj4_k1_geo-tc-214.stp #1477: PI/180.;
-
-    if (theBasis->IsKind(STANDARD_TYPE(Geom_SphericalSurface)) ||
-        theBasis->IsKind(STANDARD_TYPE(Geom_ToroidalSurface))) {
-      uFact = vFact = AngleFact;
-    }
-    else if (theBasis->IsKind(STANDARD_TYPE(Geom_CylindricalSurface))) {
-      uFact = AngleFact;
-      vFact = LengthFact;
-    }
-    else if ( theBasis->IsKind(STANDARD_TYPE(Geom_SurfaceOfRevolution))) {
-      uFact = AngleFact;
-    }
-    else if (theBasis->IsKind(STANDARD_TYPE(Geom_ConicalSurface))) {
-      const Handle(Geom_ConicalSurface) conicS = Handle(Geom_ConicalSurface)::DownCast(theBasis);
-      uFact = AngleFact;
-      vFact = LengthFact / Cos(conicS->SemiAngle());
-    }
-    else if (theBasis->IsKind(STANDARD_TYPE(Geom_Plane))) {
-      uFact = vFact = LengthFact;
-    }
-
-    const Standard_Real U1 = SS->U1() * uFact;
-    const Standard_Real U2 = SS->U2() * uFact;
-    const Standard_Real V1 = SS->V1() * vFact;
-    const Standard_Real V2 = SS->V2() * vFact;
-
-    CS = new Geom_RectangularTrimmedSurface(theBasis, U1, U2, V1, V2, SS->Usense(), SS->Vsense());
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeRectangularTrimmedSurface.hxx b/src/StepToGeom/StepToGeom_MakeRectangularTrimmedSurface.hxx
deleted file mode 100644 (file)
index e7eb492..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeRectangularTrimmedSurface_HeaderFile
-#define _StepToGeom_MakeRectangularTrimmedSurface_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_RectangularTrimmedSurface;
-class Geom_RectangularTrimmedSurface;
-
-
-//! This class implements the mapping between classes
-//! RectangularTrimmedSurface from StepGeom
-//! and class RectangularTrimmedSurface from Geom
-class StepToGeom_MakeRectangularTrimmedSurface 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_RectangularTrimmedSurface)& SS, Handle(Geom_RectangularTrimmedSurface)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeRectangularTrimmedSurface_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeSphericalSurface.cxx b/src/StepToGeom/StepToGeom_MakeSphericalSurface.cxx
deleted file mode 100644 (file)
index 8dee867..0000000
+++ /dev/null
@@ -1,40 +0,0 @@
-// Created on: 1993-07-02
-// 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.
-
-
-#include <Geom_Axis2Placement.hxx>
-#include <Geom_SphericalSurface.hxx>
-#include <gp_Ax2.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepGeom_SphericalSurface.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeSphericalSurface.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d' une SphericalSurface de Geom a partir d' une 
-// SphericalSurface de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeSphericalSurface::Convert (const Handle(StepGeom_SphericalSurface)& SS, Handle(Geom_SphericalSurface)& CS)
-{
-  Handle(Geom_Axis2Placement) A;
-  if (StepToGeom_MakeAxis2Placement::Convert(SS->Position(),A))
-  {
-    CS = new Geom_SphericalSurface(A->Ax2(), SS->Radius() * UnitsMethods::LengthFactor());
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeSphericalSurface.hxx b/src/StepToGeom/StepToGeom_MakeSphericalSurface.hxx
deleted file mode 100644 (file)
index 6ceb94a..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeSphericalSurface_HeaderFile
-#define _StepToGeom_MakeSphericalSurface_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_SphericalSurface;
-class Geom_SphericalSurface;
-
-
-//! This class implements the mapping between class
-//! SphericalSurface from StepGeom which describes a
-//! spherical_surface from Prostepand SphericalSurface from Geom
-class StepToGeom_MakeSphericalSurface 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_SphericalSurface)& Surf, Handle(Geom_SphericalSurface)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeSphericalSurface_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeSurface.cxx b/src/StepToGeom/StepToGeom_MakeSurface.cxx
deleted file mode 100644 (file)
index 314cc23..0000000
+++ /dev/null
@@ -1,132 +0,0 @@
-// Created on: 1993-07-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.
-
-//:n7 abv 15.02.99: S4132: adding translation of surface_replica
-//:p0 abv 19.02.99: management of 'done' flag improved
-//:s5 abv 22.04.99  Adding debug printouts in catch {} blocks
-//sln 03.10.01. BUC61003. creation of  offset surface is corrected
-
-#include <BRep_Tool.hxx>
-#include <BRepBuilderAPI_MakeFace.hxx>
-#include <Geom_ElementarySurface.hxx>
-#include <Geom_OffsetSurface.hxx>
-#include <Geom_SweptSurface.hxx>
-#include <gp_Trsf.hxx>
-#include <Precision.hxx>
-#include <ShapeAlgo.hxx>
-#include <ShapeAlgo_AlgoContainer.hxx>
-#include <Standard_ErrorHandler.hxx>
-#include <Standard_Failure.hxx>
-#include <StepGeom_BoundedSurface.hxx>
-#include <StepGeom_CartesianTransformationOperator3d.hxx>
-#include <StepGeom_ElementarySurface.hxx>
-#include <StepGeom_OffsetSurface.hxx>
-#include <StepGeom_Surface.hxx>
-#include <StepGeom_SurfaceReplica.hxx>
-#include <StepGeom_SweptSurface.hxx>
-#include <StepToGeom_MakeBoundedSurface.hxx>
-#include <StepToGeom_MakeElementarySurface.hxx>
-#include <StepToGeom_MakeSurface.hxx>
-#include <StepToGeom_MakeSweptSurface.hxx>
-#include <StepToGeom_MakeTransformation3d.hxx>
-#include <TopoDS.hxx>
-#include <TopoDS_Face.hxx>
-#include <UnitsMethods.hxx>
-
-//:d4
-//=============================================================================
-// Creation d' une Surface de Geom a partir d' une Surface de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeSurface::Convert (const Handle(StepGeom_Surface)& SS, Handle(Geom_Surface)& CS)
-{
-   // sln 01.10.2001 BUC61003. If entry shell is NULL do nothing
-  if(SS.IsNull()) {
-    return Standard_False;
-  }
-
-  try {
-    OCC_CATCH_SIGNALS
-    if (SS->IsKind(STANDARD_TYPE(StepGeom_BoundedSurface))) {
-      const Handle(StepGeom_BoundedSurface) S1 = Handle(StepGeom_BoundedSurface)::DownCast(SS);
-      return StepToGeom_MakeBoundedSurface::Convert(S1,Handle(Geom_BoundedSurface)::DownCast (CS));
-    }
-    if (SS->IsKind(STANDARD_TYPE(StepGeom_ElementarySurface))) {
-      const Handle(StepGeom_ElementarySurface) S1 = Handle(StepGeom_ElementarySurface)::DownCast(SS);
-      if(S1->Position().IsNull())
-        return Standard_False;
-
-      return StepToGeom_MakeElementarySurface::Convert(S1,Handle(Geom_ElementarySurface)::DownCast (CS));
-    }
-    if (SS->IsKind(STANDARD_TYPE(StepGeom_SweptSurface))) {
-      const Handle(StepGeom_SweptSurface) S1 = Handle(StepGeom_SweptSurface)::DownCast(SS);
-      return StepToGeom_MakeSweptSurface::Convert(S1,Handle(Geom_SweptSurface)::DownCast (CS));
-    }
-    if (SS->IsKind(STANDARD_TYPE(StepGeom_OffsetSurface))) { //:d4 abv 12 Mar 98
-      const Handle(StepGeom_OffsetSurface) OS = Handle(StepGeom_OffsetSurface)::DownCast(SS);
-      Handle(Geom_Surface) aBasisSurface;
-      if (StepToGeom_MakeSurface::Convert(OS->BasisSurface(),aBasisSurface))
-      {
-        // sln 03.10.01. BUC61003. creation of  offset surface is corrected
-        const Standard_Real anOffset = OS->Distance() * UnitsMethods::LengthFactor();
-        if (aBasisSurface->Continuity() == GeomAbs_C0)
-        {
-          const BRepBuilderAPI_MakeFace aBFace(aBasisSurface, Precision::Confusion());
-          if (aBFace.IsDone())
-          {
-            const TopoDS_Shape aResult = ShapeAlgo::AlgoContainer()->C0ShapeToC1Shape(aBFace.Face(), Abs(anOffset));
-            if (aResult.ShapeType() == TopAbs_FACE) 
-            {
-              aBasisSurface = BRep_Tool::Surface(TopoDS::Face(aResult));
-            }
-          }
-        }
-        if(aBasisSurface->Continuity() != GeomAbs_C0)
-        {
-          CS = new Geom_OffsetSurface ( aBasisSurface, anOffset );
-          return Standard_True;
-        }
-      }
-    }
-    else if (SS->IsKind(STANDARD_TYPE(StepGeom_SurfaceReplica))) { //:n7 abv 16 Feb 99
-      const Handle(StepGeom_SurfaceReplica) SR = Handle(StepGeom_SurfaceReplica)::DownCast(SS);
-      const Handle(StepGeom_Surface) PS = SR->ParentSurface();
-      const Handle(StepGeom_CartesianTransformationOperator3d) T = 
-        Handle(StepGeom_CartesianTransformationOperator3d)::DownCast(SR->Transformation());
-      // protect against cyclic references and wrong type of cartop
-      if ( !T.IsNull() && PS != SS ) {
-        Handle(Geom_Surface) S1;
-        if (StepToGeom_MakeSurface::Convert(PS,S1))
-        {
-          gp_Trsf T1;
-          if (StepToGeom_MakeTransformation3d::Convert(T,T1))
-          {
-            S1->Transform ( T1 );
-            CS = S1;
-            return Standard_True;
-                 }
-        }
-      }
-    }
-  }
-  catch(Standard_Failure) {
-//   ShapeTool_DB ?
-#ifdef OCCT_DEBUG //:s5
-    cout<<"Warning: StepToGeom_MakeSurface: Exception:"; 
-    Standard_Failure::Caught()->Print(cout); cout << endl;
-#endif
-  }
-  return Standard_False;
-}       
diff --git a/src/StepToGeom/StepToGeom_MakeSurface.hxx b/src/StepToGeom/StepToGeom_MakeSurface.hxx
deleted file mode 100644 (file)
index 5e2a213..0000000
+++ /dev/null
@@ -1,66 +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.
-
-#ifndef _StepToGeom_MakeSurface_HeaderFile
-#define _StepToGeom_MakeSurface_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Surface;
-class Geom_Surface;
-
-
-//! This class implements the mapping between classes
-//! Surface from StepGeom which describes a Surface
-//! from prostep and Surface from Geom.
-//! As Surface is an abstract
-//! Surface this class is an access to the sub-class required.
-class StepToGeom_MakeSurface 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Surface)& SS, Handle(Geom_Surface)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeSurface_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeSurfaceOfLinearExtrusion.cxx b/src/StepToGeom/StepToGeom_MakeSurfaceOfLinearExtrusion.cxx
deleted file mode 100644 (file)
index 684e953..0000000
+++ /dev/null
@@ -1,55 +0,0 @@
-// Created on: 1993-07-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.
-
-// sln 23.10.2001. CTS23496: Surface is not created if extrusion axis have not been succesfully created (StepToGeom_MakeSurfaceOfLinearExtrusion(...) function)
-
-#include <Geom_Curve.hxx>
-#include <Geom_Line.hxx>
-#include <Geom_SurfaceOfLinearExtrusion.hxx>
-#include <Geom_VectorWithMagnitude.hxx>
-#include <gp_Dir.hxx>
-#include <gp_Lin.hxx>
-#include <gp_Vec.hxx>
-#include <Precision.hxx>
-#include <StepGeom_SurfaceOfLinearExtrusion.hxx>
-#include <StepToGeom_MakeCurve.hxx>
-#include <StepToGeom_MakeSurfaceOfLinearExtrusion.hxx>
-#include <StepToGeom_MakeVectorWithMagnitude.hxx>
-
-//=============================================================================
-// Creation d' une SurfaceOfLinearExtrusion de Geom a partir d' une
-// SurfaceOfLinearExtrusion de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeSurfaceOfLinearExtrusion::Convert (const Handle(StepGeom_SurfaceOfLinearExtrusion)& SS,
-                                                                   Handle(Geom_SurfaceOfLinearExtrusion)& CS)
-{
-  Handle(Geom_Curve) C;
-  if (StepToGeom_MakeCurve::Convert(SS->SweptCurve(),C))
-  {
-    // sln 23.10.2001. CTS23496: Surface is not created if extrusion axis have not been succesfully created
-    Handle(Geom_VectorWithMagnitude) V;
-    if (StepToGeom_MakeVectorWithMagnitude::Convert(SS->ExtrusionAxis(),V))
-    {
-      const gp_Dir D(V->Vec());
-      Handle(Geom_Line) aLine = Handle(Geom_Line)::DownCast(C);
-      if (!aLine.IsNull() && aLine->Lin().Direction().IsParallel(D, Precision::Angular()))
-        return Standard_False;
-      CS = new Geom_SurfaceOfLinearExtrusion(C,D);
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeSurfaceOfLinearExtrusion.hxx b/src/StepToGeom/StepToGeom_MakeSurfaceOfLinearExtrusion.hxx
deleted file mode 100644 (file)
index 86b76d0..0000000
+++ /dev/null
@@ -1,65 +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.
-
-#ifndef _StepToGeom_MakeSurfaceOfLinearExtrusion_HeaderFile
-#define _StepToGeom_MakeSurfaceOfLinearExtrusion_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_SurfaceOfLinearExtrusion;
-class Geom_SurfaceOfLinearExtrusion;
-
-
-//! This class implements the mapping between class
-//! SurfaceOfLinearExtrusion from StepGeom which describes a
-//! surface_of_linear_extrusion from Prostep and
-//! SurfaceOfLinearExtrusion from Geom.
-class StepToGeom_MakeSurfaceOfLinearExtrusion 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_SurfaceOfLinearExtrusion)& SS, Handle(Geom_SurfaceOfLinearExtrusion)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeSurfaceOfLinearExtrusion_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeSurfaceOfRevolution.cxx b/src/StepToGeom/StepToGeom_MakeSurfaceOfRevolution.cxx
deleted file mode 100644 (file)
index 6ee0269..0000000
+++ /dev/null
@@ -1,71 +0,0 @@
-// Created on: 1993-07-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.
-
-
-#include <Geom_Axis1Placement.hxx>
-#include <Geom_Circle.hxx>
-#include <Geom_Conic.hxx>
-#include <Geom_Curve.hxx>
-#include <Geom_Ellipse.hxx>
-#include <Geom_SurfaceOfRevolution.hxx>
-#include <Geom_TrimmedCurve.hxx>
-#include <gp_Ax1.hxx>
-#include <gp_Dir.hxx>
-#include <gp_Lin.hxx>
-#include <gp_Pnt.hxx>
-#include <StepGeom_SurfaceOfRevolution.hxx>
-#include <StepToGeom_MakeAxis1Placement.hxx>
-#include <StepToGeom_MakeCurve.hxx>
-#include <StepToGeom_MakeSurfaceOfRevolution.hxx>
-
-//=============================================================================
-// Creation d' une SurfaceOfRevolution de Geom a partir d' une
-// SurfaceOfRevolution de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeSurfaceOfRevolution::Convert (const Handle(StepGeom_SurfaceOfRevolution)& SS, Handle(Geom_SurfaceOfRevolution)& CS)
-{
-  Handle(Geom_Curve) C;
-  if (StepToGeom_MakeCurve::Convert(SS->SweptCurve(),C))
-  {
-    Handle(Geom_Axis1Placement) A1;
-    if (StepToGeom_MakeAxis1Placement::Convert(SS->AxisPosition(),A1))
-    {
-      const gp_Ax1 A( A1->Ax1() );
-      //skl for OCC952 (one bad case revolution of circle)
-      if ( C->IsKind(STANDARD_TYPE(Geom_Circle)) || C->IsKind(STANDARD_TYPE(Geom_Ellipse)) )
-      {
-        const Handle(Geom_Conic) conic = Handle(Geom_Conic)::DownCast(C);
-        const gp_Pnt pc = conic->Location();
-        const gp_Lin rl (A);
-        if (rl.Distance(pc) < Precision::Confusion()) { //pc lies on A2
-          const gp_Dir dirline = A.Direction();
-          const gp_Dir norm = conic->Axis().Direction();
-          const gp_Dir xAxis = conic->XAxis().Direction();
-          //checking A2 lies on plane of circle
-          if( dirline.IsNormal(norm,Precision::Angular()) && (dirline.IsParallel(xAxis,Precision::Angular()) || C->IsKind(STANDARD_TYPE(Geom_Circle)))) { 
-            //change parametrization for trimming
-            gp_Ax2 axnew(pc,norm,dirline.Reversed());
-            conic->SetPosition(axnew);
-            C = new Geom_TrimmedCurve(conic, 0., M_PI);
-          }
-        }
-      }
-      CS = new Geom_SurfaceOfRevolution(C, A);
-      return Standard_True;
-    }
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeSurfaceOfRevolution.hxx b/src/StepToGeom/StepToGeom_MakeSurfaceOfRevolution.hxx
deleted file mode 100644 (file)
index 670c31d..0000000
+++ /dev/null
@@ -1,65 +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.
-
-#ifndef _StepToGeom_MakeSurfaceOfRevolution_HeaderFile
-#define _StepToGeom_MakeSurfaceOfRevolution_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_SurfaceOfRevolution;
-class Geom_SurfaceOfRevolution;
-
-
-//! This class implements the mapping between class
-//! SurfaceOfRevolution from StepGeom which describes a
-//! surface_of_revolution from Prostep and SurfaceOfRevolution
-//! from Geom
-class StepToGeom_MakeSurfaceOfRevolution 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_SurfaceOfRevolution)& SS, Handle(Geom_SurfaceOfRevolution)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeSurfaceOfRevolution_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeSweptSurface.cxx b/src/StepToGeom/StepToGeom_MakeSweptSurface.cxx
deleted file mode 100644 (file)
index aee1c7a..0000000
+++ /dev/null
@@ -1,43 +0,0 @@
-// Created on: 1993-07-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.
-
-//:p0 abv 19.02.99: management of 'done' flag improved
-
-#include <Geom_SurfaceOfLinearExtrusion.hxx>
-#include <Geom_SurfaceOfRevolution.hxx>
-#include <StepGeom_SurfaceOfLinearExtrusion.hxx>
-#include <StepGeom_SurfaceOfRevolution.hxx>
-#include <StepGeom_SweptSurface.hxx>
-#include <StepToGeom_MakeSurfaceOfLinearExtrusion.hxx>
-#include <StepToGeom_MakeSurfaceOfRevolution.hxx>
-#include <StepToGeom_MakeSweptSurface.hxx>
-
-//=============================================================================
-// Creation d' une SweptSurface de prostep a partir d' une 
-// SweptSurface de Geom
-//=============================================================================
-Standard_Boolean StepToGeom_MakeSweptSurface::Convert (const Handle(StepGeom_SweptSurface)& SS, Handle(Geom_SweptSurface)& CS)
-{
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_SurfaceOfLinearExtrusion))) {
-    const Handle(StepGeom_SurfaceOfLinearExtrusion) Sur = Handle(StepGeom_SurfaceOfLinearExtrusion)::DownCast(SS);
-    return StepToGeom_MakeSurfaceOfLinearExtrusion::Convert(Sur,Handle(Geom_SurfaceOfLinearExtrusion)::DownCast (CS));
-  }
-  if (SS->IsKind(STANDARD_TYPE(StepGeom_SurfaceOfRevolution))) {
-    const Handle(StepGeom_SurfaceOfRevolution) Sur = Handle(StepGeom_SurfaceOfRevolution)::DownCast(SS);
-    return StepToGeom_MakeSurfaceOfRevolution::Convert(Sur,Handle(Geom_SurfaceOfRevolution)::DownCast (CS));
-  }
-  return Standard_False;
-}       
diff --git a/src/StepToGeom/StepToGeom_MakeSweptSurface.hxx b/src/StepToGeom/StepToGeom_MakeSweptSurface.hxx
deleted file mode 100644 (file)
index 941ddeb..0000000
+++ /dev/null
@@ -1,66 +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.
-
-#ifndef _StepToGeom_MakeSweptSurface_HeaderFile
-#define _StepToGeom_MakeSweptSurface_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_SweptSurface;
-class Geom_SweptSurface;
-
-
-//! This class implements the mapping between classes
-//! SweptSurface from StepGeom which describes a SweptSurface
-//! from prostep and SweptSurface from Geom.
-//! As SweptSurface is an abstract SweptSurface this class
-//! is an access to the sub-class required.
-class StepToGeom_MakeSweptSurface 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_SweptSurface)& SS, Handle(Geom_SweptSurface)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeSweptSurface_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeToroidalSurface.cxx b/src/StepToGeom/StepToGeom_MakeToroidalSurface.cxx
deleted file mode 100644 (file)
index c3adb71..0000000
+++ /dev/null
@@ -1,41 +0,0 @@
-// Created on: 1993-07-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.
-
-
-#include <Geom_Axis2Placement.hxx>
-#include <Geom_ToroidalSurface.hxx>
-#include <gp_Ax2.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepGeom_ToroidalSurface.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeToroidalSurface.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d' une ToroidalSurface de Geom a partir d' une 
-// ToroidalSurface de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeToroidalSurface::Convert (const Handle(StepGeom_ToroidalSurface)& SS, Handle(Geom_ToroidalSurface)& CS)
-{
-  Handle(Geom_Axis2Placement) A;
-  if (StepToGeom_MakeAxis2Placement::Convert(SS->Position(),A))
-  {
-    const Standard_Real LF = UnitsMethods::LengthFactor();
-    CS = new Geom_ToroidalSurface(A->Ax2(), Abs(SS->MajorRadius() * LF), Abs(SS->MinorRadius() * LF));
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeToroidalSurface.hxx b/src/StepToGeom/StepToGeom_MakeToroidalSurface.hxx
deleted file mode 100644 (file)
index 7207a58..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeToroidalSurface_HeaderFile
-#define _StepToGeom_MakeToroidalSurface_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_ToroidalSurface;
-class Geom_ToroidalSurface;
-
-
-//! This class implements the mapping between class
-//! ToroidalSurface from StepGeom which describes a
-//! toroidal_surface from Prostep and ToroidalSurface from Geom
-class StepToGeom_MakeToroidalSurface 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_ToroidalSurface)& SS, Handle(Geom_ToroidalSurface)& CS);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeToroidalSurface_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeTransformation2d.cxx b/src/StepToGeom/StepToGeom_MakeTransformation2d.cxx
deleted file mode 100644 (file)
index 82c8148..0000000
+++ /dev/null
@@ -1,55 +0,0 @@
-// Created on: 1999-02-16
-// Created by: Andrey BETENEV
-// Copyright (c) 1999-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.
-
-// sln 23.10.2001. CTS23496: If problems with creation of direction occur default direction is used (StepToGeom_MakeTransformation2d(...) function)
-
-#include <Geom2d_CartesianPoint.hxx>
-#include <Geom2d_Direction.hxx>
-#include <gp_Ax2d.hxx>
-#include <gp_Trsf2d.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_CartesianTransformationOperator2d.hxx>
-#include <StepGeom_Direction.hxx>
-#include <StepToGeom_MakeCartesianPoint2d.hxx>
-#include <StepToGeom_MakeDirection2d.hxx>
-#include <StepToGeom_MakeTransformation2d.hxx>
-
-//=======================================================================
-//function : StepToGeom_MakeTransformation2d
-//purpose  : 
-//=======================================================================
-Standard_Boolean StepToGeom_MakeTransformation2d::Convert (const Handle(StepGeom_CartesianTransformationOperator2d)& SCTO, gp_Trsf2d& CT)
-{
-  //  NB : on ne s interesse ici qu au deplacement rigide
-  Handle(Geom2d_CartesianPoint) CP;
-  if (StepToGeom_MakeCartesianPoint2d::Convert(SCTO->LocalOrigin(),CP))
-  {
-    gp_Dir2d D1(1.,0.);
-    // sln 23.10.2001. CTS23496: If problems with creation of direction occur default direction is used
-    const Handle(StepGeom_Direction) A = SCTO->Axis1();
-    if (!A.IsNull())
-    {
-      Handle(Geom2d_Direction) D;
-      if (StepToGeom_MakeDirection2d::Convert(A,D))
-        D1 = D->Dir2d();
-    }
-    const gp_Ax2d result(CP->Pnt2d(),D1);
-    CT.SetTransformation(result);
-    CT = CT.Inverted();
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeTransformation2d.hxx b/src/StepToGeom/StepToGeom_MakeTransformation2d.hxx
deleted file mode 100644 (file)
index 134c3fa..0000000
+++ /dev/null
@@ -1,62 +0,0 @@
-// Created on: 1999-02-16
-// Created by: Andrey BETENEV
-// Copyright (c) 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 _StepToGeom_MakeTransformation2d_HeaderFile
-#define _StepToGeom_MakeTransformation2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_CartesianTransformationOperator2d;
-class gp_Trsf2d;
-
-
-//! Convert cartesian_transformation_operator_2d to gp_Trsf2d
-class StepToGeom_MakeTransformation2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_CartesianTransformationOperator2d)& SCTO, gp_Trsf2d& CT);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeTransformation2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeTransformation3d.cxx b/src/StepToGeom/StepToGeom_MakeTransformation3d.cxx
deleted file mode 100644 (file)
index 7d4ad38..0000000
+++ /dev/null
@@ -1,77 +0,0 @@
-// Created on: 1999-02-16
-// Created by: Andrey BETENEV
-// Copyright (c) 1999-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.
-
-// sln 23.10.2001. CTS23496: If problems with creation of direction occur default direction is used (StepToGeom_MakeTransformation3d(...) function)
-
-#include <Geom_CartesianPoint.hxx>
-#include <Geom_Direction.hxx>
-#include <gp_Ax3.hxx>
-#include <gp_Trsf.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_CartesianTransformationOperator3d.hxx>
-#include <StepGeom_Direction.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <StepToGeom_MakeDirection.hxx>
-#include <StepToGeom_MakeTransformation3d.hxx>
-
-//=======================================================================
-//function : StepToGeom_MakeTransformation3d
-//purpose  : 
-//=======================================================================
-Standard_Boolean StepToGeom_MakeTransformation3d::Convert (const Handle(StepGeom_CartesianTransformationOperator3d)& SCTO, gp_Trsf& CT)
-{
-  Handle(Geom_CartesianPoint) CP;
-  if (StepToGeom_MakeCartesianPoint::Convert(SCTO->LocalOrigin(),CP))
-  {
-    const gp_Pnt Pgp = CP->Pnt();
-
-    // sln 23.10.2001. CTS23496: If problems with creation of direction occur default direction is used
-    gp_Dir D1(1.,0.,0.);
-    const Handle(StepGeom_Direction) A1 = SCTO->Axis1();
-    if (!A1.IsNull()) {
-      Handle(Geom_Direction) D;
-      if (StepToGeom_MakeDirection::Convert(A1,D))
-        D1 = D->Dir();
-    }
-
-    gp_Dir D2(0.,1.,0.);
-    const Handle(StepGeom_Direction) A2 = SCTO->Axis2();
-    if (!A2.IsNull()) {
-      Handle(Geom_Direction) D;
-      if (StepToGeom_MakeDirection::Convert(A2,D))
-        D2 = D->Dir();
-    }
-
-    Standard_Boolean isDefaultDirectionUsed = Standard_True;
-    gp_Dir D3;
-    const Handle(StepGeom_Direction) A3 = SCTO->Axis3();
-    if (!A3.IsNull()) {
-      Handle(Geom_Direction) D;
-         if(StepToGeom_MakeDirection::Convert(A3,D)) {
-        D3 = D->Dir();
-        isDefaultDirectionUsed = Standard_False;
-      }
-    }
-    if(isDefaultDirectionUsed) 
-      D3 = D1.Crossed(D2);
-
-    const gp_Ax3 result(Pgp,D3,D1);
-    CT.SetTransformation(result);
-    CT = CT.Inverted(); //:n8 abv 16 Feb 99: tr8_as2_db.stp: reverse for accordance with LV tool
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeTransformation3d.hxx b/src/StepToGeom/StepToGeom_MakeTransformation3d.hxx
deleted file mode 100644 (file)
index c728561..0000000
+++ /dev/null
@@ -1,62 +0,0 @@
-// Created on: 1999-02-16
-// Created by: Andrey BETENEV
-// Copyright (c) 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 _StepToGeom_MakeTransformation3d_HeaderFile
-#define _StepToGeom_MakeTransformation3d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_CartesianTransformationOperator3d;
-class gp_Trsf;
-
-
-//! Convert cartesian_transformation_operator_3d to gp_Trsf
-class StepToGeom_MakeTransformation3d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_CartesianTransformationOperator3d)& SCTO, gp_Trsf& CT);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeTransformation3d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeTrimmedCurve.cxx b/src/StepToGeom/StepToGeom_MakeTrimmedCurve.cxx
deleted file mode 100644 (file)
index 8ea5b1e..0000000
+++ /dev/null
@@ -1,276 +0,0 @@
-// Created on: 1994-11-04
-// 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.
-
-//:n9 abv 16.02.99: PRO10107: check parameters on curve with PConfusion()!
-//:o6 abv 18.02.99: r0301_db #63077: application of parameter Factor moved
-//:p0 abv 19.02.99: management of 'done' flag improved
-//:p3 abv 23.02.99: bm4_id_punch_d.stp #1313: shift of parameters on ellipse with R1 < R2
-//    abv 09.02.99: S4136: eliminate using BRepAPI::Precision()
-
-#include <ElCLib.hxx>
-#include <Geom_BoundedCurve.hxx>
-#include <Geom_CartesianPoint.hxx>
-#include <Geom_Curve.hxx>
-#include <Geom_TrimmedCurve.hxx>
-#include <gp_Pnt.hxx>
-#include <Precision.hxx>
-#include <ShapeAnalysis_Curve.hxx>
-#include <StepGeom_Axis2Placement3d.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_Circle.hxx>
-#include <StepGeom_Conic.hxx>
-#include <StepGeom_Ellipse.hxx>
-#include <StepGeom_HArray1OfTrimmingSelect.hxx>
-#include <StepGeom_Hyperbola.hxx>
-#include <StepGeom_Line.hxx>
-#include <StepGeom_Parabola.hxx>
-#include <StepGeom_TrimmedCurve.hxx>
-#include <StepGeom_TrimmingSelect.hxx>
-#include <StepGeom_Vector.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <StepToGeom_MakeCurve.hxx>
-#include <StepToGeom_MakeTrimmedCurve.hxx>
-#include <UnitsMethods.hxx>
-
-//#include <GeomAPI_ProjectPointOnCurve.hxx>
-//#include <BRepAPI.hxx>
-// ----------------------------------------------------------------
-// ExtractParameter
-// ----------------------------------------------------------------
-//:o6 abv 18 Feb 99: parameter Factor added
-//:p3 abv 23 Feb 99: parameter Shift added
-static Standard_Boolean  ExtractParameter
-(const Handle(Geom_Curve) &  aGeomCurve,
- const Handle(StepGeom_HArray1OfTrimmingSelect) & TS,
- const Standard_Integer nbSel,
- const Standard_Integer MasterRep,
- const Standard_Real Factor,
- const Standard_Real Shift,
- Standard_Real & aParam)     
-{
-  Handle(StepGeom_CartesianPoint) aPoint;
-  Handle(Geom_CartesianPoint) theGeomPnt;
-  Standard_Integer i;
-//:S4136  Standard_Real precBrep = BRepAPI::Precision();
-  for ( i = 1 ; i <= nbSel ; i++) {
-    StepGeom_TrimmingSelect theSel = TS->Value(i);
-    if (MasterRep == 2 && theSel.CaseMember() > 0) {
-      aParam = Shift + Factor * theSel.ParameterValue();
-      return Standard_True;
-    }
-    else if (MasterRep == 1 && theSel.CaseNumber() > 0) {
-      aPoint = theSel.CartesianPoint();
-         StepToGeom_MakeCartesianPoint::Convert(aPoint,theGeomPnt);
-      gp_Pnt thegpPnt = theGeomPnt->Pnt();
-      
-      //:S4136: use advanced algorithm
-      ShapeAnalysis_Curve sac;
-      gp_Pnt p;
-      sac.Project ( aGeomCurve, thegpPnt, Precision::Confusion(), p, aParam );
-/* //:S4136
-      //Trim == natural boundary ?
-      if(aGeomCurve->IsKind(STANDARD_TYPE(Geom_BoundedCurve))) {
-       Standard_Real frstPar = aGeomCurve->FirstParameter();
-       Standard_Real lstPar = aGeomCurve->LastParameter();
-       gp_Pnt frstPnt = aGeomCurve->Value(frstPar);
-       gp_Pnt lstPnt = aGeomCurve->Value(lstPar);
-       if(frstPnt.IsEqual(thegpPnt,precBrep)) {
-         aParam = frstPar;
-         return Standard_True;
-       }
-       if(lstPnt.IsEqual(thegpPnt,precBrep)) {
-         aParam = lstPar;
-         return Standard_True;
-       }
-      }
-      // Project Point On Curve
-      GeomAPI_ProjectPointOnCurve PPOC(thegpPnt, aGeomCurve);
-      if (PPOC.NbPoints() == 0) {
-       return Standard_False;
-      }
-      aParam = PPOC.LowerDistanceParameter();
-*/
-      return Standard_True;
-    }
-  }
-// if the MasterRepresentation is unspecified:
-// if a ParameterValue exists, it is prefered
-
-  for ( i = 1 ; i <= nbSel ; i++) {
-    StepGeom_TrimmingSelect theSel = TS->Value(i);
-    if (theSel.CaseMember() > 0) {
-      aParam = Shift + Factor * theSel.ParameterValue();
-      
-      return Standard_True;
-    }
-  }
-// if no ParameterValue exists, it is created from the CartesianPointValue
-
-  for ( i = 1 ; i <= nbSel ; i++) {
-    StepGeom_TrimmingSelect theSel = TS->Value(i);
-    if (theSel.CaseNumber() > 0) {
-      aPoint = theSel.CartesianPoint();
-         StepToGeom_MakeCartesianPoint::Convert(aPoint,theGeomPnt);
-      gp_Pnt thegpPnt = theGeomPnt->Pnt();
-      // Project Point On Curve
-      ShapeAnalysis_Curve sac;
-      gp_Pnt p;
-      sac.Project ( aGeomCurve, thegpPnt, Precision::Confusion(), p, aParam );
-/*
-      GeomAPI_ProjectPointOnCurve PPOC(thegpPnt, aGeomCurve);
-      if (PPOC.NbPoints() == 0) {
-       return Standard_False;
-      }
-      aParam = PPOC.LowerDistanceParameter();
-*/
-      return Standard_True;
-    }
-  }
-  return Standard_False;  // I suppose
-}
-
-
-//=============================================================================
-// Creation d' une Trimmed Curve de Geom a partir d' une Trimmed Curve de Step
-//=============================================================================
-
-Standard_Boolean StepToGeom_MakeTrimmedCurve::Convert (const Handle(StepGeom_TrimmedCurve)& SC, Handle(Geom_TrimmedCurve)& CC)
-{
-  const Handle(StepGeom_Curve) theSTEPCurve = SC->BasisCurve();
-  Handle(Geom_Curve) theCurve;
-  if (!StepToGeom_MakeCurve::Convert(theSTEPCurve,theCurve))
-    return Standard_False;
-
-  const Handle(StepGeom_HArray1OfTrimmingSelect)& theTrimSel1 = SC->Trim1();
-  const Handle(StepGeom_HArray1OfTrimmingSelect)& theTrimSel2 = SC->Trim2();
-  const Standard_Integer nbSel1 = SC->NbTrim1();
-  const Standard_Integer nbSel2 = SC->NbTrim2();
-
-  Standard_Integer MasterRep;
-  switch (SC->MasterRepresentation())
-  {
-    case StepGeom_tpCartesian: MasterRep = 1; break;
-       case StepGeom_tpParameter: MasterRep = 2; break;
-       default: MasterRep = 0;
-  }
-
-  //gka 18.02.04 analysis for case when MasterRep = .Unspecified 
-  //and parameters are specified as CARTESIAN_POINT
-  Standard_Boolean isPoint = Standard_False;
-  if(MasterRep == 0 || (MasterRep == 2 && nbSel1 >1 && nbSel2 > 1)) {
-    Standard_Integer ii;
-    for(ii = 1; ii <= nbSel1; ii++)
-    {
-      if (!(theTrimSel1->Value(ii).CartesianPoint().IsNull()))
-      {
-        for(ii = 1; ii <= nbSel2; ii++)
-        {
-          if (!(theTrimSel2->Value(ii).CartesianPoint().IsNull()))
-          {
-            isPoint = Standard_True;
-            break;
-          }
-        }
-        break;
-      }
-       }
-  }
-  
-  //:o6 abv 18 Feb 99: computation of factor moved 
-  Standard_Real fact = 1., shift = 0.;
-  if (theSTEPCurve->IsKind(STANDARD_TYPE(StepGeom_Line))) {
-    const Handle(StepGeom_Line) theLine = 
-      Handle(StepGeom_Line)::DownCast(theSTEPCurve);
-    fact = theLine->Dir()->Magnitude() * UnitsMethods::LengthFactor();
-  }
-  else if (theSTEPCurve->IsKind(STANDARD_TYPE(StepGeom_Circle)) ||
-           theSTEPCurve->IsKind(STANDARD_TYPE(StepGeom_Ellipse))) {
-//    if (trim1 > 2.1*M_PI || trim2 > 2.1*M_PI) fact = M_PI / 180.;
-    fact = UnitsMethods::PlaneAngleFactor();
-    //:p3 abv 23 Feb 99: shift on pi/2 on ellipse with R1 < R2
-    const Handle(StepGeom_Ellipse) ellipse = Handle(StepGeom_Ellipse)::DownCast(theSTEPCurve);
-    if ( !ellipse.IsNull() && ellipse->SemiAxis1() - ellipse->SemiAxis2() < 0. )
-      shift = 0.5 * M_PI;
-
-    // skl 04.02.2002 for OCC133: we can not make TrimmedCurve if
-    // there is no X-direction in StepGeom_Axis2Placement3d
-    const Handle(StepGeom_Conic) conic = Handle(StepGeom_Conic)::DownCast(theSTEPCurve);
-    // CKY 6-FEB-2004 for Airbus-MedialAxis : 
-    // this restriction does not apply for trimming by POINTS 
-    if(!conic.IsNull() && MasterRep != 1) {
-      const StepGeom_Axis2Placement a2p = conic->Position();
-      if(a2p.CaseNum(a2p.Value())==2) {
-        if( !a2p.Axis2Placement3d()->HasRefDirection() ) {
-          ////gka 18.02.04 analysis for case when MasterRep = .Unspecified 
-          //and parameters are specified as CARTESIAN_POINT
-          if(isPoint /*&& !MasterRep*/)
-            MasterRep =1;
-          else {
-            if ( SC->SenseAgreement() ) 
-              CC = new Geom_TrimmedCurve(theCurve, 0., 2.*M_PI, Standard_True);
-            else 
-              CC = new Geom_TrimmedCurve(theCurve, 2.*M_PI, 0., Standard_False);
-            return Standard_True;
-          }
-        }
-      }
-    }
-  }
-
-  Standard_Real trim1 = 0.;
-  Standard_Real trim2 = 0.;
-  Handle(StepGeom_CartesianPoint) TrimCP1, TrimCP2;
-  const Standard_Boolean FoundParam1 = ExtractParameter(theCurve, theTrimSel1, nbSel1, MasterRep, fact, shift, trim1);
-  const Standard_Boolean FoundParam2 = ExtractParameter(theCurve, theTrimSel2, nbSel2, MasterRep, fact, shift, trim2);
-
-  if (FoundParam1 && FoundParam2) {
-    const Standard_Real cf = theCurve->FirstParameter();
-    const Standard_Real cl = theCurve->LastParameter();
-    //: abv 09.04.99: S4136: bm2_ug_t4-B.stp #70610: protect against OutOfRange
-    if ( !theCurve->IsPeriodic() ) {
-      if ( trim1 < cf ) trim1 = cf;
-      else if ( trim1 > cl ) trim1 = cl;
-      if ( trim2 < cf ) trim2 = cf;
-      else if ( trim2 > cl ) trim2 = cl;
-    }
-    if (Abs(trim1 - trim2) < Precision::PConfusion()) {
-      if (theCurve->IsPeriodic()) {
-        ElCLib::AdjustPeriodic(cf,cl,Precision::PConfusion(),trim1,trim2);
-      }
-      else if (theCurve->IsClosed()) {
-        if (Abs(trim1 - cf) < Precision::PConfusion()) {
-          trim2 += cl;
-        }
-        else {
-          trim1 -= cl;
-        }
-      }
-      else {
-        return Standard_False;
-      }
-    }
-//  CKY 16-DEC-1997 : USA60035 le texte de Part42 parle de degres
-//    mais des systemes ecrivent en radians. Exploiter UnitsMethods
-//:o6    trim1 = trim1 * fact;
-//:o6    trim2 = trim2 * fact;
-    if ( SC->SenseAgreement() ) 
-      CC = new Geom_TrimmedCurve(theCurve, trim1, trim2, Standard_True);
-    else //:abv 29.09.00 PRO20362: reverse parameters in case of reversed curve
-      CC = new Geom_TrimmedCurve(theCurve, trim2, trim1, Standard_False);
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeTrimmedCurve.hxx b/src/StepToGeom/StepToGeom_MakeTrimmedCurve.hxx
deleted file mode 100644 (file)
index 1f546d5..0000000
+++ /dev/null
@@ -1,65 +0,0 @@
-// Created on: 1994-11-04
-// 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 _StepToGeom_MakeTrimmedCurve_HeaderFile
-#define _StepToGeom_MakeTrimmedCurve_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_TrimmedCurve;
-class Geom_TrimmedCurve;
-
-
-//! This class implements the mapping between classes
-//! class TrimmedCurve from StepGeom which
-//! describes a Trimmed Curve from prostep and TrimmedCurve from
-//! Geom.
-class StepToGeom_MakeTrimmedCurve 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_TrimmedCurve)& SC, Handle(Geom_TrimmedCurve)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeTrimmedCurve_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeTrimmedCurve2d.cxx b/src/StepToGeom/StepToGeom_MakeTrimmedCurve2d.cxx
deleted file mode 100644 (file)
index 71778b4..0000000
+++ /dev/null
@@ -1,98 +0,0 @@
-// Created on: 1994-11-04
-// 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.
-
-//:p0 abv 19.02.99: management of 'done' flag improved
-//:p3 abv 23.02.99: bm4_id_punch_d.stp #1313: shift of parameters on ellipse with R1 < R2
-
-#include <Geom2d_BSplineCurve.hxx>
-#include <Geom2d_CartesianPoint.hxx>
-#include <Geom2d_Curve.hxx>
-#include <Geom2d_TrimmedCurve.hxx>
-#include <Geom2dConvert.hxx>
-#include <gp_Pnt2d.hxx>
-#include <StepGeom_CartesianPoint.hxx>
-#include <StepGeom_Circle.hxx>
-#include <StepGeom_Ellipse.hxx>
-#include <StepGeom_HArray1OfTrimmingSelect.hxx>
-#include <StepGeom_Hyperbola.hxx>
-#include <StepGeom_Line.hxx>
-#include <StepGeom_Parabola.hxx>
-#include <StepGeom_TrimmedCurve.hxx>
-#include <StepGeom_TrimmingSelect.hxx>
-#include <StepGeom_Vector.hxx>
-#include <StepToGeom_MakeCartesianPoint2d.hxx>
-#include <StepToGeom_MakeCurve2d.hxx>
-#include <StepToGeom_MakeTrimmedCurve2d.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d'une Trimmed Curve de Geom2d a partir d' une Trimmed Curve de Step
-//=============================================================================
-// Shall be completed to treat trimming with points
-Standard_Boolean StepToGeom_MakeTrimmedCurve2d::Convert (const Handle(StepGeom_TrimmedCurve)& SC, Handle(Geom2d_BSplineCurve)& CC)
-{
-  const Handle(StepGeom_Curve) BasisCurve = SC->BasisCurve();
-  Handle(Geom2d_Curve) theGeomBasis;
-  if (!StepToGeom_MakeCurve2d::Convert(BasisCurve,theGeomBasis))
-    return Standard_False;
-
-  if (theGeomBasis->IsKind(STANDARD_TYPE(Geom2d_BSplineCurve))) {
-    CC = Handle(Geom2d_BSplineCurve)::DownCast(theGeomBasis);
-    return Standard_True;
-  }
-
-  const Handle(StepGeom_HArray1OfTrimmingSelect)& theTrimSel1 = SC->Trim1();
-  const Handle(StepGeom_HArray1OfTrimmingSelect)& theTrimSel2 = SC->Trim2();
-  const Standard_Integer nbSel1 = SC->NbTrim1();
-  const Standard_Integer nbSel2 = SC->NbTrim2();
-  if ((nbSel1 == 1) && (nbSel2 == 1) &&
-      (theTrimSel1->Value(1).CaseMember() > 0) &&
-      (theTrimSel2->Value(1).CaseMember() > 0))
-  {
-    const Standard_Real u1 = theTrimSel1->Value(1).ParameterValue();
-    const Standard_Real u2 = theTrimSel2->Value(1).ParameterValue();
-    Standard_Real fact = 1., shift = 0.;
-
-    if (BasisCurve->IsKind(STANDARD_TYPE(StepGeom_Line))) {
-      const Handle(StepGeom_Line) theLine = Handle(StepGeom_Line)::DownCast(BasisCurve);
-      fact = theLine->Dir()->Magnitude();
-    }
-    else if (BasisCurve->IsKind(STANDARD_TYPE(StepGeom_Circle)) ||
-             BasisCurve->IsKind(STANDARD_TYPE(StepGeom_Ellipse))) {
-//      if (u1 > 2.1*M_PI || u2 > 2.1*M_PI) fact = M_PI / 180.;
-      fact = UnitsMethods::PlaneAngleFactor();
-      //:p3 abv 23 Feb 99: shift on pi/2 on ellipse with R1 < R2
-      const Handle(StepGeom_Ellipse) ellipse = Handle(StepGeom_Ellipse)::DownCast(BasisCurve);
-      if ( !ellipse.IsNull() && ellipse->SemiAxis1() - ellipse->SemiAxis2() < 0. )
-        shift = 0.5 * M_PI;
-    }
-    else if (BasisCurve->IsKind(STANDARD_TYPE(StepGeom_Parabola)) ||
-             BasisCurve->IsKind(STANDARD_TYPE(StepGeom_Hyperbola))) {
-      // LATER !!!
-    }
-//    CKY 16-DEC-1997 : USA60035 le texte de Part42 parle de degres
-//      mais des systemes ecrivent en radians. Exploiter UnitsMethods
-
-    const Standard_Real newU1 = shift + u1 * fact;
-    const Standard_Real newU2 = shift + u2 * fact;
-
-    const Handle(Geom2d_TrimmedCurve) theTrimmed =
-      new Geom2d_TrimmedCurve(theGeomBasis, newU1, newU2, SC->SenseAgreement());
-    CC = Geom2dConvert::CurveToBSplineCurve(theTrimmed);
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeTrimmedCurve2d.hxx b/src/StepToGeom/StepToGeom_MakeTrimmedCurve2d.hxx
deleted file mode 100644 (file)
index 5027565..0000000
+++ /dev/null
@@ -1,65 +0,0 @@
-// Created on: 1994-11-04
-// 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 _StepToGeom_MakeTrimmedCurve2d_HeaderFile
-#define _StepToGeom_MakeTrimmedCurve2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_TrimmedCurve;
-class Geom2d_BSplineCurve;
-
-
-//! This class implements the mapping between classes
-//! class TrimmedCurve from StepGeom which
-//! describes a Trimmed Curve from prostep and TrimmedCurve from
-//! Geom.
-class StepToGeom_MakeTrimmedCurve2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_TrimmedCurve)& SC, Handle(Geom2d_BSplineCurve)& CC);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeTrimmedCurve2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeVectorWithMagnitude.cxx b/src/StepToGeom/StepToGeom_MakeVectorWithMagnitude.cxx
deleted file mode 100644 (file)
index aedb96f..0000000
+++ /dev/null
@@ -1,43 +0,0 @@
-// Created on: 1993-07-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.
-
-// sln 22.10.2001. CTS23496: Vector is not created if direction have not been succesfully created (StepToGeom_MakeVectorWithMagnitude(...) function)
-
-#include <Geom_Direction.hxx>
-#include <Geom_VectorWithMagnitude.hxx>
-#include <gp_Dir.hxx>
-#include <gp_Vec.hxx>
-#include <StepGeom_Direction.hxx>
-#include <StepGeom_Vector.hxx>
-#include <StepToGeom_MakeDirection.hxx>
-#include <StepToGeom_MakeVectorWithMagnitude.hxx>
-#include <UnitsMethods.hxx>
-
-//=============================================================================
-// Creation d' un VectorWithMagnitude de Geom a partir d' un Vector de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeVectorWithMagnitude::Convert (const Handle(StepGeom_Vector)& SV, Handle(Geom_VectorWithMagnitude)& CV)
-{
-  // sln 22.10.2001. CTS23496: Vector is not created if direction have not been succesfully created 
-  Handle(Geom_Direction) D;
-  if (StepToGeom_MakeDirection::Convert(SV->Orientation(),D))
-  {
-    const gp_Vec V(D->Dir().XYZ() * SV->Magnitude() * UnitsMethods::LengthFactor());
-    CV = new Geom_VectorWithMagnitude(V);
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeVectorWithMagnitude.hxx b/src/StepToGeom/StepToGeom_MakeVectorWithMagnitude.hxx
deleted file mode 100644 (file)
index 9de3fd9..0000000
+++ /dev/null
@@ -1,64 +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.
-
-#ifndef _StepToGeom_MakeVectorWithMagnitude_HeaderFile
-#define _StepToGeom_MakeVectorWithMagnitude_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Vector;
-class Geom_VectorWithMagnitude;
-
-
-//! This class implements the mapping between classes
-//! Vector from StepGeom which describes a VectorWithMagnitude
-//! from Prostep and VectorWithMagnitude from Geom.
-class StepToGeom_MakeVectorWithMagnitude 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Vector)& SV, Handle(Geom_VectorWithMagnitude)& CV);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeVectorWithMagnitude_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_MakeVectorWithMagnitude2d.cxx b/src/StepToGeom/StepToGeom_MakeVectorWithMagnitude2d.cxx
deleted file mode 100644 (file)
index 9a7210b..0000000
+++ /dev/null
@@ -1,42 +0,0 @@
-// Created on: 1993-08-04
-// 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.
-
-// sln 23.10.2001. CTS23496: Vector is not created if direction have not been succesfully created (StepToGeom_MakeVectorWithMagnitude2d(...) function)
-
-#include <Geom2d_Direction.hxx>
-#include <Geom2d_VectorWithMagnitude.hxx>
-#include <gp_Dir2d.hxx>
-#include <gp_Vec2d.hxx>
-#include <StepGeom_Direction.hxx>
-#include <StepGeom_Vector.hxx>
-#include <StepToGeom_MakeDirection2d.hxx>
-#include <StepToGeom_MakeVectorWithMagnitude2d.hxx>
-
-//=============================================================================
-// Creation d' un VectorWithMagnitude de Geom2d a partir d' un Vector de Step
-//=============================================================================
-Standard_Boolean StepToGeom_MakeVectorWithMagnitude2d::Convert (const Handle(StepGeom_Vector)& SV, Handle(Geom2d_VectorWithMagnitude)& CV)
-{
-  // sln 23.10.2001. CTS23496: Vector is not created if direction have not been succesfully created (StepToGeom_MakeVectorWithMagnitude2d(...) function)
-  Handle(Geom2d_Direction) D;
-  if (StepToGeom_MakeDirection2d::Convert(SV->Orientation(),D))
-  {
-    const gp_Vec2d V(D->Dir2d().XY() * SV->Magnitude());
-    CV = new Geom2d_VectorWithMagnitude(V);
-    return Standard_True;
-  }
-  return Standard_False;
-}
diff --git a/src/StepToGeom/StepToGeom_MakeVectorWithMagnitude2d.hxx b/src/StepToGeom/StepToGeom_MakeVectorWithMagnitude2d.hxx
deleted file mode 100644 (file)
index 6a96ce7..0000000
+++ /dev/null
@@ -1,64 +0,0 @@
-// Created on: 1993-08-04
-// 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 _StepToGeom_MakeVectorWithMagnitude2d_HeaderFile
-#define _StepToGeom_MakeVectorWithMagnitude2d_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Boolean.hxx>
-class StepGeom_Vector;
-class Geom2d_VectorWithMagnitude;
-
-
-//! This class implements the mapping between classes
-//! Vector from StepGeom which describes a VectorWithMagnitude
-//! from Prostep and VectorWithMagnitude from Geom2d.
-class StepToGeom_MakeVectorWithMagnitude2d 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT static Standard_Boolean Convert (const Handle(StepGeom_Vector)& SV, Handle(Geom2d_VectorWithMagnitude)& CV);
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_MakeVectorWithMagnitude2d_HeaderFile
diff --git a/src/StepToGeom/StepToGeom_Root.cxx b/src/StepToGeom/StepToGeom_Root.cxx
deleted file mode 100644 (file)
index 3e556a6..0000000
+++ /dev/null
@@ -1,23 +0,0 @@
-// Created on: 1993-07-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.
-
-
-#include <StepToGeom_Root.hxx>
-
-Standard_Boolean StepToGeom_Root::IsDone () const
-{
-  return done; 
-}
diff --git a/src/StepToGeom/StepToGeom_Root.hxx b/src/StepToGeom/StepToGeom_Root.hxx
deleted file mode 100644 (file)
index 9f8ae83..0000000
+++ /dev/null
@@ -1,62 +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.
-
-#ifndef _StepToGeom_Root_HeaderFile
-#define _StepToGeom_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 StepToGeom which report error.
-class StepToGeom_Root 
-{
-public:
-
-  DEFINE_STANDARD_ALLOC
-
-  
-  Standard_EXPORT Standard_Boolean IsDone() const;
-
-
-
-
-protected:
-
-
-
-  Standard_Boolean done;
-
-
-private:
-
-
-
-
-
-};
-
-
-
-
-
-
-
-#endif // _StepToGeom_Root_HeaderFile
index 6d90f6e..3ee3429 100644 (file)
@@ -66,9 +66,7 @@
 #include <StepShape_OrientedClosedShell.hxx>
 #include <StepShape_Shell.hxx>
 #include <StepShape_ShellBasedSurfaceModel.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <StepToGeom_MakeCurve.hxx>
-#include <StepToGeom_MakeSurface.hxx>
+#include <StepToGeom.hxx>
 #include <StepToTopoDS_Builder.hxx>
 #include <StepToTopoDS_DataMapOfTRI.hxx>
 #include <StepToTopoDS_NMTool.hxx>
@@ -708,8 +706,8 @@ static TopoDS_Face TranslateBoundedSurf (const Handle(StepGeom_Surface) &surf,
 {
   TopoDS_Face res;
 
-  Handle(Geom_Surface) theSurf;
-  if (!StepToGeom_MakeSurface::Convert(surf,theSurf) || //:i6: protection
+  Handle(Geom_Surface) theSurf = StepToGeom::MakeSurface (surf);
+  if (theSurf.IsNull() || //:i6: protection
       !theSurf->IsKind(STANDARD_TYPE(Geom_BoundedSurface))) return res;
 
   BRepBuilderAPI_MakeFace myMkFace;
@@ -800,7 +798,7 @@ void StepToTopoDS_Builder::Init
        Handle(Geom_Curve) aGeomCrv;
        try {
          OCC_CATCH_SIGNALS
-      StepToGeom_MakeCurve::Convert(aCrv,aGeomCrv);
+          aGeomCrv = StepToGeom::MakeCurve (aCrv);
        }
        catch(Standard_Failure) {
          Handle(Message_Messenger) sout = TP->Messenger();
@@ -816,8 +814,8 @@ void StepToTopoDS_Builder::Init
     // try point
     else if ( ent->IsKind(STANDARD_TYPE(StepGeom_CartesianPoint)) ) {
       Handle(StepGeom_CartesianPoint) aPnt = Handle(StepGeom_CartesianPoint)::DownCast ( ent );
-      Handle(Geom_CartesianPoint) thePnt;
-      if (StepToGeom_MakeCartesianPoint::Convert(aPnt,thePnt)) {
+      Handle(Geom_CartesianPoint) thePnt = StepToGeom::MakeCartesianPoint (aPnt);
+      if (! thePnt.IsNull()) {
         BRepBuilderAPI_MakeVertex myMkVtx(thePnt->Pnt());
         if ( myMkVtx.IsDone() ) res = myMkVtx.Vertex();
       }
index c3c6cec..5ff6938 100644 (file)
 #include <StepRepr_MappedItem.hxx>
 #include <StepRepr_Representation.hxx>
 #include <StepRepr_RepresentationMap.hxx>
-#include <StepToGeom_MakeAxis2Placement.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <StepToGeom_MakeDirection.hxx>
-#include <StepToGeom_MakeTransformation3d.hxx>
+#include <StepToGeom.hxx>
 #include <StepToTopoDS_MakeTransformed.hxx>
 #include <TopLoc_Location.hxx>
 #include <TopoDS_Shape.hxx>
@@ -52,11 +49,11 @@ Standard_Boolean  StepToTopoDS_MakeTransformed::Compute
   if (Origin.IsNull() || Target.IsNull()) return Standard_False;
 
   // sln 23.10.2001 : If the directions have not been created do nothing.  
-  Handle(Geom_Axis2Placement) theOrig;
-  if (!StepToGeom_MakeAxis2Placement::Convert(Origin,theOrig))
+  Handle(Geom_Axis2Placement) theOrig = StepToGeom::MakeAxis2Placement (Origin);
+  if (theOrig.IsNull())
     return Standard_False;
-  Handle(Geom_Axis2Placement) theTarg;
-  if (!StepToGeom_MakeAxis2Placement::Convert(Target,theTarg))
+  Handle(Geom_Axis2Placement) theTarg = StepToGeom::MakeAxis2Placement (Target);
+  if (theTarg.IsNull())
     return Standard_False;
 
   const gp_Ax3 ax3Orig(theOrig->Ax2());
@@ -70,7 +67,7 @@ Standard_Boolean  StepToTopoDS_MakeTransformed::Compute
 Standard_Boolean  StepToTopoDS_MakeTransformed::Compute
   (const Handle(StepGeom_CartesianTransformationOperator3d)& Operator)
 {
-  return StepToGeom_MakeTransformation3d::Convert(Operator,theTrsf);
+  return StepToGeom::MakeTransformation3d (Operator, theTrsf);
 }
 
 const gp_Trsf&  StepToTopoDS_MakeTransformed::Transformation () const
index 0832773..75c394b 100644 (file)
@@ -34,7 +34,7 @@
 #include <StepGeom_PcurveOrSurface.hxx>
 #include <StepGeom_Surface.hxx>
 #include <StepGeom_SurfaceCurve.hxx>
-#include <StepToGeom_MakeCurve.hxx>
+#include <StepToGeom.hxx>
 #include <StepToTopoDS_TranslateCompositeCurve.hxx>
 #include <StepToTopoDS_TranslateEdge.hxx>
 #include <TopoDS.hxx>
@@ -177,8 +177,8 @@ Standard_Boolean StepToTopoDS_TranslateCompositeCurve::Init (const Handle(StepGe
     if ( ! crv.IsNull() ) {
       try {
         OCC_CATCH_SIGNALS
-        Handle(Geom_Curve) c3d;
-        if (StepToGeom_MakeCurve::Convert(crv,c3d)) {
+        Handle(Geom_Curve) c3d = StepToGeom::MakeCurve (crv);
+        if (! c3d.IsNull()) {
           BRepBuilderAPI_MakeEdge MkEdge ( c3d, c3d->FirstParameter(), c3d->LastParameter() );
           if (MkEdge.IsDone())
           {
index 74e49a5..c058f0b 100644 (file)
@@ -27,7 +27,7 @@
 #include <StepGeom_BSplineSurface.hxx>
 #include <StepGeom_CurveBoundedSurface.hxx>
 #include <StepGeom_HArray1OfSurfaceBoundary.hxx>
-#include <StepToGeom_MakeSurface.hxx>
+#include <StepToGeom.hxx>
 #include <StepToTopoDS_TranslateCompositeCurve.hxx>
 #include <StepToTopoDS_TranslateCurveBoundedSurface.hxx>
 #include <TopoDS.hxx>
@@ -65,8 +65,9 @@ Standard_Boolean StepToTopoDS_TranslateCurveBoundedSurface::Init (
   
   // translate basis surface 
   Handle(StepGeom_Surface) S = CBS->BasisSurface();
-  Handle(Geom_Surface) Surf;
-  if ( !StepToGeom_MakeSurface::Convert(S,Surf) ) {
+  Handle(Geom_Surface) Surf = StepToGeom::MakeSurface (S);
+  if (Surf.IsNull())
+  {
     TP->AddFail ( CBS, "Basis surface not translated" );
     return Standard_False;
   }
index 34421b9..6077aeb 100644 (file)
@@ -47,9 +47,7 @@
 #include <StepShape_OrientedEdge.hxx>
 #include <StepShape_Vertex.hxx>
 #include <StepShape_VertexPoint.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
-#include <StepToGeom_MakeCurve.hxx>
-#include <StepToGeom_MakeCurve2d.hxx>
+#include <StepToGeom.hxx>
 #include <StepToTopoDS.hxx>
 #include <StepToTopoDS_GeometricTool.hxx>
 #include <StepToTopoDS_NMTool.hxx>
@@ -150,7 +148,8 @@ static Handle(Geom_Curve) MakeCurve
 {
   Handle(Geom_Curve) C2 = Handle(Geom_Curve)::DownCast (TP->FindTransient(C1));
   if (!C2.IsNull()) return C2;
-  if (StepToGeom_MakeCurve::Convert(C1,C2))
+  C2 = StepToGeom::MakeCurve (C1);
+  if (! C2.IsNull())
     TP->BindTransient (C1,C2);
   return C2;
 }
@@ -379,9 +378,8 @@ static void GetCartesianPoints ( const Handle(StepShape_EdgeCurve)& EC,
     const Handle(StepShape_VertexPoint) VP = Handle(StepShape_VertexPoint)::DownCast(V);
     if ( VP.IsNull() ) continue;
     const Handle(StepGeom_CartesianPoint) P = Handle(StepGeom_CartesianPoint)::DownCast(VP->VertexGeometry());
-    Handle(Geom_CartesianPoint) CP;
-    StepToGeom_MakeCartesianPoint::Convert(P,CP);
-       ( i==1 ? P1 : P2 ) = CP->Pnt();
+    Handle(Geom_CartesianPoint) CP = StepToGeom::MakeCartesianPoint (P);
+    ( i==1 ? P1 : P2 ) = CP->Pnt();
   }
 }
 
@@ -503,7 +501,8 @@ Handle(Geom2d_Curve)  StepToTopoDS_TranslateEdge::MakePCurve
   const Handle(StepRepr_DefinitionalRepresentation) DRI = PCU->ReferenceToCurve();
   if( DRI.IsNull()) return C2d;
   const Handle(StepGeom_Curve) StepCurve = Handle(StepGeom_Curve)::DownCast(DRI->ItemsValue(1));
-  if (StepToGeom_MakeCurve2d::Convert(StepCurve,C2d)) {
+  C2d = StepToGeom::MakeCurve2d (StepCurve);
+  if (! C2d.IsNull()) {
     // -- if the surface is a RectangularTrimmedSurface, 
     // -- send the BasisSurface.
     C2d = UnitsMethods::DegreeToRadian(C2d, ConvSurf);
index cf2d139..26363a2 100644 (file)
@@ -63,8 +63,7 @@
 #include <StepShape_FaceBound.hxx>
 #include <StepShape_OrientedEdge.hxx>
 #include <StepShape_Vertex.hxx>
-#include <StepToGeom_MakeCurve.hxx>
-#include <StepToGeom_MakeCurve2d.hxx>
+#include <StepToGeom.hxx>
 #include <StepToTopoDS.hxx>
 #include <StepToTopoDS_GeometricTool.hxx>
 #include <StepToTopoDS_NMTool.hxx>
@@ -320,7 +319,8 @@ void StepToTopoDS_TranslateEdgeLoop::Init(const Handle(StepShape_FaceBound)& Fac
         OCC_CATCH_SIGNALS
         C1 = Handle(Geom_Curve)::DownCast (TP->FindTransient(C));
         if (C1.IsNull()) {
-          if (StepToGeom_MakeCurve::Convert(C,C1))
+          C1 = StepToGeom::MakeCurve (C);
+          if (! C1.IsNull())
             TP->BindTransient (C,C1);
           else
             TP->AddWarning(C,"Could not convert a curve. Curve definition is incorrect");
index b573e45..4830942 100644 (file)
@@ -58,7 +58,7 @@
 #include <StepShape_OrientedEdge.hxx>
 #include <StepShape_PolyLoop.hxx>
 #include <StepShape_VertexLoop.hxx>
-#include <StepToGeom_MakeSurface.hxx>
+#include <StepToGeom.hxx>
 #include <StepToTopoDS.hxx>
 #include <StepToTopoDS_NMTool.hxx>
 #include <StepToTopoDS_Tool.hxx>
@@ -154,8 +154,8 @@ void StepToTopoDS_TranslateFace::Init
 
   if (StepSurf->IsKind(STANDARD_TYPE(StepGeom_OffsetSurface))) //:d4 abv 12 Mar 98
     TP->AddWarning(StepSurf," Type OffsetSurface is out of scope of AP 214");
-  Handle(Geom_Surface) GeomSurf;
-  if (!StepToGeom_MakeSurface::Convert(StepSurf,GeomSurf))
+  Handle(Geom_Surface) GeomSurf = StepToGeom::MakeSurface (StepSurf);
+  if (GeomSurf.IsNull())
   {
     TP->AddFail(StepSurf," Surface has not been created");
     myError = StepToTopoDS_TranslateFaceOther;
index 59a2650..f414444 100644 (file)
@@ -29,7 +29,7 @@
 #include <StdFail_NotDone.hxx>
 #include <StepGeom_HArray1OfCartesianPoint.hxx>
 #include <StepShape_PolyLoop.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
+#include <StepToGeom.hxx>
 #include <StepToTopoDS_PointPair.hxx>
 #include <StepToTopoDS_Tool.hxx>
 #include <StepToTopoDS_TranslatePolyLoop.hxx>
@@ -97,7 +97,7 @@ void StepToTopoDS_TranslatePolyLoop::Init(const Handle(StepShape_PolyLoop)& PL,
     Nb++;
     Poly->SetValue(Nb, PL->PolygonValue(1));
     P1 = Poly->Value(1);
-       StepToGeom_MakeCartesianPoint::Convert(P1,GP1);
+    GP1 = StepToGeom::MakeCartesianPoint (P1);
     if (aTool.IsVertexBound(P1)) {
       V1 = aTool.FindVertex(P1);
     }
@@ -110,7 +110,7 @@ void StepToTopoDS_TranslatePolyLoop::Init(const Handle(StepShape_PolyLoop)& PL,
       P2 = Poly->Value(i);
       if (P1 == P2) continue;  // peut arriver (KK)  CKY 9-DEC-1997
       StepToTopoDS_PointPair PP(P1, P2); 
-      StepToGeom_MakeCartesianPoint::Convert(P2,GP2);
+      GP2 = StepToGeom::MakeCartesianPoint (P2);
       TopoDS_Shape aBoundEdge;
       Standard_Boolean isbound = aTool.IsEdgeBound(PP);
       if ( !isbound) {
index aec0e4b..a608656 100644 (file)
@@ -24,7 +24,7 @@
 #include <StepGeom_Point.hxx>
 #include <StepShape_Vertex.hxx>
 #include <StepShape_VertexPoint.hxx>
-#include <StepToGeom_MakeCartesianPoint.hxx>
+#include <StepToGeom.hxx>
 #include <StepToTopoDS_NMTool.hxx>
 #include <StepToTopoDS_Tool.hxx>
 #include <StepToTopoDS_TranslateVertex.hxx>
@@ -91,8 +91,7 @@ void StepToTopoDS_TranslateVertex::Init(const Handle(StepShape_Vertex)& aVertex,
     const Handle(StepShape_VertexPoint) VP = Handle(StepShape_VertexPoint)::DownCast(aVertex);
     const Handle(StepGeom_Point) P = VP->VertexGeometry();
     const Handle(StepGeom_CartesianPoint) P1 = Handle(StepGeom_CartesianPoint)::DownCast(P);
-    Handle(Geom_CartesianPoint) P2;
-    StepToGeom_MakeCartesianPoint::Convert(P1,P2);
+    Handle(Geom_CartesianPoint) P2 = StepToGeom::MakeCartesianPoint (P1);
     BRep_Builder B;
     TopoDS_Vertex V;
     B.MakeVertex(V, P2->Pnt(), Precision::Confusion()); //:S4136: preci