OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

Improving translation of PMIs from STEP. This commit consists of:

Browse Source 
0033099: Data Exchange, Step Import - Wrong PMI values in GDT

measure_with_unit entity is changed to be translated as Handle(Standard_Transient) and to be processed later, depending on the underlying type being used.

0033484: Data Exchange, Step Import - Pretessellated geometry is translated incompletely

Added proper translation for TessellatedCurveSet and ComplexTriangulatedSurfaceSet.

0030024: Data Exchange - STEP, IGES export support of BRep shapes based on tessellated geometry

Support of reading and writing tessellated geometry is added for the following STEP entities:
- triangulated face
- complex triangulated face
- tessellated shell
- tessellated solid
- tessellated shape representation

Models without BRep geometry (mesh formats like STL, OBJ and so on) are supported for writing to STEP.

New parameters are added to enable/disable tessellated geometry reading and writing:
- read.step.tessellated (On/Off/OnNoBRep) (On by default)
- write.step.tessellated (On/Off/OnNoBRep) (OnNoBRep by default)

OnNoBRep - tessellation is read/written only for entities for which there is no BRep representation.

Faces with poly triangulation are written in STEP as triangulated face entities with one coordinates list per face.
Only one poly triangulation per face (returned by BRep_Tool::Triangulation) is written to STEP.
This commit is contained in:
anv 2023-09-26 16:08:34 +01:00
parent cefc95b3c2
commit 9c355a6123
234 changed files with 11275 additions and 1458 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
dox/user_guides/step/step.md
View File

@ -94,6 +94,7 @@ The types of STEP representation entities that are recognized are:
* geometrically_bounded_wireframe_shape_representation
* geometrically_bounded_surface_shape_representation
* hybrid representations (shape_representation containing models of different type)
* tessellated_shape_representation
@subsubsection occt_step_2_2_3 Topological entities
The types of STEP topological entities that can be translated are:
@ -112,6 +113,7 @@ The types of STEP geometrical entities that can be translated are:
* directions
* curves
* surfaces
* triangulations
For further information see 2.4 Mapping STEP entities to Open CASCADE Technology shapes.
@ -335,7 +337,7 @@ Specifies preferred type of representation of the shape of the product, in case
* 4 (GBSSR) -- Prefer GEOMETRICALLY_BOUNDED_SURFACE_SHAPE_REPRESENTATION
* 5 (FBSR) -- Prefer FACETTED_BREP_SHAPE_REPRESENTATION
* 6 (EBWSR) -- Prefer EDGE_BASED_WIREFRAME_SHAPE_REPRESENTATION
* 7 (GBWSR) -- Prefer GEOMETRICALLY_BOUNDED_WIREFRAME _SHAPE_REPRESENTATION
* 7 (GBWSR) -- Prefer GEOMETRICALLY_BOUNDED_WIREFRAME_SHAPE_REPRESENTATION
When this option is not equal to 1, for products with multiple representations the representation having a type closest to the selected one in this list will be translated.
@ -445,6 +447,34 @@ of for each of the two "AXIS2_PLACEMENT_3D" entities referenced by it. as follow
}
~~~~~
<h4>read.step.tessellated:</h4>
Boolean flag regulating translation of entities that define tessellated geometry:
* TESSELLATED_SHAPE_REPRESENTATION
* TESSELLATED_SHELL
* TESSELLATED_SOLID
* TRIANGULATED_FACE
* COMPLEX_TRIANGULATED_FACE
Tesselated geometry is attached to shapes as objects of <i>Poly_Triangulation</i> type using STEP links.
* 0 (Off) -- do not translate
* 1 (On) -- translate
* 2 (OnNoBRep) - tessellation is read only for entities for which there is no BRep representation
Read this parameter with:
~~~~{.cpp}
Standard_Integer ic = Interface_Static::IVal("read.step.tessellated");
~~~~
Modify this parameter with:
~~~~{.cpp}
if(!Interface_Static::SetIVal("read.step.tessellated",1))
.. error ..
~~~~
Default value is 0 (On).
@subsubsection occt_step_2_3_4 Performing the STEP file translation
Perform the translation according to what you want to translate. You can choose either root entities (all or selected by the number of root), or select any entity by its number in the STEP file. There is a limited set of types of entities that can be used as starting entities for translation. Only the following entities are recognized as transferable:
@ -462,6 +492,11 @@ Perform the translation according to what you want to translate. You can choose
* subtypes of face_surface (including advanced_face)
* subtypes of shape_representation_relationship
* context_dependent_shape_representation
* tessellated_shape_representation
* tessellated_shell
* tessellated_solid
* triangulated_face
* complex_triangulated_face
The following methods are used for translation:
@ -681,6 +716,10 @@ Not all entities defining the assembly structure in the STEP file are translated
| | quasi_uniform_surface | Geom_BSplineSurface | |
| | rectangular_composite_surface | TopoDS_Compound | Contains *TopoDS_Faces* |
| | curve_bounded_surface | TopoDS_Face | |
| Tessellations | tessellated_shell | TopoDS_Shell | |
| | tessellated_solid | TopoDS_Solid | |
| | triangulated_face | TopoDS_Face | Contains *Poly_Triangulation* |
| | complex_triangulated_face | TopoDS_Face | Contains *Poly_Triangulation* |
@subsection occt_step_2_5 Tolerance management
@ -743,6 +782,7 @@ The following default tolerances are used when creating shapes and how they are
* *StepToTopoDS_TranslatePolyLoop* constructs *TopoDS_Edges* in *TopoDS_Wire* with help of class *StepToTopoDS_TranslateEdge*. Their tolerances are not modified inside this method.
* *StepToTopoDS_TranslateFace* constructs *TopoDS_Face* with the initial value of tolerance. *TopoDS_Wire* on *TopoDS_Face* is constructed with the help of classes *StepToTopoDS_TranslatePolyLoop, StepToTopoDS_TranslateEdgeLoop* or *StepToTopoDS_TranslateVertexLoop*.
* *StepToTopoDS_TranslateShell* calls *StepToTopoDS_TranslateFace::Init* for each face. This class does not modify the tolerance value.
* *StepToTopoDS_TranslateSolid* calls *StepToTopoDS_TranslateFace::Init* for each face. This class does not modify the tolerance value.
* *StepToTopoDS_TranslateCompositeCurve* constructs *TopoDS_Edges* in *TopoDS_Wire* with help of class *BRepAPI_MakeEdge* and have a tolerance 10-7. Pcurves from a STEP file are translated if they are present and if *read.surfacecurve.mode* is not -3. The connection between segments of a composite curve (edges in the wire) is provided by calling method *ShapeFix_Wire::FixConnected()\** with a precision equal to the initial value of tolerance.
* *StepToTopoDS_TranslateCurveBoundedSurface* constructs *TopoDS_Face* with tolerance *Precision::Confusion()*. *TopoDS_Wire* on *TopoDS_Face* is constructed with the help of class *StepToTopoDS_TranslateCompositeCurve*. Missing pcurves are computed using projection algorithm with the help of method *ShapeFix_Face::FixPcurves()*. For resulting face method *ShapeFix::SameParameter()* is called. It calls standard *BRepLib::SameParameter* for each edge in each wire, which can either increase or decrease the tolerances of the edges and vertices. *SameParameter* writes the tolerance corresponding to the real deviation of pcurves from 3D curve which can be less or greater than the tolerance in a STEP file.
* *StepToTopoDS_Builder* a high level class. Its methods perform translation with the help of the classes listed above. If the value of *read.maxprecision.mode* is set to 1 then the tolerance of subshapes of the resulting shape is limited by 0 and *read.maxprecision.val*. Else this class does not change the tolerance value.
@ -969,6 +1009,34 @@ if(!Interface_Static::SetIVal("write.step.vertex.mode",1))
~~~~~
Default value is 0.
<h4>write.step.tessellated:</h4>
Boolean flag regulating writing of entities that define tessellated geometry:
* TESSELLATED_SHAPE_REPRESENTATION
* TESSELLATED_SHELL
* TESSELLATED_SOLID
* TRIANGULATED_FACE
Tesselated geometry is taken as objects of <i>Poly_Triangulation type</i> from the active <i>TopoDS_Face</i> triangulation.
* 0 (Off) -- do not write
* 1 (On) -- write
* 2 (OnNoBRep) - tessellation is written only for entities for which there is no BRep representation
Read this parameter with:
~~~~{.cpp}
Standard_Integer ic = Interface_Static::IVal("write.step.tessellated");
~~~~
Modify this parameter with:
~~~~{.cpp}
if(!Interface_Static::SetIVal("write.step.tessellated",1))
.. error ..
~~~~
Default value is 2 (OnNoBep).
@subsubsection occt_step_3_3_3 Performing the Open CASCADE Technology shape translation
An OCCT shape can be translated to STEP using one of the following models (shape_representations):
* manifold_solid_brep (advanced_brep_shape_representation)
@ -1092,6 +1160,7 @@ The table below describes STEP entities, which are created when the assembly str
| | Geom_ToroidalSurface | toroidal_surface or degenerate_toroidal_surface | *degenerate_toroidal_surface* is produced if the minor radius is greater then the major one |
| | Geom_BezierSurface | b_spline_surface_with_knots | |
| | Geom_BsplineSurface | b_spline_surface_with_knots or rational_b_spline_surface | *rational_b_spline_surface* is produced if *Geom_BSplineSurface* is a rational Bspline |
| Triangulations | Poly_Triangulation | *triangulated_face* is produced for face active triangulation | |
@subsection occt_step_3_5 Tolerance management

202
src/RWStepAP214/RWStepAP214_GeneralModule.cxx
View File

@ -1370,6 +1370,38 @@ IMPLEMENT_STANDARD_RTTIEXT(RWStepAP214_GeneralModule,StepData_GeneralModule)
#include <StepVisual_AnnotationCurveOccurrenceAndGeomReprItem.hxx>
#include <RWStepVisual_RWAnnotationCurveOccurrenceAndGeomReprItem.hxx>
#include <StepVisual_TessellatedConnectingEdge.hxx>
#include <StepVisual_TessellatedEdge.hxx>
#include <StepVisual_TessellatedPointSet.hxx>
#include <StepVisual_TessellatedShapeRepresentation.hxx>
#include <StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.hxx>
#include <StepVisual_TessellatedShell.hxx>
#include <StepVisual_TessellatedSolid.hxx>
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <StepVisual_TessellatedVertex.hxx>
#include <StepVisual_TessellatedWire.hxx>
#include <StepVisual_TriangulatedFace.hxx>
#include <StepVisual_ComplexTriangulatedFace.hxx>
#include <StepVisual_ComplexTriangulatedSurfaceSet.hxx>
#include <StepVisual_CubicBezierTessellatedEdge.hxx>
#include <StepVisual_CubicBezierTriangulatedFace.hxx>
#include <RWStepVisual_RWTessellatedConnectingEdge.hxx>
#include <RWStepVisual_RWTessellatedEdge.hxx>
#include <RWStepVisual_RWTessellatedPointSet.hxx>
#include <RWStepVisual_RWTessellatedShapeRepresentation.hxx>
#include <RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters.hxx>
#include <RWStepVisual_RWTessellatedShell.hxx>
#include <RWStepVisual_RWTessellatedSolid.hxx>
#include <RWStepVisual_RWTessellatedStructuredItem.hxx>
#include <RWStepVisual_RWTessellatedVertex.hxx>
#include <RWStepVisual_RWTessellatedWire.hxx>
#include <RWStepVisual_RWTriangulatedFace.hxx>
#include <RWStepVisual_RWComplexTriangulatedFace.hxx>
#include <RWStepVisual_RWComplexTriangulatedSurfaceSet.hxx>
#include <RWStepVisual_RWCubicBezierTessellatedEdge.hxx>
#include <RWStepVisual_RWCubicBezierTriangulatedFace.hxx>
static Standard_Integer catsh,catdr,catstr,catdsc,cataux;
@ -5204,8 +5236,113 @@ void RWStepAP214_GeneralModule::FillSharedCase(const Standard_Integer CN,
aTool.Share(anEnt, iter);
break;
}
default : break;
}
case 804:
{
DeclareAndCast(StepVisual_TessellatedConnectingEdge, anEnt, ent);
RWStepVisual_RWTessellatedConnectingEdge aTool;
aTool.Share(anEnt, iter);
}
break;
case 805:
{
DeclareAndCast(StepVisual_TessellatedEdge, anEnt, ent);
RWStepVisual_RWTessellatedEdge aTool;
aTool.Share(anEnt, iter);
}
break;
case 806:
{
DeclareAndCast(StepVisual_TessellatedPointSet, anEnt, ent);
RWStepVisual_RWTessellatedPointSet aTool;
aTool.Share(anEnt, iter);
}
break;
case 807:
{
DeclareAndCast(StepVisual_TessellatedShapeRepresentation, anEnt, ent);
RWStepVisual_RWTessellatedShapeRepresentation aTool;
aTool.Share(anEnt, iter);
}
break;
case 808:
{
DeclareAndCast(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters, anEnt, ent);
RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters aTool;
aTool.Share(anEnt, iter);
}
break;
case 809:
{
DeclareAndCast(StepVisual_TessellatedShell, anEnt, ent);
RWStepVisual_RWTessellatedShell aTool;
aTool.Share(anEnt, iter);
}
break;
case 810:
{
DeclareAndCast(StepVisual_TessellatedSolid, anEnt, ent);
RWStepVisual_RWTessellatedSolid aTool;
aTool.Share(anEnt, iter);
}
break;
case 811:
{
DeclareAndCast(StepVisual_TessellatedStructuredItem, anEnt, ent);
RWStepVisual_RWTessellatedStructuredItem aTool;
aTool.Share(anEnt, iter);
}
break;
case 812:
{
DeclareAndCast(StepVisual_TessellatedVertex, anEnt, ent);
RWStepVisual_RWTessellatedVertex aTool;
aTool.Share(anEnt, iter);
}
break;
case 813:
{
DeclareAndCast(StepVisual_TessellatedWire, anEnt, ent);
RWStepVisual_RWTessellatedWire aTool;
aTool.Share(anEnt, iter);
}
break;
case 814:
{
DeclareAndCast(StepVisual_TriangulatedFace, anEnt, ent);
RWStepVisual_RWTriangulatedFace aTool;
aTool.Share(anEnt, iter);
}
break;
case 815:
{
DeclareAndCast(StepVisual_ComplexTriangulatedFace, anEnt, ent);
RWStepVisual_RWComplexTriangulatedFace aTool;
aTool.Share(anEnt, iter);
}
break;
case 816:
{
DeclareAndCast(StepVisual_ComplexTriangulatedSurfaceSet, anEnt, ent);
RWStepVisual_RWComplexTriangulatedSurfaceSet aTool;
aTool.Share(anEnt, iter);
}
break;
case 817:
{
DeclareAndCast(StepVisual_CubicBezierTessellatedEdge, anEnt, ent);
RWStepVisual_RWCubicBezierTessellatedEdge aTool;
aTool.Share(anEnt, iter);
}
break;
case 818:
{
DeclareAndCast(StepVisual_CubicBezierTriangulatedFace, anEnt, ent);
RWStepVisual_RWCubicBezierTriangulatedFace aTool;
aTool.Share(anEnt, iter);
}
break;
default : break;
}
}
@ -7234,6 +7371,52 @@ Standard_Boolean RWStepAP214_GeneralModule::NewVoid
case 803:
ent = new StepVisual_RepositionedTessellatedItem;
break;
case 804:
ent = new StepVisual_TessellatedConnectingEdge;
break;
case 805:
ent = new StepVisual_TessellatedEdge;
break;
case 806:
ent = new StepVisual_TessellatedPointSet;
break;
case 807:
ent = new StepVisual_TessellatedShapeRepresentation;
break;
case 808:
ent = new StepVisual_TessellatedShapeRepresentationWithAccuracyParameters;
break;
case 809:
ent = new StepVisual_TessellatedShell;
break;
case 810:
ent = new StepVisual_TessellatedSolid;
break;
case 811:
ent = new StepVisual_TessellatedStructuredItem;
break;
case 812:
ent = new StepVisual_TessellatedVertex;
break;
case 813:
ent = new StepVisual_TessellatedWire;
break;
case 814:
ent = new StepVisual_TriangulatedFace;
break;
case 815:
ent = new StepVisual_ComplexTriangulatedFace;
break;
case 816:
ent = new StepVisual_ComplexTriangulatedSurfaceSet;
break;
case 817:
ent = new StepVisual_CubicBezierTessellatedEdge;
break;
case 818:
ent = new StepVisual_CubicBezierTriangulatedFace;
break;
default:
return Standard_False;
}
@ -7838,6 +8021,21 @@ Standard_Integer RWStepAP214_GeneralModule::CategoryNumber
case 723: return catdr;
case 802: return cataux;
case 803: return cataux;
case 804: return cataux;
case 805: return cataux;
case 806: return cataux;
case 807: return cataux;
case 808: return cataux;
case 809: return cataux;
case 810: return cataux;
case 811: return cataux;
case 812: return cataux;
case 813: return cataux;
case 814: return cataux;
case 815: return cataux;
case 816: return cataux;
case 817: return cataux;
case 818: return cataux;
default : break;
}
return 0;

311
src/RWStepAP214/RWStepAP214_ReadWriteModule.cxx
View File

@ -440,6 +440,38 @@ IMPLEMENT_STANDARD_RTTIEXT(RWStepAP214_ReadWriteModule,StepData_ReadWriteModule)
#include <StepVisual_SurfaceStyleRendering.hxx>
#include <StepVisual_SurfaceStyleRenderingWithProperties.hxx>
#include <StepVisual_TessellatedConnectingEdge.hxx>
#include <StepVisual_TessellatedEdge.hxx>
#include <StepVisual_TessellatedPointSet.hxx>
#include <StepVisual_TessellatedShapeRepresentation.hxx>
#include <StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.hxx>
#include <StepVisual_TessellatedShell.hxx>
#include <StepVisual_TessellatedSolid.hxx>
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <StepVisual_TessellatedVertex.hxx>
#include <StepVisual_TessellatedWire.hxx>
#include <StepVisual_TriangulatedFace.hxx>
#include <StepVisual_ComplexTriangulatedFace.hxx>
#include <StepVisual_ComplexTriangulatedSurfaceSet.hxx>
#include <StepVisual_CubicBezierTessellatedEdge.hxx>
#include <StepVisual_CubicBezierTriangulatedFace.hxx>
#include <RWStepVisual_RWTessellatedConnectingEdge.hxx>
#include <RWStepVisual_RWTessellatedEdge.hxx>
#include <RWStepVisual_RWTessellatedPointSet.hxx>
#include <RWStepVisual_RWTessellatedShapeRepresentation.hxx>
#include <RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters.hxx>
#include <RWStepVisual_RWTessellatedShell.hxx>
#include <RWStepVisual_RWTessellatedSolid.hxx>
#include <RWStepVisual_RWTessellatedStructuredItem.hxx>
#include <RWStepVisual_RWTessellatedVertex.hxx>
#include <RWStepVisual_RWTessellatedWire.hxx>
#include <RWStepVisual_RWTriangulatedFace.hxx>
#include <RWStepVisual_RWComplexTriangulatedFace.hxx>
#include <RWStepVisual_RWComplexTriangulatedSurfaceSet.hxx>
#include <RWStepVisual_RWCubicBezierTessellatedEdge.hxx>
#include <RWStepVisual_RWCubicBezierTriangulatedFace.hxx>
#include <RWStepBasic_RWAddress.hxx>
#include <RWStepShape_RWAdvancedBrepShapeRepresentation.hxx>
#include <RWStepShape_RWAdvancedFace.hxx>
@ -2066,6 +2098,22 @@ static TCollection_AsciiString Reco_SurfaceStyleReflectanceAmbient("SURFACE_STYL
static TCollection_AsciiString Reco_SurfaceStyleRendering("SURFACE_STYLE_RENDERING");
static TCollection_AsciiString Reco_SurfaceStyleRenderingWithProperties("SURFACE_STYLE_RENDERING_WITH_PROPERTIES");
static TCollection_AsciiString Reco_TessellatedConnectingEdge("TESSELLATED_CONNECTING_EDGE");
static TCollection_AsciiString Reco_TessellatedEdge("TESSELLATED_EDGE");
static TCollection_AsciiString Reco_TessellatedPointSet("TESSELLATED_POINT_SET");
static TCollection_AsciiString Reco_TessellatedShapeRepresentation("TESSELLATED_SHAPE_REPRESENTATION");
static TCollection_AsciiString Reco_TessellatedShapeRepresentationWithAccuracyParameters("TESSELLATED_SHAPE_REPRESENTATION_WITH_ACCURACY_PARAMETERS");
static TCollection_AsciiString Reco_TessellatedShell("TESSELLATED_SHELL");
static TCollection_AsciiString Reco_TessellatedSolid("TESSELLATED_SOLID");
static TCollection_AsciiString Reco_TessellatedStructuredItem("TESSELLATED_STRUCTURED_ITEM");
static TCollection_AsciiString Reco_TessellatedVertex("TESSELLATED_VERTEX");
static TCollection_AsciiString Reco_TessellatedWire("TESSELLATED_WIRE");
static TCollection_AsciiString Reco_TriangulatedFace("TRIANGULATED_FACE");
static TCollection_AsciiString Reco_ComplexTriangulatedFace("COMPLEX_TRIANGULATED_FACE");
static TCollection_AsciiString Reco_ComplexTriangulatedSurfaceSet("COMPLEX_TRIANGULATED_SURFACE_SET");
static TCollection_AsciiString Reco_CubicBezierTessellatedEdge("CUBIC_BEZIER_TESSELLATED_EDGE");
static TCollection_AsciiString Reco_CubicBezierTriangulatedFace("CUBIC_BEZIER_TRIANGULATED_FACE");
// -- Definition of the libraries --
static NCollection_DataMap<TCollection_AsciiString, Standard_Integer> typenums;
@ -2714,21 +2762,37 @@ RWStepAP214_ReadWriteModule::RWStepAP214_ReadWriteModule ()
typenums.Bind (Reco_TessellatedAnnotationOccurrence,707);
typenums.Bind (Reco_TessellatedGeometricSet, 709);
typenums.Bind ( Reco_TessellatedCurveSet, 710);
typenums.Bind ( Reco_CoordinatesList, 711);
typenums.Bind ( Reco_ConstructiveGeometryRepresentation, 712);
typenums.Bind ( Reco_ConstructiveGeometryRepresentationRelationship, 713);
typenums.Bind ( Reco_CharacterizedRepresentation, 714);
typenums.Bind ( Reco_CameraModelD3MultiClipping, 716);
typenums.Bind ( Reco_CameraModelD3MultiClippingIntersection, 717);
typenums.Bind ( Reco_CameraModelD3MultiClippingUnion, 718);
typenums.Bind (Reco_TessellatedCurveSet, 710);
typenums.Bind (Reco_CoordinatesList, 711);
typenums.Bind (Reco_ConstructiveGeometryRepresentation, 712);
typenums.Bind (Reco_ConstructiveGeometryRepresentationRelationship, 713);
typenums.Bind (Reco_CharacterizedRepresentation, 714);
typenums.Bind (Reco_CameraModelD3MultiClipping, 716);
typenums.Bind (Reco_CameraModelD3MultiClippingIntersection, 717);
typenums.Bind (Reco_CameraModelD3MultiClippingUnion, 718);
typenums.Bind (Reco_SurfaceStyleTransparent, 720);
typenums.Bind (Reco_SurfaceStyleReflectanceAmbient, 721);
typenums.Bind (Reco_SurfaceStyleRendering, 722);
typenums.Bind (Reco_SurfaceStyleRenderingWithProperties, 723);
typenums.Bind (Reco_RepositionedTessellatedItem, 803);
typenums.Bind (Reco_TessellatedConnectingEdge, 804);
typenums.Bind (Reco_TessellatedEdge, 805);
typenums.Bind (Reco_TessellatedPointSet, 806);
typenums.Bind (Reco_TessellatedShapeRepresentation, 807);
typenums.Bind (Reco_TessellatedShapeRepresentationWithAccuracyParameters, 808);
typenums.Bind (Reco_TessellatedShell, 809);
typenums.Bind (Reco_TessellatedSolid, 810);
typenums.Bind (Reco_TessellatedStructuredItem, 811);
typenums.Bind (Reco_TessellatedVertex, 812);
typenums.Bind (Reco_TessellatedWire, 813);
typenums.Bind (Reco_TriangulatedFace, 814);
typenums.Bind (Reco_ComplexTriangulatedFace, 815);
typenums.Bind (Reco_ComplexTriangulatedSurfaceSet, 816);
typenums.Bind (Reco_CubicBezierTessellatedEdge, 817);
typenums.Bind (Reco_CubicBezierTriangulatedFace, 818);
// SHORT NAMES
// NB : la liste est celle de AP203
// Directement exploite pour les types simples
@ -4599,6 +4663,21 @@ const TCollection_AsciiString& RWStepAP214_ReadWriteModule::StepType
case 723 : return Reco_SurfaceStyleRenderingWithProperties;
case 803: return Reco_RepositionedTessellatedItem;
case 804: return Reco_TessellatedConnectingEdge;
case 805: return Reco_TessellatedEdge;
case 806: return Reco_TessellatedPointSet;
case 807: return Reco_TessellatedShapeRepresentation;
case 808: return Reco_TessellatedShapeRepresentationWithAccuracyParameters;
case 809: return Reco_TessellatedShell;
case 810: return Reco_TessellatedSolid;
case 811: return Reco_TessellatedStructuredItem;
case 812: return Reco_TessellatedVertex;
case 813: return Reco_TessellatedWire;
case 814: return Reco_TriangulatedFace;
case 815: return Reco_ComplexTriangulatedFace;
case 816: return Reco_ComplexTriangulatedSurfaceSet;
case 817: return Reco_CubicBezierTessellatedEdge;
case 818: return Reco_CubicBezierTriangulatedFace;
default : return PasReco;
}
}
@ -9547,7 +9626,111 @@ void RWStepAP214_ReadWriteModule::ReadStep(const Standard_Integer CN,
aTool.ReadStep(data, num, ach, anEnt);
break;
}
case 804:
{
DeclareAndCast(StepVisual_TessellatedConnectingEdge, anEnt, ent);
RWStepVisual_RWTessellatedConnectingEdge aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 805:
{
DeclareAndCast(StepVisual_TessellatedEdge, anEnt, ent);
RWStepVisual_RWTessellatedEdge aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 806:
{
DeclareAndCast(StepVisual_TessellatedPointSet, anEnt, ent);
RWStepVisual_RWTessellatedPointSet aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 807:
{
DeclareAndCast(StepVisual_TessellatedShapeRepresentation, anEnt, ent);
RWStepVisual_RWTessellatedShapeRepresentation aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 808:
{
DeclareAndCast(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters, anEnt, ent);
RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 809:
{
DeclareAndCast(StepVisual_TessellatedShell, anEnt, ent);
RWStepVisual_RWTessellatedShell aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 810:
{
DeclareAndCast(StepVisual_TessellatedSolid, anEnt, ent);
RWStepVisual_RWTessellatedSolid aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 811:
{
DeclareAndCast(StepVisual_TessellatedStructuredItem, anEnt, ent);
RWStepVisual_RWTessellatedStructuredItem aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 812:
{
DeclareAndCast(StepVisual_TessellatedVertex, anEnt, ent);
RWStepVisual_RWTessellatedVertex aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 813:
{
DeclareAndCast(StepVisual_TessellatedWire, anEnt, ent);
RWStepVisual_RWTessellatedWire aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 814:
{
DeclareAndCast(StepVisual_TriangulatedFace, anEnt, ent);
RWStepVisual_RWTriangulatedFace aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 815:
{
DeclareAndCast(StepVisual_ComplexTriangulatedFace, anEnt, ent);
RWStepVisual_RWComplexTriangulatedFace aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 816:
{
DeclareAndCast(StepVisual_ComplexTriangulatedSurfaceSet, anEnt, ent);
RWStepVisual_RWComplexTriangulatedSurfaceSet aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 817:
{
DeclareAndCast(StepVisual_CubicBezierTessellatedEdge, anEnt, ent);
RWStepVisual_RWCubicBezierTessellatedEdge aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
case 818:
{
DeclareAndCast(StepVisual_CubicBezierTriangulatedFace, anEnt, ent);
RWStepVisual_RWCubicBezierTriangulatedFace aTool;
aTool.ReadStep(data, num, ach, anEnt);
}
break;
default:
ach->AddFail("Type Mismatch when reading - Entity");
}
@ -14446,7 +14629,115 @@ void RWStepAP214_ReadWriteModule::WriteStep(const Standard_Integer CN,
aTool.WriteStep(SW, anEnt);
break;
}
default:
// --------------------------------------------------------------------
case 804:
{
DeclareAndCast(StepVisual_TessellatedConnectingEdge, anEnt, ent);
RWStepVisual_RWTessellatedConnectingEdge aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 805:
{
DeclareAndCast(StepVisual_TessellatedEdge, anEnt, ent);
RWStepVisual_RWTessellatedEdge aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 806:
{
DeclareAndCast(StepVisual_TessellatedPointSet, anEnt, ent);
RWStepVisual_RWTessellatedPointSet aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 807:
{
DeclareAndCast(StepVisual_TessellatedShapeRepresentation, anEnt, ent);
RWStepVisual_RWTessellatedShapeRepresentation aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 808:
{
DeclareAndCast(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters, anEnt, ent);
RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 809:
{
DeclareAndCast(StepVisual_TessellatedShell, anEnt, ent);
RWStepVisual_RWTessellatedShell aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 810:
{
DeclareAndCast(StepVisual_TessellatedSolid, anEnt, ent);
RWStepVisual_RWTessellatedSolid aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 811:
{
DeclareAndCast(StepVisual_TessellatedStructuredItem, anEnt, ent);
RWStepVisual_RWTessellatedStructuredItem aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 812:
{
DeclareAndCast(StepVisual_TessellatedVertex, anEnt, ent);
RWStepVisual_RWTessellatedVertex aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 813:
{
DeclareAndCast(StepVisual_TessellatedWire, anEnt, ent);
RWStepVisual_RWTessellatedWire aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 814:
{
DeclareAndCast(StepVisual_TriangulatedFace, anEnt, ent);
RWStepVisual_RWTriangulatedFace aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 815:
{
DeclareAndCast(StepVisual_ComplexTriangulatedFace, anEnt, ent);
RWStepVisual_RWComplexTriangulatedFace aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 816:
{
DeclareAndCast(StepVisual_ComplexTriangulatedSurfaceSet, anEnt, ent);
RWStepVisual_RWComplexTriangulatedSurfaceSet aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 817:
{
DeclareAndCast(StepVisual_CubicBezierTessellatedEdge, anEnt, ent);
RWStepVisual_RWCubicBezierTessellatedEdge aTool;
aTool.WriteStep(SW, anEnt);
}
break;
case 818:
{
DeclareAndCast(StepVisual_CubicBezierTriangulatedFace, anEnt, ent);
RWStepVisual_RWCubicBezierTriangulatedFace aTool;
aTool.WriteStep(SW, anEnt);
}
break;
default:
return;
}
}

62
src/RWStepBasic/RWStepBasic_RWConversionBasedUnit.cxx
View File

@ -17,74 +17,72 @@
#include <RWStepBasic_RWConversionBasedUnit.hxx>
#include <StepBasic_ConversionBasedUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
RWStepBasic_RWConversionBasedUnit::RWStepBasic_RWConversionBasedUnit () {}
void RWStepBasic_RWConversionBasedUnit::ReadStep
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnit)& ent) const
void RWStepBasic_RWConversionBasedUnit::ReadStep(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnit)& ent) const
{
// --- Number of Parameter Control ---
// --- Number of Parameter Control ---
if (!data->CheckNbParams(num,3,ach,"conversion_based_unit")) return;
if (!data->CheckNbParams(num,3,ach,"conversion_based_unit")) return;
// --- inherited field : dimensions ---
// --- inherited field : dimensions ---
Handle(StepBasic_DimensionalExponents) aDimensions;
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
Handle(StepBasic_DimensionalExponents) aDimensions;
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
// --- own field : name ---
// --- own field : name ---
Handle(TCollection_HAsciiString) aName;
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadString (num,2,"name",ach,aName);
Handle(TCollection_HAsciiString) aName;
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadString (num,2,"name",ach,aName);
// --- own field : conversionFactor ---
// --- own field : conversionFactor ---
Handle(StepBasic_MeasureWithUnit) aConversionFactor;
//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
data->ReadEntity(num, 3,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
Handle(Standard_Transient) aConversionFactor;
data->ReadEntity (num, 3, "conversion_factor", ach, STANDARD_TYPE(Standard_Transient), aConversionFactor);
//--- Initialisation of the read entity ---
//--- Initialisation of the read entity ---
ent->Init(aDimensions, aName, aConversionFactor);
ent->Init(aDimensions, aName, aConversionFactor);
}
void RWStepBasic_RWConversionBasedUnit::WriteStep
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnit)& ent) const
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnit)& ent) const
{
// --- inherited field dimensions ---
// --- inherited field dimensions ---
SW.Send(ent->Dimensions());
SW.Send(ent->Dimensions());
// --- own field : name ---
// --- own field : name ---
SW.Send(ent->Name());
SW.Send(ent->Name());
// --- own field : conversionFactor ---
// --- own field : conversionFactor ---
SW.Send(ent->ConversionFactor());
SW.Send(ent->ConversionFactor());
}
void RWStepBasic_RWConversionBasedUnit::Share(const Handle(StepBasic_ConversionBasedUnit)& ent, Interface_EntityIterator& iter) const
{
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->ConversionFactor());
iter.GetOneItem(ent->ConversionFactor());
}

13
src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndAreaUnit.cxx
View File

@ -20,7 +20,6 @@
#include <RWStepBasic_RWConversionBasedUnitAndAreaUnit.hxx>
#include <StepBasic_ConversionBasedUnitAndAreaUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
@ -29,9 +28,9 @@ RWStepBasic_RWConversionBasedUnitAndAreaUnit::RWStepBasic_RWConversionBasedUnitA
}
void RWStepBasic_RWConversionBasedUnitAndAreaUnit::ReadStep(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndAreaUnit)& ent) const
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndAreaUnit)& ent) const
{
Standard_Integer num = num0;
//data->NamedForComplex("AREA_UNIT",num0,num,ach);
@ -44,15 +43,15 @@ void RWStepBasic_RWConversionBasedUnitAndAreaUnit::ReadStep(const Handle(StepDat
data->ReadString (num,1,"name",ach,aName);
// --- field : conversionFactor ---
Handle(StepBasic_MeasureWithUnit) aConversionFactor;
data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
Handle(Standard_Transient) aConversionFactor;
data->ReadEntity (num, 2, "conversion_factor", ach, STANDARD_TYPE(Standard_Transient), aConversionFactor);
num = data->NextForComplex(num);
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
Handle(StepBasic_DimensionalExponents) aDimensions;
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
ent->Init(aDimensions,aName,aConversionFactor);
ent->Init(aDimensions,aName, aConversionFactor);
}
void RWStepBasic_RWConversionBasedUnitAndAreaUnit::WriteStep(StepData_StepWriter& SW,

87
src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndLengthUnit.cxx
View File

@ -19,96 +19,95 @@
#include <StepBasic_ConversionBasedUnitAndLengthUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_LengthUnit.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
RWStepBasic_RWConversionBasedUnitAndLengthUnit::RWStepBasic_RWConversionBasedUnitAndLengthUnit () {}
void RWStepBasic_RWConversionBasedUnitAndLengthUnit::ReadStep
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndLengthUnit)& ent) const
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndLengthUnit)& ent) const
{
Standard_Integer num = num0;
Standard_Integer num = num0;
// --- Instance of plex componant ConversionBasedUnit ---
// --- Instance of plex component ConversionBasedUnit ---
if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
// --- field : name ---
// --- field : name ---
Handle(TCollection_HAsciiString) aName;
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadString (num,1,"name",ach,aName);
Handle(TCollection_HAsciiString) aName;
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadString (num,1,"name",ach,aName);
// --- field : conversionFactor ---
// --- field : conversionFactor ---
Handle(StepBasic_MeasureWithUnit) aConversionFactor;
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
Handle(Standard_Transient) aConversionFactor;
data->ReadEntity (num, 2, "conversion_factor", ach, STANDARD_TYPE(Standard_Transient), aConversionFactor);
num = data->NextForComplex(num);
num = data->NextForComplex(num);
// --- Instance of plex componant LengthUnit ---
// --- Instance of plex component LengthUnit ---
if (!data->CheckNbParams(num,0,ach,"length_unit")) return;
if (!data->CheckNbParams(num,0,ach,"length_unit")) return;
num = data->NextForComplex(num);
num = data->NextForComplex(num);
// --- Instance of common supertype NamedUnit ---
// --- Instance of common supertype NamedUnit ---
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
// --- field : dimensions ---
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
// --- field : dimensions ---
Handle(StepBasic_DimensionalExponents) aDimensions;
//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
Handle(StepBasic_DimensionalExponents) aDimensions;
//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
//--- Initialisation of the red entity ---
//--- Initialisation of the red entity ---
ent->Init(aDimensions,aName,aConversionFactor);
ent->Init(aDimensions,aName,aConversionFactor);
}
void RWStepBasic_RWConversionBasedUnitAndLengthUnit::WriteStep
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndLengthUnit)& ent) const
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndLengthUnit)& ent) const
{
// --- Instance of plex componant ConversionBasedUnit ---
// --- Instance of plex component ConversionBasedUnit ---
SW.StartEntity("CONVERSION_BASED_UNIT");
// --- field : name ---
SW.StartEntity("CONVERSION_BASED_UNIT");
// --- field : name ---
SW.Send(ent->Name());
// --- field : conversionFactor ---
SW.Send(ent->Name());
// --- field : conversionFactor ---
SW.Send(ent->ConversionFactor());
SW.Send(ent->ConversionFactor());
// --- Instance of plex componant LengthUnit ---
// --- Instance of plex component LengthUnit ---
SW.StartEntity("LENGTH_UNIT");
SW.StartEntity("LENGTH_UNIT");
// --- Instance of common supertype NamedUnit ---
// --- Instance of common supertype NamedUnit ---
SW.StartEntity("NAMED_UNIT");
// --- field : dimensions ---
SW.StartEntity("NAMED_UNIT");
// --- field : dimensions ---
SW.Send(ent->Dimensions());
SW.Send(ent->Dimensions());
}
void RWStepBasic_RWConversionBasedUnitAndLengthUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndLengthUnit)& ent, Interface_EntityIterator& iter) const
{
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->ConversionFactor());
iter.GetOneItem(ent->ConversionFactor());
}

15
src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndMassUnit.cxx
View File

@ -19,7 +19,6 @@
#include <StepBasic_ConversionBasedUnitAndMassUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MassUnit.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
@ -38,10 +37,10 @@ RWStepBasic_RWConversionBasedUnitAndMassUnit::RWStepBasic_RWConversionBasedUnitA
//=======================================================================
void RWStepBasic_RWConversionBasedUnitAndMassUnit::ReadStep
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndMassUnit)& ent) const
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndMassUnit)& ent) const
{
Standard_Integer num = num0;
@ -53,9 +52,9 @@ void RWStepBasic_RWConversionBasedUnitAndMassUnit::ReadStep
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadString (num,1,"name",ach,aName);
// --- field : conversionFactor ---
Handle(StepBasic_MeasureWithUnit) aConversionFactor;
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
Handle(Standard_Transient) aConversionFactor;
data->ReadEntity (num, 2, "conversion_factor", ach, STANDARD_TYPE(Standard_Transient), aConversionFactor);
num = data->NextForComplex(num);
@ -72,7 +71,7 @@ void RWStepBasic_RWConversionBasedUnitAndMassUnit::ReadStep
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
//--- Initialisation of the red entity ---
ent->Init(aDimensions,aName,aConversionFactor);
ent->Init(aDimensions,aName, aConversionFactor);
}

82
src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit.cxx
View File

@ -19,7 +19,6 @@
#include <StepBasic_ConversionBasedUnit.hxx>
#include <StepBasic_ConversionBasedUnitAndPlaneAngleUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_PlaneAngleUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
@ -27,71 +26,72 @@
RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit::RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit () {}
void RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit::ReadStep
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)& ent) const
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)& ent) const
{
// sln 09.10.2001. BUC61003. Correction of looking for items of complex entity in case of them do not saticfy to alphabetical order
// CONVERSION_BASED_UNIT
Standard_Integer num = 0;//num0;
data->NamedForComplex("CONVERSION_BASED_UNIT", "CNBSUN",num0,num,ach);
if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
Handle(TCollection_HAsciiString) aName;
data->ReadString (num,1,"name",ach,aName);
Handle(StepBasic_MeasureWithUnit) aConversionFactor;
data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
// NAMED_UNIT
//num = 0; //gka TRJ9 c2-id-214.stp
data->NamedForComplex("NAMED_UNIT", "NMDUNT",num0,num,ach);
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
Handle(StepBasic_DimensionalExponents) aDimensions;
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
Standard_Integer num = 0;//num0;
data->NamedForComplex("CONVERSION_BASED_UNIT", "CNBSUN",num0,num,ach);
if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
Handle(TCollection_HAsciiString) aName;
data->ReadString (num,1,"name",ach,aName);
// PLANE_ANGLE_UNIT
//num = 0; //gka
data->NamedForComplex("PLANE_ANGLE_UNIT", "PLANUN",num0,num,ach);
if (!data->CheckNbParams(num,0,ach,"plane_angle_unit")) return;
ent->Init(aDimensions,aName,aConversionFactor);
Handle(Standard_Transient) aConversionFactor;
data->ReadEntity (num, 2, "conversion_factor", ach, STANDARD_TYPE(Standard_Transient), aConversionFactor);
// NAMED_UNIT
//num = 0; //gka TRJ9 c2-id-214.stp
data->NamedForComplex("NAMED_UNIT", "NMDUNT",num0,num,ach);
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
Handle(StepBasic_DimensionalExponents) aDimensions;
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
// PLANE_ANGLE_UNIT
//num = 0; //gka
data->NamedForComplex("PLANE_ANGLE_UNIT", "PLANUN",num0,num,ach);
if (!data->CheckNbParams(num,0,ach,"plane_angle_unit")) return;
ent->Init(aDimensions,aName,aConversionFactor);
}
void RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit::WriteStep
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)& ent) const
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)& ent) const
{
// --- Instance of plex componant ConversionBasedUnit ---
// --- Instance of plex component ConversionBasedUnit ---
SW.StartEntity("CONVERSION_BASED_UNIT");
// --- field : name ---
SW.StartEntity("CONVERSION_BASED_UNIT");
// --- field : name ---
SW.Send(ent->Name());
// --- field : conversionFactor ---
SW.Send(ent->Name());
// --- field : conversionFactor ---
SW.Send(ent->ConversionFactor());
SW.Send(ent->ConversionFactor());
// --- Instance of common supertype NamedUnit ---
// --- Instance of common supertype NamedUnit ---
SW.StartEntity("NAMED_UNIT");
// --- field : dimensions ---
SW.StartEntity("NAMED_UNIT");
// --- field : dimensions ---
SW.Send(ent->Dimensions());
SW.Send(ent->Dimensions());
// --- Instance of plex componant PlaneAngleUnit ---
// --- Instance of plex component PlaneAngleUnit ---
SW.StartEntity("PLANE_ANGLE_UNIT");
SW.StartEntity("PLANE_ANGLE_UNIT");
}
void RWStepBasic_RWConversionBasedUnitAndPlaneAngleUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)& ent, Interface_EntityIterator& iter) const
{
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->ConversionFactor());
iter.GetOneItem(ent->ConversionFactor());
}

87
src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndRatioUnit.cxx
View File

@ -18,7 +18,6 @@
#include <StepBasic_ConversionBasedUnit.hxx>
#include <StepBasic_ConversionBasedUnitAndRatioUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_RatioUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
@ -26,89 +25,89 @@
RWStepBasic_RWConversionBasedUnitAndRatioUnit::RWStepBasic_RWConversionBasedUnitAndRatioUnit () {}
void RWStepBasic_RWConversionBasedUnitAndRatioUnit::ReadStep
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndRatioUnit)& ent) const
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndRatioUnit)& ent) const
{
Standard_Integer num = num0;
Standard_Integer num = num0;
// --- Instance of plex componant ConversionBasedUnit ---
// --- Instance of plex component ConversionBasedUnit ---
if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
// --- field : name ---
// --- field : name ---
Handle(TCollection_HAsciiString) aName;
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadString (num,1,"name",ach,aName);
Handle(TCollection_HAsciiString) aName;
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadString (num,1,"name",ach,aName);
// --- field : conversionFactor ---
// --- field : conversionFactor ---
Handle(StepBasic_MeasureWithUnit) aConversionFactor;
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
Handle(Standard_Transient) aConversionFactor;
data->ReadEntity(num, 2, "conversion_factor", ach, STANDARD_TYPE(Standard_Transient), aConversionFactor);
num = data->NextForComplex(num);
num = data->NextForComplex(num);
// --- Instance of common supertype NamedUnit ---
// --- Instance of common supertype NamedUnit ---
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
// --- field : dimensions ---
// --- field : dimensions ---
Handle(StepBasic_DimensionalExponents) aDimensions;
//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
Handle(StepBasic_DimensionalExponents) aDimensions;
//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
num = data->NextForComplex(num);
num = data->NextForComplex(num);
// --- Instance of plex componant RatioUnit ---
// --- Instance of plex component RatioUnit ---
if (!data->CheckNbParams(num,0,ach,"ratio_unit")) return;
if (!data->CheckNbParams(num,0,ach,"ratio_unit")) return;
//--- Initialisation of the red entity ---
//--- Initialisation of the red entity ---
ent->Init(aDimensions,aName,aConversionFactor);
ent->Init(aDimensions,aName, aConversionFactor);
}
void RWStepBasic_RWConversionBasedUnitAndRatioUnit::WriteStep
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndRatioUnit)& ent) const
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndRatioUnit)& ent) const
{
// --- Instance of plex componant ConversionBasedUnit ---
// --- Instance of plex component ConversionBasedUnit ---
SW.StartEntity("CONVERSION_BASED_UNIT");
// --- field : name ---
SW.StartEntity("CONVERSION_BASED_UNIT");
// --- field : name ---
SW.Send(ent->Name());
// --- field : conversionFactor ---
SW.Send(ent->Name());
// --- field : conversionFactor ---
SW.Send(ent->ConversionFactor());
SW.Send(ent->ConversionFactor());
// --- Instance of plex componant RatioUnit ---
// --- Instance of plex component RatioUnit ---
SW.StartEntity("RATIO_UNIT");
SW.StartEntity("RATIO_UNIT");
// --- Instance of common supertype NamedUnit ---
// --- Instance of common supertype NamedUnit ---
SW.StartEntity("NAMED_UNIT");
// --- field : dimensions ---
SW.StartEntity("NAMED_UNIT");
// --- field : dimensions ---
SW.Send(ent->Dimensions());
SW.Send(ent->Dimensions());
}
void RWStepBasic_RWConversionBasedUnitAndRatioUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndRatioUnit)& ent, Interface_EntityIterator& iter) const
{
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->ConversionFactor());
iter.GetOneItem(ent->ConversionFactor());
}

87
src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit.cxx
View File

@ -18,7 +18,6 @@
#include <StepBasic_ConversionBasedUnit.hxx>
#include <StepBasic_ConversionBasedUnitAndSolidAngleUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_SolidAngleUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
@ -26,89 +25,89 @@
RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit::RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit () {}
void RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit::ReadStep
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndSolidAngleUnit)& ent) const
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndSolidAngleUnit)& ent) const
{
Standard_Integer num = num0;
Standard_Integer num = num0;
// --- Instance of plex componant ConversionBasedUnit ---
// --- Instance of plex component ConversionBasedUnit ---
if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
// --- field : name ---
// --- field : name ---
Handle(TCollection_HAsciiString) aName;
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadString (num,1,"name",ach,aName);
Handle(TCollection_HAsciiString) aName;
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadString (num,1,"name",ach,aName);
// --- field : conversionFactor ---
// --- field : conversionFactor ---
Handle(StepBasic_MeasureWithUnit) aConversionFactor;
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
Handle(Standard_Transient) aConversionFactor;
data->ReadEntity (num, 2, "conversion_factor", ach, STANDARD_TYPE(Standard_Transient), aConversionFactor);
num = data->NextForComplex(num);
num = data->NextForComplex(num);
// --- Instance of common supertype NamedUnit ---
// --- Instance of common supertype NamedUnit ---
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
// --- field : dimensions ---
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
// --- field : dimensions ---
Handle(StepBasic_DimensionalExponents) aDimensions;
//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
Handle(StepBasic_DimensionalExponents) aDimensions;
//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
num = data->NextForComplex(num);
num = data->NextForComplex(num);
// --- Instance of plex componant SolidAngleUnit ---
// --- Instance of plex component SolidAngleUnit ---
if (!data->CheckNbParams(num,0,ach,"solid_angle_unit")) return;
if (!data->CheckNbParams(num,0,ach,"solid_angle_unit")) return;
//--- Initialisation of the red entity ---
//--- Initialisation of the red entity ---
ent->Init(aDimensions,aName,aConversionFactor);
ent->Init(aDimensions,aName,aConversionFactor);
}
void RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit::WriteStep
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndSolidAngleUnit)& ent) const
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndSolidAngleUnit)& ent) const
{
// --- Instance of plex componant ConversionBasedUnit ---
// --- Instance of plex component ConversionBasedUnit ---
SW.StartEntity("CONVERSION_BASED_UNIT");
// --- field : name ---
SW.StartEntity("CONVERSION_BASED_UNIT");
// --- field : name ---
SW.Send(ent->Name());
// --- field : conversionFactor ---
SW.Send(ent->Name());
// --- field : conversionFactor ---
SW.Send(ent->ConversionFactor());
SW.Send(ent->ConversionFactor());
// --- Instance of common supertype NamedUnit ---
// --- Instance of common supertype NamedUnit ---
SW.StartEntity("NAMED_UNIT");
// --- field : dimensions ---
SW.StartEntity("NAMED_UNIT");
// --- field : dimensions ---
SW.Send(ent->Dimensions());
SW.Send(ent->Dimensions());
// --- Instance of plex componant SolidAngleUnit ---
// --- Instance of plex component SolidAngleUnit ---
SW.StartEntity("SOLID_ANGLE_UNIT");
SW.StartEntity("SOLID_ANGLE_UNIT");
}
void RWStepBasic_RWConversionBasedUnitAndSolidAngleUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndSolidAngleUnit)& ent, Interface_EntityIterator& iter) const
{
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->ConversionFactor());
iter.GetOneItem(ent->ConversionFactor());
}

88
src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndTimeUnit.cxx
View File

@ -18,7 +18,6 @@
#include <StepBasic_ConversionBasedUnit.hxx>
#include <StepBasic_ConversionBasedUnitAndTimeUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_TimeUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
@ -26,89 +25,88 @@
RWStepBasic_RWConversionBasedUnitAndTimeUnit::RWStepBasic_RWConversionBasedUnitAndTimeUnit () {}
void RWStepBasic_RWConversionBasedUnitAndTimeUnit::ReadStep
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndTimeUnit)& ent) const
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndTimeUnit)& ent) const
{
Standard_Integer num = num0;
Standard_Integer num = num0;
// --- Instance of plex componant ConversionBasedUnit ---
// --- Instance of plex component ConversionBasedUnit ---
if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
if (!data->CheckNbParams(num,2,ach,"conversion_based_unit")) return;
// --- field : name ---
// --- field : name ---
Handle(TCollection_HAsciiString) aName;
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadString (num,1,"name",ach,aName);
Handle(TCollection_HAsciiString) aName;
//szv#4:S4163:12Mar99 `Standard_Boolean stat1 =` not needed
data->ReadString (num,1,"name",ach,aName);
// --- field : conversionFactor ---
// --- field : conversionFactor ---
Handle(StepBasic_MeasureWithUnit) aConversionFactor;
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
//szv#4:S4163:12Mar99 `Standard_Boolean stat2 =` not needed
Handle(Standard_Transient) aConversionFactor;
data->ReadEntity (num, 2, "conversion_factor", ach, STANDARD_TYPE(Standard_Transient), aConversionFactor);
num = data->NextForComplex(num);
num = data->NextForComplex(num);
// --- Instance of common supertype NamedUnit ---
// --- Instance of common supertype NamedUnit ---
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
// --- field : dimensions ---
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
// --- field : dimensions ---
Handle(StepBasic_DimensionalExponents) aDimensions;
//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
Handle(StepBasic_DimensionalExponents) aDimensions;
//szv#4:S4163:12Mar99 `Standard_Boolean stat3 =` not needed
data->ReadEntity(num, 1,"dimensions", ach, STANDARD_TYPE(StepBasic_DimensionalExponents), aDimensions);
num = data->NextForComplex(num);
num = data->NextForComplex(num);
// --- Instance of plex componant TimeUnit ---
// --- Instance of plex component TimeUnit ---
if (!data->CheckNbParams(num,0,ach,"time_unit")) return;
if (!data->CheckNbParams(num,0,ach,"time_unit")) return;
//--- Initialisation of the red entity ---
//--- Initialisation of the red entity ---
ent->Init(aDimensions,aName,aConversionFactor);
ent->Init(aDimensions,aName, aConversionFactor);
}
void RWStepBasic_RWConversionBasedUnitAndTimeUnit::WriteStep
(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndTimeUnit)& ent) const
void RWStepBasic_RWConversionBasedUnitAndTimeUnit::WriteStep(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndTimeUnit)& ent) const
{
// --- Instance of plex componant ConversionBasedUnit ---
// --- Instance of plex component ConversionBasedUnit ---
SW.StartEntity("CONVERSION_BASED_UNIT");
// --- field : name ---
SW.StartEntity("CONVERSION_BASED_UNIT");
// --- field : name ---
SW.Send(ent->Name());
// --- field : conversionFactor ---
SW.Send(ent->Name());
// --- field : conversionFactor ---
SW.Send(ent->ConversionFactor());
SW.Send(ent->ConversionFactor());
// --- Instance of plex componant TimeUnit ---
// --- Instance of plex component TimeUnit ---
SW.StartEntity("TIME_UNIT");
SW.StartEntity("TIME_UNIT");
// --- Instance of common supertype NamedUnit ---
// --- Instance of common supertype NamedUnit ---
SW.StartEntity("NAMED_UNIT");
// --- field : dimensions ---
SW.StartEntity("NAMED_UNIT");
// --- field : dimensions ---
SW.Send(ent->Dimensions());
SW.Send(ent->Dimensions());
}
void RWStepBasic_RWConversionBasedUnitAndTimeUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndTimeUnit)& ent, Interface_EntityIterator& iter) const
{
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->ConversionFactor());
iter.GetOneItem(ent->ConversionFactor());
}

17
src/RWStepBasic/RWStepBasic_RWConversionBasedUnitAndVolumeUnit.cxx
View File

@ -20,7 +20,6 @@
#include <RWStepBasic_RWConversionBasedUnitAndVolumeUnit.hxx>
#include <StepBasic_ConversionBasedUnitAndVolumeUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
@ -29,9 +28,9 @@ RWStepBasic_RWConversionBasedUnitAndVolumeUnit::RWStepBasic_RWConversionBasedUni
}
void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::ReadStep(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndVolumeUnit)& ent) const
const Standard_Integer num0,
Handle(Interface_Check)& ach,
const Handle(StepBasic_ConversionBasedUnitAndVolumeUnit)& ent) const
{
Standard_Integer num = num0;
// --- Instance of plex componant ConversionBasedUnit ---
@ -40,8 +39,8 @@ void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::ReadStep(const Handle(StepD
data->ReadString (num,1,"name",ach,aName);
// --- field : conversionFactor ---
Handle(StepBasic_MeasureWithUnit) aConversionFactor;
data->ReadEntity(num, 2,"conversion_factor", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aConversionFactor);
Handle(Standard_Transient) aConversionFactor;
data->ReadEntity (num, 2, "conversion_factor", ach, STANDARD_TYPE(Standard_Transient), aConversionFactor);
num = data->NextForComplex(num);
if (!data->CheckNbParams(num,1,ach,"named_unit")) return;
@ -51,11 +50,11 @@ void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::ReadStep(const Handle(StepD
data->NamedForComplex("VOLUME_UNIT","VLMUNT",num0,num,ach);
if (!data->CheckNbParams(num,0,ach,"volume_unit")) return;
ent->Init(aDimensions,aName,aConversionFactor);
ent->Init(aDimensions,aName, aConversionFactor);
}
void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::WriteStep(StepData_StepWriter& SW,
const Handle(StepBasic_ConversionBasedUnitAndVolumeUnit)& ent) const
const Handle(StepBasic_ConversionBasedUnitAndVolumeUnit)& ent) const
{
SW.StartEntity("CONVERSION_BASED_UNIT");
SW.Send(ent->Name());
@ -66,7 +65,7 @@ void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::WriteStep(StepData_StepWrit
}
void RWStepBasic_RWConversionBasedUnitAndVolumeUnit::Share(const Handle(StepBasic_ConversionBasedUnitAndVolumeUnit)& ent,
Interface_EntityIterator& iter) const
Interface_EntityIterator& iter) const
{
iter.GetOneItem(ent->Dimensions());
iter.GetOneItem(ent->ConversionFactor());

7
src/RWStepDimTol/RWStepDimTol_RWAngularityTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWAngularityTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_AngularityTolerance.hxx>
@ -55,8 +54,8 @@ void RWStepDimTol_RWAngularityTolerance::ReadStep (const Handle(StepData_StepRea
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -79,7 +78,7 @@ void RWStepDimTol_RWAngularityTolerance::ReadStep (const Handle(StepData_StepRea
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect,
aGeometricToleranceWithDatumReference_DatumSystem);
}

7
src/RWStepDimTol/RWStepDimTol_RWCircularRunoutTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWCircularRunoutTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_CircularRunoutTolerance.hxx>
@ -55,8 +54,8 @@ void RWStepDimTol_RWCircularRunoutTolerance::ReadStep (const Handle(StepData_Ste
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -79,7 +78,7 @@ void RWStepDimTol_RWCircularRunoutTolerance::ReadStep (const Handle(StepData_Ste
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect,
aGeometricToleranceWithDatumReference_DatumSystem);
}

7
src/RWStepDimTol/RWStepDimTol_RWCoaxialityTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWCoaxialityTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_CoaxialityTolerance.hxx>
@ -55,8 +54,8 @@ void RWStepDimTol_RWCoaxialityTolerance::ReadStep (const Handle(StepData_StepRea
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -79,7 +78,7 @@ void RWStepDimTol_RWCoaxialityTolerance::ReadStep (const Handle(StepData_StepRea
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect,
aGeometricToleranceWithDatumReference_DatumSystem);
}

7
src/RWStepDimTol/RWStepDimTol_RWConcentricityTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWConcentricityTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_ConcentricityTolerance.hxx>
@ -55,8 +54,8 @@ void RWStepDimTol_RWConcentricityTolerance::ReadStep (const Handle(StepData_Step
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -79,7 +78,7 @@ void RWStepDimTol_RWConcentricityTolerance::ReadStep (const Handle(StepData_Step
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect,
aGeometricToleranceWithDatumReference_DatumSystem);
}

7
src/RWStepDimTol/RWStepDimTol_RWCylindricityTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWCylindricityTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_CylindricityTolerance.hxx>
@ -53,8 +52,8 @@ void RWStepDimTol_RWCylindricityTolerance::ReadStep (const Handle(StepData_StepR
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -62,7 +61,7 @@ void RWStepDimTol_RWCylindricityTolerance::ReadStep (const Handle(StepData_StepR
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect);
}

8
src/RWStepDimTol/RWStepDimTol_RWFlatnessTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWFlatnessTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_FlatnessTolerance.hxx>
@ -36,7 +35,6 @@ RWStepDimTol_RWFlatnessTolerance::RWStepDimTol_RWFlatnessTolerance ()
//function : ReadStep
//purpose :
//=======================================================================
void RWStepDimTol_RWFlatnessTolerance::ReadStep (const Handle(StepData_StepReaderData)& data,
const Standard_Integer num,
Handle(Interface_Check)& ach,
@ -53,8 +51,8 @@ void RWStepDimTol_RWFlatnessTolerance::ReadStep (const Handle(StepData_StepReade
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -62,7 +60,7 @@ void RWStepDimTol_RWFlatnessTolerance::ReadStep (const Handle(StepData_StepReade
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect);
}

7
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRef.cxx
View File

@ -17,7 +17,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRef.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
@ -54,8 +53,10 @@ void RWStepDimTol_RWGeoTolAndGeoTolWthDatRef::ReadStep
data->ReadString (num, 1, "name", ach, aName);
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);

7
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol.hxx>
#include <StepBasic_LengthMeasureWithUnit.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
@ -56,8 +55,10 @@ void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol::ReadStep
data->ReadString (num, 1, "name", ach, aName);
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);

7
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod.cxx
View File

@ -17,7 +17,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
@ -55,8 +54,10 @@ void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndGeoTolWthMod::ReadStep
data->ReadString (num, 1, "name", ach, aName);
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);

7
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol.cxx
View File

@ -15,7 +15,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
@ -53,8 +52,10 @@ void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol::ReadStep
data->ReadString (num, 1, "name", ach, aName);
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);

6
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol.cxx
View File

@ -56,8 +56,10 @@ void RWStepDimTol_RWGeoTolAndGeoTolWthDatRefAndUneqDisGeoTol::ReadStep
data->ReadString (num, 1, "name", ach, aName);
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);

7
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthMaxTol.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWGeoTolAndGeoTolWthMaxTol.hxx>
#include <StepBasic_LengthMeasureWithUnit.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
@ -53,8 +52,10 @@ void RWStepDimTol_RWGeoTolAndGeoTolWthMaxTol::ReadStep
data->ReadString (num, 1, "name", ach, aName);
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);

7
src/RWStepDimTol/RWStepDimTol_RWGeoTolAndGeoTolWthMod.cxx
View File

@ -17,7 +17,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWGeoTolAndGeoTolWthMod.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
@ -52,8 +51,10 @@ void RWStepDimTol_RWGeoTolAndGeoTolWthMod::ReadStep
data->ReadString (num, 1, "name", ach, aName);
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);

5
src/RWStepDimTol/RWStepDimTol_RWGeometricTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWGeometricTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricTolerance.hxx>
@ -53,8 +52,8 @@ void RWStepDimTol_RWGeometricTolerance::ReadStep (const Handle(StepData_StepRead
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "toleranced_shape_aspect", ach, aTolerancedShapeAspect);

7
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithDatumReference.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWGeometricToleranceWithDatumReference.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
@ -55,8 +54,8 @@ void RWStepDimTol_RWGeometricToleranceWithDatumReference::ReadStep (const Handle
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -79,7 +78,7 @@ void RWStepDimTol_RWGeometricToleranceWithDatumReference::ReadStep (const Handle
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect,
aDatumSystem);
}

5
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepBasic_LengthMeasureWithUnit.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_AreaUnitType.hxx>
@ -56,8 +55,8 @@ void RWStepDimTol_RWGeometricToleranceWithDefinedAreaUnit::
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aTolerancedShapeAspect);

5
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithDefinedUnit.cxx
View File

@ -17,7 +17,6 @@
#include <Interface_EntityIterator.hxx>
#include <StepBasic_LengthMeasureWithUnit.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
@ -53,8 +52,8 @@ void RWStepDimTol_RWGeometricToleranceWithDefinedUnit::ReadStep (const Handle(St
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aTolerancedShapeAspect);

5
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithMaximumTolerance.cxx
View File

@ -24,7 +24,6 @@
#include <StepDimTol_GeometricToleranceTarget.hxx>
#include <StepDimTol_GeometricToleranceWithMaximumTolerance.hxx>
#include <StepDimTol_HArray1OfGeometricToleranceModifier.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
//=======================================================================
//function : RWStepDimTol_RWGeometricTolerance
@ -57,8 +56,8 @@ void RWStepDimTol_RWGeometricToleranceWithMaximumTolerance::
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aTolerancedShapeAspect);

5
src/RWStepDimTol/RWStepDimTol_RWGeometricToleranceWithModifiers.cxx
View File

@ -17,7 +17,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricToleranceModifier.hxx>
@ -56,8 +55,8 @@ void RWStepDimTol_RWGeometricToleranceWithModifiers::
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aTolerancedShapeAspect);

7
src/RWStepDimTol/RWStepDimTol_RWLineProfileTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWLineProfileTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
@ -53,8 +52,8 @@ void RWStepDimTol_RWLineProfileTolerance::ReadStep (const Handle(StepData_StepRe
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -62,7 +61,7 @@ void RWStepDimTol_RWLineProfileTolerance::ReadStep (const Handle(StepData_StepRe
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect);
}

7
src/RWStepDimTol/RWStepDimTol_RWModifiedGeometricTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWModifiedGeometricTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
@ -53,8 +52,8 @@ void RWStepDimTol_RWModifiedGeometricTolerance::ReadStep (const Handle(StepData_
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -74,7 +73,7 @@ void RWStepDimTol_RWModifiedGeometricTolerance::ReadStep (const Handle(StepData_
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect,
aModifier);
}

7
src/RWStepDimTol/RWStepDimTol_RWParallelismTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWParallelismTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
@ -55,8 +54,8 @@ void RWStepDimTol_RWParallelismTolerance::ReadStep (const Handle(StepData_StepRe
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -79,7 +78,7 @@ void RWStepDimTol_RWParallelismTolerance::ReadStep (const Handle(StepData_StepRe
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect,
aGeometricToleranceWithDatumReference_DatumSystem);
}

7
src/RWStepDimTol/RWStepDimTol_RWPerpendicularityTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWPerpendicularityTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
@ -55,8 +54,8 @@ void RWStepDimTol_RWPerpendicularityTolerance::ReadStep (const Handle(StepData_S
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -79,7 +78,7 @@ void RWStepDimTol_RWPerpendicularityTolerance::ReadStep (const Handle(StepData_S
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect,
aGeometricToleranceWithDatumReference_DatumSystem);
}

7
src/RWStepDimTol/RWStepDimTol_RWPositionTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWPositionTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
@ -53,8 +52,8 @@ void RWStepDimTol_RWPositionTolerance::ReadStep (const Handle(StepData_StepReade
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -62,7 +61,7 @@ void RWStepDimTol_RWPositionTolerance::ReadStep (const Handle(StepData_StepReade
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect);
}

7
src/RWStepDimTol/RWStepDimTol_RWRoundnessTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWRoundnessTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
@ -53,8 +52,8 @@ void RWStepDimTol_RWRoundnessTolerance::ReadStep (const Handle(StepData_StepRead
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -62,7 +61,7 @@ void RWStepDimTol_RWRoundnessTolerance::ReadStep (const Handle(StepData_StepRead
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect);
}

7
src/RWStepDimTol/RWStepDimTol_RWStraightnessTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWStraightnessTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
@ -53,8 +52,8 @@ void RWStepDimTol_RWStraightnessTolerance::ReadStep (const Handle(StepData_StepR
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -62,7 +61,7 @@ void RWStepDimTol_RWStraightnessTolerance::ReadStep (const Handle(StepData_StepR
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect);
}

7
src/RWStepDimTol/RWStepDimTol_RWSurfaceProfileTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWSurfaceProfileTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_GeometricToleranceTarget.hxx>
@ -53,8 +52,8 @@ void RWStepDimTol_RWSurfaceProfileTolerance::ReadStep (const Handle(StepData_Ste
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -62,7 +61,7 @@ void RWStepDimTol_RWSurfaceProfileTolerance::ReadStep (const Handle(StepData_Ste
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect);
}

7
src/RWStepDimTol/RWStepDimTol_RWSymmetryTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWSymmetryTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
@ -55,8 +54,8 @@ void RWStepDimTol_RWSymmetryTolerance::ReadStep (const Handle(StepData_StepReade
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -79,7 +78,7 @@ void RWStepDimTol_RWSymmetryTolerance::ReadStep (const Handle(StepData_StepReade
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect,
aGeometricToleranceWithDatumReference_DatumSystem);
}

7
src/RWStepDimTol/RWStepDimTol_RWTotalRunoutTolerance.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepDimTol_RWTotalRunoutTolerance.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepDimTol_DatumReference.hxx>
@ -55,8 +54,8 @@ void RWStepDimTol_RWTotalRunoutTolerance::ReadStep (const Handle(StepData_StepRe
Handle(TCollection_HAsciiString) aGeometricTolerance_Description;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aGeometricTolerance_Description);
Handle(StepBasic_MeasureWithUnit) aGeometricTolerance_Magnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aGeometricTolerance_Magnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aGeometricTolerance_TolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aGeometricTolerance_TolerancedShapeAspect);
@ -79,7 +78,7 @@ void RWStepDimTol_RWTotalRunoutTolerance::ReadStep (const Handle(StepData_StepRe
// Initialize entity
ent->Init(aGeometricTolerance_Name,
aGeometricTolerance_Description,
aGeometricTolerance_Magnitude,
aMagnitude,
aGeometricTolerance_TolerancedShapeAspect,
aGeometricToleranceWithDatumReference_DatumSystem);
}

4
src/RWStepDimTol/RWStepDimTol_RWUnequallyDisposedGeometricTolerance.cxx
View File

@ -54,8 +54,8 @@ void RWStepDimTol_RWUnequallyDisposedGeometricTolerance::
Handle(TCollection_HAsciiString) aDescription;
data->ReadString (num, 2, "geometric_tolerance.description", ach, aDescription);
Handle(StepBasic_MeasureWithUnit) aMagnitude;
data->ReadEntity (num, 3, "geometric_tolerance.magnitude", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aMagnitude);
Handle(Standard_Transient) aMagnitude;
data->ReadEntity (num, 3, "magnitude", ach, STANDARD_TYPE(Standard_Transient), aMagnitude);
StepDimTol_GeometricToleranceTarget aTolerancedShapeAspect;
data->ReadEntity (num, 4, "geometric_tolerance.toleranced_shape_aspect", ach, aTolerancedShapeAspect);

5
src/RWStepRepr/RWStepRepr_RWMakeFromUsageOption.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepRepr_RWMakeFromUsageOption.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
@ -76,8 +75,8 @@ void RWStepRepr_RWMakeFromUsageOption::ReadStep (const Handle(StepData_StepReade
Handle(TCollection_HAsciiString) aRankingRationale;
data->ReadString (num, 7, "ranking_rationale", ach, aRankingRationale);
Handle(StepBasic_MeasureWithUnit) aQuantity;
data->ReadEntity (num, 8, "quantity", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aQuantity);
Handle(Standard_Transient) aQuantity;
data->ReadEntity (num, 8, "quantity", ach, STANDARD_TYPE(Standard_Transient), aQuantity);
// Initialize entity
ent->Init(aProductDefinitionRelationship_Id,

5
src/RWStepRepr/RWStepRepr_RWParallelOffset.cxx
View File

@ -16,7 +16,6 @@
#include <RWStepRepr_RWParallelOffset.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepRepr_ParallelOffset.hxx>
@ -62,8 +61,8 @@ void RWStepRepr_RWParallelOffset::ReadStep (const Handle(StepData_StepReaderData
// Own fields of ParallelOffset
Handle(StepBasic_MeasureWithUnit) anOffset;
data->ReadEntity (num, 5, "offset", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), anOffset);
Handle(Standard_Transient) anOffset;
data->ReadEntity(num, 5, "offset", ach, STANDARD_TYPE(Standard_Transient), anOffset);
// Initialize entity
ent->Init(aShapeAspect_Name,

5
src/RWStepRepr/RWStepRepr_RWQuantifiedAssemblyComponentUsage.cxx
View File

@ -18,7 +18,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepRepr_RWQuantifiedAssemblyComponentUsage.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_ProductDefinition.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
@ -81,8 +80,8 @@ void RWStepRepr_RWQuantifiedAssemblyComponentUsage::ReadStep (const Handle(StepD
// Own fields of QuantifiedAssemblyComponentUsage
Handle(StepBasic_MeasureWithUnit) aQuantity;
data->ReadEntity (num, 7, "quantity", ach, STANDARD_TYPE(StepBasic_MeasureWithUnit), aQuantity);
Handle(Standard_Transient) aQuantity;
data->ReadEntity (num, 7, "quantity", ach, STANDARD_TYPE(Standard_Transient), aQuantity);
// Initialize entity
ent->Init(aProductDefinitionRelationship_Id,

67
src/RWStepShape/RWStepShape_RWMeasureQualification.cxx
View File

@ -15,7 +15,6 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepShape_RWMeasureQualification.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepShape_HArray1OfValueQualifier.hxx>
@ -25,57 +24,53 @@
RWStepShape_RWMeasureQualification::RWStepShape_RWMeasureQualification () {}
void RWStepShape_RWMeasureQualification::ReadStep
(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num,
Handle(Interface_Check)& ach,
const Handle(StepShape_MeasureQualification)& ent) const
void RWStepShape_RWMeasureQualification::ReadStep(const Handle(StepData_StepReaderData)& data,
const Standard_Integer num,
Handle(Interface_Check)& ach,
const Handle(StepShape_MeasureQualification)& ent) const
{
// --- Number of Parameter Control ---
// --- Number of Parameter Control ---
if (!data->CheckNbParams(num,4,ach,"measure_qualification")) return;
if (!data->CheckNbParams(num,4,ach,"measure_qualification")) return;
// --- own field : name ---
// --- own field : name ---
Handle(TCollection_HAsciiString) aName;
data->ReadString (num,1,"name",ach,aName);
Handle(TCollection_HAsciiString) aName;
data->ReadString (num,1,"name",ach,aName);
// --- own field : description ---
// --- own field : description ---
Handle(TCollection_HAsciiString) aDescr;
data->ReadString (num,2,"description",ach,aDescr);
Handle(TCollection_HAsciiString) aDescr;
data->ReadString (num,2,"description",ach,aDescr);
// --- own field : qualified_measure ---
// --- own field : qualified_measure ---
Handle(Standard_Transient) aQualifiedMeasure;
data->ReadEntity (num, 3, "qualified_measure", ach, STANDARD_TYPE(Standard_Transient), aQualifiedMeasure);
Handle(StepBasic_MeasureWithUnit) aQM;
data->ReadEntity (num,3,"qualified_measure",ach,
STANDARD_TYPE(StepBasic_MeasureWithUnit),aQM);
// --- own field : qualifiers ---
// --- own field : qualifiers ---
Handle(StepShape_HArray1OfValueQualifier) quals;
Standard_Integer nsub4;
if (data->ReadSubList (num,4,"qualifiers",ach,nsub4)) {
Standard_Integer nb4 = data->NbParams(nsub4);
quals = new StepShape_HArray1OfValueQualifier (1,nb4);
for (Standard_Integer i4 = 1; i4 <= nb4; i4 ++) {
StepShape_ValueQualifier VQ;
if (data->ReadEntity (nsub4,i4,"qualifier",ach,VQ))
quals->SetValue (i4,VQ);
}
}
Handle(StepShape_HArray1OfValueQualifier) quals;
Standard_Integer nsub4;
if (data->ReadSubList (num,4,"qualifiers",ach,nsub4)) {
Standard_Integer nb4 = data->NbParams(nsub4);
quals = new StepShape_HArray1OfValueQualifier (1,nb4);
for (Standard_Integer i4 = 1; i4 <= nb4; i4 ++) {
StepShape_ValueQualifier VQ;
if (data->ReadEntity (nsub4,i4,"qualifier",ach,VQ))
quals->SetValue (i4,VQ);
}
}
//--- Initialisation of the read entity ---
//--- Initialisation of the read entity ---
ent->Init(aName, aDescr, aQM, quals);
ent->Init(aName, aDescr, aQualifiedMeasure, quals);
}
void RWStepShape_RWMeasureQualification::WriteStep
(StepData_StepWriter& SW,
const Handle(StepShape_MeasureQualification)& ent) const
void RWStepShape_RWMeasureQualification::WriteStep(StepData_StepWriter& SW,
const Handle(StepShape_MeasureQualification)& ent) const
{
SW.Send(ent->Name());
SW.Send(ent->Description());

53
src/RWStepShape/RWStepShape_RWToleranceValue.cxx
View File

@ -15,12 +15,9 @@
#include <Interface_Check.hxx>
#include <Interface_EntityIterator.hxx>
#include <RWStepShape_RWToleranceValue.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <StepShape_ToleranceValue.hxx>
#include <StepRepr_MeasureRepresentationItem.hxx>
#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
RWStepShape_RWToleranceValue::RWStepShape_RWToleranceValue () {}
@ -30,52 +27,26 @@ void RWStepShape_RWToleranceValue::ReadStep
Handle(Interface_Check)& ach,
const Handle(StepShape_ToleranceValue)& ent) const
{
// --- Number of Parameter Control ---
// --- Number of Parameter Control ---
if (!data->CheckNbParams(num,2,ach,"tolerance_value")) return;
if (!data->CheckNbParams(num,2,ach,"tolerance_value")) return;
// --- own field : lower_bound ---
// --- own field : lower_bound ---
Handle(Standard_Transient) LB;
if(!data->ReadEntity (num,1,"lower_bound",ach,
STANDARD_TYPE(StepBasic_MeasureWithUnit),LB))
{
Handle(StepRepr_MeasureRepresentationItem) aMSR;
Handle(StepRepr_ReprItemAndMeasureWithUnit) aRIMU;
if(data->ReadEntity (num,1,"lower_bound",ach,
STANDARD_TYPE(StepRepr_MeasureRepresentationItem),aMSR) ||
data->ReadEntity (num,1,"lower_bound",ach,STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit), aRIMU))
{
if(!aMSR.IsNull())
LB = aMSR;
else if(!aRIMU.IsNull())
LB = aRIMU;
}
}
Handle(Standard_Transient) aLowerBound;
data->ReadEntity (num, 1, "lower_bound", ach, STANDARD_TYPE(Standard_Transient), aLowerBound);
// --- own field : upper_bound ---
Handle(Standard_Transient) UB;
if(!data->ReadEntity (num,2,"upper_bound",ach,
STANDARD_TYPE(StepBasic_MeasureWithUnit),UB))
{
Handle(StepRepr_MeasureRepresentationItem) aMSR1;
Handle(StepRepr_ReprItemAndMeasureWithUnit) aRIMU1;
if(data->ReadEntity (num,2,"upper_bound",ach,STANDARD_TYPE(StepRepr_MeasureRepresentationItem),aMSR1) ||
data->ReadEntity (num,2,"upper_bound",ach,STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit), aRIMU1))
{
if(!aMSR1.IsNull())
UB = aMSR1;
else if(!aRIMU1.IsNull())
UB = aRIMU1;
}
}
Handle(Standard_Transient) anUpperBound;
data->ReadEntity (num, 2, "upper_bound", ach, STANDARD_TYPE(Standard_Transient), anUpperBound);
//--- Initialisation of the read entity ---
if( !LB.IsNull() && !UB.IsNull())
//--- Initialisation of the read entity ---
if (!aLowerBound.IsNull() && !anUpperBound.IsNull())
{
ach->ClearFails();
ent->Init(LB,UB);
}
ent->Init(aLowerBound, anUpperBound);
}

32
src/RWStepVisual/FILES
View File

@ -160,5 +160,33 @@ RWStepVisual_RWCoordinatesList.hxx
RWStepVisual_RWCoordinatesList.cxx
RWStepVisual_RWTessellatedCurveSet.hxx
RWStepVisual_RWTessellatedCurveSet.cxx
RWStepVisual_RWComplexTriangulatedFace.cxx
RWStepVisual_RWComplexTriangulatedFace.hxx
RWStepVisual_RWComplexTriangulatedSurfaceSet.cxx
RWStepVisual_RWComplexTriangulatedSurfaceSet.hxx
RWStepVisual_RWCubicBezierTessellatedEdge.cxx
RWStepVisual_RWCubicBezierTessellatedEdge.hxx
RWStepVisual_RWCubicBezierTriangulatedFace.cxx
RWStepVisual_RWCubicBezierTriangulatedFace.hxx
RWStepVisual_RWTessellatedConnectingEdge.cxx
RWStepVisual_RWTessellatedConnectingEdge.hxx
RWStepVisual_RWTessellatedEdge.cxx
RWStepVisual_RWTessellatedEdge.hxx
RWStepVisual_RWTessellatedPointSet.cxx
RWStepVisual_RWTessellatedPointSet.hxx
RWStepVisual_RWTessellatedShapeRepresentation.cxx
RWStepVisual_RWTessellatedShapeRepresentation.hxx
RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters.cxx
RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters.hxx
RWStepVisual_RWTessellatedShell.cxx
RWStepVisual_RWTessellatedShell.hxx
RWStepVisual_RWTessellatedSolid.cxx
RWStepVisual_RWTessellatedSolid.hxx
RWStepVisual_RWTessellatedStructuredItem.cxx
RWStepVisual_RWTessellatedStructuredItem.hxx
RWStepVisual_RWTessellatedVertex.cxx
RWStepVisual_RWTessellatedVertex.hxx
RWStepVisual_RWTessellatedWire.cxx
RWStepVisual_RWTessellatedWire.hxx
RWStepVisual_RWTriangulatedFace.cxx
RWStepVisual_RWTriangulatedFace.hxx

271
src/RWStepVisual/RWStepVisual_RWComplexTriangulatedFace.cxx Normal file
View File

@ -0,0 +1,271 @@
// Created on : Thu Mar 24 18:30:11 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWComplexTriangulatedFace.hxx>
#include <StepVisual_ComplexTriangulatedFace.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Standard_Real.hxx>
#include <StepVisual_FaceOrSurface.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray2OfInteger.hxx>
//=======================================================================
//function : RWStepVisual_RWComplexTriangulatedFace
//purpose :
//=======================================================================
RWStepVisual_RWComplexTriangulatedFace::RWStepVisual_RWComplexTriangulatedFace() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWComplexTriangulatedFace::ReadStep (const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_ComplexTriangulatedFace)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 8, theCheck, "complex_triangulated_face"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Inherited fields of TessellatedFace
Handle(StepVisual_CoordinatesList) aTessellatedFace_Coordinates;
theData->ReadEntity(theNum, 2, "tessellated_face.coordinates", theCheck,
STANDARD_TYPE(StepVisual_CoordinatesList), aTessellatedFace_Coordinates);
Standard_Integer aTessellatedFace_Pnmax;
theData->ReadInteger(theNum, 3, "tessellated_face.pnmax", theCheck, aTessellatedFace_Pnmax);
Handle(TColStd_HArray2OfReal) aTessellatedFace_Normals;
Standard_Integer sub4 = 0;
if (theData->ReadSubList(theNum, 4, "tessellated_face.normals", theCheck, sub4))
{
Standard_Integer nb0 = theData->NbParams(sub4);
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub4,1));
aTessellatedFace_Normals = new TColStd_HArray2OfReal(1, nb0, 1, nbj0);
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer subj4 = 0;
if ( theData->ReadSubList (sub4, i0, "sub-part(tessellated_face.normals)", theCheck, subj4) ) {
Standard_Integer num4 = subj4;
for (Standard_Integer j0 = 1; j0 <= nbj0; j0++)
{
Standard_Real anIt0;
theData->ReadReal(num4, j0, "real", theCheck, anIt0);
aTessellatedFace_Normals->SetValue(i0,j0, anIt0);
}
}
}
}
StepVisual_FaceOrSurface aTessellatedFace_GeometricLink;
Standard_Boolean hasTessellatedFace_GeometricLink = Standard_True;
if (theData->IsParamDefined(theNum, 5))
{
theData->ReadEntity(theNum, 5, "tessellated_face.geometric_link", theCheck, aTessellatedFace_GeometricLink);
}
else
{
hasTessellatedFace_GeometricLink = Standard_False;
aTessellatedFace_GeometricLink = StepVisual_FaceOrSurface();
}
// Own fields of ComplexTriangulatedFace
Handle(TColStd_HArray1OfInteger) aPnindex;
Standard_Integer sub6 = 0;
if (theData->ReadSubList(theNum, 6, "pnindex", theCheck, sub6))
{
Standard_Integer nb0 = theData->NbParams(sub6);
aPnindex = new TColStd_HArray1OfInteger(1, nb0);
Standard_Integer num2 = sub6;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num2, i0, "integer", theCheck, anIt0);
aPnindex->SetValue(i0, anIt0);
}
}
Handle(TColStd_HArray2OfInteger) aTriangleStrips;
Standard_Integer sub7 = 0;
if (theData->ReadSubList(theNum, 7, "triangle_strips", theCheck, sub7))
{
Standard_Integer nb0 = theData->NbParams(sub7);
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub7,1));
aTriangleStrips = new TColStd_HArray2OfInteger(1, nb0, 1, nbj0);
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer subj7 = 0;
if ( theData->ReadSubList (sub7, i0, "sub-part(triangle_strips)", theCheck, subj7) ) {
Standard_Integer num4 = subj7;
for (Standard_Integer j0 = 1; j0 <= nbj0; j0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num4, j0, "integer", theCheck, anIt0);
aTriangleStrips->SetValue(i0,j0, anIt0);
}
}
}
}
Handle(TColStd_HArray2OfInteger) aTriangleFans;
Standard_Integer sub8 = 0;
if (theData->ReadSubList(theNum, 8, "triangle_fans", theCheck, sub8))
{
Standard_Integer nb0 = theData->NbParams(sub8);
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub8,1));
aTriangleFans = new TColStd_HArray2OfInteger(1, nb0, 1, nbj0);
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer subj8 = 0;
if ( theData->ReadSubList (sub8, i0, "sub-part(triangle_fans)", theCheck, subj8) ) {
Standard_Integer num4 = subj8;
for (Standard_Integer j0 = 1; j0 <= nbj0; j0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num4, j0, "integer", theCheck, anIt0);
aTriangleFans->SetValue(i0,j0, anIt0);
}
}
}
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aTessellatedFace_Coordinates, aTessellatedFace_Pnmax, aTessellatedFace_Normals, hasTessellatedFace_GeometricLink, aTessellatedFace_GeometricLink, aPnindex, aTriangleStrips, aTriangleFans);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWComplexTriangulatedFace::WriteStep (StepData_StepWriter& theSW,
const Handle(StepVisual_ComplexTriangulatedFace)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedFace
theSW.Send(theEnt->Coordinates());
theSW.Send(theEnt->Pnmax());
theSW.OpenSub();
for (Standard_Integer i3 = 1; i3 <= theEnt->Normals()->RowLength(); i3++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
for (Standard_Integer j3 = 1; j3 <= theEnt->Normals()->ColLength(); j3++)
{
Standard_Real Var0 = theEnt->Normals()->Value(i3,j3);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
if (theEnt->HasGeometricLink())
{
theSW.Send(theEnt->GeometricLink().Value());
}
else
{
theSW.SendUndef();
}
// Own fields of ComplexTriangulatedFace
theSW.OpenSub();
for (Standard_Integer i5 = 1; i5 <= theEnt->Pnindex()->Length(); i5++)
{
Standard_Integer Var0 = theEnt->Pnindex()->Value(i5);
theSW.Send(Var0);
}
theSW.CloseSub();
theSW.OpenSub();
for (Standard_Integer i6 = 1; i6 <= theEnt->TriangleStrips()->RowLength(); i6++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
for (Standard_Integer j6 = 1; j6 <= theEnt->TriangleStrips()->ColLength(); j6++)
{
Standard_Integer Var0 = theEnt->TriangleStrips()->Value(i6,j6);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
theSW.OpenSub();
for (Standard_Integer i7 = 1; i7 <= theEnt->TriangleFans()->RowLength(); i7++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
for (Standard_Integer j7 = 1; j7 <= theEnt->TriangleFans()->ColLength(); j7++)
{
Standard_Integer Var0 = theEnt->TriangleFans()->Value(i7,j7);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWComplexTriangulatedFace::Share (const Handle(StepVisual_ComplexTriangulatedFace)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Inherited fields of TessellatedFace
theIter.AddItem(theEnt->StepVisual_TessellatedFace::Coordinates());
if (theEnt->StepVisual_TessellatedFace::HasGeometricLink())
{
theIter.AddItem(theEnt->StepVisual_TessellatedFace::GeometricLink().Value());
}
// Own fields of ComplexTriangulatedFace
}

53
src/RWStepVisual/RWStepVisual_RWComplexTriangulatedFace.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:11 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWComplexTriangulatedFace_HeaderFile_
#define _RWStepVisual_RWComplexTriangulatedFace_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_ComplexTriangulatedFace;
//! Read & Write tool for ComplexTriangulatedFace
class RWStepVisual_RWComplexTriangulatedFace
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWComplexTriangulatedFace();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_ComplexTriangulatedFace)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_ComplexTriangulatedFace)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_ComplexTriangulatedFace)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWComplexTriangulatedFace_HeaderFile_

254
src/RWStepVisual/RWStepVisual_RWComplexTriangulatedSurfaceSet.cxx Normal file
View File

@ -0,0 +1,254 @@
// Created on : Thu Mar 24 18:30:11 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWComplexTriangulatedSurfaceSet.hxx>
#include <StepVisual_ComplexTriangulatedSurfaceSet.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Standard_Real.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray2OfInteger.hxx>
#include <TColStd_HArray1OfTransient.hxx>
//=======================================================================
//function : RWStepVisual_RWComplexTriangulatedSurfaceSet
//purpose :
//=======================================================================
RWStepVisual_RWComplexTriangulatedSurfaceSet::RWStepVisual_RWComplexTriangulatedSurfaceSet() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWComplexTriangulatedSurfaceSet::ReadStep(
const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_ComplexTriangulatedSurfaceSet)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 7, theCheck, "complex_triangulated_surface_set"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Inherited fields of TessellatedSurfaceSet
Handle(StepVisual_CoordinatesList) aTessellatedSurfaceSet_Coordinates;
theData->ReadEntity(theNum, 2, "tessellated_surface_set.coordinates", theCheck,
STANDARD_TYPE(StepVisual_CoordinatesList), aTessellatedSurfaceSet_Coordinates);
Standard_Integer aTessellatedSurfaceSet_Pnmax;
theData->ReadInteger(theNum, 3, "tessellated_surface_set.pnmax", theCheck, aTessellatedSurfaceSet_Pnmax);
Handle(TColStd_HArray2OfReal) aTessellatedSurfaceSet_Normals;
Standard_Integer sub4 = 0;
if (theData->ReadSubList(theNum, 4, "tessellated_surface_set.normals", theCheck, sub4))
{
Standard_Integer nb0 = theData->NbParams(sub4);
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub4,1));
aTessellatedSurfaceSet_Normals = new TColStd_HArray2OfReal(1, nb0, 1, nbj0);
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer subj4 = 0;
if ( theData->ReadSubList (sub4, i0, "sub-part(tessellated_surface_set.normals)", theCheck, subj4) ) {
Standard_Integer num4 = subj4;
for (Standard_Integer j0 = 1; j0 <= nbj0; j0++)
{
Standard_Real anIt0;
theData->ReadReal(num4, j0, "real", theCheck, anIt0);
aTessellatedSurfaceSet_Normals->SetValue(i0,j0, anIt0);
}
}
}
}
// Own fields of ComplexTriangulatedSurfaceSet
Handle(TColStd_HArray1OfInteger) aPnindex;
Standard_Integer sub5 = 0;
if (theData->ReadSubList(theNum, 5, "pnindex", theCheck, sub5))
{
Standard_Integer nb0 = theData->NbParams(sub5);
aPnindex = new TColStd_HArray1OfInteger(1, nb0);
Standard_Integer num2 = sub5;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num2, i0, "integer", theCheck, anIt0);
aPnindex->SetValue(i0, anIt0);
}
}
Handle(TColStd_HArray1OfTransient) aTriangleStrips;
Standard_Integer sub6 = 0;
if (theData->ReadSubList(theNum, 6, "triangle_strips", theCheck, sub6))
{
Standard_Integer nb0 = theData->NbParams(sub6);
aTriangleStrips = new TColStd_HArray1OfTransient(1, nb0);
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub6, i0));
Handle(TColStd_HArray1OfInteger) aSingleTriangleStrip = new TColStd_HArray1OfInteger(1, nbj0);
Standard_Integer subj6 = 0;
if ( theData->ReadSubList (sub6, i0, "sub-part(triangle_strips)", theCheck, subj6) ) {
Standard_Integer num4 = subj6;
for (Standard_Integer j0 = 1; j0 <= nbj0; j0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num4, j0, "integer", theCheck, anIt0);
aSingleTriangleStrip->SetValue(j0, anIt0);
}
aTriangleStrips->SetValue(i0, aSingleTriangleStrip);
}
}
}
Handle(TColStd_HArray1OfTransient) aTriangleFans;
Standard_Integer sub7 = 0;
if (theData->ReadSubList(theNum, 7, "triangle_fans", theCheck, sub7))
{
Standard_Integer nb0 = theData->NbParams(sub7);
aTriangleFans = new TColStd_HArray1OfTransient(1, nb0);
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub7, i0));
Handle(TColStd_HArray1OfInteger) aSingleTriangleFan = new TColStd_HArray1OfInteger(1, nbj0);
Standard_Integer subj7 = 0;
if ( theData->ReadSubList (sub7, i0, "sub-part(triangle_fans)", theCheck, subj7) ) {
Standard_Integer num4 = subj7;
for (Standard_Integer j0 = 1; j0 <= nbj0; j0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num4, j0, "integer", theCheck, anIt0);
aSingleTriangleFan->SetValue(j0, anIt0);
}
aTriangleFans->SetValue(i0, aSingleTriangleFan);
}
}
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aTessellatedSurfaceSet_Coordinates, aTessellatedSurfaceSet_Pnmax, aTessellatedSurfaceSet_Normals, aPnindex, aTriangleStrips, aTriangleFans);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWComplexTriangulatedSurfaceSet::WriteStep(
StepData_StepWriter& theSW,
const Handle(StepVisual_ComplexTriangulatedSurfaceSet)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedSurfaceSet
theSW.Send(theEnt->Coordinates());
theSW.Send(theEnt->Pnmax());
theSW.OpenSub();
for (Standard_Integer i3 = 1; i3 <= theEnt->Normals()->RowLength(); i3++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
for (Standard_Integer j3 = 1; j3 <= theEnt->Normals()->ColLength(); j3++)
{
Standard_Real Var0 = theEnt->Normals()->Value(i3,j3);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
// Own fields of ComplexTriangulatedSurfaceSet
theSW.OpenSub();
for (Standard_Integer i4 = 1; i4 <= theEnt->Pnindex()->Length(); i4++)
{
Standard_Integer Var0 = theEnt->Pnindex()->Value(i4);
theSW.Send(Var0);
}
theSW.CloseSub();
theSW.OpenSub();
for (Standard_Integer i5 = 1; i5 <= theEnt->NbTriangleStrips(); i5++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
Handle(TColStd_HArray1OfInteger) aTriangleStrip = Handle(TColStd_HArray1OfInteger)::DownCast(theEnt->TriangleStrips()->Value(i5));
for (Standard_Integer j5 = 1; j5 <= aTriangleStrip->Length(); j5++)
{
Standard_Integer Var0 = aTriangleStrip->Value(j5);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
theSW.OpenSub();
for (Standard_Integer i6 = 1; i6 <= theEnt->NbTriangleFans(); i6++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
Handle(TColStd_HArray1OfInteger) aTriangleFan = Handle(TColStd_HArray1OfInteger)::DownCast(theEnt->TriangleFans()->Value(i6));
for (Standard_Integer j6 = 1; j6 <= aTriangleFan->Length(); j6++)
{
Standard_Integer Var0 = aTriangleFan->Value(j6);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWComplexTriangulatedSurfaceSet::Share(
const Handle(StepVisual_ComplexTriangulatedSurfaceSet)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Inherited fields of TessellatedSurfaceSet
theIter.AddItem(theEnt->StepVisual_TessellatedSurfaceSet::Coordinates());
// Own fields of ComplexTriangulatedSurfaceSet
}

53
src/RWStepVisual/RWStepVisual_RWComplexTriangulatedSurfaceSet.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:11 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWComplexTriangulatedSurfaceSet_HeaderFile_
#define _RWStepVisual_RWComplexTriangulatedSurfaceSet_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_ComplexTriangulatedSurfaceSet;
//! Read & Write tool for ComplexTriangulatedSurfaceSet
class RWStepVisual_RWComplexTriangulatedSurfaceSet
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWComplexTriangulatedSurfaceSet();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_ComplexTriangulatedSurfaceSet)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_ComplexTriangulatedSurfaceSet)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_ComplexTriangulatedSurfaceSet)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWComplexTriangulatedSurfaceSet_HeaderFile_

151
src/RWStepVisual/RWStepVisual_RWCubicBezierTessellatedEdge.cxx Normal file
View File

@ -0,0 +1,151 @@
// Created on : Thu Mar 24 18:30:11 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWCubicBezierTessellatedEdge.hxx>
#include <StepVisual_CubicBezierTessellatedEdge.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <StepVisual_EdgeOrCurve.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <Standard_Integer.hxx>
//=======================================================================
//function : RWStepVisual_RWCubicBezierTessellatedEdge
//purpose :
//=======================================================================
RWStepVisual_RWCubicBezierTessellatedEdge::RWStepVisual_RWCubicBezierTessellatedEdge() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWCubicBezierTessellatedEdge::ReadStep(
const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_CubicBezierTessellatedEdge)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 4, theCheck, "cubic_bezier_tessellated_edge"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Inherited fields of TessellatedEdge
Handle(StepVisual_CoordinatesList) aTessellatedEdge_Coordinates;
theData->ReadEntity(theNum, 2, "tessellated_edge.coordinates", theCheck,
STANDARD_TYPE(StepVisual_CoordinatesList), aTessellatedEdge_Coordinates);
StepVisual_EdgeOrCurve aTessellatedEdge_GeometricLink;
Standard_Boolean hasTessellatedEdge_GeometricLink = Standard_True;
if (theData->IsParamDefined(theNum, 3))
{
theData->ReadEntity(theNum, 3, "tessellated_edge.geometric_link", theCheck, aTessellatedEdge_GeometricLink);
}
else
{
hasTessellatedEdge_GeometricLink = Standard_False;
aTessellatedEdge_GeometricLink = StepVisual_EdgeOrCurve();
}
Handle(TColStd_HArray1OfInteger) aTessellatedEdge_LineStrip;
Standard_Integer sub4 = 0;
if (theData->ReadSubList(theNum, 4, "tessellated_edge.line_strip", theCheck, sub4))
{
Standard_Integer nb0 = theData->NbParams(sub4);
aTessellatedEdge_LineStrip = new TColStd_HArray1OfInteger(1, nb0);
Standard_Integer num2 = sub4;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num2, i0, "integer", theCheck, anIt0);
aTessellatedEdge_LineStrip->SetValue(i0, anIt0);
}
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aTessellatedEdge_Coordinates, hasTessellatedEdge_GeometricLink, aTessellatedEdge_GeometricLink, aTessellatedEdge_LineStrip);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWCubicBezierTessellatedEdge::WriteStep(
StepData_StepWriter& theSW,
const Handle(StepVisual_CubicBezierTessellatedEdge)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedEdge
theSW.Send(theEnt->Coordinates());
if (theEnt->HasGeometricLink())
{
theSW.Send(theEnt->GeometricLink().Value());
}
else
{
theSW.SendUndef();
}
theSW.OpenSub();
for (Standard_Integer i3 = 1; i3 <= theEnt->LineStrip()->Length(); i3++)
{
Standard_Integer Var0 = theEnt->LineStrip()->Value(i3);
theSW.Send(Var0);
}
theSW.CloseSub();
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWCubicBezierTessellatedEdge::Share(
const Handle(StepVisual_CubicBezierTessellatedEdge)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Inherited fields of TessellatedEdge
theIter.AddItem(theEnt->StepVisual_TessellatedEdge::Coordinates());
if (theEnt->StepVisual_TessellatedEdge::HasGeometricLink())
{
theIter.AddItem(theEnt->StepVisual_TessellatedEdge::GeometricLink().Value());
}
}

53
src/RWStepVisual/RWStepVisual_RWCubicBezierTessellatedEdge.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:11 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWCubicBezierTessellatedEdge_HeaderFile_
#define _RWStepVisual_RWCubicBezierTessellatedEdge_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_CubicBezierTessellatedEdge;
//! Read & Write tool for CubicBezierTessellatedEdge
class RWStepVisual_RWCubicBezierTessellatedEdge
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWCubicBezierTessellatedEdge();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_CubicBezierTessellatedEdge)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_CubicBezierTessellatedEdge)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_CubicBezierTessellatedEdge)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWCubicBezierTessellatedEdge_HeaderFile_

215
src/RWStepVisual/RWStepVisual_RWCubicBezierTriangulatedFace.cxx Normal file
View File

@ -0,0 +1,215 @@
// Created on : Thu Mar 24 18:30:11 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWCubicBezierTriangulatedFace.hxx>
#include <StepVisual_CubicBezierTriangulatedFace.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Standard_Real.hxx>
#include <StepVisual_FaceOrSurface.hxx>
#include <TColStd_HArray2OfInteger.hxx>
#include <TColStd_HArray1OfInteger.hxx>
//=======================================================================
//function : RWStepVisual_RWCubicBezierTriangulatedFace
//purpose :
//=======================================================================
RWStepVisual_RWCubicBezierTriangulatedFace::RWStepVisual_RWCubicBezierTriangulatedFace() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWCubicBezierTriangulatedFace::ReadStep(
const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_CubicBezierTriangulatedFace)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 6, theCheck, "cubic_bezier_triangulated_face"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Inherited fields of TessellatedFace
Handle(StepVisual_CoordinatesList) aTessellatedFace_Coordinates;
theData->ReadEntity(theNum, 2, "tessellated_face.coordinates", theCheck,
STANDARD_TYPE(StepVisual_CoordinatesList), aTessellatedFace_Coordinates);
Standard_Integer aTessellatedFace_Pnmax;
theData->ReadInteger(theNum, 3, "tessellated_face.pnmax", theCheck, aTessellatedFace_Pnmax);
Handle(TColStd_HArray2OfReal) aTessellatedFace_Normals;
Standard_Integer sub4 = 0;
if (theData->ReadSubList(theNum, 4, "tessellated_face.normals", theCheck, sub4))
{
Standard_Integer nb0 = theData->NbParams(sub4);
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub4,1));
aTessellatedFace_Normals = new TColStd_HArray2OfReal(1, nb0, 1, nbj0);
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer subj4 = 0;
if ( theData->ReadSubList (sub4, i0, "sub-part(tessellated_face.normals)", theCheck, subj4) ) {
Standard_Integer num4 = subj4;
for (Standard_Integer j0 = 1; j0 <= nbj0; j0++)
{
Standard_Real anIt0;
theData->ReadReal(num4, j0, "real", theCheck, anIt0);
aTessellatedFace_Normals->SetValue(i0,j0, anIt0);
}
}
}
}
StepVisual_FaceOrSurface aTessellatedFace_GeometricLink;
Standard_Boolean hasTessellatedFace_GeometricLink = Standard_True;
if (theData->IsParamDefined(theNum, 5))
{
theData->ReadEntity(theNum, 5, "tessellated_face.geometric_link", theCheck, aTessellatedFace_GeometricLink);
}
else
{
hasTessellatedFace_GeometricLink = Standard_False;
aTessellatedFace_GeometricLink = StepVisual_FaceOrSurface();
}
// Own fields of CubicBezierTriangulatedFace
Handle(TColStd_HArray2OfInteger) aCtriangles;
Standard_Integer sub6 = 0;
if (theData->ReadSubList(theNum, 6, "ctriangles", theCheck, sub6))
{
Standard_Integer nb0 = theData->NbParams(sub6);
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub6,1));
aCtriangles = new TColStd_HArray2OfInteger(1, nb0, 1, nbj0);
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer subj6 = 0;
if ( theData->ReadSubList (sub6, i0, "sub-part(ctriangles)", theCheck, subj6) ) {
Standard_Integer num4 = subj6;
for (Standard_Integer j0 = 1; j0 <= nbj0; j0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num4, j0, "integer", theCheck, anIt0);
aCtriangles->SetValue(i0,j0, anIt0);
}
}
}
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aTessellatedFace_Coordinates, aTessellatedFace_Pnmax, aTessellatedFace_Normals, hasTessellatedFace_GeometricLink, aTessellatedFace_GeometricLink, aCtriangles);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWCubicBezierTriangulatedFace::WriteStep(
StepData_StepWriter& theSW,
const Handle(StepVisual_CubicBezierTriangulatedFace)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedFace
theSW.Send(theEnt->Coordinates());
theSW.Send(theEnt->Pnmax());
theSW.OpenSub();
for (Standard_Integer i3 = 1; i3 <= theEnt->Normals()->RowLength(); i3++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
for (Standard_Integer j3 = 1; j3 <= theEnt->Normals()->ColLength(); j3++)
{
Standard_Real Var0 = theEnt->Normals()->Value(i3,j3);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
if (theEnt->HasGeometricLink())
{
theSW.Send(theEnt->GeometricLink().Value());
}
else
{
theSW.SendUndef();
}
// Own fields of CubicBezierTriangulatedFace
theSW.OpenSub();
for (Standard_Integer i5 = 1; i5 <= theEnt->Ctriangles()->RowLength(); i5++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
for (Standard_Integer j5 = 1; j5 <= theEnt->Ctriangles()->ColLength(); j5++)
{
Standard_Integer Var0 = theEnt->Ctriangles()->Value(i5,j5);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWCubicBezierTriangulatedFace::Share(
const Handle(StepVisual_CubicBezierTriangulatedFace)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Inherited fields of TessellatedFace
theIter.AddItem(theEnt->StepVisual_TessellatedFace::Coordinates());
if (theEnt->StepVisual_TessellatedFace::HasGeometricLink())
{
theIter.AddItem(theEnt->StepVisual_TessellatedFace::GeometricLink().Value());
}
// Own fields of CubicBezierTriangulatedFace
}

53
src/RWStepVisual/RWStepVisual_RWCubicBezierTriangulatedFace.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:11 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWCubicBezierTriangulatedFace_HeaderFile_
#define _RWStepVisual_RWCubicBezierTriangulatedFace_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_CubicBezierTriangulatedFace;
//! Read & Write tool for CubicBezierTriangulatedFace
class RWStepVisual_RWCubicBezierTriangulatedFace
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWCubicBezierTriangulatedFace();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_CubicBezierTriangulatedFace)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_CubicBezierTriangulatedFace)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_CubicBezierTriangulatedFace)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWCubicBezierTriangulatedFace_HeaderFile_

226
src/RWStepVisual/RWStepVisual_RWTessellatedConnectingEdge.cxx Normal file
View File

@ -0,0 +1,226 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTessellatedConnectingEdge.hxx>
#include <StepVisual_TessellatedConnectingEdge.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <StepVisual_EdgeOrCurve.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <Standard_Integer.hxx>
#include <StepData_Logical.hxx>
#include <StepVisual_TessellatedFace.hxx>
//=======================================================================
//function : RWStepVisual_RWTessellatedConnectingEdge
//purpose :
//=======================================================================
RWStepVisual_RWTessellatedConnectingEdge::RWStepVisual_RWTessellatedConnectingEdge() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedConnectingEdge::ReadStep(
const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedConnectingEdge)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 9, theCheck, "tessellated_connecting_edge"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Inherited fields of TessellatedEdge
Handle(StepVisual_CoordinatesList) aTessellatedEdge_Coordinates;
theData->ReadEntity(theNum, 2, "tessellated_edge.coordinates", theCheck,
STANDARD_TYPE(StepVisual_CoordinatesList), aTessellatedEdge_Coordinates);
StepVisual_EdgeOrCurve aTessellatedEdge_GeometricLink;
Standard_Boolean hasTessellatedEdge_GeometricLink = Standard_True;
if (theData->IsParamDefined(theNum, 3))
{
theData->ReadEntity(theNum, 3, "tessellated_edge.geometric_link", theCheck, aTessellatedEdge_GeometricLink);
}
else
{
hasTessellatedEdge_GeometricLink = Standard_False;
aTessellatedEdge_GeometricLink = StepVisual_EdgeOrCurve();
}
Handle(TColStd_HArray1OfInteger) aTessellatedEdge_LineStrip;
Standard_Integer sub4 = 0;
if (theData->ReadSubList(theNum, 4, "tessellated_edge.line_strip", theCheck, sub4))
{
Standard_Integer nb0 = theData->NbParams(sub4);
aTessellatedEdge_LineStrip = new TColStd_HArray1OfInteger(1, nb0);
Standard_Integer num2 = sub4;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num2, i0, "integer", theCheck, anIt0);
aTessellatedEdge_LineStrip->SetValue(i0, anIt0);
}
}
// Own fields of TessellatedConnectingEdge
StepData_Logical aSmooth;
theData->ReadLogical(theNum, 5, "smooth", theCheck, aSmooth);
Handle(StepVisual_TessellatedFace) aFace1;
theData->ReadEntity(theNum, 6, "face1", theCheck,
STANDARD_TYPE(StepVisual_TessellatedFace), aFace1);
Handle(StepVisual_TessellatedFace) aFace2;
theData->ReadEntity(theNum, 7, "face2", theCheck,
STANDARD_TYPE(StepVisual_TessellatedFace), aFace2);
Handle(TColStd_HArray1OfInteger) aLineStripFace1;
Standard_Integer sub8 = 0;
if (theData->ReadSubList(theNum, 8, "line_strip_face1", theCheck, sub8))
{
Standard_Integer nb0 = theData->NbParams(sub8);
aLineStripFace1 = new TColStd_HArray1OfInteger(1, nb0);
Standard_Integer num2 = sub8;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num2, i0, "integer", theCheck, anIt0);
aLineStripFace1->SetValue(i0, anIt0);
}
}
Handle(TColStd_HArray1OfInteger) aLineStripFace2;
Standard_Integer sub9 = 0;
if (theData->ReadSubList(theNum, 9, "line_strip_face2", theCheck, sub9))
{
Standard_Integer nb0 = theData->NbParams(sub9);
aLineStripFace2 = new TColStd_HArray1OfInteger(1, nb0);
Standard_Integer num2 = sub9;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num2, i0, "integer", theCheck, anIt0);
aLineStripFace2->SetValue(i0, anIt0);
}
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aTessellatedEdge_Coordinates, hasTessellatedEdge_GeometricLink, aTessellatedEdge_GeometricLink, aTessellatedEdge_LineStrip, aSmooth, aFace1, aFace2, aLineStripFace1, aLineStripFace2);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedConnectingEdge::WriteStep(
StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedConnectingEdge)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedEdge
theSW.Send(theEnt->Coordinates());
if (theEnt->HasGeometricLink())
{
theSW.Send(theEnt->GeometricLink().Value());
}
else
{
theSW.SendUndef();
}
theSW.OpenSub();
for (Standard_Integer i3 = 1; i3 <= theEnt->LineStrip()->Length(); i3++)
{
Standard_Integer Var0 = theEnt->LineStrip()->Value(i3);
theSW.Send(Var0);
}
theSW.CloseSub();
// Own fields of TessellatedConnectingEdge
theSW.SendLogical(theEnt->Smooth());
theSW.Send(theEnt->Face1());
theSW.Send(theEnt->Face2());
theSW.OpenSub();
for (Standard_Integer i7 = 1; i7 <= theEnt->LineStripFace1()->Length(); i7++)
{
Standard_Integer Var0 = theEnt->LineStripFace1()->Value(i7);
theSW.Send(Var0);
}
theSW.CloseSub();
theSW.OpenSub();
for (Standard_Integer i8 = 1; i8 <= theEnt->LineStripFace2()->Length(); i8++)
{
Standard_Integer Var0 = theEnt->LineStripFace2()->Value(i8);
theSW.Send(Var0);
}
theSW.CloseSub();
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedConnectingEdge::Share(
const Handle(StepVisual_TessellatedConnectingEdge)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Inherited fields of TessellatedEdge
theIter.AddItem(theEnt->StepVisual_TessellatedEdge::Coordinates());
if (theEnt->StepVisual_TessellatedEdge::HasGeometricLink())
{
theIter.AddItem(theEnt->StepVisual_TessellatedEdge::GeometricLink().Value());
}
// Own fields of TessellatedConnectingEdge
theIter.AddItem(theEnt->Face1());
theIter.AddItem(theEnt->Face2());
}

53
src/RWStepVisual/RWStepVisual_RWTessellatedConnectingEdge.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTessellatedConnectingEdge_HeaderFile_
#define _RWStepVisual_RWTessellatedConnectingEdge_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TessellatedConnectingEdge;
//! Read & Write tool for TessellatedConnectingEdge
class RWStepVisual_RWTessellatedConnectingEdge
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTessellatedConnectingEdge();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedConnectingEdge)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedConnectingEdge)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TessellatedConnectingEdge)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTessellatedConnectingEdge_HeaderFile_

148
src/RWStepVisual/RWStepVisual_RWTessellatedEdge.cxx Normal file
View File

@ -0,0 +1,148 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTessellatedEdge.hxx>
#include <StepVisual_TessellatedEdge.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <StepVisual_EdgeOrCurve.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <Standard_Integer.hxx>
//=======================================================================
//function : RWStepVisual_RWTessellatedEdge
//purpose :
//=======================================================================
RWStepVisual_RWTessellatedEdge::RWStepVisual_RWTessellatedEdge() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedEdge::ReadStep (const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedEdge)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 4, theCheck, "tessellated_edge"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Own fields of TessellatedEdge
Handle(StepVisual_CoordinatesList) aCoordinates;
theData->ReadEntity(theNum, 2, "coordinates", theCheck,
STANDARD_TYPE(StepVisual_CoordinatesList), aCoordinates);
StepVisual_EdgeOrCurve aGeometricLink;
Standard_Boolean hasGeometricLink = Standard_True;
if (theData->IsParamDefined(theNum, 3))
{
theData->ReadEntity(theNum, 3, "geometric_link", theCheck, aGeometricLink);
}
else
{
hasGeometricLink = Standard_False;
aGeometricLink = StepVisual_EdgeOrCurve();
}
Handle(TColStd_HArray1OfInteger) aLineStrip;
Standard_Integer sub4 = 0;
if (theData->ReadSubList(theNum, 4, "line_strip", theCheck, sub4))
{
Standard_Integer nb0 = theData->NbParams(sub4);
aLineStrip = new TColStd_HArray1OfInteger(1, nb0);
Standard_Integer num2 = sub4;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num2, i0, "integer", theCheck, anIt0);
aLineStrip->SetValue(i0, anIt0);
}
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aCoordinates, hasGeometricLink, aGeometricLink, aLineStrip);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedEdge::WriteStep (StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedEdge)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedEdge
theSW.Send(theEnt->Coordinates());
if (theEnt->HasGeometricLink())
{
theSW.Send(theEnt->GeometricLink().Value());
}
else
{
theSW.SendUndef();
}
theSW.OpenSub();
for (Standard_Integer i3 = 1; i3 <= theEnt->LineStrip()->Length(); i3++)
{
Standard_Integer Var0 = theEnt->LineStrip()->Value(i3);
theSW.Send(Var0);
}
theSW.CloseSub();
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedEdge::Share (const Handle(StepVisual_TessellatedEdge)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Own fields of TessellatedEdge
theIter.AddItem(theEnt->Coordinates());
if (theEnt->HasGeometricLink())
{
theIter.AddItem(theEnt->GeometricLink().Value());
}
}

53
src/RWStepVisual/RWStepVisual_RWTessellatedEdge.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTessellatedEdge_HeaderFile_
#define _RWStepVisual_RWTessellatedEdge_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TessellatedEdge;
//! Read & Write tool for TessellatedEdge
class RWStepVisual_RWTessellatedEdge
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTessellatedEdge();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedEdge)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedEdge)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TessellatedEdge)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTessellatedEdge_HeaderFile_

121
src/RWStepVisual/RWStepVisual_RWTessellatedPointSet.cxx Normal file
View File

@ -0,0 +1,121 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTessellatedPointSet.hxx>
#include <StepVisual_TessellatedPointSet.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <Standard_Integer.hxx>
//=======================================================================
//function : RWStepVisual_RWTessellatedPointSet
//purpose :
//=======================================================================
RWStepVisual_RWTessellatedPointSet::RWStepVisual_RWTessellatedPointSet() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedPointSet::ReadStep (const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedPointSet)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 3, theCheck, "tessellated_point_set"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Own fields of TessellatedPointSet
Handle(StepVisual_CoordinatesList) aCoordinates;
theData->ReadEntity(theNum, 2, "coordinates", theCheck,
STANDARD_TYPE(StepVisual_CoordinatesList), aCoordinates);
Handle(TColStd_HArray1OfInteger) aPointList;
Standard_Integer sub3 = 0;
if (theData->ReadSubList(theNum, 3, "point_list", theCheck, sub3))
{
Standard_Integer nb0 = theData->NbParams(sub3);
aPointList = new TColStd_HArray1OfInteger(1, nb0);
Standard_Integer num2 = sub3;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num2, i0, "integer", theCheck, anIt0);
aPointList->SetValue(i0, anIt0);
}
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aCoordinates, aPointList);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedPointSet::WriteStep (StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedPointSet)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedPointSet
theSW.Send(theEnt->Coordinates());
theSW.OpenSub();
for (Standard_Integer i2 = 1; i2 <= theEnt->PointList()->Length(); i2++)
{
Standard_Integer Var0 = theEnt->PointList()->Value(i2);
theSW.Send(Var0);
}
theSW.CloseSub();
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedPointSet::Share (const Handle(StepVisual_TessellatedPointSet)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Own fields of TessellatedPointSet
theIter.AddItem(theEnt->Coordinates());
}

53
src/RWStepVisual/RWStepVisual_RWTessellatedPointSet.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTessellatedPointSet_HeaderFile_
#define _RWStepVisual_RWTessellatedPointSet_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TessellatedPointSet;
//! Read & Write tool for TessellatedPointSet
class RWStepVisual_RWTessellatedPointSet
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTessellatedPointSet();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedPointSet)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedPointSet)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TessellatedPointSet)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTessellatedPointSet_HeaderFile_

125
src/RWStepVisual/RWStepVisual_RWTessellatedShapeRepresentation.cxx Normal file
View File

@ -0,0 +1,125 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTessellatedShapeRepresentation.hxx>
#include <StepVisual_TessellatedShapeRepresentation.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_HArray1OfRepresentationItem.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <StepRepr_RepresentationContext.hxx>
//=======================================================================
//function : RWStepVisual_RWTessellatedShapeRepresentation
//purpose :
//=======================================================================
RWStepVisual_RWTessellatedShapeRepresentation::RWStepVisual_RWTessellatedShapeRepresentation() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedShapeRepresentation::ReadStep(
const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedShapeRepresentation)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 3, theCheck, "tessellated_shape_representation"))
{
return;
}
// Inherited fields of Representation
Handle(TCollection_HAsciiString) aRepresentation_Name;
theData->ReadString(theNum, 1, "representation.name", theCheck, aRepresentation_Name);
Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
Standard_Integer sub2 = 0;
if (theData->ReadSubList(theNum, 2, "representation.items", theCheck, sub2))
{
Standard_Integer nb0 = theData->NbParams(sub2);
aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem(1, nb0);
Standard_Integer num2 = sub2;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Handle(StepRepr_RepresentationItem) anIt0;
theData->ReadEntity(num2, i0, "representation_item", theCheck,
STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
aRepresentation_Items->SetValue(i0, anIt0);
}
}
Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
theData->ReadEntity(theNum, 3, "representation.context_of_items", theCheck,
STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
// Initialize entity
theEnt->Init(aRepresentation_Name, aRepresentation_Items, aRepresentation_ContextOfItems);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedShapeRepresentation::WriteStep(
StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedShapeRepresentation)& theEnt) const
{
// Own fields of Representation
theSW.Send(theEnt->Name());
theSW.OpenSub();
for (Standard_Integer i1 = 1; i1 <= theEnt->Items()->Length(); i1++)
{
Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
theSW.Send(Var0);
}
theSW.CloseSub();
theSW.Send(theEnt->ContextOfItems());
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedShapeRepresentation::Share(
const Handle(StepVisual_TessellatedShapeRepresentation)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of Representation
for (Standard_Integer i1 = 1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++)
{
Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
theIter.AddItem(Var0);
}
theIter.AddItem(theEnt->StepRepr_Representation::ContextOfItems());
}

53
src/RWStepVisual/RWStepVisual_RWTessellatedShapeRepresentation.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTessellatedShapeRepresentation_HeaderFile_
#define _RWStepVisual_RWTessellatedShapeRepresentation_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TessellatedShapeRepresentation;
//! Read & Write tool for TessellatedShapeRepresentation
class RWStepVisual_RWTessellatedShapeRepresentation
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTessellatedShapeRepresentation();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedShapeRepresentation)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedShapeRepresentation)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TessellatedShapeRepresentation)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTessellatedShapeRepresentation_HeaderFile_

152
src/RWStepVisual/RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters.cxx Normal file
View File

@ -0,0 +1,152 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters.hxx>
#include <StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepRepr_HArray1OfRepresentationItem.hxx>
#include <StepRepr_RepresentationItem.hxx>
#include <StepRepr_RepresentationContext.hxx>
//=======================================================================
//function : RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters
//purpose :
//=======================================================================
RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters::RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters::ReadStep(
const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 4, theCheck, "tessellated_shape_representation_with_accuracy_parameters"))
{
return;
}
// Inherited fields of Representation
Handle(TCollection_HAsciiString) aRepresentation_Name;
theData->ReadString(theNum, 1, "representation.name", theCheck, aRepresentation_Name);
Handle(StepRepr_HArray1OfRepresentationItem) aRepresentation_Items;
Standard_Integer sub2 = 0;
if (theData->ReadSubList(theNum, 2, "representation.items", theCheck, sub2))
{
Standard_Integer nb0 = theData->NbParams(sub2);
aRepresentation_Items = new StepRepr_HArray1OfRepresentationItem(1, nb0);
Standard_Integer num2 = sub2;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Handle(StepRepr_RepresentationItem) anIt0;
theData->ReadEntity(num2, i0, "representation_item", theCheck,
STANDARD_TYPE(StepRepr_RepresentationItem), anIt0);
aRepresentation_Items->SetValue(i0, anIt0);
}
}
Handle(StepRepr_RepresentationContext) aRepresentation_ContextOfItems;
theData->ReadEntity(theNum, 3, "representation.context_of_items", theCheck,
STANDARD_TYPE(StepRepr_RepresentationContext), aRepresentation_ContextOfItems);
// Own fields of TessellatedShapeRepresentationWithAccuracyParameters
Handle(TColStd_HArray1OfReal) aTessellationAccuracyParameters;
Standard_Integer sub4 = 0;
if (theData->ReadSubList(theNum, 4, "tessellation_accuracy_parameters", theCheck, sub4))
{
Standard_Integer nb0 = theData->NbParams(sub4);
aTessellationAccuracyParameters = new TColStd_HArray1OfReal(1, nb0);
Standard_Integer num2 = sub4;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Real anIt0;
theData->ReadReal(num2, i0, "tessellation_accuracy_parameter_item", theCheck, anIt0);
aTessellationAccuracyParameters->SetValue(i0, anIt0);
}
}
// Initialize entity
theEnt->Init(aRepresentation_Name, aRepresentation_Items, aRepresentation_ContextOfItems, aTessellationAccuracyParameters);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters::WriteStep(
StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters)& theEnt) const
{
// Own fields of Representation
theSW.Send(theEnt->Name());
theSW.OpenSub();
for (Standard_Integer i1 = 1; i1 <= theEnt->Items()->Length(); i1++)
{
Handle(StepRepr_RepresentationItem) Var0 = theEnt->Items()->Value(i1);
theSW.Send(Var0);
}
theSW.CloseSub();
theSW.Send(theEnt->ContextOfItems());
// Own fields of TessellatedShapeRepresentationWithAccuracyParameters
theSW.OpenSub();
for (Standard_Integer i3 = 1; i3 <= theEnt->TessellationAccuracyParameters()->Length(); i3++)
{
Standard_Real Var0 = theEnt->TessellationAccuracyParameters()->Value(i3);
theSW.Send(Var0);
}
theSW.CloseSub();
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters::Share(
const Handle(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of Representation
for (Standard_Integer i1 = 1; i1 <= theEnt->StepRepr_Representation::Items()->Length(); i1++)
{
Handle(StepRepr_RepresentationItem) Var0 = theEnt->StepRepr_Representation::Items()->Value(i1);
theIter.AddItem(Var0);
}
theIter.AddItem(theEnt->StepRepr_Representation::ContextOfItems());
}

53
src/RWStepVisual/RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters_HeaderFile_
#define _RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TessellatedShapeRepresentationWithAccuracyParameters;
//! Read & Write tool for TessellatedShapeRepresentationWithAccuracyParameters
class RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTessellatedShapeRepresentationWithAccuracyParameters_HeaderFile_

147
src/RWStepVisual/RWStepVisual_RWTessellatedShell.cxx Normal file
View File

@ -0,0 +1,147 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTessellatedShell.hxx>
#include <StepVisual_TessellatedShell.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_HArray1OfTessellatedStructuredItem.hxx>
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <StepShape_ConnectedFaceSet.hxx>
//=======================================================================
//function : RWStepVisual_RWTessellatedShell
//purpose :
//=======================================================================
RWStepVisual_RWTessellatedShell::RWStepVisual_RWTessellatedShell() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedShell::ReadStep (const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedShell)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 3, theCheck, "tessellated_shell"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Own fields of TessellatedShell
Handle(StepVisual_HArray1OfTessellatedStructuredItem) aItems;
Standard_Integer sub2 = 0;
if (theData->ReadSubList(theNum, 2, "items", theCheck, sub2))
{
Standard_Integer nb0 = theData->NbParams(sub2);
aItems = new StepVisual_HArray1OfTessellatedStructuredItem(1, nb0);
Standard_Integer num2 = sub2;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Handle(StepVisual_TessellatedStructuredItem) anIt0;
theData->ReadEntity(num2, i0, "tessellated_structured_item", theCheck,
STANDARD_TYPE(StepVisual_TessellatedStructuredItem), anIt0);
aItems->SetValue(i0, anIt0);
}
}
Handle(StepShape_ConnectedFaceSet) aTopologicalLink;
Standard_Boolean hasTopologicalLink = Standard_True;
if (theData->IsParamDefined(theNum, 3))
{
theData->ReadEntity(theNum, 3, "topological_link", theCheck,
STANDARD_TYPE(StepShape_ConnectedFaceSet), aTopologicalLink);
}
else
{
hasTopologicalLink = Standard_False;
aTopologicalLink.Nullify();
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aItems, hasTopologicalLink, aTopologicalLink);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedShell::WriteStep (StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedShell)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedShell
theSW.OpenSub();
for (Standard_Integer i1 = 1; i1 <= theEnt->Items()->Length(); i1++)
{
Handle(StepVisual_TessellatedStructuredItem) Var0 = theEnt->Items()->Value(i1);
theSW.Send(Var0);
}
theSW.CloseSub();
if (theEnt->HasTopologicalLink())
{
theSW.Send(theEnt->TopologicalLink());
}
else
{
theSW.SendUndef();
}
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedShell::Share (const Handle(StepVisual_TessellatedShell)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Own fields of TessellatedShell
for (Standard_Integer i1 = 1; i1 <= theEnt->Items()->Length(); i1++)
{
Handle(StepVisual_TessellatedStructuredItem) Var0 = theEnt->Items()->Value(i1);
theIter.AddItem(Var0);
}
if (theEnt->HasTopologicalLink())
{
theIter.AddItem(theEnt->TopologicalLink());
}
}

53
src/RWStepVisual/RWStepVisual_RWTessellatedShell.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTessellatedShell_HeaderFile_
#define _RWStepVisual_RWTessellatedShell_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TessellatedShell;
//! Read & Write tool for TessellatedShell
class RWStepVisual_RWTessellatedShell
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTessellatedShell();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedShell)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedShell)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TessellatedShell)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTessellatedShell_HeaderFile_

147
src/RWStepVisual/RWStepVisual_RWTessellatedSolid.cxx Normal file
View File

@ -0,0 +1,147 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTessellatedSolid.hxx>
#include <StepVisual_TessellatedSolid.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_HArray1OfTessellatedStructuredItem.hxx>
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <StepShape_ManifoldSolidBrep.hxx>
//=======================================================================
//function : RWStepVisual_RWTessellatedSolid
//purpose :
//=======================================================================
RWStepVisual_RWTessellatedSolid::RWStepVisual_RWTessellatedSolid() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedSolid::ReadStep (const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedSolid)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 3, theCheck, "tessellated_solid"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Own fields of TessellatedSolid
Handle(StepVisual_HArray1OfTessellatedStructuredItem) aItems;
Standard_Integer sub2 = 0;
if (theData->ReadSubList(theNum, 2, "items", theCheck, sub2))
{
Standard_Integer nb0 = theData->NbParams(sub2);
aItems = new StepVisual_HArray1OfTessellatedStructuredItem(1, nb0);
Standard_Integer num2 = sub2;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Handle(StepVisual_TessellatedStructuredItem) anIt0;
theData->ReadEntity(num2, i0, "tessellated_structured_item", theCheck,
STANDARD_TYPE(StepVisual_TessellatedStructuredItem), anIt0);
aItems->SetValue(i0, anIt0);
}
}
Handle(StepShape_ManifoldSolidBrep) aGeometricLink;
Standard_Boolean hasGeometricLink = Standard_True;
if (theData->IsParamDefined(theNum, 3))
{
theData->ReadEntity(theNum, 3, "geometric_link", theCheck,
STANDARD_TYPE(StepShape_ManifoldSolidBrep), aGeometricLink);
}
else
{
hasGeometricLink = Standard_False;
aGeometricLink.Nullify();
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aItems, hasGeometricLink, aGeometricLink);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedSolid::WriteStep (StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedSolid)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedSolid
theSW.OpenSub();
for (Standard_Integer i1 = 1; i1 <= theEnt->Items()->Length(); i1++)
{
Handle(StepVisual_TessellatedStructuredItem) Var0 = theEnt->Items()->Value(i1);
theSW.Send(Var0);
}
theSW.CloseSub();
if (theEnt->HasGeometricLink())
{
theSW.Send(theEnt->GeometricLink());
}
else
{
theSW.SendUndef();
}
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedSolid::Share (const Handle(StepVisual_TessellatedSolid)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Own fields of TessellatedSolid
for (Standard_Integer i1 = 1; i1 <= theEnt->Items()->Length(); i1++)
{
Handle(StepVisual_TessellatedStructuredItem) Var0 = theEnt->Items()->Value(i1);
theIter.AddItem(Var0);
}
if (theEnt->HasGeometricLink())
{
theIter.AddItem(theEnt->GeometricLink());
}
}

53
src/RWStepVisual/RWStepVisual_RWTessellatedSolid.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTessellatedSolid_HeaderFile_
#define _RWStepVisual_RWTessellatedSolid_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TessellatedSolid;
//! Read & Write tool for TessellatedSolid
class RWStepVisual_RWTessellatedSolid
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTessellatedSolid();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedSolid)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedSolid)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TessellatedSolid)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTessellatedSolid_HeaderFile_

82
src/RWStepVisual/RWStepVisual_RWTessellatedStructuredItem.cxx Normal file
View File

@ -0,0 +1,82 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTessellatedStructuredItem.hxx>
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
//=======================================================================
//function : RWStepVisual_RWTessellatedStructuredItem
//purpose :
//=======================================================================
RWStepVisual_RWTessellatedStructuredItem::RWStepVisual_RWTessellatedStructuredItem() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedStructuredItem::ReadStep(
const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedStructuredItem)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 1, theCheck, "tessellated_structured_item"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Initialize entity
theEnt->Init(aRepresentationItem_Name);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedStructuredItem::WriteStep(
StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedStructuredItem)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedStructuredItem::Share(
const Handle(StepVisual_TessellatedStructuredItem)&,
Interface_EntityIterator&) const
{
}

53
src/RWStepVisual/RWStepVisual_RWTessellatedStructuredItem.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTessellatedStructuredItem_HeaderFile_
#define _RWStepVisual_RWTessellatedStructuredItem_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TessellatedStructuredItem;
//! Read & Write tool for TessellatedStructuredItem
class RWStepVisual_RWTessellatedStructuredItem
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTessellatedStructuredItem();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedStructuredItem)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedStructuredItem)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TessellatedStructuredItem)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTessellatedStructuredItem_HeaderFile_

130
src/RWStepVisual/RWStepVisual_RWTessellatedVertex.cxx Normal file
View File

@ -0,0 +1,130 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTessellatedVertex.hxx>
#include <StepVisual_TessellatedVertex.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <StepShape_VertexPoint.hxx>
#include <Standard_Integer.hxx>
//=======================================================================
//function : RWStepVisual_RWTessellatedVertex
//purpose :
//=======================================================================
RWStepVisual_RWTessellatedVertex::RWStepVisual_RWTessellatedVertex() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedVertex::ReadStep (const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedVertex)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 4, theCheck, "tessellated_vertex"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Own fields of TessellatedVertex
Handle(StepVisual_CoordinatesList) aCoordinates;
theData->ReadEntity(theNum, 2, "coordinates", theCheck,
STANDARD_TYPE(StepVisual_CoordinatesList), aCoordinates);
Handle(StepShape_VertexPoint) aTopologicalLink;
Standard_Boolean hasTopologicalLink = Standard_True;
if (theData->IsParamDefined(theNum, 3))
{
theData->ReadEntity(theNum, 3, "topological_link", theCheck,
STANDARD_TYPE(StepShape_VertexPoint), aTopologicalLink);
}
else
{
hasTopologicalLink = Standard_False;
aTopologicalLink.Nullify();
}
Standard_Integer aPointIndex;
theData->ReadInteger(theNum, 4, "point_index", theCheck, aPointIndex);
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aCoordinates, hasTopologicalLink, aTopologicalLink, aPointIndex);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedVertex::WriteStep (StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedVertex)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedVertex
theSW.Send(theEnt->Coordinates());
if (theEnt->HasTopologicalLink())
{
theSW.Send(theEnt->TopologicalLink());
}
else
{
theSW.SendUndef();
}
theSW.Send(theEnt->PointIndex());
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedVertex::Share (const Handle(StepVisual_TessellatedVertex)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Own fields of TessellatedVertex
theIter.AddItem(theEnt->Coordinates());
if (theEnt->HasTopologicalLink())
{
theIter.AddItem(theEnt->TopologicalLink());
}
}

53
src/RWStepVisual/RWStepVisual_RWTessellatedVertex.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTessellatedVertex_HeaderFile_
#define _RWStepVisual_RWTessellatedVertex_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TessellatedVertex;
//! Read & Write tool for TessellatedVertex
class RWStepVisual_RWTessellatedVertex
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTessellatedVertex();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedVertex)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedVertex)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TessellatedVertex)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTessellatedVertex_HeaderFile_

145
src/RWStepVisual/RWStepVisual_RWTessellatedWire.cxx Normal file
View File

@ -0,0 +1,145 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTessellatedWire.hxx>
#include <StepVisual_TessellatedWire.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_HArray1OfTessellatedEdgeOrVertex.hxx>
#include <StepVisual_TessellatedEdgeOrVertex.hxx>
#include <StepVisual_PathOrCompositeCurve.hxx>
//=======================================================================
//function : RWStepVisual_RWTessellatedWire
//purpose :
//=======================================================================
RWStepVisual_RWTessellatedWire::RWStepVisual_RWTessellatedWire() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedWire::ReadStep (const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedWire)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 3, theCheck, "tessellated_wire"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Own fields of TessellatedWire
Handle(StepVisual_HArray1OfTessellatedEdgeOrVertex) aItems;
Standard_Integer sub2 = 0;
if (theData->ReadSubList(theNum, 2, "items", theCheck, sub2))
{
Standard_Integer nb0 = theData->NbParams(sub2);
aItems = new StepVisual_HArray1OfTessellatedEdgeOrVertex(1, nb0);
Standard_Integer num2 = sub2;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
StepVisual_TessellatedEdgeOrVertex anIt0;
theData->ReadEntity(num2, i0, "tessellated_edge_or_vertex", theCheck, anIt0);
aItems->SetValue(i0, anIt0);
}
}
StepVisual_PathOrCompositeCurve aGeometricModelLink;
Standard_Boolean hasGeometricModelLink = Standard_True;
if (theData->IsParamDefined(theNum, 3))
{
theData->ReadEntity(theNum, 3, "geometric_model_link", theCheck, aGeometricModelLink);
}
else
{
hasGeometricModelLink = Standard_False;
aGeometricModelLink = StepVisual_PathOrCompositeCurve();
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aItems, hasGeometricModelLink, aGeometricModelLink);
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedWire::WriteStep (StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedWire)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedWire
theSW.OpenSub();
for (Standard_Integer i1 = 1; i1 <= theEnt->Items()->Length(); i1++)
{
StepVisual_TessellatedEdgeOrVertex Var0 = theEnt->Items()->Value(i1);
theSW.Send(Var0.Value());
}
theSW.CloseSub();
if (theEnt->HasGeometricModelLink())
{
theSW.Send(theEnt->GeometricModelLink().Value());
}
else
{
theSW.SendUndef();
}
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTessellatedWire::Share (const Handle(StepVisual_TessellatedWire)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Own fields of TessellatedWire
for (Standard_Integer i1 = 1; i1 <= theEnt->Items()->Length(); i1++)
{
StepVisual_TessellatedEdgeOrVertex Var0 = theEnt->Items()->Value(i1);
theIter.AddItem(Var0.Value());
}
if (theEnt->HasGeometricModelLink())
{
theIter.AddItem(theEnt->GeometricModelLink().Value());
}
}

53
src/RWStepVisual/RWStepVisual_RWTessellatedWire.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTessellatedWire_HeaderFile_
#define _RWStepVisual_RWTessellatedWire_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TessellatedWire;
//! Read & Write tool for TessellatedWire
class RWStepVisual_RWTessellatedWire
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTessellatedWire();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TessellatedWire)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TessellatedWire)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TessellatedWire)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTessellatedWire_HeaderFile_

239
src/RWStepVisual/RWStepVisual_RWTriangulatedFace.cxx Normal file
View File

@ -0,0 +1,239 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <RWStepVisual_RWTriangulatedFace.hxx>
#include <StepVisual_TriangulatedFace.hxx>
#include <Interface_EntityIterator.hxx>
#include <StepData_StepReaderData.hxx>
#include <StepData_StepWriter.hxx>
#include <TCollection_HAsciiString.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <Standard_Integer.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <Standard_Real.hxx>
#include <StepVisual_FaceOrSurface.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray2OfInteger.hxx>
//=======================================================================
//function : RWStepVisual_RWTriangulatedFace
//purpose :
//=======================================================================
RWStepVisual_RWTriangulatedFace::RWStepVisual_RWTriangulatedFace() {}
//=======================================================================
//function : ReadStep
//purpose :
//=======================================================================
void RWStepVisual_RWTriangulatedFace::ReadStep (const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TriangulatedFace)& theEnt) const
{
// Check number of parameters
if (!theData->CheckNbParams(theNum, 7, theCheck, "triangulated_face"))
{
return;
}
// Inherited fields of RepresentationItem
Handle(TCollection_HAsciiString) aRepresentationItem_Name;
theData->ReadString(theNum, 1, "representation_item.name", theCheck, aRepresentationItem_Name);
// Inherited fields of TessellatedFace
Handle(StepVisual_CoordinatesList) aTessellatedFace_Coordinates;
theData->ReadEntity(theNum, 2, "tessellated_face.coordinates", theCheck,
STANDARD_TYPE(StepVisual_CoordinatesList), aTessellatedFace_Coordinates);
Standard_Integer aTessellatedFace_Pnmax;
theData->ReadInteger(theNum, 3, "tessellated_face.pnmax", theCheck, aTessellatedFace_Pnmax);
Handle(TColStd_HArray2OfReal) aTessellatedFace_Normals;
Standard_Integer sub4 = 0;
if (theData->ReadSubList(theNum, 4, "tessellated_face.normals", theCheck, sub4))
{
Standard_Integer nb0 = theData->NbParams(sub4);
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub4,1));
aTessellatedFace_Normals = new TColStd_HArray2OfReal(1, nb0, 1, nbj0);
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer subj4 = 0;
if ( theData->ReadSubList (sub4, i0, "sub-part(tessellated_face.normals)", theCheck, subj4) ) {
Standard_Integer num4 = subj4;
for (Standard_Integer j0 = 1; j0 <= nbj0; j0++)
{
Standard_Real anIt0;
theData->ReadReal(num4, j0, "real", theCheck, anIt0);
aTessellatedFace_Normals->SetValue(i0,j0, anIt0);
}
}
}
}
StepVisual_FaceOrSurface aTessellatedFace_GeometricLink;
Standard_Boolean hasTessellatedFace_GeometricLink = Standard_True;
if (theData->IsParamDefined(theNum, 5))
{
theData->ReadEntity(theNum, 5, "tessellated_face.geometric_link", theCheck, aTessellatedFace_GeometricLink);
}
else
{
hasTessellatedFace_GeometricLink = Standard_False;
aTessellatedFace_GeometricLink = StepVisual_FaceOrSurface();
}
// Own fields of TriangulatedFace
Handle(TColStd_HArray1OfInteger) aPnindex;
Standard_Integer sub6 = 0;
if (theData->ReadSubList(theNum, 6, "pnindex", theCheck, sub6))
{
Standard_Integer nb0 = theData->NbParams(sub6);
aPnindex = new TColStd_HArray1OfInteger(1, nb0);
Standard_Integer num2 = sub6;
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num2, i0, "integer", theCheck, anIt0);
aPnindex->SetValue(i0, anIt0);
}
}
Handle(TColStd_HArray2OfInteger) aTriangles;
Standard_Integer sub7 = 0;
if (theData->ReadSubList(theNum, 7, "triangles", theCheck, sub7))
{
Standard_Integer nb0 = theData->NbParams(sub7);
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub7,1));
aTriangles = new TColStd_HArray2OfInteger(1, nb0, 1, nbj0);
for (Standard_Integer i0 = 1; i0 <= nb0; i0++)
{
Standard_Integer subj7 = 0;
if ( theData->ReadSubList (sub7, i0, "sub-part(triangles)", theCheck, subj7) ) {
Standard_Integer num4 = subj7;
for (Standard_Integer j0 = 1; j0 <= nbj0; j0++)
{
Standard_Integer anIt0;
theData->ReadInteger(num4, j0, "integer", theCheck, anIt0);
aTriangles->SetValue(i0,j0, anIt0);
}
}
}
}
// Initialize entity
theEnt->Init(aRepresentationItem_Name, aTessellatedFace_Coordinates, aTessellatedFace_Pnmax, aTessellatedFace_Normals, hasTessellatedFace_GeometricLink, aTessellatedFace_GeometricLink, aPnindex, aTriangles);
#ifdef OCCT_DEBUG
std::cout << aTessellatedFace_Pnmax << " " << (aTriangles.IsNull() ? 0 : aTriangles->NbRows()) << std::endl;
#endif
}
//=======================================================================
//function : WriteStep
//purpose :
//=======================================================================
void RWStepVisual_RWTriangulatedFace::WriteStep (StepData_StepWriter& theSW,
const Handle(StepVisual_TriangulatedFace)& theEnt) const
{
// Own fields of RepresentationItem
theSW.Send(theEnt->Name());
// Own fields of TessellatedFace
theSW.Send(theEnt->Coordinates());
theSW.Send(theEnt->Pnmax());
theSW.OpenSub();
for (Standard_Integer i3 = 1; i3 <= theEnt->Normals()->NbRows(); i3++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
for (Standard_Integer j3 = 1; j3 <= theEnt->Normals()->NbColumns(); j3++)
{
Standard_Real Var0 = theEnt->Normals()->Value(i3,j3);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
if (theEnt->HasGeometricLink())
{
theSW.Send(theEnt->GeometricLink().Value());
}
else
{
theSW.SendUndef();
}
// Own fields of TriangulatedFace
theSW.OpenSub();
for (Standard_Integer i5 = 1; i5 <= theEnt->Pnindex()->Length(); i5++)
{
Standard_Integer Var0 = theEnt->Pnindex()->Value(i5);
theSW.Send(Var0);
}
theSW.CloseSub();
theSW.OpenSub();
for (Standard_Integer i6 = 1; i6 <= theEnt->Triangles()->NbRows(); i6++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
for (Standard_Integer j6 = 1; j6 <= theEnt->Triangles()->NbColumns(); j6++)
{
Standard_Integer Var0 = theEnt->Triangles()->Value(i6,j6);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
}
//=======================================================================
//function : Share
//purpose :
//=======================================================================
void RWStepVisual_RWTriangulatedFace::Share (const Handle(StepVisual_TriangulatedFace)&theEnt,
Interface_EntityIterator& theIter) const
{
// Inherited fields of RepresentationItem
// Inherited fields of TessellatedFace
theIter.AddItem(theEnt->StepVisual_TessellatedFace::Coordinates());
if (theEnt->StepVisual_TessellatedFace::HasGeometricLink())
{
theIter.AddItem(theEnt->StepVisual_TessellatedFace::GeometricLink().Value());
}
// Own fields of TriangulatedFace
}

53
src/RWStepVisual/RWStepVisual_RWTriangulatedFace.hxx Normal file
View File

@ -0,0 +1,53 @@
// Created on : Thu Mar 24 18:30:12 2022
// Created by: snn
// Generator: Express (EXPRESS -> CASCADE/XSTEP Translator) V2.0
// Copyright (c) Open CASCADE 2022
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _RWStepVisual_RWTriangulatedFace_HeaderFile_
#define _RWStepVisual_RWTriangulatedFace_HeaderFile_
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
class StepData_StepReaderData;
class Interface_Check;
class StepData_StepWriter;
class Interface_EntityIterator;
class StepVisual_TriangulatedFace;
//! Read & Write tool for TriangulatedFace
class RWStepVisual_RWTriangulatedFace
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT RWStepVisual_RWTriangulatedFace();
Standard_EXPORT void ReadStep(const Handle(StepData_StepReaderData)& theData,
const Standard_Integer theNum,
Handle(Interface_Check)& theCheck,
const Handle(StepVisual_TriangulatedFace)& theEnt) const;
Standard_EXPORT void WriteStep(StepData_StepWriter& theSW,
const Handle(StepVisual_TriangulatedFace)& theEnt) const;
Standard_EXPORT void Share(const Handle(StepVisual_TriangulatedFace)& theEnt,
Interface_EntityIterator& theIter) const;
};
#endif // _RWStepVisual_RWTriangulatedFace_HeaderFile_

8
src/STEPCAFControl/STEPCAFControl_GDTProperty.cxx
View File

@ -1311,6 +1311,7 @@ Handle(TCollection_HAsciiString) STEPCAFControl_GDTProperty::GetTolValueType(con
//=======================================================================
Handle(StepVisual_TessellatedGeometricSet) STEPCAFControl_GDTProperty::GetTessellation(const TopoDS_Shape theShape)
{
Handle(StepVisual_TessellatedGeometricSet) aGeomSet;
// Build coordinate list and curves
NCollection_Handle<StepVisual_VectorOfHSequenceOfInteger> aCurves = new StepVisual_VectorOfHSequenceOfInteger;
NCollection_Vector<gp_XYZ> aCoords;
@ -1344,6 +1345,11 @@ Handle(StepVisual_TessellatedGeometricSet) STEPCAFControl_GDTProperty::GetTessel
aCurves->Append(aCurve);
}
if (!aCoords.Length())
{
return aGeomSet;
}
Handle(TColgp_HArray1OfXYZ) aPoints = new TColgp_HArray1OfXYZ(1, aCoords.Length());
for (Standard_Integer i = 1; i <= aPoints->Length(); i++) {
aPoints->SetValue(i, aCoords.Value(i - 1));
@ -1355,7 +1361,7 @@ Handle(StepVisual_TessellatedGeometricSet) STEPCAFControl_GDTProperty::GetTessel
aCurveSet->Init(new TCollection_HAsciiString(), aCoordList, aCurves);
NCollection_Handle<StepVisual_Array1OfTessellatedItem> aTessItems = new StepVisual_Array1OfTessellatedItem(1, 1);
aTessItems->SetValue(1, aCurveSet);
Handle(StepVisual_TessellatedGeometricSet) aGeomSet = new StepVisual_TessellatedGeometricSet();
aGeomSet = new StepVisual_TessellatedGeometricSet();
aGeomSet->Init(new TCollection_HAsciiString(), aTessItems);
return aGeomSet;
}

378
src/STEPCAFControl/STEPCAFControl_Reader.cxx
View File

@ -277,6 +277,7 @@
#include <StepVisual_TessellatedItem.hxx>
#include <StepVisual_TessellatedGeometricSet.hxx>
#include <StepVisual_TessellatedCurveSet.hxx>
#include <StepVisual_ComplexTriangulatedSurfaceSet.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <NCollection_Vector.hxx>
@ -1746,54 +1747,201 @@ Standard_Boolean STEPCAFControl_Reader::ReadSHUOs(const Handle(XSControl_WorkSes
return Standard_True;
}
//=======================================================================
//function : GetMeasureWithUnit
//purpose :
//=======================================================================
static Handle(StepBasic_MeasureWithUnit) GetMeasureWithUnit(const Handle(Standard_Transient)& theMeasure)
{
Handle(StepBasic_MeasureWithUnit) aMeasureWithUnit;
if (theMeasure->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
{
aMeasureWithUnit = Handle(StepBasic_MeasureWithUnit)::DownCast(theMeasure);
}
else if (theMeasure->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
{
Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(theMeasure);
aMeasureWithUnit = aReprMeasureItem->GetMeasureWithUnit();
}
return aMeasureWithUnit;
}
//=======================================================================
//function : GetMassConversionFactor
//purpose :
//=======================================================================
static Standard_Boolean GetMassConversionFactor(Handle(StepBasic_NamedUnit)& NU,
Standard_Real& afact)
static Standard_Boolean GetMassConversionFactor(Handle(StepBasic_NamedUnit)& theNUnit,
Standard_Real& theFact)
{
afact = 1.;
if (!NU->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndMassUnit))) return Standard_False;
Handle(StepBasic_ConversionBasedUnitAndMassUnit) CBUMU =
Handle(StepBasic_ConversionBasedUnitAndMassUnit)::DownCast(NU);
Handle(StepBasic_MeasureWithUnit) MWUCBU = CBUMU->ConversionFactor();
afact = MWUCBU->ValueComponent();
StepBasic_Unit anUnit2 = MWUCBU->UnitComponent();
if (anUnit2.CaseNum(anUnit2.Value()) == 1) {
theFact = 1.;
if (!theNUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndMassUnit)))
{
return Standard_False;
}
Handle(StepBasic_ConversionBasedUnitAndMassUnit) aCBUMU =
Handle(StepBasic_ConversionBasedUnitAndMassUnit)::DownCast(theNUnit);
Handle(StepBasic_MeasureWithUnit) aMWUCBU = GetMeasureWithUnit(aCBUMU->ConversionFactor());
theFact = aMWUCBU->ValueComponent();
StepBasic_Unit anUnit2 = aMWUCBU->UnitComponent();
if (anUnit2.CaseNum(anUnit2.Value()) == 1)
{
Handle(StepBasic_NamedUnit) NU2 = anUnit2.NamedUnit();
if (NU2->IsKind(STANDARD_TYPE(StepBasic_SiUnit))) {
if (NU2->IsKind(STANDARD_TYPE(StepBasic_SiUnit)))
{
Handle(StepBasic_SiUnit) SU = Handle(StepBasic_SiUnit)::DownCast(NU2);
if (SU->Name() == StepBasic_sunGram) {
if (SU->Name() == StepBasic_sunGram)
{
if (SU->HasPrefix())
afact *= STEPConstruct_UnitContext::ConvertSiPrefix(SU->Prefix());
{
theFact *= STEPConstruct_UnitContext::ConvertSiPrefix(SU->Prefix());
}
}
}
}
return Standard_True;
}
// ============================================================================
// Method : createMesh
// Purpose : creates a Poly_Triangulation from ComplexTriangulatedSurfaceSet
// ============================================================================
Handle(Poly_Triangulation) createMesh(const Handle(StepVisual_ComplexTriangulatedSurfaceSet)& theTriangulatedSufaceSet,
const Standard_Real theFact)
{
Handle(StepVisual_CoordinatesList) aCoords = theTriangulatedSufaceSet->Coordinates();
Handle(TColgp_HArray1OfXYZ) aNodes = aCoords->Points();
Handle(TColStd_HArray1OfTransient) aTriaStrips = theTriangulatedSufaceSet->TriangleStrips();
Handle(TColStd_HArray1OfTransient) aTriaFans = theTriangulatedSufaceSet->TriangleFans();
const Standard_Boolean aHasUVNodes = Standard_False;
const Standard_Integer aNbNormals = theTriangulatedSufaceSet->NbNormals();
// Number of pairs (Point, Normal). It is possible for one point to have multiple normals. This is
// useful when the underlying surface is not C1 continuous.
const Standard_Integer aNbPairs = aNbNormals > 1 ? theTriangulatedSufaceSet->NbPnindex() : aNodes->Length();
const Standard_Boolean aHasNormals = aNbNormals > 0;
// Counting number of triangles in the triangle strips list.
// A triangle strip is a list of 3 or more points defining a set of connected triangles.
Standard_Integer aNbTriaStrips = 0;
for (Standard_Integer i = 1; i <= theTriangulatedSufaceSet->NbTriangleStrips(); ++i)
{
Handle(TColStd_HArray1OfInteger) aTriangleStrip = Handle(TColStd_HArray1OfInteger)::DownCast(aTriaStrips->Value(i));
aNbTriaStrips += aTriangleStrip->Length() - 2;
}
// Counting number of triangles in the triangle fans list.
// A triangle fan is a set of 3 or more points defining a set of connected triangles sharing a common vertex.
Standard_Integer aNbTriaFans = 0;
for (Standard_Integer i = 1; i <= theTriangulatedSufaceSet->NbTriangleFans(); ++i)
{
Handle(TColStd_HArray1OfInteger) aTriangleFan = Handle(TColStd_HArray1OfInteger)::DownCast(aTriaFans->Value(i));
aNbTriaFans += aTriangleFan->Length() - 2;
}
Handle(Poly_Triangulation) aMesh = new Poly_Triangulation(aNbPairs, aNbTriaStrips + aNbTriaFans, aHasUVNodes);
for (Standard_Integer j = 1; j <= aNbPairs; ++j)
{
const gp_XYZ& aPoint = aNodes->Value(aNbNormals > 1 ? theTriangulatedSufaceSet->PnindexValue(j) : j);
aMesh->ChangeNode(j) = theFact * aPoint;
}
// Creating triangles from triangle strips. Processing is split in two parts to
// path through nodes in the same direction.
Standard_Integer k = 1;
for (Standard_Integer i = 1; i <= theTriangulatedSufaceSet->NbTriangleStrips(); ++i)
{
Handle(TColStd_HArray1OfInteger) aTriangleStrip = Handle(TColStd_HArray1OfInteger)::DownCast(aTriaStrips->Value(i));
for (Standard_Integer j = 3; j <= aTriangleStrip->Length(); j += 2)
{
if (aTriangleStrip->Value(j) != aTriangleStrip->Value(j - 2) &&
aTriangleStrip->Value(j) != aTriangleStrip->Value(j - 1))
{
aMesh->ChangeTriangle(k++) = Poly_Triangle(aTriangleStrip->Value(j - 2),
aTriangleStrip->Value(j),
aTriangleStrip->Value(j - 1));
}
}
for (Standard_Integer j = 4; j <= aTriangleStrip->Length(); j += 2)
{
if (aTriangleStrip->Value(j) != aTriangleStrip->Value(j - 2) &&
aTriangleStrip->Value(j) != aTriangleStrip->Value(j - 1))
{
aMesh->ChangeTriangle(k++) = Poly_Triangle(aTriangleStrip->Value(j - 2),
aTriangleStrip->Value(j - 1),
aTriangleStrip->Value(j));
}
}
}
// Creating triangles from triangle strips.
for (Standard_Integer i = 1; i <= theTriangulatedSufaceSet->NbTriangleFans(); ++i)
{
Handle(TColStd_HArray1OfInteger) aTriangleFan = Handle(TColStd_HArray1OfInteger)::DownCast(aTriaFans->Value(i));
for (Standard_Integer j = 3; j <= aTriangleFan->Length(); ++j)
{
aMesh->ChangeTriangle(k++) = Poly_Triangle(aTriangleFan->Value(1),
aTriangleFan->Value(j - 1),
aTriangleFan->Value(j));
}
}
if (aHasNormals)
{
Handle(TColStd_HArray2OfReal) aNormals = theTriangulatedSufaceSet->Normals();
Handle(TShort_HArray1OfShortReal) aPolyNormals = new TShort_HArray1OfShortReal(1, aNbPairs * 3);
aMesh->SetNormals(aPolyNormals);
gp_XYZ aNorm;
if (theTriangulatedSufaceSet->NbNormals() == 1)
{
aNorm.SetX(aNormals->Value(1, 1));
aNorm.SetY(aNormals->Value(1, 2));
aNorm.SetZ(aNormals->Value(1, 3));
for (Standard_Integer i = 1; i <= aNbPairs; ++i)
{
aMesh->SetNormal(i, aNorm);
}
}
else
{
for (Standard_Integer i = 1; i <= aNbPairs; ++i)
{
aNorm.SetX(aNormals->Value(i, 1));
aNorm.SetY(aNormals->Value(i, 2));
aNorm.SetZ(aNormals->Value(i, 3));
aMesh->SetNormal(i, aNorm);
}
}
}
return aMesh;
}
//=======================================================================
//function : readPMIPresentation
//purpose : read polyline or tessellated presentation for
// (Annotation_Curve_Occurrence or Draughting_Callout)
//=======================================================================
Standard_Boolean readPMIPresentation(const Handle(Standard_Transient)& thePresentEntity,
const Handle(XSControl_TransferReader)& theTR,
const Standard_Real theFact,
TopoDS_Shape& thePresentation,
Handle(TCollection_HAsciiString)& thePresentName,
Bnd_Box& theBox)
const Handle(XSControl_TransferReader)& theTR,
const Standard_Real theFact,
TopoDS_Shape& thePresentation,
Handle(TCollection_HAsciiString)& thePresentName,
Bnd_Box& theBox)
{
if (thePresentEntity.IsNull())
{
return Standard_False;
}
Handle(Transfer_TransientProcess) aTP = theTR->TransientProcess();
Handle(StepVisual_AnnotationOccurrence) anAO;
NCollection_Vector<Handle(StepVisual_StyledItem)> anAnnotations;
if (thePresentEntity->IsKind(STANDARD_TYPE(StepVisual_AnnotationOccurrence)))
{
anAO = Handle(StepVisual_AnnotationOccurrence)::DownCast(thePresentEntity);
if (!anAO.IsNull()) {
if (!anAO.IsNull())
{
thePresentName = anAO->Name();
anAnnotations.Append(anAO);
}
@ -1818,17 +1966,17 @@ Standard_Boolean readPMIPresentation(const Handle(Standard_Transient)& thePresen
}
if (!anAnnotations.Length())
{
return Standard_False;
}
BRep_Builder aB;
TopoDS_Compound aResAnnotation;
aB.MakeCompound(aResAnnotation);
Standard_Integer i = 0;
Bnd_Box aBox;
Standard_Integer nbShapes = 0;
for (; i < anAnnotations.Length(); i++)
Standard_Integer aNbShapes = 0;
for (Standard_Integer i = 0; i < anAnnotations.Length(); i++)
{
Handle(StepVisual_StyledItem) anItem = anAnnotations(i);
anAO = Handle(StepVisual_AnnotationOccurrence)::DownCast(anItem);
@ -1839,19 +1987,19 @@ Standard_Boolean readPMIPresentation(const Handle(Standard_Transient)& thePresen
anAnnotationShape = STEPConstruct::FindShape(aTP, aCurveItem);
if (anAnnotationShape.IsNull())
{
Handle(Transfer_Binder) binder = theTR->Actor()->Transfer(aCurveItem, aTP);
if (!binder.IsNull() && binder->HasResult()) {
anAnnotationShape = TransferBRep::ShapeResult(aTP, binder);
Handle(Transfer_Binder) aBinder = theTR->Actor()->Transfer(aCurveItem, aTP);
if (!aBinder.IsNull() && aBinder->HasResult()) {
anAnnotationShape = TransferBRep::ShapeResult(aTP, aBinder);
}
}
}
//case of tessellated entities
else
{
Handle(StepRepr_RepresentationItem) aTessItem = anItem->Item();
if (aTessItem.IsNull())
Handle(StepRepr_RepresentationItem) aRepresentationItem = anItem->Item();
if (aRepresentationItem.IsNull())
continue;
Handle(StepVisual_TessellatedGeometricSet) aTessSet = Handle(StepVisual_TessellatedGeometricSet)::DownCast(aTessItem);
Handle(StepVisual_TessellatedGeometricSet) aTessSet = Handle(StepVisual_TessellatedGeometricSet)::DownCast(aRepresentationItem);
if (aTessSet.IsNull())
continue;
gp_Trsf aTransf;
@ -1874,55 +2022,75 @@ Standard_Boolean readPMIPresentation(const Handle(Standard_Transient)& thePresen
}
}
NCollection_Handle<StepVisual_Array1OfTessellatedItem> aListItems = aTessSet->Items();
Standard_Integer nb = aListItems.IsNull() ? 0 : aListItems->Length();
Handle(StepVisual_TessellatedCurveSet) aTessCurve;
for (Standard_Integer n = 1; n <= nb && aTessCurve.IsNull(); n++)
{
aTessCurve = Handle(StepVisual_TessellatedCurveSet)::DownCast(aListItems->Value(n));
}
if (aTessCurve.IsNull())
continue;
Handle(StepVisual_CoordinatesList) aCoordList = aTessCurve->CoordList();
if (aCoordList.IsNull())
continue;
Handle(TColgp_HArray1OfXYZ) aPoints = aCoordList->Points();
if (aPoints.IsNull() || aPoints->Length() == 0)
continue;
NCollection_Handle<StepVisual_VectorOfHSequenceOfInteger> aCurves = aTessCurve->Curves();
Standard_Integer aNbC = (aCurves.IsNull() ? 0 : aCurves->Length());
Standard_Integer aNbItems = aListItems.IsNull() ? 0 : aListItems->Length();
TopoDS_Compound aComp;
aB.MakeCompound(aComp);
Standard_Integer k = 0;
for (; k < aNbC; k++)
for (Standard_Integer j = 1; j <= aNbItems; j++)
{
Handle(TColStd_HSequenceOfInteger) anIndexes = aCurves->Value(k);
TopoDS_Wire aCurW;
aB.MakeWire(aCurW);
for (Standard_Integer n = 1; n < anIndexes->Length(); n++)
Handle(StepVisual_TessellatedItem) aTessItem = aListItems->Value(j);
if (aTessItem.IsNull())
{
Standard_Integer ind = anIndexes->Value(n);
Standard_Integer indnext = anIndexes->Value(n + 1);
if (ind > aPoints->Length() || indnext > aPoints->Length())
continue;
gp_Pnt aP1(aPoints->Value(ind) * theFact);
gp_Pnt aP2(aPoints->Value(indnext) * theFact);
BRepBuilderAPI_MakeEdge aMaker(aP1, aP2);
if (aMaker.IsDone())
continue;
}
if (aTessItem->IsKind(STANDARD_TYPE(StepVisual_TessellatedCurveSet)))
{
Handle(StepVisual_TessellatedCurveSet) aTessCurve = Handle(StepVisual_TessellatedCurveSet)::DownCast(aTessItem);
Handle(StepVisual_CoordinatesList) aCoordList = aTessCurve->CoordList();
if (aCoordList.IsNull())
{
TopoDS_Edge aCurE = aMaker.Edge();
aB.Add(aCurW, aCurE);
continue;
}
Handle(TColgp_HArray1OfXYZ) aPoints = aCoordList->Points();
if (aPoints.IsNull() || aPoints->Length() == 0)
{
continue;
}
NCollection_Handle<StepVisual_VectorOfHSequenceOfInteger> aCurves = aTessCurve->Curves();
Standard_Integer aNbCurves = (aCurves.IsNull() ? 0 : aCurves->Length());
for (Standard_Integer k = 0; k < aNbCurves; k++)
{
Handle(TColStd_HSequenceOfInteger) anIndexes = aCurves->Value(k);
TopoDS_Wire aCurW;
aB.MakeWire(aCurW);
for (Standard_Integer n = 1; n < anIndexes->Length(); n++)
{
Standard_Integer anIndex = anIndexes->Value(n);
Standard_Integer aNextIndex = anIndexes->Value(n + 1);
if (anIndex > aPoints->Length() || aNextIndex > aPoints->Length())
{
continue;
}
gp_Pnt aP1(aPoints->Value(anIndex) * theFact);
gp_Pnt aP2(aPoints->Value(aNextIndex) * theFact);
BRepBuilderAPI_MakeEdge aMaker(aP1, aP2);
if (aMaker.IsDone())
{
TopoDS_Edge aCurE = aMaker.Edge();
aB.Add(aCurW, aCurE);
}
}
aB.Add(aComp, aCurW);
}
}
aB.Add(aComp, aCurW);
else if (aTessItem->IsKind(STANDARD_TYPE(StepVisual_ComplexTriangulatedSurfaceSet)))
{
Handle(StepVisual_ComplexTriangulatedSurfaceSet) aTessSurfSet = Handle(StepVisual_ComplexTriangulatedSurfaceSet)::DownCast(aTessItem);
Handle(Poly_Triangulation) aSurfSetMesh = createMesh(aTessSurfSet, theFact);
TopoDS_Face aFace;
aB.MakeFace(aFace, aSurfSetMesh);
aB.Add(aComp, aFace);
}
}
if (!aComp.IsNull())
{
anAnnotationShape = aComp.Moved(aTransf);
}
anAnnotationShape = aComp.Moved(aTransf);
}
if (!anAnnotationShape.IsNull())
{
nbShapes++;
aNbShapes++;
aB.Add(aResAnnotation, anAnnotationShape);
if (i == anAnnotations.Length() - 1)
BRepBndLib::AddClose(anAnnotationShape, aBox);
@ -1931,7 +2099,7 @@ Standard_Boolean readPMIPresentation(const Handle(Standard_Transient)& thePresen
thePresentation = aResAnnotation;
theBox = aBox;
return (nbShapes > 0);
return (aNbShapes > 0);
}
//=======================================================================
@ -2957,24 +3125,32 @@ TDF_Label STEPCAFControl_Reader::createGDTObjectInXCAF(const Handle(Standard_Tra
aDGTTool->SetDimTol(shL, 1, arr, aName, DimSize->Name());
}
// read tolerances and datums
else if (theEnt->IsKind(STANDARD_TYPE(StepDimTol_GeometricTolerance))) {
else if (theEnt->IsKind(STANDARD_TYPE(StepDimTol_GeometricTolerance)))
{
Handle(StepDimTol_GeometricTolerance) GT =
Handle(StepDimTol_GeometricTolerance)::DownCast(theEnt);
// read common data for tolerance
//Standard_Real dim = GT->Magnitude()->ValueComponent();
Handle(StepBasic_MeasureWithUnit) dim3 = GT->Magnitude();
if (dim3.IsNull()) continue;
Standard_Real dim = dim3->ValueComponent();
StepBasic_Unit anUnit = GT->Magnitude()->UnitComponent();
if (GT->Magnitude().IsNull())
{
continue;
}
Handle(StepBasic_MeasureWithUnit) aMWU = GetMeasureWithUnit(GT->Magnitude());
if (aMWU.IsNull())
{
continue;
}
Standard_Real aVal = aMWU->ValueComponent();
StepBasic_Unit anUnit = aMWU->UnitComponent();
if (anUnit.IsNull()) continue;
if (!(anUnit.CaseNum(anUnit.Value()) == 1)) continue;
Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
STEPConstruct_UnitContext anUnitCtx;
anUnitCtx.ComputeFactors(NU);
dim = dim * anUnitCtx.LengthFactor();
aVal = aVal * anUnitCtx.LengthFactor();
//std::cout<<"GeometricTolerance: Magnitude = "<<dim<<std::endl;
Handle(TColStd_HArray1OfReal) arr = new TColStd_HArray1OfReal(1, 1);
arr->SetValue(1, dim);
arr->SetValue(1, aVal);
Handle(TCollection_HAsciiString) aName = GT->Name();
Handle(TCollection_HAsciiString) aDescription = GT->Description();
Handle(StepShape_AdvancedFace) AF = Handle(StepShape_AdvancedFace)::DownCast(RI);
@ -3501,16 +3677,7 @@ static void setDimObjectToXCAF(const Handle(Standard_Transient)& theEnt,
Handle(Standard_Transient) aUpperBound = aTV->UpperBound();
if(aUpperBound.IsNull())
continue;
Handle(StepBasic_MeasureWithUnit) aMWU;
if(aUpperBound->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)) )
aMWU = Handle(StepBasic_MeasureWithUnit)::DownCast(aUpperBound);
else if(aUpperBound->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)) )
{
Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aUpperBound);
aMWU = aReprMeasureItem->GetMeasureWithUnit();
}
Handle(StepBasic_MeasureWithUnit) aMWU = GetMeasureWithUnit(aUpperBound);
if(aMWU.IsNull())
continue;
Standard_Real aVal = aMWU->ValueComponent();
@ -3537,15 +3704,7 @@ static void setDimObjectToXCAF(const Handle(Standard_Transient)& theEnt,
if(aLowerBound.IsNull())
continue;
if(aLowerBound->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)) )
aMWU = Handle(StepBasic_MeasureWithUnit)::DownCast(aLowerBound);
else if(aLowerBound->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)) )
{
Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aLowerBound);
aMWU = aReprMeasureItem->GetMeasureWithUnit();
}
aMWU = GetMeasureWithUnit(aLowerBound);
if(aMWU.IsNull())
continue;
@ -3904,17 +4063,26 @@ static void setGeomTolObjectToXCAF(const Handle(Standard_Transient)& theEnt,
XCAFDimTolObjects_GeomToleranceType aType = XCAFDimTolObjects_GeomToleranceType_None;
getTolType(theEnt, aType);
aTolObj->SetType(aType);
if (!aTolEnt->Magnitude().IsNull()) {
//get value
Standard_Real aVal = aTolEnt->Magnitude()->ValueComponent();
StepBasic_Unit anUnit = aTolEnt->Magnitude()->UnitComponent();
if (anUnit.IsNull()) return;
if (!(anUnit.CaseNum(anUnit.Value()) == 1)) return;
Handle(StepBasic_NamedUnit) NU = anUnit.NamedUnit();
STEPConstruct_UnitContext anUnitCtx;
anUnitCtx.ComputeFactors(NU);
aVal = aVal * anUnitCtx.LengthFactor();
aTolObj->SetValue(aVal);
if (!aTolEnt->Magnitude().IsNull())
{
Handle(StepBasic_MeasureWithUnit) aMWU = GetMeasureWithUnit(aTolEnt->Magnitude());
if (!aMWU.IsNull())
{
// Get value
Standard_Real aVal = aMWU->ValueComponent();
StepBasic_Unit anUnit = aMWU->UnitComponent();
if (!anUnit.IsNull() && anUnit.CaseNum(anUnit.Value()) == 1)
{
Handle(StepBasic_NamedUnit) aNU = anUnit.NamedUnit();
STEPConstruct_UnitContext anUnitCtx;
anUnitCtx.ComputeFactors(aNU);
if (anUnitCtx.LengthFactor() > 0.)
{
aVal = aVal * anUnitCtx.LengthFactor();
}
}
aTolObj->SetValue(aVal);
}
}
//get modifiers
XCAFDimTolObjects_GeomToleranceTypeValue aTypeV = XCAFDimTolObjects_GeomToleranceTypeValue_None;

4
src/STEPCAFControl/STEPCAFControl_Writer.cxx
View File

@ -2553,6 +2553,10 @@ void STEPCAFControl_Writer::WritePresentation(const Handle(XSControl_WorkSession
// Presentation
Handle(StepVisual_TessellatedGeometricSet) aGeomSet = STEPCAFControl_GDTProperty::GetTessellation(thePresentation);
if (aGeomSet.IsNull())
{
return;
}
Handle(StepVisual_TessellatedAnnotationOccurrence) aTAO = new StepVisual_TessellatedAnnotationOccurrence();
aTAO->Init(new TCollection_HAsciiString(), myGDTPrsCurveStyle, aGeomSet);
StepVisual_DraughtingCalloutElement aDCElement;

135
src/STEPConstruct/STEPConstruct_UnitContext.cxx
View File

@ -48,6 +48,7 @@
#include <StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx.hxx>
#include <StepRepr_GlobalUncertaintyAssignedContext.hxx>
#include <StepRepr_GlobalUnitAssignedContext.hxx>
#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
#include <TCollection_HAsciiString.hxx>
#include <UnitsMethods.hxx>
@ -121,13 +122,13 @@ void STEPConstruct_UnitContext::Init(const Standard_Real Tol3d)
Handle(StepBasic_DimensionalExponents) theDimExp = new StepBasic_DimensionalExponents;
theDimExp->Init ( 1., 0., 0., 0., 0., 0., 0. );
Handle(TCollection_HAsciiString) convName = new TCollection_HAsciiString ( uName );
Handle(StepBasic_ConversionBasedUnitAndLengthUnit) convUnit =
Handle(TCollection_HAsciiString) aConvName = new TCollection_HAsciiString(uName);
Handle(StepBasic_ConversionBasedUnitAndLengthUnit) aConvUnit =
new StepBasic_ConversionBasedUnitAndLengthUnit;
convUnit->Init ( theDimExp, convName, measure );
lengthUnit = convUnit;
aConvUnit->Init(theDimExp, aConvName, measure);
lengthUnit = aConvUnit;
}
else lengthUnit = siUnit;
@ -287,60 +288,74 @@ Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepRepr
}
Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepBasic_NamedUnit)& aUnit)
Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepBasic_NamedUnit)& theUnit)
{
//:f3 abv 8 Apr 98: ProSTEP TR8 tr8_as_sd_sw: the case of unrecognized entity
if ( aUnit.IsNull() )
if (theUnit.IsNull())
return -1;
Standard_Integer status = 0;
Standard_Real theFactor= 0.;
Standard_Real theSIUNF = 0.;
Standard_Real theFactor = 0.;
Standard_Real theSIUNF = 0.;
Standard_Real parameter= 0.;
Standard_Boolean parameterDone = Standard_False;
if(aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnit))) {
Handle(StepBasic_ConversionBasedUnit) theCBU =
Handle(StepBasic_ConversionBasedUnit)::DownCast(aUnit);
if(theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnit)))
{
Handle(StepBasic_ConversionBasedUnit) aCBU =
Handle(StepBasic_ConversionBasedUnit)::DownCast(theUnit);
// Handle(StepBasic_DimensionalExponents) theDimExp = theCBU->Dimensions();
Handle(StepBasic_MeasureWithUnit) theMWU;
if(!theCBU.IsNull()) {
theMWU = theCBU->ConversionFactor();
// sln 8.10.2001: the case of unrecognized entity
if(theMWU.IsNull())
return -1;
Handle(StepBasic_MeasureWithUnit) aMWU;
if(!aCBU.IsNull())
{
Handle(Standard_Transient) aConvFactor = aCBU->ConversionFactor();
if (aConvFactor->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
{
aMWU = Handle(StepBasic_MeasureWithUnit)::DownCast(aConvFactor);
}
else if (aConvFactor->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
{
Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aConvFactor);
aMWU = aReprMeasureItem->GetMeasureWithUnit();
}
// sln 8.10.2001: the case of unrecognized entity
if(aMWU.IsNull())
return -1;
//if (!theMWU->IsKind(STANDARD_TYPE(StepBasic_LengthMeasureWithUnit))) { gka
// return 2;
// return 2;
//}
Handle(StepBasic_NamedUnit) theTargetUnit = theMWU->UnitComponent().NamedUnit();
Handle(StepBasic_NamedUnit) theTargetUnit = aMWU->UnitComponent().NamedUnit();
//StepBasic_Unit theTargetUnit = theMWU->UnitComponent();
Standard_Real theSIPFactor = 1.;
//:f5 abv 24 Apr 98: ProSTEP TR8 tr8_bv1_tc: INCHES
//gka Handle(StepBasic_SiUnitAndLengthUnit) theSUALU =
// Handle(StepBasic_SiUnitAndLengthUnit)::DownCast(theTargetUnit);
// Handle(StepBasic_SiUnit) theSIU;
// if ( ! theSUALU.IsNull() ) theSIU = Handle(StepBasic_SiUnit)::DownCast(theSUALU);
Handle(StepBasic_SiUnit) theSIU = //f5
Handle(StepBasic_SiUnit)::DownCast(theTargetUnit);//f5
if (!theSIU.IsNull()) {
if (theSIU->HasPrefix()) {
// Treat the prefix
StepBasic_SiPrefix aPrefix = theSIU->Prefix();
theSIPFactor = ConvertSiPrefix(aPrefix);
}
// Treat the SiUnitName
if (!SiUnitNameFactor(theSIU,theSIUNF)) status = 11; // et continue
//std::cout << "The SiUnitNameFactor is :";
//std::cout << theSIUNF << std::endl;
//gka
//Handle(StepBasic_SiUnitAndLengthUnit) theSUALU =
//Handle(StepBasic_SiUnitAndLengthUnit)::DownCast(theTargetUnit);
//Handle(StepBasic_SiUnit) theSIU;
//if ( ! theSUALU.IsNull() ) theSIU = Handle(StepBasic_SiUnit)::DownCast(theSUALU);
Handle(StepBasic_SiUnit) theSIU = Handle(StepBasic_SiUnit)::DownCast(theTargetUnit); //f5
if (!theSIU.IsNull())
{
if (theSIU->HasPrefix())
{
// Treat the prefix
StepBasic_SiPrefix aPrefix = theSIU->Prefix();
theSIPFactor = ConvertSiPrefix(aPrefix);
}
// Treat the SiUnitName
if (!SiUnitNameFactor(theSIU,theSIUNF)) status = 11; // et continue
//std::cout << "The SiUnitNameFactor is :";
//std::cout << theSIUNF << std::endl;
}
else {
// std::cout << "Recursive algo required - Aborted" << std::endl;
return 3;
else
{
//std::cout << "Recursive algo required - Aborted" << std::endl;
return 3;
}
Standard_Real theMVAL = theMWU->ValueComponent();
Standard_Real theMVAL = aMWU->ValueComponent();
theFactor = theSIPFactor * theMVAL; // * theSIUNF * pow(10.,theLExp)
}
parameter = theFactor;
@ -353,9 +368,10 @@ Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepBasi
std::cout << "Error in the file : parameter double defined" << std::endl;
#endif
}
}
else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnit))) {
Handle(StepBasic_SiUnit) theSIU = Handle(StepBasic_SiUnit)::DownCast(aUnit);
}
else if (theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnit)))
{
Handle(StepBasic_SiUnit) theSIU = Handle(StepBasic_SiUnit)::DownCast(theUnit);
Standard_Real theSIPFactor = 1.;
if (theSIU->HasPrefix()) {
// Treat the prefix
@ -388,8 +404,9 @@ Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepBasi
return 0;
}
if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndLengthUnit))||
aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndLengthUnit))) {
if (theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndLengthUnit))||
theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndLengthUnit)))
{
#ifdef METER
lengthFactor = parameter;
#else
@ -404,18 +421,21 @@ Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepBasi
#endif
}
} // end of LengthUnit
else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit))||
aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndPlaneAngleUnit))) {
else if (theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)) ||
theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndPlaneAngleUnit)))
{
planeAngleFactor = parameter;
planeAngleDone = Standard_True;
} // end of PlaneAngleUnit
else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndSolidAngleUnit))||
aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndSolidAngleUnit))) {
else if (theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndSolidAngleUnit)) ||
theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndSolidAngleUnit)))
{
solidAngleFactor = parameter;
solidAngleDone = Standard_True;
} // end of SolidAngleUnit
else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndAreaUnit)) ||
aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndAreaUnit))) {
else if (theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndAreaUnit)) ||
theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndAreaUnit)))
{
Standard_Real af;
#ifdef METER
af = parameter;
@ -425,8 +445,9 @@ Standard_Integer STEPConstruct_UnitContext::ComputeFactors(const Handle(StepBasi
areaDone = Standard_True;
areaFactor = pow(af,2);
}
else if (aUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndVolumeUnit)) ||
aUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndVolumeUnit))) {
else if (theUnit->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndVolumeUnit)) ||
theUnit->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndVolumeUnit)))
{
Standard_Real af;
#ifdef METER
af = parameter;

49
src/STEPControl/STEPControl_ActorRead.cxx
View File

@ -87,6 +87,10 @@
#include <StepShape_ShapeDefinitionRepresentation.hxx>
#include <StepShape_ShapeRepresentation.hxx>
#include <StepShape_ShellBasedSurfaceModel.hxx>
#include <StepVisual_TriangulatedFace.hxx>
#include <StepVisual_TessellatedShell.hxx>
#include <StepVisual_TessellatedShapeRepresentation.hxx>
#include <StepVisual_TessellatedSolid.hxx>
#include <StepToGeom.hxx>
#include <StepToTopoDS_Builder.hxx>
#include <StepToTopoDS_DataMapOfTRI.hxx>
@ -94,6 +98,7 @@
#include <StepToTopoDS_Tool.hxx>
#include <StepToTopoDS_TranslateFace.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Compound.hxx>
@ -102,6 +107,7 @@
#include <TopoDS_Shape.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Solid.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_MapOfShape.hxx>
@ -208,6 +214,7 @@ STEPControl_ActorRead::STEPControl_ActorRead()
myMaxTol(0.0)
{
}
// ============================================================================
// Method : STEPControl_ActorRead::Recognize
// Purpose : tells if an entity is valid for transfer by this Actor
@ -235,6 +242,8 @@ Standard_Boolean STEPControl_ActorRead::Recognize
return Standard_False;
}
const Standard_Boolean aCanReadTessGeom = (Interface_Static::IVal("read.step.tessellated") != 0);
if (start->IsKind(STANDARD_TYPE(StepShape_FacetedBrep))) return Standard_True;
if (start->IsKind(STANDARD_TYPE(StepShape_BrepWithVoids))) return Standard_True;
if (start->IsKind(STANDARD_TYPE(StepShape_ManifoldSolidBrep))) return Standard_True;
@ -245,6 +254,10 @@ Standard_Boolean STEPControl_ActorRead::Recognize
if (start->IsKind(STANDARD_TYPE(StepShape_FaceSurface))) return Standard_True;
if (start->IsKind(STANDARD_TYPE(StepShape_EdgeBasedWireframeModel))) return Standard_True;
if (start->IsKind(STANDARD_TYPE(StepShape_FaceBasedSurfaceModel))) return Standard_True;
if (aCanReadTessGeom && start->IsKind(STANDARD_TYPE(StepVisual_TessellatedFace))) return Standard_True;
if (aCanReadTessGeom && start->IsKind(STANDARD_TYPE(StepVisual_TessellatedShell))) return Standard_True;
if (aCanReadTessGeom && start->IsKind(STANDARD_TYPE(StepVisual_TessellatedSolid))) return Standard_True;
if (aCanReadTessGeom && start->IsKind(STANDARD_TYPE(StepVisual_TessellatedShapeRepresentation))) return Standard_True;
// REPRESENTATION_RELATIONSHIP et consorts : on regarde le contenu ...
@ -853,6 +866,7 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(
gp_Trsf aTrsf;
Message_ProgressScope aPSRoot(theProgress, "Sub-assembly", isManifold ? 1 : 2);
Message_ProgressScope aPS (aPSRoot.Next(), "Transfer", nb);
TopTools_IndexedMapOfShape aCompoundedShapes;
for (Standard_Integer i = 1; i <= nb && aPS.More(); i ++)
{
Message_ProgressRange aRange = aPS.Next();
@ -909,8 +923,13 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(
TopoDS_Shape theResult = TransferBRep::ShapeResult (binder);
if (!theResult.IsNull()) {
OneResult = theResult;
B.Add(comp, theResult);
nsh ++;
if (!aCompoundedShapes.Contains(theResult))
{
aCompoundedShapes.Add(theResult);
TopExp::MapShapes(theResult, aCompoundedShapes);
B.Add(comp, theResult);
nsh++;
}
}
}
@ -1390,6 +1409,8 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity
// Start progress scope (no need to check if progress exists -- it is safe)
Message_ProgressScope aPS(theProgress, "Transfer stage", isManifold ? 2 : 1);
const Standard_Boolean aReadTessellatedWhenNoBRepOnly = (Interface_Static::IVal("read.step.tessellated") == 2);
Standard_Boolean aHasGeom = Standard_True;
try {
OCC_CATCH_SIGNALS
Message_ProgressRange aRange = aPS.Next();
@ -1425,6 +1446,27 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity
myShapeBuilder.Init(GetCasted(StepShape_FaceBasedSurfaceModel, start), TP);
found = Standard_True;
}
// TODO: Normally, StepVisual_Tessellated* entities should be processed after
// StepShape_* entities in order to resolve links to BRep topological objects.
// Currently it is not guaranteed and might require changes in the processing order.
else if (start->IsKind(STANDARD_TYPE(StepVisual_TessellatedSolid)))
{
myShapeBuilder.Init(GetCasted(StepVisual_TessellatedSolid, start), TP,
aReadTessellatedWhenNoBRepOnly, aHasGeom, aRange);
found = Standard_True;
}
else if (start->IsKind(STANDARD_TYPE(StepVisual_TessellatedShell)))
{
myShapeBuilder.Init(GetCasted(StepVisual_TessellatedShell, start), TP,
aReadTessellatedWhenNoBRepOnly, aHasGeom, aRange);
found = Standard_True;
}
else if (start->IsKind(STANDARD_TYPE(StepVisual_TessellatedFace)))
{
myShapeBuilder.Init(GetCasted(StepVisual_TessellatedFace, start), TP,
aReadTessellatedWhenNoBRepOnly, aHasGeom);
found = Standard_True;
}
}
catch(Standard_Failure const&) {
TP->AddFail(start,"Exeption is raised. Entity was not translated.");
@ -1438,7 +1480,8 @@ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity
if (found && myShapeBuilder.IsDone()) {
mappedShape = myShapeBuilder.Value();
// Apply ShapeFix (on manifold shapes only. Non-manifold topology is processed separately: ssv; 13.11.2010)
if (isManifold) {
if (isManifold && aHasGeom)
{
Handle(Standard_Transient) info;
mappedShape =
XSAlgo::AlgoContainer()->ProcessShape( mappedShape, myPrecision, myMaxTol,

224
src/STEPControl/STEPControl_ActorWrite.cxx
View File

@ -19,6 +19,7 @@
#include <BRep_Builder.hxx>
#include <BRep_Tool.hxx>
#include <BRep_TEdge.hxx>
#include <BRepTools_Modifier.hxx>
#include <Geom_Curve.hxx>
#include <Geom_Line.hxx>
@ -70,6 +71,9 @@
#include <StepShape_ShellBasedSurfaceModel.hxx>
#include <StepShape_TopologicalRepresentationItem.hxx>
#include <StepShape_VertexPoint.hxx>
#include <StepVisual_TessellatedItem.hxx>
#include <StepVisual_TessellatedShapeRepresentation.hxx>
#include <StepVisual_TessellatedSolid.hxx>
#include <TCollection_HAsciiString.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
#include <TopExp.hxx>
@ -80,7 +84,6 @@
#include <TopoDS_Shape.hxx>
#include <TopoDS_Solid.hxx>
#include <TopoDSToStep.hxx>
#include <TopoDSToStep_Builder.hxx>
#include <TopoDSToStep_FacetedTool.hxx>
#include <TopoDSToStep_MakeBrepWithVoids.hxx>
#include <TopoDSToStep_MakeFacetedBrep.hxx>
@ -169,6 +172,58 @@ static void DumpWhatIs(const TopoDS_Shape& S) {
}
#endif
static Standard_Boolean hasGeometry(const TopoDS_Shape& theShape)
{
TopAbs_ShapeEnum aType = theShape.ShapeType();
if (aType == TopAbs_VERTEX)
{
return Standard_True;
}
else if (aType == TopAbs_EDGE)
{
Handle(BRep_TEdge) TE = Handle(BRep_TEdge)::DownCast(theShape.TShape());
BRep_ListIteratorOfListOfCurveRepresentation itrc(TE->Curves());
while (itrc.More())
{
const Handle(BRep_CurveRepresentation)& CR = itrc.Value();
Standard_Boolean aHasGeometry = (CR->IsCurve3D() && !CR->Curve3D().IsNull())
|| CR->IsCurveOnSurface()
|| CR->IsRegularity()
|| (CR->IsPolygon3D() && !CR->Polygon3D().IsNull())
|| CR->IsPolygonOnTriangulation()
|| CR->IsPolygonOnSurface();
if (!aHasGeometry)
return Standard_False;
itrc.Next();
}
return Standard_True;
}
else if (aType == TopAbs_FACE)
{
Handle(BRep_TFace) TF = Handle(BRep_TFace)::DownCast(theShape.TShape());
if (!TF->Surface().IsNull())
{
return Standard_True;
}
}
else
{
TopoDS_Iterator anIt(theShape, Standard_False, Standard_False);
for (; anIt.More(); anIt.Next())
{
const TopoDS_Shape& aShape = anIt.Value();
Standard_Boolean aHasGeometry = hasGeometry(aShape);
if (!aHasGeometry)
return Standard_False;
}
return Standard_True;
}
return Standard_False;
}
//=======================================================================
// Function : IsManifoldShape
// Purpose : Used to define whether the passed shape has manifold
@ -904,25 +959,30 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
// BRepTools_Modifier DMT(aShape,DM);
// if ( DMT.IsDone() ) aShape = DMT.ModifiedShape ( aShape );
//// aShape = TopoDSToStep::DirectFaces(xShape);
Message_ProgressScope aPS1(aPS.Next(), NULL, 2);
TopoDS_Shape aShape = xShape;
Handle(Standard_Transient) info;
Standard_Real maxTol = Interface_Static::RVal("read.maxprecision.val");
Message_ProgressScope aPS1 (aPS.Next(), NULL, 2);
if (hasGeometry(aShape))
{
Standard_Real maxTol = Interface_Static::RVal("read.maxprecision.val");
TopoDS_Shape aShape;
aShape = XSAlgo::AlgoContainer()->ProcessShape(xShape, Tol, maxTol,
"write.step.resource.name",
"write.step.sequence", info,
aPS1.Next());
if (aPS1.UserBreak())
return Handle(Transfer_Binder)();
aShape = XSAlgo::AlgoContainer()->ProcessShape(xShape, Tol, maxTol,
"write.step.resource.name",
"write.step.sequence", info,
aPS1.Next());
if (aPS1.UserBreak())
return Handle(Transfer_Binder)();
}
if (!isManifold) {
if (!isManifold)
{
mergeInfoForNM(FP, info);
}
// create a STEP entity corresponding to shape
Handle(StepGeom_GeometricRepresentationItem) item;
Handle(StepGeom_GeometricRepresentationItem) item, itemTess;
switch (trmode)
{
case STEPControl_ManifoldSolidBrep:
@ -938,28 +998,33 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
if ( nbShells >1 ) {
TopoDSToStep_MakeBrepWithVoids MkBRepWithVoids(aSolid,FP, aPS1.Next());
MkBRepWithVoids.Tolerance() = Tol;
if (MkBRepWithVoids.IsDone()) {
if (MkBRepWithVoids.IsDone())
{
item = MkBRepWithVoids.Value();
}
else nbShells = 1; //smth went wrong; let it will be just Manifold
itemTess = MkBRepWithVoids.TessellatedValue();
}
else nbShells = 1; //smth went wrong; let it will be just Manifold
}
if ( nbShells ==1 ) {
TopoDSToStep_MakeManifoldSolidBrep MkManifoldSolidBrep(aSolid,FP, aPS1.Next());
TopoDSToStep_MakeManifoldSolidBrep MkManifoldSolidBrep(aSolid,FP, aPS1.Next());
MkManifoldSolidBrep.Tolerance() = Tol;
if (MkManifoldSolidBrep.IsDone()) {
if (MkManifoldSolidBrep.IsDone())
{
item = MkManifoldSolidBrep.Value();
}
}
itemTess = MkManifoldSolidBrep.TessellatedValue();
}
}
}
else if (aShape.ShapeType() == TopAbs_SHELL) {
TopoDS_Shell aShell = TopoDS::Shell(aShape);
TopoDSToStep_MakeManifoldSolidBrep MkManifoldSolidBrep(aShell,FP, aPS1.Next());
MkManifoldSolidBrep.Tolerance() = Tol;
if (MkManifoldSolidBrep.IsDone()) {
if (MkManifoldSolidBrep.IsDone())
{
item = MkManifoldSolidBrep.Value();
}
}
itemTess = MkManifoldSolidBrep.TessellatedValue();
}
}
break;
}
case STEPControl_BrepWithVoids:
@ -968,8 +1033,10 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
TopoDS_Solid aSolid = TopoDS::Solid(aShape);
TopoDSToStep_MakeBrepWithVoids MkBRepWithVoids(aSolid,FP, aPS1.Next());
MkBRepWithVoids.Tolerance() = Tol;
if (MkBRepWithVoids.IsDone()) {
if (MkBRepWithVoids.IsDone())
{
item = MkBRepWithVoids.Value();
itemTess = MkBRepWithVoids.TessellatedValue();
}
}
break;
@ -991,9 +1058,11 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
TopoDS_Solid aSolid = TopoDS::Solid(aShape);
TopoDSToStep_MakeFacetedBrep MkFacetedBrep(aSolid,FP, aPS1.Next());
MkFacetedBrep.Tolerance() = Tol;
if (MkFacetedBrep.IsDone()) {
if (MkFacetedBrep.IsDone())
{
item = MkFacetedBrep.Value();
}
itemTess = MkFacetedBrep.TessellatedValue();
}
}
break;
}
@ -1015,9 +1084,11 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
TopoDSToStep_MakeFacetedBrepAndBrepWithVoids
MkFacetedBrepAndBrepWithVoids(aSolid,FP, aPS1.Next());
MkFacetedBrepAndBrepWithVoids.Tolerance() = Tol;
if (MkFacetedBrepAndBrepWithVoids.IsDone()) {
if (MkFacetedBrepAndBrepWithVoids.IsDone())
{
item = MkFacetedBrepAndBrepWithVoids.Value();
}
itemTess = MkFacetedBrepAndBrepWithVoids.TessellatedValue();
}
}
break;
}
@ -1028,28 +1099,34 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
TopoDSToStep_MakeShellBasedSurfaceModel
MkShellBasedSurfaceModel(aSolid, FP, aPS1.Next());
MkShellBasedSurfaceModel.Tolerance() = Tol;
if (MkShellBasedSurfaceModel.IsDone()) {
if (MkShellBasedSurfaceModel.IsDone())
{
item = MkShellBasedSurfaceModel.Value();
}
itemTess = MkShellBasedSurfaceModel.TessellatedValue();
}
}
else if (aShape.ShapeType() == TopAbs_SHELL) {
TopoDS_Shell aShell = TopoDS::Shell(aShape);
// Non-manifold topology is stored via NMSSR containing series of SBSM (ssv; 13.11.2010)
TopoDSToStep_MakeShellBasedSurfaceModel MkShellBasedSurfaceModel(aShell, FP, aPS1.Next());
MkShellBasedSurfaceModel.Tolerance() = Tol;
if (MkShellBasedSurfaceModel.IsDone()) {
if (MkShellBasedSurfaceModel.IsDone())
{
item = MkShellBasedSurfaceModel.Value();
itemTess = MkShellBasedSurfaceModel.TessellatedValue();
}
}
else if (aShape.ShapeType() == TopAbs_FACE) {
TopoDS_Face aFace = TopoDS::Face(aShape);
TopoDSToStep_MakeShellBasedSurfaceModel
TopoDSToStep_MakeShellBasedSurfaceModel
MkShellBasedSurfaceModel(aFace, FP, aPS1.Next());
MkShellBasedSurfaceModel.Tolerance() = Tol;
if (MkShellBasedSurfaceModel.IsDone()) {
if (MkShellBasedSurfaceModel.IsDone())
{
item = MkShellBasedSurfaceModel.Value();
}
}
itemTess = MkShellBasedSurfaceModel.TessellatedValue();
}
}
break;
}
case STEPControl_GeometricCurveSet:
@ -1097,24 +1174,48 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
}
default: break;
}
if ( item.IsNull() ) continue;
if ( item.IsNull() && itemTess.IsNull() ) continue;
// add resulting item to the FP
ItemSeq->Append(item);
Handle(TransferBRep_ShapeMapper) submapper;
if ( xShape.IsSame ( mapper->Value() ) )
submapper = Handle(TransferBRep_ShapeMapper)::DownCast ( start );
if ( submapper.IsNull() ) submapper = TransferBRep::ShapeMapper (FP,xShape);
Handle(Transfer_Binder) subbind = FP->Find ( submapper );
if ( subbind.IsNull() ) {
subbind = TransientResult ( item );
FP->Bind ( submapper, subbind );
if (!item.IsNull())
{
ItemSeq->Append(item);
Handle(TransferBRep_ShapeMapper) submapper;
if (xShape.IsSame(mapper->Value()))
submapper = Handle(TransferBRep_ShapeMapper)::DownCast(start);
if (submapper.IsNull())
submapper = TransferBRep::ShapeMapper(FP, xShape);
Handle(Transfer_Binder) subbind = FP->Find(submapper);
if (subbind.IsNull())
{
subbind = TransientResult(item);
FP->Bind(submapper, subbind);
}
else
subbind->AddResult(TransientResult(item));
}
if (!itemTess.IsNull())
{
ItemSeq->Append(itemTess);
Handle(TransferBRep_ShapeMapper) submapper;
if (xShape.IsSame(mapper->Value()))
submapper = Handle(TransferBRep_ShapeMapper)::DownCast(start);
if (submapper.IsNull())
submapper = TransferBRep::ShapeMapper(FP, xShape);
Handle(Transfer_Binder) subbind = FP->Find(submapper);
if (subbind.IsNull())
{
subbind = TransientResult(itemTess);
FP->Bind(submapper, subbind);
}
else
subbind->AddResult(TransientResult(itemTess));
}
else subbind->AddResult ( TransientResult ( item ) );
//:abv 24Jan99 CAX-IF TRJ3: Update FinderProcess map to take into account shape processing
// UpdateMap ( xShape, CSMT, DMT, FP );
XSAlgo::AlgoContainer()->MergeTransferInfo(FP, info);
if (!info.IsNull())
XSAlgo::AlgoContainer()->MergeTransferInfo(FP, info);
}
// - Make Shape Representation
@ -1210,6 +1311,8 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
ShapeRepr1 = new StepShape_GeometricallyBoundedWireframeShapeRepresentation;
else if (items->Value(j)->IsKind(STANDARD_TYPE(StepShape_FacetedBrep)))
ShapeRepr1 = new StepShape_FacetedBrepShapeRepresentation;
else if (items->Value(j)->IsKind(STANDARD_TYPE(StepVisual_TessellatedItem)))
ShapeRepr1 = new StepVisual_TessellatedShapeRepresentation;
else ShapeRepr1 = new StepShape_ShapeRepresentation;
Handle(StepRepr_HArray1OfRepresentationItem) repr1 = new StepRepr_HArray1OfRepresentationItem(1,2);
@ -1233,6 +1336,33 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
}
}
else {
Standard_Integer nC = 0;
for (Standard_Integer i = 1; i <= items->Length(); i++)
{
if (!items->Value(i)->IsKind(STANDARD_TYPE(StepVisual_TessellatedItem)))
continue;
++nC;
}
if (nC > 0)
{
Handle(StepRepr_HArray1OfRepresentationItem) itemsTess = new StepRepr_HArray1OfRepresentationItem(1, nC);
Standard_Integer i = 1;
for (Standard_Integer j = 1; j <= items->Length(); j++)
{
if (!items->Value(j)->IsKind(STANDARD_TYPE(StepVisual_TessellatedItem)))
continue;
itemsTess->SetValue(i++, items->Value(j));
}
Handle(StepShape_ShapeRepresentation) shapeTessRepr = new StepVisual_TessellatedShapeRepresentation;
shapeTessRepr->SetItems(itemsTess);
STEPConstruct_UnitContext mk1;
mk1.Init(Tol);
shapeTessRepr->SetContextOfItems(mk1.Value());
shapeTessRepr->SetName(new TCollection_HAsciiString(""));
aSeqBindRelation.Append(TransientResult(shapeTessRepr));
}
if (!useExistingNMSSR)
shapeRep->SetItems(items);
else {

16
src/STEPControl/STEPControl_Controller.cxx
View File

@ -247,6 +247,22 @@ STEPControl_Controller::STEPControl_Controller ()
Interface_Static::Init("step", "read.step.codepage", '&', "eval iso8859-9"); // Resource_FormatType_iso8859_9
Interface_Static::SetCVal("read.step.codepage", "UTF8");
// Tessellated geometry reading: Off by default
Interface_Static::Init("step", "read.step.tessellated", 'e', "");
Interface_Static::Init("step", "read.step.tessellated", '&', "enum 0");
Interface_Static::Init("step", "read.step.tessellated", '&', "eval Off"); // 0
Interface_Static::Init("step", "read.step.tessellated", '&', "eval On"); // 1
Interface_Static::Init("step", "read.step.tessellated", '&', "eval OnNoBRep"); // 2
Interface_Static::SetCVal("read.step.tessellated", "On");
// Tessellated geometry writing: Off by default
Interface_Static::Init("step", "write.step.tessellated", 'e', "");
Interface_Static::Init("step", "write.step.tessellated", '&', "enum 0");
Interface_Static::Init("step", "write.step.tessellated", '&', "eval Off"); // 0
Interface_Static::Init("step", "write.step.tessellated", '&', "eval On"); // 1
Interface_Static::Init("step", "write.step.tessellated", '&', "eval OnNoBRep"); // 2
Interface_Static::SetCVal("write.step.tessellated", "OnNoBRep");
Standard_STATIC_ASSERT((int)Resource_FormatType_iso8859_9 - (int)Resource_FormatType_CP1250 == 17); // "Error: Invalid Codepage Enumeration"
init = Standard_True;

24
src/STEPControl/STEPControl_Reader.cxx
View File

@ -52,6 +52,7 @@
#include <StepRepr_RepresentationContext.hxx>
#include <StepRepr_RepresentationMap.hxx>
#include <StepRepr_RepresentationRelationship.hxx>
#include <StepRepr_ReprItemAndMeasureWithUnit.hxx>
#include <StepRepr_ShapeAspect.hxx>
#include <StepShape_ManifoldSolidBrep.hxx>
#include <StepShape_ShapeDefinitionRepresentation.hxx>
@ -514,21 +515,32 @@ Standard_Boolean STEPControl_Reader::findUnits(
Handle(StepBasic_HArray1OfNamedUnit) anUnits = aContext->Units();
Standard_Integer nbU = aContext->NbUnits();
Standard_Integer nbFind = 0;
for (Standard_Integer i = 1; i <= nbU; i++) {
for (Standard_Integer i = 1; i <= nbU; i++)
{
Handle(StepBasic_NamedUnit) aNamedUnit = aContext->UnitsValue(i);
Handle(StepBasic_ConversionBasedUnit) aConvUnit =
Handle(StepBasic_ConversionBasedUnit)::DownCast(aNamedUnit);
Standard_Integer anInd = 0;
TCollection_AsciiString aName;
Standard_Real anUnitFact = 0;
if( !aConvUnit.IsNull() )
if(!aConvUnit.IsNull())
{
Handle(StepBasic_MeasureWithUnit) aMeasWithUnit =
aConvUnit->ConversionFactor();
Handle(StepBasic_MeasureWithUnit) aMeasWithUnit;
Handle(Standard_Transient) aConvFactor = aConvUnit->ConversionFactor();
if (aConvFactor->IsKind(STANDARD_TYPE(StepBasic_MeasureWithUnit)))
{
aMeasWithUnit = Handle(StepBasic_MeasureWithUnit)::DownCast(aConvFactor);
}
else if (aConvFactor->IsKind(STANDARD_TYPE(StepRepr_ReprItemAndMeasureWithUnit)))
{
Handle(StepRepr_ReprItemAndMeasureWithUnit) aReprMeasureItem =
Handle(StepRepr_ReprItemAndMeasureWithUnit)::DownCast(aConvFactor);
aMeasWithUnit = aReprMeasureItem->GetMeasureWithUnit();
}
if(aMeasWithUnit.IsNull())
continue;
if( aMeasWithUnit->IsKind(STANDARD_TYPE(StepBasic_LengthMeasureWithUnit)) )
anInd = 1;
else if( aMeasWithUnit->IsKind(STANDARD_TYPE(StepBasic_PlaneAngleMeasureWithUnit)) )

31
src/StepAP214/StepAP214_Protocol.cxx
View File

@ -757,6 +757,22 @@ static Standard_CString schemaAP242DIS = "AP242_MANAGED_MODEL_BASED_3D_ENGINEERI
#include <StepVisual_SurfaceStyleRendering.hxx>
#include <StepVisual_SurfaceStyleRenderingWithProperties.hxx>
#include <StepVisual_TessellatedConnectingEdge.hxx>
#include <StepVisual_TessellatedEdge.hxx>
#include <StepVisual_TessellatedPointSet.hxx>
#include <StepVisual_TessellatedShapeRepresentation.hxx>
#include <StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.hxx>
#include <StepVisual_TessellatedShell.hxx>
#include <StepVisual_TessellatedSolid.hxx>
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <StepVisual_TessellatedVertex.hxx>
#include <StepVisual_TessellatedWire.hxx>
#include <StepVisual_TriangulatedFace.hxx>
#include <StepVisual_ComplexTriangulatedFace.hxx>
#include <StepVisual_ComplexTriangulatedSurfaceSet.hxx>
#include <StepVisual_CubicBezierTessellatedEdge.hxx>
#include <StepVisual_CubicBezierTriangulatedFace.hxx>
static int THE_StepAP214_Protocol_init = 0;
static Interface_DataMapOfTransientInteger types(803);
@ -1472,6 +1488,21 @@ StepAP214_Protocol::StepAP214_Protocol ()
types.Bind (STANDARD_TYPE(StepVisual_SurfaceStyleRenderingWithProperties), 723);
types.Bind(STANDARD_TYPE(StepVisual_RepositionedTessellatedGeometricSet), 802);
types.Bind(STANDARD_TYPE(StepVisual_RepositionedTessellatedItem), 803);
types.Bind(STANDARD_TYPE(StepVisual_TessellatedConnectingEdge), 804);
types.Bind(STANDARD_TYPE(StepVisual_TessellatedEdge), 805);
types.Bind(STANDARD_TYPE(StepVisual_TessellatedPointSet), 806);
types.Bind(STANDARD_TYPE(StepVisual_TessellatedShapeRepresentation), 807);
types.Bind(STANDARD_TYPE(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters), 808);
types.Bind(STANDARD_TYPE(StepVisual_TessellatedShell), 809);
types.Bind(STANDARD_TYPE(StepVisual_TessellatedSolid), 810);
types.Bind(STANDARD_TYPE(StepVisual_TessellatedStructuredItem), 811);
types.Bind(STANDARD_TYPE(StepVisual_TessellatedVertex), 812);
types.Bind(STANDARD_TYPE(StepVisual_TessellatedWire), 813);
types.Bind(STANDARD_TYPE(StepVisual_TriangulatedFace), 814);
types.Bind(STANDARD_TYPE(StepVisual_ComplexTriangulatedFace), 815);
types.Bind(STANDARD_TYPE(StepVisual_ComplexTriangulatedSurfaceSet), 816);
types.Bind(STANDARD_TYPE(StepVisual_CubicBezierTessellatedEdge), 817);
types.Bind(STANDARD_TYPE(StepVisual_CubicBezierTriangulatedFace), 818);
}

32
src/StepBasic/StepBasic_ConversionBasedUnit.cxx
View File

@ -15,42 +15,40 @@
#include <Standard_Type.hxx>
#include <StepBasic_ConversionBasedUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <TCollection_HAsciiString.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ConversionBasedUnit,StepBasic_NamedUnit)
StepBasic_ConversionBasedUnit::StepBasic_ConversionBasedUnit () {}
void StepBasic_ConversionBasedUnit::Init(
const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
void StepBasic_ConversionBasedUnit::Init(const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor)
{
// --- classe own fields ---
name = aName;
conversionFactor = aConversionFactor;
// --- classe inherited fields ---
StepBasic_NamedUnit::Init(aDimensions);
// --- classe own fields ---
myName = theName;
myConversionFactor = theConversionFactor;
// --- classe inherited fields ---
StepBasic_NamedUnit::Init(theDimensions);
}
void StepBasic_ConversionBasedUnit::SetName(const Handle(TCollection_HAsciiString)& aName)
void StepBasic_ConversionBasedUnit::SetName(const Handle(TCollection_HAsciiString)& theName)
{
name = aName;
myName = theName;
}
Handle(TCollection_HAsciiString) StepBasic_ConversionBasedUnit::Name() const
{
return name;
return myName;
}
void StepBasic_ConversionBasedUnit::SetConversionFactor(const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
void StepBasic_ConversionBasedUnit::SetConversionFactor(const Handle(Standard_Transient)& theConversionFactor)
{
conversionFactor = aConversionFactor;
myConversionFactor = theConversionFactor;
}
Handle(StepBasic_MeasureWithUnit) StepBasic_ConversionBasedUnit::ConversionFactor() const
Handle(Standard_Transient) StepBasic_ConversionBasedUnit::ConversionFactor() const
{
return conversionFactor;
return myConversionFactor;
}

15
src/StepBasic/StepBasic_ConversionBasedUnit.hxx
View File

@ -22,7 +22,6 @@
#include <StepBasic_NamedUnit.hxx>
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
class StepBasic_DimensionalExponents;
@ -39,15 +38,17 @@ public:
//! Returns a ConversionBasedUnit
Standard_EXPORT StepBasic_ConversionBasedUnit();
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& aDimensions, const Handle(TCollection_HAsciiString)& aName, const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor);
Standard_EXPORT void SetName (const Handle(TCollection_HAsciiString)& aName);
Standard_EXPORT void SetName (const Handle(TCollection_HAsciiString)& theName);
Standard_EXPORT Handle(TCollection_HAsciiString) Name() const;
Standard_EXPORT void SetConversionFactor (const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
Standard_EXPORT void SetConversionFactor (const Handle(Standard_Transient)& theConversionFactor);
Standard_EXPORT Handle(StepBasic_MeasureWithUnit) ConversionFactor() const;
Standard_EXPORT Handle(Standard_Transient) ConversionFactor() const;
@ -62,8 +63,8 @@ protected:
private:
Handle(TCollection_HAsciiString) name;
Handle(StepBasic_MeasureWithUnit) conversionFactor;
Handle(TCollection_HAsciiString) myName;
Handle(Standard_Transient) myConversionFactor;
};

19
src/StepBasic/StepBasic_ConversionBasedUnitAndLengthUnit.cxx
View File

@ -17,33 +17,32 @@
#include <StepBasic_ConversionBasedUnitAndLengthUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_LengthUnit.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <TCollection_HAsciiString.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ConversionBasedUnitAndLengthUnit,StepBasic_ConversionBasedUnit)
StepBasic_ConversionBasedUnitAndLengthUnit::StepBasic_ConversionBasedUnitAndLengthUnit () {}
void StepBasic_ConversionBasedUnitAndLengthUnit::Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
void StepBasic_ConversionBasedUnitAndLengthUnit::Init(const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor)
{
// --- ANDOR componant fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
StepBasic_ConversionBasedUnit::Init(theDimensions, theName, theConversionFactor);
// --- ANDOR componant fields ---
lengthUnit = new StepBasic_LengthUnit();
lengthUnit->Init(aDimensions);
myLengthUnit = new StepBasic_LengthUnit();
myLengthUnit->Init(theDimensions);
}
void StepBasic_ConversionBasedUnitAndLengthUnit::SetLengthUnit(const Handle(StepBasic_LengthUnit)& aLengthUnit)
void StepBasic_ConversionBasedUnitAndLengthUnit::SetLengthUnit(const Handle(StepBasic_LengthUnit)& theLengthUnit)
{
lengthUnit = aLengthUnit;
myLengthUnit = theLengthUnit;
}
Handle(StepBasic_LengthUnit) StepBasic_ConversionBasedUnitAndLengthUnit::LengthUnit() const
{
return lengthUnit;
return myLengthUnit;
}

9
src/StepBasic/StepBasic_ConversionBasedUnitAndLengthUnit.hxx
View File

@ -24,7 +24,6 @@
class StepBasic_LengthUnit;
class StepBasic_DimensionalExponents;
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
class StepBasic_ConversionBasedUnitAndLengthUnit;
@ -40,9 +39,11 @@ public:
//! Returns a ConversionBasedUnitAndLengthUnit
Standard_EXPORT StepBasic_ConversionBasedUnitAndLengthUnit();
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& aDimensions, const Handle(TCollection_HAsciiString)& aName, const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor);
Standard_EXPORT void SetLengthUnit (const Handle(StepBasic_LengthUnit)& aLengthUnit);
Standard_EXPORT void SetLengthUnit (const Handle(StepBasic_LengthUnit)& theLengthUnit);
Standard_EXPORT Handle(StepBasic_LengthUnit) LengthUnit() const;
@ -59,7 +60,7 @@ protected:
private:
Handle(StepBasic_LengthUnit) lengthUnit;
Handle(StepBasic_LengthUnit) myLengthUnit;
};

21
src/StepBasic/StepBasic_ConversionBasedUnitAndMassUnit.cxx
View File

@ -17,7 +17,6 @@
#include <StepBasic_ConversionBasedUnitAndMassUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MassUnit.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <TCollection_HAsciiString.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepBasic_ConversionBasedUnitAndMassUnit,StepBasic_ConversionBasedUnit)
@ -36,17 +35,16 @@ StepBasic_ConversionBasedUnitAndMassUnit::StepBasic_ConversionBasedUnitAndMassUn
//purpose :
//=======================================================================
void StepBasic_ConversionBasedUnitAndMassUnit::Init
(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
void StepBasic_ConversionBasedUnitAndMassUnit::Init(const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor)
{
// --- ANDOR componant fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
StepBasic_ConversionBasedUnit::Init(theDimensions, theName, theConversionFactor);
// --- ANDOR componant fields ---
massUnit = new StepBasic_MassUnit();
massUnit->Init(aDimensions);
myMassUnit = new StepBasic_MassUnit();
myMassUnit->Init(theDimensions);
}
@ -55,10 +53,9 @@ void StepBasic_ConversionBasedUnitAndMassUnit::Init
//purpose :
//=======================================================================
void StepBasic_ConversionBasedUnitAndMassUnit::SetMassUnit
(const Handle(StepBasic_MassUnit)& aMassUnit)
void StepBasic_ConversionBasedUnitAndMassUnit::SetMassUnit(const Handle(StepBasic_MassUnit)& theMassUnit)
{
massUnit = aMassUnit;
myMassUnit = theMassUnit;
}
@ -69,6 +66,6 @@ void StepBasic_ConversionBasedUnitAndMassUnit::SetMassUnit
Handle(StepBasic_MassUnit) StepBasic_ConversionBasedUnitAndMassUnit::MassUnit() const
{
return massUnit;
return myMassUnit;
}

9
src/StepBasic/StepBasic_ConversionBasedUnitAndMassUnit.hxx
View File

@ -23,7 +23,6 @@
class StepBasic_MassUnit;
class StepBasic_DimensionalExponents;
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
class StepBasic_ConversionBasedUnitAndMassUnit;
@ -39,9 +38,11 @@ public:
//! Returns a ConversionBasedUnitAndLengthUnit
Standard_EXPORT StepBasic_ConversionBasedUnitAndMassUnit();
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& aDimensions, const Handle(TCollection_HAsciiString)& aName, const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor);
Standard_EXPORT void SetMassUnit (const Handle(StepBasic_MassUnit)& aMassUnit);
Standard_EXPORT void SetMassUnit (const Handle(StepBasic_MassUnit)& theMassUnit);
Standard_EXPORT Handle(StepBasic_MassUnit) MassUnit() const;
@ -58,7 +59,7 @@ protected:
private:
Handle(StepBasic_MassUnit) massUnit;
Handle(StepBasic_MassUnit) myMassUnit;
};

19
src/StepBasic/StepBasic_ConversionBasedUnitAndPlaneAngleUnit.cxx
View File

@ -16,7 +16,6 @@
#include <StepBasic_ConversionBasedUnit.hxx>
#include <StepBasic_ConversionBasedUnitAndPlaneAngleUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_PlaneAngleUnit.hxx>
#include <TCollection_HAsciiString.hxx>
@ -26,26 +25,26 @@ StepBasic_ConversionBasedUnitAndPlaneAngleUnit::StepBasic_ConversionBasedUnitAnd
{
}
void StepBasic_ConversionBasedUnitAndPlaneAngleUnit::Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
void StepBasic_ConversionBasedUnitAndPlaneAngleUnit::Init(const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor)
{
// --- ANDOR componant fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
StepBasic_ConversionBasedUnit::Init(theDimensions, theName, theConversionFactor);
// --- ANDOR componant fields ---
planeAngleUnit = new StepBasic_PlaneAngleUnit();
planeAngleUnit->Init(aDimensions);
myPlaneAngleUnit = new StepBasic_PlaneAngleUnit();
myPlaneAngleUnit->Init(theDimensions);
}
void StepBasic_ConversionBasedUnitAndPlaneAngleUnit::SetPlaneAngleUnit(const Handle(StepBasic_PlaneAngleUnit)& aPlaneAngleUnit)
void StepBasic_ConversionBasedUnitAndPlaneAngleUnit::SetPlaneAngleUnit(const Handle(StepBasic_PlaneAngleUnit)& thePlaneAngleUnit)
{
planeAngleUnit = aPlaneAngleUnit;
myPlaneAngleUnit = thePlaneAngleUnit;
}
Handle(StepBasic_PlaneAngleUnit) StepBasic_ConversionBasedUnitAndPlaneAngleUnit::PlaneAngleUnit() const
{
return planeAngleUnit;
return myPlaneAngleUnit;
}

9
src/StepBasic/StepBasic_ConversionBasedUnitAndPlaneAngleUnit.hxx
View File

@ -24,7 +24,6 @@
class StepBasic_PlaneAngleUnit;
class StepBasic_DimensionalExponents;
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
class StepBasic_ConversionBasedUnitAndPlaneAngleUnit;
@ -40,9 +39,11 @@ public:
//! Returns a ConversionBasedUnitAndPlaneAngleUnit
Standard_EXPORT StepBasic_ConversionBasedUnitAndPlaneAngleUnit();
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& aDimensions, const Handle(TCollection_HAsciiString)& aName, const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor);
Standard_EXPORT void SetPlaneAngleUnit (const Handle(StepBasic_PlaneAngleUnit)& aPlaneAngleUnit);
Standard_EXPORT void SetPlaneAngleUnit (const Handle(StepBasic_PlaneAngleUnit)& thePlaneAngleUnit);
Standard_EXPORT Handle(StepBasic_PlaneAngleUnit) PlaneAngleUnit() const;
@ -59,7 +60,7 @@ protected:
private:
Handle(StepBasic_PlaneAngleUnit) planeAngleUnit;
Handle(StepBasic_PlaneAngleUnit) myPlaneAngleUnit;
};

19
src/StepBasic/StepBasic_ConversionBasedUnitAndRatioUnit.cxx
View File

@ -16,7 +16,6 @@
#include <StepBasic_ConversionBasedUnit.hxx>
#include <StepBasic_ConversionBasedUnitAndRatioUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_RatioUnit.hxx>
#include <TCollection_HAsciiString.hxx>
@ -26,25 +25,25 @@ StepBasic_ConversionBasedUnitAndRatioUnit::StepBasic_ConversionBasedUnitAndRatio
{
}
void StepBasic_ConversionBasedUnitAndRatioUnit::Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
void StepBasic_ConversionBasedUnitAndRatioUnit::Init(const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor)
{
// --- ANDOR componant fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
StepBasic_ConversionBasedUnit::Init(theDimensions, theName, theConversionFactor);
// --- ANDOR componant fields ---
ratioUnit = new StepBasic_RatioUnit();
ratioUnit->Init(aDimensions);
myRatioUnit = new StepBasic_RatioUnit();
myRatioUnit->Init(theDimensions);
}
void StepBasic_ConversionBasedUnitAndRatioUnit::SetRatioUnit(const Handle(StepBasic_RatioUnit)& aRatioUnit)
void StepBasic_ConversionBasedUnitAndRatioUnit::SetRatioUnit(const Handle(StepBasic_RatioUnit)& theRatioUnit)
{
ratioUnit = aRatioUnit;
myRatioUnit = theRatioUnit;
}
Handle(StepBasic_RatioUnit) StepBasic_ConversionBasedUnitAndRatioUnit::RatioUnit() const
{
return ratioUnit;
return myRatioUnit;
}

9
src/StepBasic/StepBasic_ConversionBasedUnitAndRatioUnit.hxx
View File

@ -24,7 +24,6 @@
class StepBasic_RatioUnit;
class StepBasic_DimensionalExponents;
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
class StepBasic_ConversionBasedUnitAndRatioUnit;
@ -40,9 +39,11 @@ public:
//! Returns a ConversionBasedUnitAndRatioUnit
Standard_EXPORT StepBasic_ConversionBasedUnitAndRatioUnit();
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& aDimensions, const Handle(TCollection_HAsciiString)& aName, const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor);
Standard_EXPORT void SetRatioUnit (const Handle(StepBasic_RatioUnit)& aRatioUnit);
Standard_EXPORT void SetRatioUnit (const Handle(StepBasic_RatioUnit)& theRatioUnit);
Standard_EXPORT Handle(StepBasic_RatioUnit) RatioUnit() const;
@ -59,7 +60,7 @@ protected:
private:
Handle(StepBasic_RatioUnit) ratioUnit;
Handle(StepBasic_RatioUnit) myRatioUnit;
};

19
src/StepBasic/StepBasic_ConversionBasedUnitAndSolidAngleUnit.cxx
View File

@ -16,7 +16,6 @@
#include <StepBasic_ConversionBasedUnit.hxx>
#include <StepBasic_ConversionBasedUnitAndSolidAngleUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_SolidAngleUnit.hxx>
#include <TCollection_HAsciiString.hxx>
@ -26,26 +25,26 @@ StepBasic_ConversionBasedUnitAndSolidAngleUnit::StepBasic_ConversionBasedUnitAnd
{
}
void StepBasic_ConversionBasedUnitAndSolidAngleUnit::Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
void StepBasic_ConversionBasedUnitAndSolidAngleUnit::Init(const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor)
{
// --- ANDOR componant fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
StepBasic_ConversionBasedUnit::Init(theDimensions, theName, theConversionFactor);
// --- ANDOR componant fields ---
solidAngleUnit = new StepBasic_SolidAngleUnit();
solidAngleUnit->Init(aDimensions);
mySolidAngleUnit = new StepBasic_SolidAngleUnit();
mySolidAngleUnit->Init(theDimensions);
}
void StepBasic_ConversionBasedUnitAndSolidAngleUnit::SetSolidAngleUnit(const Handle(StepBasic_SolidAngleUnit)& aSolidAngleUnit)
void StepBasic_ConversionBasedUnitAndSolidAngleUnit::SetSolidAngleUnit(const Handle(StepBasic_SolidAngleUnit)& theSolidAngleUnit)
{
solidAngleUnit = aSolidAngleUnit;
mySolidAngleUnit = theSolidAngleUnit;
}
Handle(StepBasic_SolidAngleUnit) StepBasic_ConversionBasedUnitAndSolidAngleUnit::SolidAngleUnit() const
{
return solidAngleUnit;
return mySolidAngleUnit;
}

9
src/StepBasic/StepBasic_ConversionBasedUnitAndSolidAngleUnit.hxx
View File

@ -24,7 +24,6 @@
class StepBasic_SolidAngleUnit;
class StepBasic_DimensionalExponents;
class TCollection_HAsciiString;
class StepBasic_MeasureWithUnit;
class StepBasic_ConversionBasedUnitAndSolidAngleUnit;
@ -40,9 +39,11 @@ public:
//! Returns a ConversionBasedUnitAndSolidAngleUnit
Standard_EXPORT StepBasic_ConversionBasedUnitAndSolidAngleUnit();
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& aDimensions, const Handle(TCollection_HAsciiString)& aName, const Handle(StepBasic_MeasureWithUnit)& aConversionFactor);
Standard_EXPORT void Init (const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor);
Standard_EXPORT void SetSolidAngleUnit (const Handle(StepBasic_SolidAngleUnit)& aSolidAngleUnit);
Standard_EXPORT void SetSolidAngleUnit (const Handle(StepBasic_SolidAngleUnit)& theSolidAngleUnit);
Standard_EXPORT Handle(StepBasic_SolidAngleUnit) SolidAngleUnit() const;
@ -59,7 +60,7 @@ protected:
private:
Handle(StepBasic_SolidAngleUnit) solidAngleUnit;
Handle(StepBasic_SolidAngleUnit) mySolidAngleUnit;
};

19
src/StepBasic/StepBasic_ConversionBasedUnitAndTimeUnit.cxx
View File

@ -16,7 +16,6 @@
#include <StepBasic_ConversionBasedUnit.hxx>
#include <StepBasic_ConversionBasedUnitAndTimeUnit.hxx>
#include <StepBasic_DimensionalExponents.hxx>
#include <StepBasic_MeasureWithUnit.hxx>
#include <StepBasic_TimeUnit.hxx>
#include <TCollection_HAsciiString.hxx>
@ -26,26 +25,26 @@ StepBasic_ConversionBasedUnitAndTimeUnit::StepBasic_ConversionBasedUnitAndTimeUn
{
}
void StepBasic_ConversionBasedUnitAndTimeUnit::Init(const Handle(StepBasic_DimensionalExponents)& aDimensions,
const Handle(TCollection_HAsciiString)& aName,
const Handle(StepBasic_MeasureWithUnit)& aConversionFactor)
void StepBasic_ConversionBasedUnitAndTimeUnit::Init(const Handle(StepBasic_DimensionalExponents)& theDimensions,
const Handle(TCollection_HAsciiString)& theName,
const Handle(Standard_Transient)& theConversionFactor)
{
// --- ANDOR componant fields ---
StepBasic_ConversionBasedUnit::Init(aDimensions, aName, aConversionFactor);
StepBasic_ConversionBasedUnit::Init(theDimensions, theName, theConversionFactor);
// --- ANDOR componant fields ---
timeUnit = new StepBasic_TimeUnit();
timeUnit->Init(aDimensions);
myTimeUnit = new StepBasic_TimeUnit();
myTimeUnit->Init(theDimensions);
}
void StepBasic_ConversionBasedUnitAndTimeUnit::SetTimeUnit(const Handle(StepBasic_TimeUnit)& aTimeUnit)
void StepBasic_ConversionBasedUnitAndTimeUnit::SetTimeUnit(const Handle(StepBasic_TimeUnit)& theTimeUnit)
{
timeUnit = aTimeUnit;
myTimeUnit = theTimeUnit;
}
Handle(StepBasic_TimeUnit) StepBasic_ConversionBasedUnitAndTimeUnit::TimeUnit() const
{
return timeUnit;
return myTimeUnit;
}

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