OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-05 18:16:23 +03:00
Code Packages Releases Activity

0024023: Revamp the OCCT Handle -- StepToGeom

Browse Source 
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
This commit is contained in:
abv 2015-07-03 11:24:43 +03:00
parent e8862cf41a
commit caaeed1b91
109 changed files with 2256 additions and 6503 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/QABugs/QABugs_19.cxx Executable file → Normal file
View File

@ -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)

13
src/STEPControl/STEPControl_ActorRead.cxx
View 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;
}

96
src/StepToGeom/FILES
View File

@ -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

2042
src/StepToGeom/StepToGeom.cxx Normal file
View File

File diff suppressed because it is too large Load Diff

160
src/StepToGeom/StepToGeom.hxx Normal file
View File

@ -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

51
src/StepToGeom/StepToGeom_MakeAxis1Placement.cxx
View File

@ -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;
}

63
src/StepToGeom/StepToGeom_MakeAxis1Placement.hxx
View File

@ -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

72
src/StepToGeom/StepToGeom_MakeAxis2Placement.cxx
View File

@ -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;
}

63
src/StepToGeom/StepToGeom_MakeAxis2Placement.hxx
View File

@ -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

52
src/StepToGeom/StepToGeom_MakeAxisPlacement.cxx
View File

@ -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;
}

63
src/StepToGeom/StepToGeom_MakeAxisPlacement.hxx
View File

@ -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

59
src/StepToGeom/StepToGeom_MakeBSplineCurve.cxx
View File

@ -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

63
src/StepToGeom/StepToGeom_MakeBSplineCurve.hxx
View File

@ -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

19
src/StepToGeom/StepToGeom_MakeBSplineCurve.pxx
View File

@ -14,17 +14,12 @@
// 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);
@ -89,14 +84,14 @@
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 ? ---
@ -120,6 +115,7 @@
//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);
@ -135,5 +131,4 @@
if ( SC->ClosedCurve() && CC->Degree() >1 && CC->IsClosed() ) {
CC->SetPeriodic();
}
return Standard_True;
}
return CC;

60
src/StepToGeom/StepToGeom_MakeBSplineCurve2d.cxx
View File

@ -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

63
src/StepToGeom/StepToGeom_MakeBSplineCurve2d.hxx
View File

@ -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

199
src/StepToGeom/StepToGeom_MakeBSplineSurface.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeBSplineSurface.hxx
View File

@ -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

185
src/StepToGeom/StepToGeom_MakeBoundedCurve.cxx
View File

@ -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;
}

67
src/StepToGeom/StepToGeom_MakeBoundedCurve.hxx
View File

@ -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

55
src/StepToGeom/StepToGeom_MakeBoundedCurve2d.cxx
View File

@ -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;
}

67
src/StepToGeom/StepToGeom_MakeBoundedCurve2d.hxx
View File

@ -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

240
src/StepToGeom/StepToGeom_MakeBoundedSurface.cxx
View File

@ -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;
}

67
src/StepToGeom/StepToGeom_MakeBoundedSurface.hxx
View File

@ -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

40
src/StepToGeom/StepToGeom_MakeCartesianPoint.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeCartesianPoint.hxx
View File

@ -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

38
src/StepToGeom/StepToGeom_MakeCartesianPoint2d.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeCartesianPoint2d.hxx
View File

@ -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

46
src/StepToGeom/StepToGeom_MakeCircle.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeCircle.hxx
View File

@ -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

46
src/StepToGeom/StepToGeom_MakeCircle2d.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeCircle2d.hxx
View File

@ -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

59
src/StepToGeom/StepToGeom_MakeConic.cxx
View File

@ -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;
}

66
src/StepToGeom/StepToGeom_MakeConic.hxx
View File

@ -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

59
src/StepToGeom/StepToGeom_MakeConic2d.cxx
View File

@ -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;
}

66
src/StepToGeom/StepToGeom_MakeConic2d.hxx
View File

@ -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

45
src/StepToGeom/StepToGeom_MakeConicalSurface.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeConicalSurface.hxx
View File

@ -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

110
src/StepToGeom/StepToGeom_MakeCurve.cxx
View File

@ -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;
}

66
src/StepToGeom/StepToGeom_MakeCurve.hxx
View File

@ -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

79
src/StepToGeom/StepToGeom_MakeCurve2d.cxx
View File

@ -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;
}

66
src/StepToGeom/StepToGeom_MakeCurve2d.hxx
View File

@ -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

40
src/StepToGeom/StepToGeom_MakeCylindricalSurface.cxx
View File

@ -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;
}

65
src/StepToGeom/StepToGeom_MakeCylindricalSurface.hxx
View File

@ -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

41
src/StepToGeom/StepToGeom_MakeDirection.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeDirection.hxx
View File

@ -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

40
src/StepToGeom/StepToGeom_MakeDirection2d.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeDirection2d.hxx
View File

@ -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

64
src/StepToGeom/StepToGeom_MakeElementarySurface.cxx
View File

@ -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;
}

66
src/StepToGeom/StepToGeom_MakeElementarySurface.hxx
View File

@ -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

58
src/StepToGeom/StepToGeom_MakeEllipse.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeEllipse.hxx
View File

@ -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

57
src/StepToGeom/StepToGeom_MakeEllipse2d.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeEllipse2d.hxx
View File

@ -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

48
src/StepToGeom/StepToGeom_MakeHyperbola.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeHyperbola.hxx
View File

@ -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

46
src/StepToGeom/StepToGeom_MakeHyperbola2d.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeHyperbola2d.hxx
View File

@ -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

53
src/StepToGeom/StepToGeom_MakeLine.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeLine.hxx
View File

@ -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

51
src/StepToGeom/StepToGeom_MakeLine2d.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeLine2d.hxx
View File

@ -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

46
src/StepToGeom/StepToGeom_MakeParabola.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeParabola.hxx
View File

@ -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

46
src/StepToGeom/StepToGeom_MakeParabola2d.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeParabola2d.hxx
View File

@ -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

38
src/StepToGeom/StepToGeom_MakePlane.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakePlane.hxx
View File

@ -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

61
src/StepToGeom/StepToGeom_MakePolyline.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakePolyline.hxx
View File

@ -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

61
src/StepToGeom/StepToGeom_MakePolyline2d.cxx
View File

@ -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;
}

63
src/StepToGeom/StepToGeom_MakePolyline2d.hxx
View File

@ -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

78
src/StepToGeom/StepToGeom_MakeRectangularTrimmedSurface.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeRectangularTrimmedSurface.hxx
View File

@ -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

40
src/StepToGeom/StepToGeom_MakeSphericalSurface.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeSphericalSurface.hxx
View File

@ -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

132
src/StepToGeom/StepToGeom_MakeSurface.cxx
View File

@ -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;
}

66
src/StepToGeom/StepToGeom_MakeSurface.hxx
View File

@ -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

55
src/StepToGeom/StepToGeom_MakeSurfaceOfLinearExtrusion.cxx
View File

@ -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;
}

65
src/StepToGeom/StepToGeom_MakeSurfaceOfLinearExtrusion.hxx
View File

@ -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

71
src/StepToGeom/StepToGeom_MakeSurfaceOfRevolution.cxx
View File

@ -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;
}

65
src/StepToGeom/StepToGeom_MakeSurfaceOfRevolution.hxx
View File

@ -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

43
src/StepToGeom/StepToGeom_MakeSweptSurface.cxx
View File

@ -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;
}

66
src/StepToGeom/StepToGeom_MakeSweptSurface.hxx
View File

@ -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

41
src/StepToGeom/StepToGeom_MakeToroidalSurface.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeToroidalSurface.hxx
View File

@ -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

55
src/StepToGeom/StepToGeom_MakeTransformation2d.cxx
View File

@ -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;
}

62
src/StepToGeom/StepToGeom_MakeTransformation2d.hxx
View File

@ -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

77
src/StepToGeom/StepToGeom_MakeTransformation3d.cxx
View File

@ -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;
}

62
src/StepToGeom/StepToGeom_MakeTransformation3d.hxx
View File

@ -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

276
src/StepToGeom/StepToGeom_MakeTrimmedCurve.cxx
View File

@ -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;
}

65
src/StepToGeom/StepToGeom_MakeTrimmedCurve.hxx
View File

@ -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

98
src/StepToGeom/StepToGeom_MakeTrimmedCurve2d.cxx
View File

@ -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;
}

65
src/StepToGeom/StepToGeom_MakeTrimmedCurve2d.hxx
View File

@ -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

43
src/StepToGeom/StepToGeom_MakeVectorWithMagnitude.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeVectorWithMagnitude.hxx
View File

@ -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

42
src/StepToGeom/StepToGeom_MakeVectorWithMagnitude2d.cxx
View File

@ -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;
}

64
src/StepToGeom/StepToGeom_MakeVectorWithMagnitude2d.hxx
View File

@ -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

23
src/StepToGeom/StepToGeom_Root.cxx
View File

@ -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;
}

62
src/StepToGeom/StepToGeom_Root.hxx
View File

@ -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

Some files were not shown because too many files have changed in this diff Show More