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

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

Browse Source 
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:
snn 2022-04-04 18:08:34 +03:00 committed by afokin
parent e9c43fee29
commit cec41bb93d
128 changed files with 9920 additions and 403 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.
@ -337,7 +339,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.
@ -447,6 +449,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:
@ -464,6 +494,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:
@ -683,6 +718,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
@ -745,6 +784,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.
@ -971,6 +1011,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)
@ -1094,6 +1162,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

@ -1527,6 +1527,37 @@ IMPLEMENT_STANDARD_RTTIEXT(RWStepAP214_GeneralModule,StepData_GeneralModule)
#include <StepKinematics_UniversalPairValue.hxx>
#include <StepKinematics_UniversalPairWithRange.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;
@ -5901,8 +5932,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;
}
}
@ -8162,7 +8298,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;
}
@ -8844,6 +9025,21 @@ Standard_Integer RWStepAP214_GeneralModule::CategoryNumber
case 801: return cataux;
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;

294
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>
@ -2302,6 +2334,22 @@ static TCollection_AsciiString Reco_UniversalPairWithRange("UNIVERSAL_PAIR_WITH_
static TCollection_AsciiString Reco_KinematicPair("KINEMATIC_PAIR");
static TCollection_AsciiString Reco_MechanismStateRepresentation("MECHANISM_STATE_REPRESENTATION");
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;
@ -3042,6 +3090,21 @@ RWStepAP214_ReadWriteModule::RWStepAP214_ReadWriteModule ()
typenums.Bind(Reco_KinematicPair, 799);
typenums.Bind(Reco_MechanismStateRepresentation, 801);
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
@ -5014,6 +5077,21 @@ const TCollection_AsciiString& RWStepAP214_ReadWriteModule::StepType
case 799: return Reco_KinematicPair;
case 801: return Reco_MechanismStateRepresentation;
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;
}
}
@ -10511,7 +10589,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");
}
@ -15948,7 +16130,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;
}
}

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_

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

@ -0,0 +1,247 @@
// 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>
//=======================================================================
//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_HArray2OfInteger) aTriangleStrips;
Standard_Integer sub6 = 0;
if (theData->ReadSubList(theNum, 6, "triangle_strips", theCheck, sub6))
{
Standard_Integer nb0 = theData->NbParams(sub6);
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub6,1));
aTriangleStrips = 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(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);
aTriangleStrips->SetValue(i0,j0, anIt0);
}
}
}
}
Handle(TColStd_HArray2OfInteger) aTriangleFans;
Standard_Integer sub7 = 0;
if (theData->ReadSubList(theNum, 7, "triangle_fans", theCheck, sub7))
{
Standard_Integer nb0 = theData->NbParams(sub7);
Standard_Integer nbj0 = theData->NbParams(theData->ParamNumber(sub7,1));
aTriangleFans = 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_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);
aTriangleFans->SetValue(i0,j0, anIt0);
}
}
}
}
// 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->TriangleStrips()->RowLength(); i5++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
for (Standard_Integer j5 = 1; j5 <= theEnt->TriangleStrips()->ColLength(); j5++)
{
Standard_Integer Var0 = theEnt->TriangleStrips()->Value(i5,j5);
theSW.Send(Var0);
}
theSW.CloseSub();
}
theSW.CloseSub();
theSW.OpenSub();
for (Standard_Integer i6 = 1; i6 <= theEnt->TriangleFans()->RowLength(); i6++)
{
theSW.NewLine(Standard_False);
theSW.OpenSub();
for (Standard_Integer j6 = 1; j6 <= theEnt->TriangleFans()->ColLength(); j6++)
{
Standard_Integer Var0 = theEnt->TriangleFans()->Value(i6,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_

49
src/STEPControl/STEPControl_ActorRead.cxx
View File

@ -88,6 +88,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>
@ -95,6 +99,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>
@ -103,6 +108,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>
@ -209,6 +215,7 @@ STEPControl_ActorRead::STEPControl_ActorRead()
myMaxTol(0.0)
{
}
// ============================================================================
// Method : STEPControl_ActorRead::Recognize
// Purpose : tells if an entity is valid for transfer by this Actor
@ -236,6 +243,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;
@ -246,6 +255,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 ...
@ -859,6 +872,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();
@ -915,8 +929,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, Standard_False, Standard_False);
B.Add(comp, theResult);
nsh++;
}
}
}
@ -1396,6 +1415,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();
@ -1431,6 +1452,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,"Exception is raised. Entity was not translated.");
@ -1444,7 +1486,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,

228
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>
@ -71,6 +72,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>
@ -81,7 +85,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>
@ -170,6 +173,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
@ -906,25 +961,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:
@ -940,28 +1000,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:
@ -970,8 +1035,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;
@ -993,9 +1060,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;
}
@ -1017,9 +1086,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;
}
@ -1030,28 +1101,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:
@ -1099,24 +1176,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
@ -1212,6 +1313,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);
@ -1235,6 +1338,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 {
@ -1243,8 +1373,8 @@ Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
Handle(StepRepr_HArray1OfRepresentationItem) newItems =
new StepRepr_HArray1OfRepresentationItem(1, oldItems->Length() + 1);
Standard_Integer el = 1;
for (Standard_Integer i = 1; i <= oldItems->Length(); i++)
newItems->SetValue(el++, oldItems->Value(i));
for (Standard_Integer i = 1; i <= oldItems->Length(); i++)
newItems->SetValue( el++, oldItems->Value(i) );
newItems->SetValue( el, items->Value( items->Length() ) );
shapeRep->SetItems(newItems);
}

16
src/STEPControl/STEPControl_Controller.cxx
View File

@ -248,6 +248,22 @@ STEPControl_Controller::STEPControl_Controller ()
Interface_Static::Init("step", "read.step.codepage", '&', "eval CP850"); // Resource_FormatType_CP850
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_CP850 - (int)Resource_FormatType_CP1250 == 18); // "Error: Invalid Codepage Enumeration"
init = Standard_True;

31
src/StepAP214/StepAP214_Protocol.cxx
View File

@ -836,6 +836,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);
@ -1630,6 +1646,21 @@ StepAP214_Protocol::StepAP214_Protocol ()
types.Bind(STANDARD_TYPE(StepKinematics_MechanismStateRepresentation), 801);
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);
}

3
src/StepToTopoDS/FILES
View File

@ -51,6 +51,9 @@ StepToTopoDS_TranslatePolyLoopError.hxx
StepToTopoDS_TranslateShell.cxx
StepToTopoDS_TranslateShell.hxx
StepToTopoDS_TranslateShellError.hxx
StepToTopoDS_TranslateSolid.cxx
StepToTopoDS_TranslateSolid.hxx
StepToTopoDS_TranslateSolidError.hxx
StepToTopoDS_TranslateVertex.cxx
StepToTopoDS_TranslateVertex.hxx
StepToTopoDS_TranslateVertexError.hxx

118
src/StepToTopoDS/StepToTopoDS_Builder.cxx
View File

@ -66,6 +66,9 @@
#include <StepShape_OrientedClosedShell.hxx>
#include <StepShape_Shell.hxx>
#include <StepShape_ShellBasedSurfaceModel.hxx>
#include <StepVisual_TessellatedFace.hxx>
#include <StepVisual_TessellatedShell.hxx>
#include <StepVisual_TessellatedSolid.hxx>
#include <StepToGeom.hxx>
#include <StepToTopoDS_Builder.hxx>
#include <StepToTopoDS_DataMapOfTRI.hxx>
@ -76,6 +79,7 @@
#include <StepToTopoDS_TranslateEdge.hxx>
#include <StepToTopoDS_TranslateFace.hxx>
#include <StepToTopoDS_TranslateShell.hxx>
#include <StepToTopoDS_TranslateSolid.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Compound.hxx>
@ -805,6 +809,120 @@ void StepToTopoDS_Builder::Init
}
// ***end DTH Apr/6
// ============================================================================
// Method : StepToTopoDS_Builder::Init
// Purpose : Builds a TopoDS_Solid from StepVisual_TessellatedSolid
// ============================================================================
void StepToTopoDS_Builder::Init(const Handle(StepVisual_TessellatedSolid)& theTSo,
const Handle(Transfer_TransientProcess)& theTP,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom,
const Message_ProgressRange& theProgress)
{
StepToTopoDS_TranslateSolid aTranSolid;
aTranSolid.SetPrecision(Precision());
aTranSolid.SetMaxTol(MaxTol());
StepToTopoDS_Tool aTool;
StepToTopoDS_DataMapOfTRI aMap;
aTool.Init(aMap, theTP);
StepToTopoDS_NMTool dummyNMTool;
aTranSolid.Init(theTSo, theTP, aTool, dummyNMTool, theReadTessellatedWhenNoBRepOnly,
theHasGeom, theProgress);
if (aTranSolid.IsDone())
{
TopoDS_Shape aS = aTranSolid.Value();
TransferBRep::SetShapeResult(theTP, theTSo, aS);
myResult = TopoDS::Solid(aS);
myError = StepToTopoDS_BuilderDone;
done = Standard_True;
}
else
{
theTP->AddWarning(theTSo, " TessellatedSolid not mapped to TopoDS");
myError = StepToTopoDS_BuilderOther;
done = Standard_True;
}
}
// ============================================================================
// Method : StepToTopoDS_Builder::Init
// Purpose : Builds a TopoDS_Shell from StepVisual_TessellatedShell
// ============================================================================
void StepToTopoDS_Builder::Init(const Handle(StepVisual_TessellatedShell)& theTSh,
const Handle(Transfer_TransientProcess)& theTP,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom,
const Message_ProgressRange& theProgress)
{
StepToTopoDS_TranslateShell aTranShell;
aTranShell.SetPrecision(Precision());
aTranShell.SetMaxTol(MaxTol());
StepToTopoDS_Tool aTool;
StepToTopoDS_DataMapOfTRI aMap;
aTool.Init(aMap, theTP);
StepToTopoDS_NMTool dummyNMTool;
aTranShell.Init(theTSh, aTool, dummyNMTool, theReadTessellatedWhenNoBRepOnly,
theHasGeom, theProgress);
if (aTranShell.IsDone())
{
TopoDS_Shape aS = aTranShell.Value();
TransferBRep::SetShapeResult(theTP, theTSh, aS);
myResult = TopoDS::Shell(aS);
myError = StepToTopoDS_BuilderDone;
done = Standard_True;
}
else
{
theTP->AddWarning(theTSh, " TessellatedShell not mapped to TopoDS");
myError = StepToTopoDS_BuilderOther;
done = Standard_True;
}
}
// ============================================================================
// Method : StepToTopoDS_Builder::Init
// Purpose : Builds a TopoDS_Face from StepVisual_TessellatedFace
// ============================================================================
void StepToTopoDS_Builder::Init(const Handle(StepVisual_TessellatedFace)& theTF,
const Handle(Transfer_TransientProcess)& theTP,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom)
{
StepToTopoDS_TranslateFace aTranFace;
aTranFace.SetPrecision(Precision());
aTranFace.SetMaxTol(MaxTol());
StepToTopoDS_Tool aTool;
StepToTopoDS_DataMapOfTRI aMap;
aTool.Init(aMap, theTP);
StepToTopoDS_NMTool dummyNMTool;
aTranFace.Init(theTF, aTool, dummyNMTool, theReadTessellatedWhenNoBRepOnly, theHasGeom);
if (aTranFace.IsDone())
{
TopoDS_Shape aS = aTranFace.Value();
TransferBRep::SetShapeResult(theTP, theTF, aS);
myResult = TopoDS::Face(aS);
myError = StepToTopoDS_BuilderDone;
done = Standard_True;
}
else
{
theTP->AddWarning(theTF, " TessellatedFace not mapped to TopoDS");
myError = StepToTopoDS_BuilderOther;
done = Standard_True;
}
}
// ============================================================================
// Method : Value

20
src/StepToTopoDS/StepToTopoDS_Builder.hxx
View File

@ -37,6 +37,9 @@ class StepToTopoDS_NMTool;
class StepShape_GeometricSet;
class StepShape_EdgeBasedWireframeModel;
class StepShape_FaceBasedSurfaceModel;
class StepVisual_TessellatedFace;
class StepVisual_TessellatedShell;
class StepVisual_TessellatedSolid;
class Transfer_ActorOfTransientProcess;
@ -83,6 +86,23 @@ public:
const Standard_Boolean isManifold = Standard_False,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT void Init (const Handle(StepVisual_TessellatedSolid)& theTSo,
const Handle(Transfer_TransientProcess)& theTP,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT void Init (const Handle(StepVisual_TessellatedShell)& theTSh,
const Handle(Transfer_TransientProcess)& theTP,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT void Init (const Handle(StepVisual_TessellatedFace)& theTF,
const Handle(Transfer_TransientProcess)& theTP,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom);
Standard_EXPORT const TopoDS_Shape& Value() const;
Standard_EXPORT StepToTopoDS_BuilderError Error() const;

250
src/StepToTopoDS/StepToTopoDS_TranslateFace.cxx
View File

@ -41,6 +41,7 @@
#include <Geom_ToroidalSurface.hxx>
#include <GeomAbs_Shape.hxx>
#include <GeomAdaptor_Surface.hxx>
#include <MoniTool_Macros.hxx>
#include <Precision.hxx>
#include <ShapeAlgo.hxx>
#include <ShapeAlgo_AlgoContainer.hxx>
@ -77,8 +78,11 @@
#include <TopoDS_Vertex.hxx>
#include <TopoDS_Wire.hxx>
#include <Transfer_TransientProcess.hxx>
#include <TransferBRep_ShapeBinder.hxx>
#include <StepGeom_RectangularTrimmedSurface.hxx>
#include <StepGeom_ToroidalSurface.hxx>
#include <StepVisual_TriangulatedFace.hxx>
#include <StepVisual_ComplexTriangulatedFace.hxx>
//#3 rln 16/02/98
//#include <GeomAdaptor_Curve.hxx>
@ -111,6 +115,21 @@ StepToTopoDS_TranslateFace::StepToTopoDS_TranslateFace
Init(FS, T, NMTool);
}
// ============================================================================
// Method : StepToTopoDS_TranslateFace::StepToTopoDS_TranslateFace
// Purpose : Constructor with either TriangulatedFace or
// ComplexTriangulatedFace and a Tool
// ============================================================================
StepToTopoDS_TranslateFace::StepToTopoDS_TranslateFace(const Handle(StepVisual_TessellatedFace)& theTF,
StepToTopoDS_Tool& theTool,
StepToTopoDS_NMTool& theNMTool,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom)
{
Init(theTF, theTool, theNMTool, theReadTessellatedWhenNoBRepOnly, theHasGeom);
}
// ============================================================================
// Method : Init
// Purpose : Init with a FaceSurface and a Tool
@ -381,6 +400,237 @@ void StepToTopoDS_TranslateFace::Init
done = Standard_True;
}
// ============================================================================
// Method : Init
// Purpose : Init with either StepVisual_TriangulatedFace or
// StepVisual_ComplexTriangulatedFace and a Tool
// ============================================================================
void StepToTopoDS_TranslateFace::Init(const Handle(StepVisual_TessellatedFace)& theTF,
StepToTopoDS_Tool& theTool,
StepToTopoDS_NMTool& theNMTool,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom)
{
if (theTF.IsNull())
return;
Handle(Transfer_TransientProcess) aTP = theTool.TransientProcess();
BRep_Builder aB;
TopoDS_Face aF;
if (theTF->HasGeometricLink())
{
Handle(TransferBRep_ShapeBinder) aBinder
= Handle(TransferBRep_ShapeBinder)::DownCast(aTP->Find(theTF->GeometricLink().Face()));
if (aBinder)
{
aF = aBinder->Face();
theHasGeom = Standard_True;
}
if (!aF.IsNull() && !BRep_Tool::Surface(aF).IsNull() && theReadTessellatedWhenNoBRepOnly)
{
// Face has BRep but OnNoBRep param is specified
return;
}
}
if (aF.IsNull())
{
aB.MakeFace(aF);
theHasGeom = Standard_False;
}
Handle(Poly_Triangulation) aMesh;
if (DeclareAndCast(StepVisual_TriangulatedFace, aTriaF, theTF))
{
aMesh = createMesh(aTriaF);
}
else if (DeclareAndCast(StepVisual_ComplexTriangulatedFace, aCompTriaF, theTF))
{
aMesh = createMesh(aCompTriaF);
}
else
{
aTP->AddWarning(theTF, " Triangulated or ComplexTriangulated entity is supported only.");
return;
}
if (aMesh.IsNull())
{
aTP->AddWarning(theTF, " Poly triangulation is not set to TopoDS face.");
return;
}
aB.UpdateFace(aF, aMesh);
if (theNMTool.IsActive())
theNMTool.Bind(theTF, aF);
myResult = aF;
myError = StepToTopoDS_TranslateFaceDone;
done = Standard_True;
}
// ============================================================================
// Method : createMesh
// Purpose : creates a Poly_Triangulation from TriangulatedFace
// ============================================================================
Handle(Poly_Triangulation)
StepToTopoDS_TranslateFace::createMesh(const Handle(StepVisual_TriangulatedFace)& theTF) const
{
Handle(StepVisual_CoordinatesList) aCoords = theTF->Coordinates();
Handle(TColgp_HArray1OfXYZ) aNodes = aCoords->Points();
Handle(TColStd_HArray2OfInteger) aTriangles = theTF->Triangles();
const Standard_Boolean aHasUVNodes = Standard_False;
const Standard_Boolean aHasNormals = (theTF->NbNormals() > 0);
Handle(Poly_Triangulation) aMesh = new Poly_Triangulation(theTF->NbPnindex(), theTF->NbTriangles(), aHasUVNodes, aHasNormals);
for (Standard_Integer j = 1; j <= theTF->NbPnindex(); ++j)
{
aMesh->SetNode(j, aNodes->Value(theTF->PnindexValue(j)));
}
for (Standard_Integer k = 1; k <= theTF->NbTriangles(); ++k)
{
aMesh->SetTriangle(k, Poly_Triangle(aTriangles->Value(k, 1), aTriangles->Value(k, 2), aTriangles->Value(k, 3)));
}
if (aHasNormals)
{
Handle(TColStd_HArray2OfReal) aNormals = theTF->Normals();
gp_XYZ aNorm;
if (theTF->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 <= theTF->NbPnindex(); ++i)
{
aMesh->SetNormal(i, aNorm);
}
}
else
{
for (Standard_Integer i = 1; i <= theTF->NbNormals(); ++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;
}
// ============================================================================
// Method : createMesh
// Purpose : creates a Poly_Triangulation from ComplexTriangulatedFace
// ============================================================================
Handle(Poly_Triangulation)
StepToTopoDS_TranslateFace::createMesh(const Handle(StepVisual_ComplexTriangulatedFace)& theTF) const
{
Handle(StepVisual_CoordinatesList) aCoords = theTF->Coordinates();
Handle(TColgp_HArray1OfXYZ) aNodes = aCoords->Points();
Handle(TColStd_HArray2OfInteger) aTriaStrips = theTF->TriangleStrips();
Handle(TColStd_HArray2OfInteger) aTriaFans = theTF->TriangleFans();
const Standard_Boolean aHasUVNodes = Standard_False;
const Standard_Boolean aHasNormals = (theTF->NbNormals() > 0);
Standard_Integer aNbTriaStrips = 0;
for (Standard_Integer i = 1; i <= theTF->NbTriangleStrips(); ++i)
{
for (Standard_Integer j = 3; j <= aTriaStrips->UpperCol(); j += 2)
{
if (aTriaStrips->Value(i, j) != aTriaStrips->Value(i, j - 2) &&
aTriaStrips->Value(i, j) != aTriaStrips->Value(i, j - 1))
++aNbTriaStrips;
}
for (Standard_Integer j = 4; j <= aTriaStrips->UpperCol(); j += 2)
{
if (aTriaStrips->Value(i, j) != aTriaStrips->Value(i, j - 2) &&
aTriaStrips->Value(i, j) != aTriaStrips->Value(i, j - 1))
++aNbTriaStrips;
}
}
Standard_Integer aNbTriaFans = 0;
for (Standard_Integer i = 1; i <= theTF->NbTriangleFans(); ++i)
{
Standard_Integer v1 = aTriaStrips->Value(i, 1);
for (Standard_Integer j = 3; j <= aTriaStrips->UpperCol(); ++j)
{
if (aTriaStrips->Value(i, j) != v1 && aTriaStrips->Value(i, j - 1) != v1)
++aNbTriaFans;
}
}
Handle(Poly_Triangulation) aMesh = new Poly_Triangulation(theTF->NbPnindex(),
aNbTriaStrips + aNbTriaFans, aHasUVNodes, aHasNormals);
for (Standard_Integer j = 1; j <= theTF->NbPnindex(); ++j)
{
aMesh->SetNode(j, aNodes->Value(theTF->PnindexValue(j)));
}
Standard_Integer k = 1;
for (Standard_Integer i = 1; i <= theTF->NbTriangleStrips(); ++i)
{
for (Standard_Integer j = 3; j <= aTriaStrips->UpperCol(); j += 2)
{
if (aTriaStrips->Value(i, j) != aTriaStrips->Value(i, j - 2) &&
aTriaStrips->Value(i, j) != aTriaStrips->Value(i, j - 1))
{
aMesh->SetTriangle(k++, Poly_Triangle(aTriaStrips->Value(i, j - 2),
aTriaStrips->Value(i, j),
aTriaStrips->Value(i, j - 1)));
}
}
for (Standard_Integer j = 4; j <= aTriaStrips->UpperCol(); j += 2)
{
if (aTriaStrips->Value(i, j) != aTriaStrips->Value(i, j - 2) &&
aTriaStrips->Value(i, j) != aTriaStrips->Value(i, j - 1))
{
aMesh->SetTriangle(k++, Poly_Triangle(aTriaStrips->Value(i, j - 2),
aTriaStrips->Value(i, j - 1),
aTriaStrips->Value(i, j)));
}
}
}
if (aHasNormals)
{
Handle(TColStd_HArray2OfReal) aNormals = theTF->Normals();
gp_XYZ aNorm;
if (theTF->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 <= theTF->NbPnindex(); ++i)
{
aMesh->SetNormal(i, aNorm);
}
}
else
{
for (Standard_Integer i = 1; i <= theTF->NbNormals(); ++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;
}
// ============================================================================
// Method : Value

19
src/StepToTopoDS/StepToTopoDS_TranslateFace.hxx
View File

@ -24,10 +24,13 @@
#include <StepToTopoDS_TranslateFaceError.hxx>
#include <TopoDS_Shape.hxx>
#include <StepToTopoDS_Root.hxx>
class Poly_Triangulation;
class StepShape_FaceSurface;
class StepToTopoDS_Tool;
class StepToTopoDS_NMTool;
class StepVisual_TessellatedFace;
class StepVisual_TriangulatedFace;
class StepVisual_ComplexTriangulatedFace;
class StepToTopoDS_TranslateFace : public StepToTopoDS_Root
@ -41,8 +44,20 @@ public:
Standard_EXPORT StepToTopoDS_TranslateFace(const Handle(StepShape_FaceSurface)& FS, StepToTopoDS_Tool& T, StepToTopoDS_NMTool& NMTool);
Standard_EXPORT StepToTopoDS_TranslateFace(const Handle(StepVisual_TessellatedFace)& theTF,
StepToTopoDS_Tool& theTool,
StepToTopoDS_NMTool& theNMTool,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom);
Standard_EXPORT void Init (const Handle(StepShape_FaceSurface)& FS, StepToTopoDS_Tool& T, StepToTopoDS_NMTool& NMTool);
Standard_EXPORT void Init (const Handle(StepVisual_TessellatedFace)& theTF,
StepToTopoDS_Tool& theTool,
StepToTopoDS_NMTool& theNMTool,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom);
Standard_EXPORT const TopoDS_Shape& Value() const;
Standard_EXPORT StepToTopoDS_TranslateFaceError Error() const;
@ -58,6 +73,8 @@ protected:
private:
Handle(Poly_Triangulation) createMesh(const Handle(StepVisual_TriangulatedFace)& theTF) const;
Handle(Poly_Triangulation) createMesh(const Handle(StepVisual_ComplexTriangulatedFace)& theTF) const;
StepToTopoDS_TranslateFaceError myError;

85
src/StepToTopoDS/StepToTopoDS_TranslateShell.cxx
View File

@ -25,11 +25,14 @@
#include <StepToTopoDS_Tool.hxx>
#include <StepToTopoDS_TranslateFace.hxx>
#include <StepToTopoDS_TranslateShell.hxx>
#include <StepVisual_TessellatedShell.hxx>
#include <StepVisual_TriangulatedFace.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Shell.hxx>
#include <Transfer_TransientProcess.hxx>
#include <TransferBRep_ShapeBinder.hxx>
// ============================================================================
// Method : StepToTopoDS_TranslateShell::StepToTopoDS_TranslateShell
@ -108,6 +111,88 @@ void StepToTopoDS_TranslateShell::Init
}
}
// ============================================================================
// Method : Init
// Purpose : Init with a ConnectedFaceSet and a Tool
// ============================================================================
void StepToTopoDS_TranslateShell::Init(const Handle(StepVisual_TessellatedShell)& theTSh,
StepToTopoDS_Tool& theTool,
StepToTopoDS_NMTool& theNMTool,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom,
const Message_ProgressRange& theProgress)
{
if (theTSh.IsNull())
return;
BRep_Builder aB;
TopoDS_Shell aSh;
Standard_Integer aNb = theTSh->NbItems();
Message_ProgressScope aPS(theProgress, "Face", theTSh->HasTopologicalLink() ? aNb + 1 : aNb);
Handle(Transfer_TransientProcess) aTP = theTool.TransientProcess();
if (theTSh->HasTopologicalLink())
{
Handle(TransferBRep_ShapeBinder) aBinder
= Handle(TransferBRep_ShapeBinder)::DownCast(aTP->Find(theTSh->TopologicalLink()));
if (aBinder.IsNull())
{
aSh = aBinder->Shell();
theHasGeom = Standard_True;
}
}
Standard_Boolean aNewShell = Standard_False;
if (aSh.IsNull())
{
aB.MakeShell(aSh);
aNewShell = Standard_True;
theHasGeom = Standard_False;
}
StepToTopoDS_TranslateFace aTranTF;
aTranTF.SetPrecision(Precision());
aTranTF.SetMaxTol(MaxTol());
for (Standard_Integer i = 1; i <= aNb && aPS.More(); i++, aPS.Next())
{
#ifdef OCCT_DEBUG
std::cout << "Processing Face : " << i << std::endl;
#endif
Handle(StepVisual_TessellatedStructuredItem) anItem = theTSh->ItemsValue(i);
if (anItem->IsKind(STANDARD_TYPE(StepVisual_TessellatedFace)))
{
Handle(StepVisual_TessellatedFace) aTFace = Handle(StepVisual_TessellatedFace)::DownCast(anItem);
Standard_Boolean aHasFaceGeom = Standard_False;
aTranTF.Init(aTFace, theTool, theNMTool, theReadTessellatedWhenNoBRepOnly, aHasFaceGeom);
if (aTranTF.IsDone())
{
if (aNewShell)
{
aB.Add(aSh, TopoDS::Face(aTranTF.Value()));
}
theHasGeom &= aHasFaceGeom;
}
else
{
aTP->AddWarning(anItem, " Triangulated face if not mapped to TopoDS");
}
}
else
{
aTP->AddWarning(anItem, " Face is not of TriangulatedFace Type; not mapped to TopoDS");
}
}
aSh.Closed(BRep_Tool::IsClosed(aSh));
myResult = aSh;
myError = StepToTopoDS_TranslateShellDone;
done = Standard_True;
}
// ============================================================================
// Method : Value
// Purpose : Return the mapped Shape

9
src/StepToTopoDS/StepToTopoDS_TranslateShell.hxx
View File

@ -27,11 +27,11 @@
#include <Message_ProgressRange.hxx>
class StepShape_ConnectedFaceSet;
class StepVisual_TessellatedShell;
class StepToTopoDS_Tool;
class StepToTopoDS_NMTool;
class StepToTopoDS_TranslateShell : public StepToTopoDS_Root
{
public:
@ -46,6 +46,13 @@ public:
StepToTopoDS_NMTool& NMTool,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT void Init (const Handle(StepVisual_TessellatedShell)& theTSh,
StepToTopoDS_Tool& theTool,
StepToTopoDS_NMTool& theNMTool,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT const TopoDS_Shape& Value() const;
Standard_EXPORT StepToTopoDS_TranslateShellError Error() const;

148
src/StepToTopoDS/StepToTopoDS_TranslateSolid.cxx Normal file
View File

@ -0,0 +1,148 @@
// Copyright (c) 2022 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 <BRep_Builder.hxx>
#include <Message_ProgressScope.hxx>
#include <StdFail_NotDone.hxx>
#include <StepShape_ConnectedFaceSet.hxx>
#include <StepShape_FaceSurface.hxx>
#include <StepToTopoDS_NMTool.hxx>
#include <StepToTopoDS_Tool.hxx>
#include <StepToTopoDS_TranslateFace.hxx>
#include <StepToTopoDS_TranslateSolid.hxx>
#include <StepVisual_TessellatedFace.hxx>
#include <StepVisual_TessellatedSolid.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Shell.hxx>
#include <Transfer_TransientProcess.hxx>
#include <TransferBRep_ShapeBinder.hxx>
// ============================================================================
// Method : StepToTopoDS_TranslateSolid::StepToTopoDS_TranslateSolid
// Purpose : Empty Constructor
// ============================================================================
StepToTopoDS_TranslateSolid::StepToTopoDS_TranslateSolid()
: myError(StepToTopoDS_TranslateSolidOther)
{
done = Standard_False;
}
// ============================================================================
// Method : Init
// Purpose : Init with a TessellatedSolid and a Tool
// ============================================================================
void StepToTopoDS_TranslateSolid::Init(const Handle(StepVisual_TessellatedSolid)& theTSo,
const Handle(Transfer_TransientProcess)& theTP,
StepToTopoDS_Tool& theTool,
StepToTopoDS_NMTool& theNMTool,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom,
const Message_ProgressRange& theProgress)
{
if (theTSo.IsNull())
return;
BRep_Builder aB;
TopoDS_Shell aSh;
TopoDS_Solid aSo;
Standard_Integer aNb = theTSo->NbItems();
Message_ProgressScope aPS(theProgress, "Face", aNb);
if (theTSo->HasGeometricLink() && theTP->IsBound(theTSo->GeometricLink()))
{
Handle(TransferBRep_ShapeBinder) aBinder
= Handle(TransferBRep_ShapeBinder)::DownCast(theTP->Find(theTSo->GeometricLink()));
if (aBinder)
aSo = aBinder->Solid();
}
Standard_Boolean aNewSolid = Standard_False;
if (aSo.IsNull())
{
aB.MakeShell(aSh);
aB.MakeSolid(aSo);
aNewSolid = Standard_True;
theHasGeom = Standard_False;
}
Handle(Transfer_TransientProcess) aTP = theTool.TransientProcess();
StepToTopoDS_TranslateFace aTranTF;
aTranTF.SetPrecision(Precision());
aTranTF.SetMaxTol(MaxTol());
for (Standard_Integer i = 1; i <= aNb && aPS.More(); i++, aPS.Next())
{
#ifdef OCCT_DEBUG
std::cout << "Processing Face : " << i << std::endl;
#endif
Handle(StepVisual_TessellatedStructuredItem) anItem = theTSo->ItemsValue(i);
if (anItem->IsKind(STANDARD_TYPE(StepVisual_TessellatedFace)))
{
Handle(StepVisual_TessellatedFace) aTFace = Handle(StepVisual_TessellatedFace)::DownCast(anItem);
Standard_Boolean aHasFaceGeom = Standard_False;
aTranTF.Init(aTFace, theTool, theNMTool, theReadTessellatedWhenNoBRepOnly, aHasFaceGeom);
if (aTranTF.IsDone())
{
if (aNewSolid)
{
aB.Add(aSh, TopoDS::Face(aTranTF.Value()));
}
theHasGeom &= aHasFaceGeom;
}
else
{
aTP->AddWarning(anItem, " Tessellated face if not mapped to TopoDS");
}
}
else
{
aTP->AddWarning(anItem, " Face is not of TessellatedFace Type; not mapped to TopoDS");
}
}
if (aNewSolid)
{
aB.Add(aSo, aSh);
}
myResult = aSo;
myError = StepToTopoDS_TranslateSolidDone;
done = Standard_True;
}
// ============================================================================
// Method : Value
// Purpose : Return the mapped Shape
// ============================================================================
const TopoDS_Shape& StepToTopoDS_TranslateSolid::Value() const
{
StdFail_NotDone_Raise_if (!done, "StepToTopoDS_TranslateSolid::Value() - no result");
return myResult;
}
// ============================================================================
// Method : Error
// Purpose : Return the TranslateShell Error code
// ============================================================================
StepToTopoDS_TranslateSolidError StepToTopoDS_TranslateSolid::Error() const
{
return myError;
}

62
src/StepToTopoDS/StepToTopoDS_TranslateSolid.hxx Normal file
View File

@ -0,0 +1,62 @@
// Copyright (c) 2022 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _StepToTopoDS_TranslateSolid_HeaderFile
#define _StepToTopoDS_TranslateSolid_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <StepToTopoDS_TranslateSolidError.hxx>
#include <TopoDS_Shape.hxx>
#include <StepToTopoDS_Root.hxx>
#include <Message_ProgressRange.hxx>
class StepShape_ConnectedFaceSet;
class StepVisual_TessellatedSolid;
class StepToTopoDS_Tool;
class StepToTopoDS_NMTool;
class Transfer_TransientProcess;
class StepToTopoDS_TranslateSolid : public StepToTopoDS_Root
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT StepToTopoDS_TranslateSolid();
Standard_EXPORT void Init(const Handle(StepVisual_TessellatedSolid)& theTSo,
const Handle(Transfer_TransientProcess)& theTP,
StepToTopoDS_Tool& theTool,
StepToTopoDS_NMTool& theNMTool,
const Standard_Boolean theReadTessellatedWhenNoBRepOnly,
Standard_Boolean& theHasGeom,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT const TopoDS_Shape& Value() const;
Standard_EXPORT StepToTopoDS_TranslateSolidError Error() const;
protected:
private:
StepToTopoDS_TranslateSolidError myError;
TopoDS_Shape myResult;
};
#endif // _StepToTopoDS_TranslateSolid_HeaderFile

23
src/StepToTopoDS/StepToTopoDS_TranslateSolidError.hxx Normal file
View File

@ -0,0 +1,23 @@
// Copyright (c) 2022 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of 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 _StepToTopoDS_TranslateSolidError_HeaderFile
#define _StepToTopoDS_TranslateSolidError_HeaderFile
enum StepToTopoDS_TranslateSolidError
{
StepToTopoDS_TranslateSolidDone,
StepToTopoDS_TranslateSolidOther
};
#endif // _StepToTopoDS_TranslateSolidError_HeaderFile

46
src/StepVisual/FILES
View File

@ -262,3 +262,49 @@ StepVisual_TessellatedCurveSet.hxx
StepVisual_TessellatedCurveSet.cxx
StepVisual_CoordinatesList.hxx
StepVisual_CoordinatesList.cxx
StepVisual_Array1OfTessellatedEdgeOrVertex.hxx
StepVisual_Array1OfTessellatedStructuredItem.hxx
StepVisual_ComplexTriangulatedFace.cxx
StepVisual_ComplexTriangulatedFace.hxx
StepVisual_ComplexTriangulatedSurfaceSet.cxx
StepVisual_ComplexTriangulatedSurfaceSet.hxx
StepVisual_CubicBezierTessellatedEdge.cxx
StepVisual_CubicBezierTessellatedEdge.hxx
StepVisual_CubicBezierTriangulatedFace.cxx
StepVisual_CubicBezierTriangulatedFace.hxx
StepVisual_EdgeOrCurve.cxx
StepVisual_EdgeOrCurve.hxx
StepVisual_FaceOrSurface.cxx
StepVisual_FaceOrSurface.hxx
StepVisual_HArray1OfTessellatedEdgeOrVertex.hxx
StepVisual_HArray1OfTessellatedStructuredItem.hxx
StepVisual_PathOrCompositeCurve.cxx
StepVisual_PathOrCompositeCurve.hxx
StepVisual_TessellatedConnectingEdge.cxx
StepVisual_TessellatedConnectingEdge.hxx
StepVisual_TessellatedEdge.cxx
StepVisual_TessellatedEdge.hxx
StepVisual_TessellatedEdgeOrVertex.cxx
StepVisual_TessellatedEdgeOrVertex.hxx
StepVisual_TessellatedFace.cxx
StepVisual_TessellatedFace.hxx
StepVisual_TessellatedPointSet.cxx
StepVisual_TessellatedPointSet.hxx
StepVisual_TessellatedShapeRepresentation.cxx
StepVisual_TessellatedShapeRepresentation.hxx
StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.cxx
StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.hxx
StepVisual_TessellatedShell.cxx
StepVisual_TessellatedShell.hxx
StepVisual_TessellatedSolid.cxx
StepVisual_TessellatedSolid.hxx
StepVisual_TessellatedStructuredItem.cxx
StepVisual_TessellatedStructuredItem.hxx
StepVisual_TessellatedSurfaceSet.cxx
StepVisual_TessellatedSurfaceSet.hxx
StepVisual_TessellatedVertex.cxx
StepVisual_TessellatedVertex.hxx
StepVisual_TessellatedWire.cxx
StepVisual_TessellatedWire.hxx
StepVisual_TriangulatedFace.cxx
StepVisual_TriangulatedFace.hxx

26
src/StepVisual/StepVisual_Array1OfTessellatedEdgeOrVertex.hxx Normal file
View File

@ -0,0 +1,26 @@
// 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 StepVisual_Array1OfTessellatedEdgeOrVertex_HeaderFile
#define StepVisual_Array1OfTessellatedEdgeOrVertex_HeaderFile
#include <StepVisual_TessellatedEdgeOrVertex.hxx>
#include <NCollection_Array1.hxx>
typedef NCollection_Array1<StepVisual_TessellatedEdgeOrVertex> StepVisual_Array1OfTessellatedEdgeOrVertex;
#endif

26
src/StepVisual/StepVisual_Array1OfTessellatedStructuredItem.hxx Normal file
View File

@ -0,0 +1,26 @@
// 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 StepVisual_Array1OfTessellatedStructuredItem_HeaderFile
#define StepVisual_Array1OfTessellatedStructuredItem_HeaderFile
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <NCollection_Array1.hxx>
typedef NCollection_Array1<Handle(StepVisual_TessellatedStructuredItem)> StepVisual_Array1OfTessellatedStructuredItem;
#endif

171
src/StepVisual/StepVisual_ComplexTriangulatedFace.cxx Normal file
View File

@ -0,0 +1,171 @@
// 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 <StepVisual_ComplexTriangulatedFace.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_ComplexTriangulatedFace, StepVisual_TessellatedFace)
//=======================================================================
//function : StepVisual_ComplexTriangulatedFace
//purpose :
//=======================================================================
StepVisual_ComplexTriangulatedFace::StepVisual_ComplexTriangulatedFace ()
{
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_ComplexTriangulatedFace::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theTessellatedFace_Coordinates,
const Standard_Integer theTessellatedFace_Pnmax,
const Handle(TColStd_HArray2OfReal)& theTessellatedFace_Normals,
const Standard_Boolean theHasTessellatedFace_GeometricLink,
const StepVisual_FaceOrSurface& theTessellatedFace_GeometricLink,
const Handle(TColStd_HArray1OfInteger)& thePnindex,
const Handle(TColStd_HArray2OfInteger)& theTriangleStrips,
const Handle(TColStd_HArray2OfInteger)& theTriangleFans)
{
StepVisual_TessellatedFace::Init(theRepresentationItem_Name,
theTessellatedFace_Coordinates,
theTessellatedFace_Pnmax,
theTessellatedFace_Normals,
theHasTessellatedFace_GeometricLink,
theTessellatedFace_GeometricLink);
myPnindex = thePnindex;
myTriangleStrips = theTriangleStrips;
myTriangleFans = theTriangleFans;
}
//=======================================================================
//function : Pnindex
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfInteger) StepVisual_ComplexTriangulatedFace::Pnindex () const
{
return myPnindex;
}
//=======================================================================
//function : SetPnindex
//purpose :
//=======================================================================
void StepVisual_ComplexTriangulatedFace::SetPnindex(const Handle(TColStd_HArray1OfInteger)& thePnindex)
{
myPnindex = thePnindex;
}
//=======================================================================
//function : NbPnindex
//purpose :
//=======================================================================
Standard_Integer StepVisual_ComplexTriangulatedFace::NbPnindex() const
{
if (myPnindex.IsNull())
{
return 0;
}
return myPnindex->Length();
}
//=======================================================================
//function : PnindexValue
//purpose :
//=======================================================================
Standard_Integer StepVisual_ComplexTriangulatedFace::PnindexValue(const Standard_Integer theNum) const
{
return myPnindex->Value(theNum);
}
//=======================================================================
//function : TriangleStrips
//purpose :
//=======================================================================
Handle(TColStd_HArray2OfInteger) StepVisual_ComplexTriangulatedFace::TriangleStrips () const
{
return myTriangleStrips;
}
//=======================================================================
//function : SetTriangleStrips
//purpose :
//=======================================================================
void StepVisual_ComplexTriangulatedFace::SetTriangleStrips(const Handle(TColStd_HArray2OfInteger)& theTriangleStrips)
{
myTriangleStrips = theTriangleStrips;
}
//=======================================================================
//function : NbTriangleStrips
//purpose :
//=======================================================================
Standard_Integer StepVisual_ComplexTriangulatedFace::NbTriangleStrips() const
{
if (myTriangleStrips.IsNull())
{
return 0;
}
return myTriangleStrips->ColLength();
}
//=======================================================================
//function : TriangleFans
//purpose :
//=======================================================================
Handle(TColStd_HArray2OfInteger) StepVisual_ComplexTriangulatedFace::TriangleFans () const
{
return myTriangleFans;
}
//=======================================================================
//function : SetTriangleFans
//purpose :
//=======================================================================
void StepVisual_ComplexTriangulatedFace::SetTriangleFans(const Handle(TColStd_HArray2OfInteger)& theTriangleFans)
{
myTriangleFans = theTriangleFans;
}
//=======================================================================
//function : NbTriangleFans
//purpose :
//=======================================================================
Standard_Integer StepVisual_ComplexTriangulatedFace::NbTriangleFans() const
{
if (myTriangleFans.IsNull())
{
return 0;
}
return myTriangleFans->ColLength();
}

89
src/StepVisual/StepVisual_ComplexTriangulatedFace.hxx Normal file
View File

@ -0,0 +1,89 @@
// 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 _StepVisual_ComplexTriangulatedFace_HeaderFile_
#define _StepVisual_ComplexTriangulatedFace_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedFace.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray2OfInteger.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_ComplexTriangulatedFace, StepVisual_TessellatedFace)
//! Representation of STEP entity ComplexTriangulatedFace
class StepVisual_ComplexTriangulatedFace : public StepVisual_TessellatedFace
{
public :
//! default constructor
Standard_EXPORT StepVisual_ComplexTriangulatedFace();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theTessellatedFace_Coordinates,
const Standard_Integer theTessellatedFace_Pnmax,
const Handle(TColStd_HArray2OfReal)& theTessellatedFace_Normals,
const Standard_Boolean theHasTessellatedFace_GeometricLink,
const StepVisual_FaceOrSurface& theTessellatedFace_GeometricLink,
const Handle(TColStd_HArray1OfInteger)& thePnindex,
const Handle(TColStd_HArray2OfInteger)& theTriangleStrips,
const Handle(TColStd_HArray2OfInteger)& theTriangleFans);
//! Returns field Pnindex
Standard_EXPORT Handle(TColStd_HArray1OfInteger) Pnindex() const;
//! Sets field Pnindex
Standard_EXPORT void SetPnindex (const Handle(TColStd_HArray1OfInteger)& thePnindex);
//! Returns number of Pnindex
Standard_EXPORT Standard_Integer NbPnindex() const;
//! Returns value of Pnindex by its num
Standard_EXPORT Standard_Integer PnindexValue(const Standard_Integer theNum) const;
//! Returns field TriangleStrips
Standard_EXPORT Handle(TColStd_HArray2OfInteger) TriangleStrips() const;
//! Sets field TriangleStrips
Standard_EXPORT void SetTriangleStrips (const Handle(TColStd_HArray2OfInteger)& theTriangleStrips);
//! Returns number of TriangleStrips
Standard_EXPORT Standard_Integer NbTriangleStrips() const;
//! Returns field TriangleFans
Standard_EXPORT Handle(TColStd_HArray2OfInteger) TriangleFans() const;
//! Sets field TriangleFans
Standard_EXPORT void SetTriangleFans (const Handle(TColStd_HArray2OfInteger)& theTriangleFans);
//! Returns number of TriangleFans
Standard_EXPORT Standard_Integer NbTriangleFans() const;
DEFINE_STANDARD_RTTIEXT(StepVisual_ComplexTriangulatedFace, StepVisual_TessellatedFace)
private:
Handle(TColStd_HArray1OfInteger) myPnindex;
Handle(TColStd_HArray2OfInteger) myTriangleStrips;
Handle(TColStd_HArray2OfInteger) myTriangleFans;
};
#endif // _StepVisual_ComplexTriangulatedFace_HeaderFile_

167
src/StepVisual/StepVisual_ComplexTriangulatedSurfaceSet.cxx Normal file
View File

@ -0,0 +1,167 @@
// 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 <StepVisual_ComplexTriangulatedSurfaceSet.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_ComplexTriangulatedSurfaceSet, StepVisual_TessellatedSurfaceSet)
//=======================================================================
//function : StepVisual_ComplexTriangulatedSurfaceSet
//purpose :
//=======================================================================
StepVisual_ComplexTriangulatedSurfaceSet::StepVisual_ComplexTriangulatedSurfaceSet ()
{
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_ComplexTriangulatedSurfaceSet::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theTessellatedSurfaceSet_Coordinates,
const Standard_Integer theTessellatedSurfaceSet_Pnmax,
const Handle(TColStd_HArray2OfReal)& theTessellatedSurfaceSet_Normals,
const Handle(TColStd_HArray1OfInteger)& thePnindex,
const Handle(TColStd_HArray2OfInteger)& theTriangleStrips,
const Handle(TColStd_HArray2OfInteger)& theTriangleFans)
{
StepVisual_TessellatedSurfaceSet::Init(theRepresentationItem_Name,
theTessellatedSurfaceSet_Coordinates,
theTessellatedSurfaceSet_Pnmax,
theTessellatedSurfaceSet_Normals);
myPnindex = thePnindex;
myTriangleStrips = theTriangleStrips;
myTriangleFans = theTriangleFans;
}
//=======================================================================
//function : Pnindex
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfInteger) StepVisual_ComplexTriangulatedSurfaceSet::Pnindex () const
{
return myPnindex;
}
//=======================================================================
//function : SetPnindex
//purpose :
//=======================================================================
void StepVisual_ComplexTriangulatedSurfaceSet::SetPnindex(const Handle(TColStd_HArray1OfInteger)& thePnindex)
{
myPnindex = thePnindex;
}
//=======================================================================
//function : NbPnindex
//purpose :
//=======================================================================
Standard_Integer StepVisual_ComplexTriangulatedSurfaceSet::NbPnindex() const
{
if (myPnindex.IsNull())
{
return 0;
}
return myPnindex->Length();
}
//=======================================================================
//function : PnindexValue
//purpose :
//=======================================================================
Standard_Integer StepVisual_ComplexTriangulatedSurfaceSet::PnindexValue(const Standard_Integer theNum) const
{
return myPnindex->Value(theNum);
}
//=======================================================================
//function : TriangleStrips
//purpose :
//=======================================================================
Handle(TColStd_HArray2OfInteger) StepVisual_ComplexTriangulatedSurfaceSet::TriangleStrips () const
{
return myTriangleStrips;
}
//=======================================================================
//function : SetTriangleStrips
//purpose :
//=======================================================================
void StepVisual_ComplexTriangulatedSurfaceSet::SetTriangleStrips(const Handle(TColStd_HArray2OfInteger)& theTriangleStrips)
{
myTriangleStrips = theTriangleStrips;
}
//=======================================================================
//function : NbTriangleStrips
//purpose :
//=======================================================================
Standard_Integer StepVisual_ComplexTriangulatedSurfaceSet::NbTriangleStrips() const
{
if (myTriangleStrips.IsNull())
{
return 0;
}
return myTriangleStrips->ColLength();
}
//=======================================================================
//function : TriangleFans
//purpose :
//=======================================================================
Handle(TColStd_HArray2OfInteger) StepVisual_ComplexTriangulatedSurfaceSet::TriangleFans () const
{
return myTriangleFans;
}
//=======================================================================
//function : SetTriangleFans
//purpose :
//=======================================================================
void StepVisual_ComplexTriangulatedSurfaceSet::SetTriangleFans(const Handle(TColStd_HArray2OfInteger)& theTriangleFans)
{
myTriangleFans = theTriangleFans;
}
//=======================================================================
//function : NbTriangleFans
//purpose :
//=======================================================================
Standard_Integer StepVisual_ComplexTriangulatedSurfaceSet::NbTriangleFans() const
{
if (myTriangleFans.IsNull())
{
return 0;
}
return myTriangleFans->ColLength();
}

87
src/StepVisual/StepVisual_ComplexTriangulatedSurfaceSet.hxx Normal file
View File

@ -0,0 +1,87 @@
// 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 _StepVisual_ComplexTriangulatedSurfaceSet_HeaderFile_
#define _StepVisual_ComplexTriangulatedSurfaceSet_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedSurfaceSet.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray2OfInteger.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_ComplexTriangulatedSurfaceSet, StepVisual_TessellatedSurfaceSet)
//! Representation of STEP entity ComplexTriangulatedSurfaceSet
class StepVisual_ComplexTriangulatedSurfaceSet : public StepVisual_TessellatedSurfaceSet
{
public :
//! default constructor
Standard_EXPORT StepVisual_ComplexTriangulatedSurfaceSet();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theTessellatedSurfaceSet_Coordinates,
const Standard_Integer theTessellatedSurfaceSet_Pnmax,
const Handle(TColStd_HArray2OfReal)& theTessellatedSurfaceSet_Normals,
const Handle(TColStd_HArray1OfInteger)& thePnindex,
const Handle(TColStd_HArray2OfInteger)& theTriangleStrips,
const Handle(TColStd_HArray2OfInteger)& theTriangleFans);
//! Returns field Pnindex
Standard_EXPORT Handle(TColStd_HArray1OfInteger) Pnindex() const;
//! Sets field Pnindex
Standard_EXPORT void SetPnindex (const Handle(TColStd_HArray1OfInteger)& thePnindex);
//! Returns number of Pnindex
Standard_EXPORT Standard_Integer NbPnindex() const;
//! Returns value of Pnindex by its num
Standard_EXPORT Standard_Integer PnindexValue(const Standard_Integer theNum) const;
//! Returns field TriangleStrips
Standard_EXPORT Handle(TColStd_HArray2OfInteger) TriangleStrips() const;
//! Sets field TriangleStrips
Standard_EXPORT void SetTriangleStrips (const Handle(TColStd_HArray2OfInteger)& theTriangleStrips);
//! Returns number of TriangleStrips
Standard_EXPORT Standard_Integer NbTriangleStrips() const;
//! Returns field TriangleFans
Standard_EXPORT Handle(TColStd_HArray2OfInteger) TriangleFans() const;
//! Sets field TriangleFans
Standard_EXPORT void SetTriangleFans (const Handle(TColStd_HArray2OfInteger)& theTriangleFans);
//! Returns number of TriangleFans
Standard_EXPORT Standard_Integer NbTriangleFans() const;
DEFINE_STANDARD_RTTIEXT(StepVisual_ComplexTriangulatedSurfaceSet, StepVisual_TessellatedSurfaceSet)
private:
Handle(TColStd_HArray1OfInteger) myPnindex;
Handle(TColStd_HArray2OfInteger) myTriangleStrips;
Handle(TColStd_HArray2OfInteger) myTriangleFans;
};
#endif // _StepVisual_ComplexTriangulatedSurfaceSet_HeaderFile_

28
src/StepVisual/StepVisual_CubicBezierTessellatedEdge.cxx Normal file
View File

@ -0,0 +1,28 @@
// 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 <StepVisual_CubicBezierTessellatedEdge.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CubicBezierTessellatedEdge, StepVisual_TessellatedEdge)
//=======================================================================
//function : StepVisual_CubicBezierTessellatedEdge
//purpose :
//=======================================================================
StepVisual_CubicBezierTessellatedEdge::StepVisual_CubicBezierTessellatedEdge ()
{
}

40
src/StepVisual/StepVisual_CubicBezierTessellatedEdge.hxx Normal file
View File

@ -0,0 +1,40 @@
// 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 _StepVisual_CubicBezierTessellatedEdge_HeaderFile_
#define _StepVisual_CubicBezierTessellatedEdge_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedEdge.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_CubicBezierTessellatedEdge, StepVisual_TessellatedEdge)
//! Representation of STEP entity CubicBezierTessellatedEdge
class StepVisual_CubicBezierTessellatedEdge : public StepVisual_TessellatedEdge
{
public :
//! default constructor
Standard_EXPORT StepVisual_CubicBezierTessellatedEdge();
DEFINE_STANDARD_RTTIEXT(StepVisual_CubicBezierTessellatedEdge, StepVisual_TessellatedEdge)
};
#endif // _StepVisual_CubicBezierTessellatedEdge_HeaderFile_

80
src/StepVisual/StepVisual_CubicBezierTriangulatedFace.cxx Normal file
View File

@ -0,0 +1,80 @@
// 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 <StepVisual_CubicBezierTriangulatedFace.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_CubicBezierTriangulatedFace, StepVisual_TessellatedFace)
//=======================================================================
//function : StepVisual_CubicBezierTriangulatedFace
//purpose :
//=======================================================================
StepVisual_CubicBezierTriangulatedFace::StepVisual_CubicBezierTriangulatedFace ()
{
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_CubicBezierTriangulatedFace::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theTessellatedFace_Coordinates,
const Standard_Integer theTessellatedFace_Pnmax,
const Handle(TColStd_HArray2OfReal)& theTessellatedFace_Normals,
const Standard_Boolean theHasTessellatedFace_GeometricLink,
const StepVisual_FaceOrSurface& theTessellatedFace_GeometricLink,
const Handle(TColStd_HArray2OfInteger)& theCtriangles)
{
StepVisual_TessellatedFace::Init(theRepresentationItem_Name,
theTessellatedFace_Coordinates,
theTessellatedFace_Pnmax,
theTessellatedFace_Normals,
theHasTessellatedFace_GeometricLink,
theTessellatedFace_GeometricLink);
myCtriangles = theCtriangles;
}
//=======================================================================
//function : Ctriangles
//purpose :
//=======================================================================
Handle(TColStd_HArray2OfInteger) StepVisual_CubicBezierTriangulatedFace::Ctriangles () const
{
return myCtriangles;
}
//=======================================================================
//function : SetCtriangles
//purpose :
//=======================================================================
void StepVisual_CubicBezierTriangulatedFace::SetCtriangles(const Handle(TColStd_HArray2OfInteger)& theCtriangles)
{
myCtriangles = theCtriangles;
}
Standard_Integer StepVisual_CubicBezierTriangulatedFace::NbCtriangles() const
{
if (myCtriangles.IsNull())
{
return 0;
}
return myCtriangles->ColLength();
}

63
src/StepVisual/StepVisual_CubicBezierTriangulatedFace.hxx Normal file
View File

@ -0,0 +1,63 @@
// 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 _StepVisual_CubicBezierTriangulatedFace_HeaderFile_
#define _StepVisual_CubicBezierTriangulatedFace_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedFace.hxx>
#include <TColStd_HArray2OfInteger.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_CubicBezierTriangulatedFace, StepVisual_TessellatedFace)
//! Representation of STEP entity CubicBezierTriangulatedFace
class StepVisual_CubicBezierTriangulatedFace : public StepVisual_TessellatedFace
{
public :
//! default constructor
Standard_EXPORT StepVisual_CubicBezierTriangulatedFace();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theTessellatedFace_Coordinates,
const Standard_Integer theTessellatedFace_Pnmax,
const Handle(TColStd_HArray2OfReal)& theTessellatedFace_Normals,
const Standard_Boolean theHasTessellatedFace_GeometricLink,
const StepVisual_FaceOrSurface& theTessellatedFace_GeometricLink,
const Handle(TColStd_HArray2OfInteger)& theCtriangles);
//! Returns field Ctriangles
Standard_EXPORT Handle(TColStd_HArray2OfInteger) Ctriangles() const;
//! Sets field Ctriangles
Standard_EXPORT void SetCtriangles (const Handle(TColStd_HArray2OfInteger)& theCtriangles);
//! Returns number of Ctriangles
Standard_EXPORT Standard_Integer NbCtriangles() const;
DEFINE_STANDARD_RTTIEXT(StepVisual_CubicBezierTriangulatedFace, StepVisual_TessellatedFace)
private:
Handle(TColStd_HArray2OfInteger) myCtriangles;
};
#endif // _StepVisual_CubicBezierTriangulatedFace_HeaderFile_

61
src/StepVisual/StepVisual_EdgeOrCurve.cxx Normal file
View File

@ -0,0 +1,61 @@
// 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 <StepVisual_EdgeOrCurve.hxx>
#include <StepGeom_Curve.hxx>
#include <StepShape_Edge.hxx>
//=======================================================================
//function : StepVisual_EdgeOrCurve
//purpose :
//=======================================================================
StepVisual_EdgeOrCurve::StepVisual_EdgeOrCurve ()
{
}
//=======================================================================
//function : CaseNum
//purpose :
//=======================================================================
Standard_Integer StepVisual_EdgeOrCurve::CaseNum (const Handle(Standard_Transient)& ent) const
{
if (ent.IsNull()) return 0;
if (ent->IsKind(STANDARD_TYPE(StepGeom_Curve))) return 1;
if (ent->IsKind(STANDARD_TYPE(StepShape_Edge))) return 2;
return 0;
}
//=======================================================================
//function : Curve
//purpose :
//=======================================================================
Handle(StepGeom_Curve) StepVisual_EdgeOrCurve::Curve () const
{
return Handle(StepGeom_Curve)::DownCast(Value());
}
//=======================================================================
//function : Edge
//purpose :
//=======================================================================
Handle(StepShape_Edge) StepVisual_EdgeOrCurve::Edge () const
{
return Handle(StepShape_Edge)::DownCast(Value());
}

53
src/StepVisual/StepVisual_EdgeOrCurve.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 _StepVisual_EdgeOrCurve_HeaderFile
#define _StepVisual_EdgeOrCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <StepData_SelectType.hxx>
#include <Standard_Integer.hxx>
class Standard_Transient;
class StepGeom_Curve;
class StepShape_Edge;
//! Representation of STEP SELECT type EdgeOrCurve
class StepVisual_EdgeOrCurve : public StepData_SelectType
{
public:
DEFINE_STANDARD_ALLOC
//! Empty constructor
Standard_EXPORT StepVisual_EdgeOrCurve();
//! Recognizes a kind of EdgeOrCurve select type
//! -- 1 -> Curve
//! -- 2 -> Edge
Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE;
//! Returns Value as Curve (or Null if another type)
Standard_EXPORT Handle(StepGeom_Curve) Curve() const;
//! Returns Value as Edge (or Null if another type)
Standard_EXPORT Handle(StepShape_Edge) Edge() const;
};
#endif // _StepVisual_EdgeOrCurve_HeaderFile

61
src/StepVisual/StepVisual_FaceOrSurface.cxx Normal file
View File

@ -0,0 +1,61 @@
// 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 <StepVisual_FaceOrSurface.hxx>
#include <StepShape_Face.hxx>
#include <StepGeom_Surface.hxx>
//=======================================================================
//function : StepVisual_FaceOrSurface
//purpose :
//=======================================================================
StepVisual_FaceOrSurface::StepVisual_FaceOrSurface ()
{
}
//=======================================================================
//function : CaseNum
//purpose :
//=======================================================================
Standard_Integer StepVisual_FaceOrSurface::CaseNum (const Handle(Standard_Transient)& ent) const
{
if (ent.IsNull()) return 0;
if (ent->IsKind(STANDARD_TYPE(StepShape_Face))) return 1;
if (ent->IsKind(STANDARD_TYPE(StepGeom_Surface))) return 2;
return 0;
}
//=======================================================================
//function : Face
//purpose :
//=======================================================================
Handle(StepShape_Face) StepVisual_FaceOrSurface::Face () const
{
return Handle(StepShape_Face)::DownCast(Value());
}
//=======================================================================
//function : Surface
//purpose :
//=======================================================================
Handle(StepGeom_Surface) StepVisual_FaceOrSurface::Surface () const
{
return Handle(StepGeom_Surface)::DownCast(Value());
}

53
src/StepVisual/StepVisual_FaceOrSurface.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 _StepVisual_FaceOrSurface_HeaderFile
#define _StepVisual_FaceOrSurface_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <StepData_SelectType.hxx>
#include <Standard_Integer.hxx>
class Standard_Transient;
class StepShape_Face;
class StepGeom_Surface;
//! Representation of STEP SELECT type FaceOrSurface
class StepVisual_FaceOrSurface : public StepData_SelectType
{
public:
DEFINE_STANDARD_ALLOC
//! Empty constructor
Standard_EXPORT StepVisual_FaceOrSurface();
//! Recognizes a kind of FaceOrSurface select type
//! -- 1 -> Face
//! -- 2 -> Surface
Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE;
//! Returns Value as Face (or Null if another type)
Standard_EXPORT Handle(StepShape_Face) Face() const;
//! Returns Value as Surface (or Null if another type)
Standard_EXPORT Handle(StepGeom_Surface) Surface() const;
};
#endif // _StepVisual_FaceOrSurface_HeaderFile

26
src/StepVisual/StepVisual_HArray1OfTessellatedEdgeOrVertex.hxx Normal file
View File

@ -0,0 +1,26 @@
// 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 StepVisual_HArray1OfTessellatedEdgeOrVertex_HeaderFile
#define StepVisual_HArray1OfTessellatedEdgeOrVertex_HeaderFile
#include <StepVisual_Array1OfTessellatedEdgeOrVertex.hxx>
#include <NCollection_HArray1.hxx>
DEFINE_HARRAY1(StepVisual_HArray1OfTessellatedEdgeOrVertex, StepVisual_Array1OfTessellatedEdgeOrVertex);
#endif

26
src/StepVisual/StepVisual_HArray1OfTessellatedStructuredItem.hxx Normal file
View File

@ -0,0 +1,26 @@
// 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 StepVisual_HArray1OfTessellatedStructuredItem_HeaderFile
#define StepVisual_HArray1OfTessellatedStructuredItem_HeaderFile
#include <StepVisual_Array1OfTessellatedStructuredItem.hxx>
#include <NCollection_HArray1.hxx>
DEFINE_HARRAY1(StepVisual_HArray1OfTessellatedStructuredItem, StepVisual_Array1OfTessellatedStructuredItem);
#endif

61
src/StepVisual/StepVisual_PathOrCompositeCurve.cxx Normal file
View File

@ -0,0 +1,61 @@
// 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 <StepVisual_PathOrCompositeCurve.hxx>
#include <StepGeom_CompositeCurve.hxx>
#include <StepShape_Path.hxx>
//=======================================================================
//function : StepVisual_PathOrCompositeCurve
//purpose :
//=======================================================================
StepVisual_PathOrCompositeCurve::StepVisual_PathOrCompositeCurve ()
{
}
//=======================================================================
//function : CaseNum
//purpose :
//=======================================================================
Standard_Integer StepVisual_PathOrCompositeCurve::CaseNum (const Handle(Standard_Transient)& ent) const
{
if (ent.IsNull()) return 0;
if (ent->IsKind(STANDARD_TYPE(StepGeom_CompositeCurve))) return 1;
if (ent->IsKind(STANDARD_TYPE(StepShape_Path))) return 2;
return 0;
}
//=======================================================================
//function : CompositeCurve
//purpose :
//=======================================================================
Handle(StepGeom_CompositeCurve) StepVisual_PathOrCompositeCurve::CompositeCurve () const
{
return Handle(StepGeom_CompositeCurve)::DownCast(Value());
}
//=======================================================================
//function : Path
//purpose :
//=======================================================================
Handle(StepShape_Path) StepVisual_PathOrCompositeCurve::Path () const
{
return Handle(StepShape_Path)::DownCast(Value());
}

53
src/StepVisual/StepVisual_PathOrCompositeCurve.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 _StepVisual_PathOrCompositeCurve_HeaderFile
#define _StepVisual_PathOrCompositeCurve_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <StepData_SelectType.hxx>
#include <Standard_Integer.hxx>
class Standard_Transient;
class StepGeom_CompositeCurve;
class StepShape_Path;
//! Representation of STEP SELECT type PathOrCompositeCurve
class StepVisual_PathOrCompositeCurve : public StepData_SelectType
{
public:
DEFINE_STANDARD_ALLOC
//! Empty constructor
Standard_EXPORT StepVisual_PathOrCompositeCurve();
//! Recognizes a kind of PathOrCompositeCurve select type
//! -- 1 -> CompositeCurve
//! -- 2 -> Path
Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE;
//! Returns Value as CompositeCurve (or Null if another type)
Standard_EXPORT Handle(StepGeom_CompositeCurve) CompositeCurve() const;
//! Returns Value as Path (or Null if another type)
Standard_EXPORT Handle(StepShape_Path) Path() const;
};
#endif // _StepVisual_PathOrCompositeCurve_HeaderFile

213
src/StepVisual/StepVisual_TessellatedConnectingEdge.cxx Normal file
View File

@ -0,0 +1,213 @@
// 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 <StepVisual_TessellatedConnectingEdge.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedConnectingEdge, StepVisual_TessellatedEdge)
//=======================================================================
//function : StepVisual_TessellatedConnectingEdge
//purpose :
//=======================================================================
StepVisual_TessellatedConnectingEdge::StepVisual_TessellatedConnectingEdge ()
{
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TessellatedConnectingEdge::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theTessellatedEdge_Coordinates,
const Standard_Boolean theHasTessellatedEdge_GeometricLink,
const StepVisual_EdgeOrCurve& theTessellatedEdge_GeometricLink,
const Handle(TColStd_HArray1OfInteger)& theTessellatedEdge_LineStrip,
const StepData_Logical theSmooth,
const Handle(StepVisual_TessellatedFace)& theFace1,
const Handle(StepVisual_TessellatedFace)& theFace2,
const Handle(TColStd_HArray1OfInteger)& theLineStripFace1,
const Handle(TColStd_HArray1OfInteger)& theLineStripFace2)
{
StepVisual_TessellatedEdge::Init(theRepresentationItem_Name,
theTessellatedEdge_Coordinates,
theHasTessellatedEdge_GeometricLink,
theTessellatedEdge_GeometricLink,
theTessellatedEdge_LineStrip);
mySmooth = theSmooth;
myFace1 = theFace1;
myFace2 = theFace2;
myLineStripFace1 = theLineStripFace1;
myLineStripFace2 = theLineStripFace2;
}
//=======================================================================
//function : Smooth
//purpose :
//=======================================================================
StepData_Logical StepVisual_TessellatedConnectingEdge::Smooth () const
{
return mySmooth;
}
//=======================================================================
//function : SetSmooth
//purpose :
//=======================================================================
void StepVisual_TessellatedConnectingEdge::SetSmooth(const StepData_Logical theSmooth)
{
mySmooth = theSmooth;
}
//=======================================================================
//function : Face1
//purpose :
//=======================================================================
Handle(StepVisual_TessellatedFace) StepVisual_TessellatedConnectingEdge::Face1 () const
{
return myFace1;
}
//=======================================================================
//function : SetFace1
//purpose :
//=======================================================================
void StepVisual_TessellatedConnectingEdge::SetFace1(const Handle(StepVisual_TessellatedFace)& theFace1)
{
myFace1 = theFace1;
}
//=======================================================================
//function : Face2
//purpose :
//=======================================================================
Handle(StepVisual_TessellatedFace) StepVisual_TessellatedConnectingEdge::Face2 () const
{
return myFace2;
}
//=======================================================================
//function : SetFace2
//purpose :
//=======================================================================
void StepVisual_TessellatedConnectingEdge::SetFace2(const Handle(StepVisual_TessellatedFace)& theFace2)
{
myFace2 = theFace2;
}
//=======================================================================
//function : LineStripFace1
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfInteger) StepVisual_TessellatedConnectingEdge::LineStripFace1 () const
{
return myLineStripFace1;
}
//=======================================================================
//function : SetLineStripFace1
//purpose :
//=======================================================================
void StepVisual_TessellatedConnectingEdge::SetLineStripFace1(const Handle(TColStd_HArray1OfInteger)& theLineStripFace1)
{
myLineStripFace1 = theLineStripFace1;
}
//=======================================================================
//function : NbLineStripFace1
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedConnectingEdge::NbLineStripFace1() const
{
if (myLineStripFace1.IsNull())
{
return 0;
}
return myLineStripFace1->Length();
}
//=======================================================================
//function : LineStripFace1Value
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedConnectingEdge::LineStripFace1Value(const Standard_Integer theNum) const
{
return myLineStripFace1->Value(theNum);
}
//=======================================================================
//function : LineStripFace2
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfInteger) StepVisual_TessellatedConnectingEdge::LineStripFace2 () const
{
return myLineStripFace2;
}
//=======================================================================
//function : SetLineStripFace2
//purpose :
//=======================================================================
void StepVisual_TessellatedConnectingEdge::SetLineStripFace2(const Handle(TColStd_HArray1OfInteger)& theLineStripFace2)
{
myLineStripFace2 = theLineStripFace2;
}
//=======================================================================
//function : NbLineStripFace2
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedConnectingEdge::NbLineStripFace2() const
{
if (myLineStripFace2.IsNull())
{
return 0;
}
return myLineStripFace2->Length();
}
//=======================================================================
//function : LineStripFace2Value
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedConnectingEdge::LineStripFace2Value(const Standard_Integer theNum) const
{
return myLineStripFace2->Value(theNum);
}

105
src/StepVisual/StepVisual_TessellatedConnectingEdge.hxx Normal file
View File

@ -0,0 +1,105 @@
// 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 _StepVisual_TessellatedConnectingEdge_HeaderFile_
#define _StepVisual_TessellatedConnectingEdge_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedEdge.hxx>
#include <StepData_Logical.hxx>
#include <StepVisual_TessellatedFace.hxx>
#include <TColStd_HArray1OfInteger.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedConnectingEdge, StepVisual_TessellatedEdge)
//! Representation of STEP entity TessellatedConnectingEdge
class StepVisual_TessellatedConnectingEdge : public StepVisual_TessellatedEdge
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedConnectingEdge();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theTessellatedEdge_Coordinates,
const Standard_Boolean theHasTessellatedEdge_GeometricLink,
const StepVisual_EdgeOrCurve& theTessellatedEdge_GeometricLink,
const Handle(TColStd_HArray1OfInteger)& theTessellatedEdge_LineStrip,
const StepData_Logical theSmooth,
const Handle(StepVisual_TessellatedFace)& theFace1,
const Handle(StepVisual_TessellatedFace)& theFace2,
const Handle(TColStd_HArray1OfInteger)& theLineStripFace1,
const Handle(TColStd_HArray1OfInteger)& theLineStripFace2);
//! Returns field Smooth
Standard_EXPORT StepData_Logical Smooth() const;
//! Sets field Smooth
Standard_EXPORT void SetSmooth (const StepData_Logical theSmooth);
//! Returns field Face1
Standard_EXPORT Handle(StepVisual_TessellatedFace) Face1() const;
//! Sets field Face1
Standard_EXPORT void SetFace1 (const Handle(StepVisual_TessellatedFace)& theFace1);
//! Returns field Face2
Standard_EXPORT Handle(StepVisual_TessellatedFace) Face2() const;
//! Sets field Face2
Standard_EXPORT void SetFace2 (const Handle(StepVisual_TessellatedFace)& theFace2);
//! Returns field LineStripFace1
Standard_EXPORT Handle(TColStd_HArray1OfInteger) LineStripFace1() const;
//! Sets field LineStripFace1
Standard_EXPORT void SetLineStripFace1 (const Handle(TColStd_HArray1OfInteger)& theLineStripFace1);
//! Returns number of LineStripFace1
Standard_EXPORT Standard_Integer NbLineStripFace1() const;
//! Returns value of LineStripFace1 by its num
Standard_EXPORT Standard_Integer LineStripFace1Value(const Standard_Integer theNum) const;
//! Returns field LineStripFace2
Standard_EXPORT Handle(TColStd_HArray1OfInteger) LineStripFace2() const;
//! Sets field LineStripFace2
Standard_EXPORT void SetLineStripFace2 (const Handle(TColStd_HArray1OfInteger)& theLineStripFace2);
//! Returns number of LineStripFace2
Standard_EXPORT Standard_Integer NbLineStripFace2() const;
//! Returns value of LineStripFace2 by its num
Standard_EXPORT Standard_Integer LineStripFace2Value(const Standard_Integer theNum) const;
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedConnectingEdge, StepVisual_TessellatedEdge)
private:
StepData_Logical mySmooth;
Handle(StepVisual_TessellatedFace) myFace1;
Handle(StepVisual_TessellatedFace) myFace2;
Handle(TColStd_HArray1OfInteger) myLineStripFace1;
Handle(TColStd_HArray1OfInteger) myLineStripFace2;
};
#endif // _StepVisual_TessellatedConnectingEdge_HeaderFile_

153
src/StepVisual/StepVisual_TessellatedEdge.cxx Normal file
View File

@ -0,0 +1,153 @@
// 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 <StepVisual_TessellatedEdge.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedEdge, StepVisual_TessellatedStructuredItem)
//=======================================================================
//function : StepVisual_TessellatedEdge
//purpose :
//=======================================================================
StepVisual_TessellatedEdge::StepVisual_TessellatedEdge ()
{
myHasGeometricLink = Standard_False;
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TessellatedEdge::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theCoordinates,
const Standard_Boolean theHasGeometricLink,
const StepVisual_EdgeOrCurve& theGeometricLink,
const Handle(TColStd_HArray1OfInteger)& theLineStrip)
{
StepVisual_TessellatedStructuredItem::Init(theRepresentationItem_Name);
myCoordinates = theCoordinates;
myHasGeometricLink = theHasGeometricLink;
if (myHasGeometricLink)
{
myGeometricLink = theGeometricLink;
}
else
{
myGeometricLink = StepVisual_EdgeOrCurve();
}
myLineStrip = theLineStrip;
}
//=======================================================================
//function : Coordinates
//purpose :
//=======================================================================
Handle(StepVisual_CoordinatesList) StepVisual_TessellatedEdge::Coordinates () const
{
return myCoordinates;
}
//=======================================================================
//function : SetCoordinates
//purpose :
//=======================================================================
void StepVisual_TessellatedEdge::SetCoordinates(const Handle(StepVisual_CoordinatesList)& theCoordinates)
{
myCoordinates = theCoordinates;
}
//=======================================================================
//function : GeometricLink
//purpose :
//=======================================================================
StepVisual_EdgeOrCurve StepVisual_TessellatedEdge::GeometricLink () const
{
return myGeometricLink;
}
//=======================================================================
//function : SetGeometricLink
//purpose :
//=======================================================================
void StepVisual_TessellatedEdge::SetGeometricLink(const StepVisual_EdgeOrCurve& theGeometricLink)
{
myGeometricLink = theGeometricLink;
}
//=======================================================================
//function : HasGeometricLink
//purpose :
//=======================================================================
Standard_Boolean StepVisual_TessellatedEdge::HasGeometricLink () const
{
return myHasGeometricLink;
}
//=======================================================================
//function : LineStrip
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfInteger) StepVisual_TessellatedEdge::LineStrip () const
{
return myLineStrip;
}
//=======================================================================
//function : SetLineStrip
//purpose :
//=======================================================================
void StepVisual_TessellatedEdge::SetLineStrip(const Handle(TColStd_HArray1OfInteger)& theLineStrip)
{
myLineStrip = theLineStrip;
}
//=======================================================================
//function : NbLineStrip
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedEdge::NbLineStrip() const
{
if (myLineStrip.IsNull())
{
return 0;
}
return myLineStrip->Length();
}
//=======================================================================
//function : LineStripValue
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedEdge::LineStripValue(const Standard_Integer theNum) const
{
return myLineStrip->Value(theNum);
}

84
src/StepVisual/StepVisual_TessellatedEdge.hxx Normal file
View File

@ -0,0 +1,84 @@
// 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 _StepVisual_TessellatedEdge_HeaderFile_
#define _StepVisual_TessellatedEdge_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <StepVisual_EdgeOrCurve.hxx>
#include <TColStd_HArray1OfInteger.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedEdge, StepVisual_TessellatedStructuredItem)
//! Representation of STEP entity TessellatedEdge
class StepVisual_TessellatedEdge : public StepVisual_TessellatedStructuredItem
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedEdge();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theCoordinates,
const Standard_Boolean theHasGeometricLink,
const StepVisual_EdgeOrCurve& theGeometricLink,
const Handle(TColStd_HArray1OfInteger)& theLineStrip);
//! Returns field Coordinates
Standard_EXPORT Handle(StepVisual_CoordinatesList) Coordinates() const;
//! Sets field Coordinates
Standard_EXPORT void SetCoordinates (const Handle(StepVisual_CoordinatesList)& theCoordinates);
//! Returns field GeometricLink
Standard_EXPORT StepVisual_EdgeOrCurve GeometricLink() const;
//! Sets field GeometricLink
Standard_EXPORT void SetGeometricLink (const StepVisual_EdgeOrCurve& theGeometricLink);
//! Returns True if optional field GeometricLink is defined
Standard_EXPORT Standard_Boolean HasGeometricLink() const;
//! Returns field LineStrip
Standard_EXPORT Handle(TColStd_HArray1OfInteger) LineStrip() const;
//! Sets field LineStrip
Standard_EXPORT void SetLineStrip (const Handle(TColStd_HArray1OfInteger)& theLineStrip);
//! Returns number of LineStrip
Standard_EXPORT Standard_Integer NbLineStrip() const;
//! Returns value of LineStrip by its num
Standard_EXPORT Standard_Integer LineStripValue(const Standard_Integer theNum) const;
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedEdge, StepVisual_TessellatedStructuredItem)
private:
Handle(StepVisual_CoordinatesList) myCoordinates;
StepVisual_EdgeOrCurve myGeometricLink; //!< optional
Handle(TColStd_HArray1OfInteger) myLineStrip;
Standard_Boolean myHasGeometricLink; //!< flag "is GeometricLink defined"
};
#endif // _StepVisual_TessellatedEdge_HeaderFile_

61
src/StepVisual/StepVisual_TessellatedEdgeOrVertex.cxx Normal file
View File

@ -0,0 +1,61 @@
// 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 <StepVisual_TessellatedEdgeOrVertex.hxx>
#include <StepVisual_TessellatedEdge.hxx>
#include <StepVisual_TessellatedVertex.hxx>
//=======================================================================
//function : StepVisual_TessellatedEdgeOrVertex
//purpose :
//=======================================================================
StepVisual_TessellatedEdgeOrVertex::StepVisual_TessellatedEdgeOrVertex ()
{
}
//=======================================================================
//function : CaseNum
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedEdgeOrVertex::CaseNum (const Handle(Standard_Transient)& ent) const
{
if (ent.IsNull()) return 0;
if (ent->IsKind(STANDARD_TYPE(StepVisual_TessellatedEdge))) return 1;
if (ent->IsKind(STANDARD_TYPE(StepVisual_TessellatedVertex))) return 2;
return 0;
}
//=======================================================================
//function : TessellatedEdge
//purpose :
//=======================================================================
Handle(StepVisual_TessellatedEdge) StepVisual_TessellatedEdgeOrVertex::TessellatedEdge () const
{
return Handle(StepVisual_TessellatedEdge)::DownCast(Value());
}
//=======================================================================
//function : TessellatedVertex
//purpose :
//=======================================================================
Handle(StepVisual_TessellatedVertex) StepVisual_TessellatedEdgeOrVertex::TessellatedVertex () const
{
return Handle(StepVisual_TessellatedVertex)::DownCast(Value());
}

53
src/StepVisual/StepVisual_TessellatedEdgeOrVertex.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 _StepVisual_TessellatedEdgeOrVertex_HeaderFile
#define _StepVisual_TessellatedEdgeOrVertex_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <StepData_SelectType.hxx>
#include <Standard_Integer.hxx>
class Standard_Transient;
class StepVisual_TessellatedEdge;
class StepVisual_TessellatedVertex;
//! Representation of STEP SELECT type TessellatedEdgeOrVertex
class StepVisual_TessellatedEdgeOrVertex : public StepData_SelectType
{
public:
DEFINE_STANDARD_ALLOC
//! Empty constructor
Standard_EXPORT StepVisual_TessellatedEdgeOrVertex();
//! Recognizes a kind of TessellatedEdgeOrVertex select type
//! -- 1 -> TessellatedEdge
//! -- 2 -> TessellatedVertex
Standard_EXPORT Standard_Integer CaseNum (const Handle(Standard_Transient)& ent) const Standard_OVERRIDE;
//! Returns Value as TessellatedEdge (or Null if another type)
Standard_EXPORT Handle(StepVisual_TessellatedEdge) TessellatedEdge() const;
//! Returns Value as TessellatedVertex (or Null if another type)
Standard_EXPORT Handle(StepVisual_TessellatedVertex) TessellatedVertex() const;
};
#endif // _StepVisual_TessellatedEdgeOrVertex_HeaderFile

164
src/StepVisual/StepVisual_TessellatedFace.cxx Normal file
View File

@ -0,0 +1,164 @@
// 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 <StepVisual_TessellatedFace.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedFace, StepVisual_TessellatedStructuredItem)
//=======================================================================
//function : StepVisual_TessellatedFace
//purpose :
//=======================================================================
StepVisual_TessellatedFace::StepVisual_TessellatedFace ()
{
myHasGeometricLink = Standard_False;
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TessellatedFace::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theCoordinates,
const Standard_Integer thePnmax,
const Handle(TColStd_HArray2OfReal)& theNormals,
const Standard_Boolean theHasGeometricLink,
const StepVisual_FaceOrSurface& theGeometricLink)
{
StepVisual_TessellatedStructuredItem::Init(theRepresentationItem_Name);
myCoordinates = theCoordinates;
myPnmax = thePnmax;
myNormals = theNormals;
myHasGeometricLink = theHasGeometricLink;
if (myHasGeometricLink)
{
myGeometricLink = theGeometricLink;
}
else
{
myGeometricLink = StepVisual_FaceOrSurface();
}
}
//=======================================================================
//function : Coordinates
//purpose :
//=======================================================================
Handle(StepVisual_CoordinatesList) StepVisual_TessellatedFace::Coordinates () const
{
return myCoordinates;
}
//=======================================================================
//function : SetCoordinates
//purpose :
//=======================================================================
void StepVisual_TessellatedFace::SetCoordinates(const Handle(StepVisual_CoordinatesList)& theCoordinates)
{
myCoordinates = theCoordinates;
}
//=======================================================================
//function : Pnmax
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedFace::Pnmax () const
{
return myPnmax;
}
//=======================================================================
//function : SetPnmax
//purpose :
//=======================================================================
void StepVisual_TessellatedFace::SetPnmax(const Standard_Integer thePnmax)
{
myPnmax = thePnmax;
}
//=======================================================================
//function : Normals
//purpose :
//=======================================================================
Handle(TColStd_HArray2OfReal) StepVisual_TessellatedFace::Normals () const
{
return myNormals;
}
//=======================================================================
//function : SetNormals
//purpose :
//=======================================================================
void StepVisual_TessellatedFace::SetNormals(const Handle(TColStd_HArray2OfReal)& theNormals)
{
myNormals = theNormals;
}
//=======================================================================
//function : NbNormals
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedFace::NbNormals() const
{
if (myNormals.IsNull())
{
return 0;
}
return myNormals->ColLength();
}
//=======================================================================
//function : GeometricLink
//purpose :
//=======================================================================
StepVisual_FaceOrSurface StepVisual_TessellatedFace::GeometricLink () const
{
return myGeometricLink;
}
//=======================================================================
//function : SetGeometricLink
//purpose :
//=======================================================================
void StepVisual_TessellatedFace::SetGeometricLink(const StepVisual_FaceOrSurface& theGeometricLink)
{
myGeometricLink = theGeometricLink;
}
//=======================================================================
//function : HasGeometricLink
//purpose :
//=======================================================================
Standard_Boolean StepVisual_TessellatedFace::HasGeometricLink () const
{
return myHasGeometricLink;
}

89
src/StepVisual/StepVisual_TessellatedFace.hxx Normal file
View File

@ -0,0 +1,89 @@
// 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 _StepVisual_TessellatedFace_HeaderFile_
#define _StepVisual_TessellatedFace_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <TColStd_HArray2OfReal.hxx>
#include <StepVisual_FaceOrSurface.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedFace, StepVisual_TessellatedStructuredItem)
//! Representation of STEP entity TessellatedFace
class StepVisual_TessellatedFace : public StepVisual_TessellatedStructuredItem
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedFace();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theCoordinates,
const Standard_Integer thePnmax,
const Handle(TColStd_HArray2OfReal)& theNormals,
const Standard_Boolean theHasGeometricLink,
const StepVisual_FaceOrSurface& theGeometricLink);
//! Returns field Coordinates
Standard_EXPORT Handle(StepVisual_CoordinatesList) Coordinates() const;
//! Sets field Coordinates
Standard_EXPORT void SetCoordinates (const Handle(StepVisual_CoordinatesList)& theCoordinates);
//! Returns field Pnmax
Standard_EXPORT Standard_Integer Pnmax() const;
//! Sets field Pnmax
Standard_EXPORT void SetPnmax (const Standard_Integer thePnmax);
//! Returns field Normals
Standard_EXPORT Handle(TColStd_HArray2OfReal) Normals() const;
//! Sets field Normals
Standard_EXPORT void SetNormals (const Handle(TColStd_HArray2OfReal)& theNormals);
//! Returns number of Normals
Standard_EXPORT Standard_Integer NbNormals() const;
//! Returns field GeometricLink
Standard_EXPORT StepVisual_FaceOrSurface GeometricLink() const;
//! Sets field GeometricLink
Standard_EXPORT void SetGeometricLink (const StepVisual_FaceOrSurface& theGeometricLink);
//! Returns True if optional field GeometricLink is defined
Standard_EXPORT Standard_Boolean HasGeometricLink() const;
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedFace, StepVisual_TessellatedStructuredItem)
private:
Handle(StepVisual_CoordinatesList) myCoordinates;
Standard_Integer myPnmax;
Handle(TColStd_HArray2OfReal) myNormals;
StepVisual_FaceOrSurface myGeometricLink; //!< optional
Standard_Boolean myHasGeometricLink; //!< flag "is GeometricLink defined"
};
#endif // _StepVisual_TessellatedFace_HeaderFile_

110
src/StepVisual/StepVisual_TessellatedPointSet.cxx Normal file
View File

@ -0,0 +1,110 @@
// 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 <StepVisual_TessellatedPointSet.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedPointSet, StepVisual_TessellatedItem)
//=======================================================================
//function : StepVisual_TessellatedPointSet
//purpose :
//=======================================================================
StepVisual_TessellatedPointSet::StepVisual_TessellatedPointSet ()
{
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TessellatedPointSet::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theCoordinates,
const Handle(TColStd_HArray1OfInteger)& thePointList)
{
StepVisual_TessellatedItem::Init(theRepresentationItem_Name);
myCoordinates = theCoordinates;
myPointList = thePointList;
}
//=======================================================================
//function : Coordinates
//purpose :
//=======================================================================
Handle(StepVisual_CoordinatesList) StepVisual_TessellatedPointSet::Coordinates () const
{
return myCoordinates;
}
//=======================================================================
//function : SetCoordinates
//purpose :
//=======================================================================
void StepVisual_TessellatedPointSet::SetCoordinates(const Handle(StepVisual_CoordinatesList)& theCoordinates)
{
myCoordinates = theCoordinates;
}
//=======================================================================
//function : PointList
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfInteger) StepVisual_TessellatedPointSet::PointList () const
{
return myPointList;
}
//=======================================================================
//function : SetPointList
//purpose :
//=======================================================================
void StepVisual_TessellatedPointSet::SetPointList(const Handle(TColStd_HArray1OfInteger)& thePointList)
{
myPointList = thePointList;
}
//=======================================================================
//function : NbPointList
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedPointSet::NbPointList() const
{
if (myPointList.IsNull())
{
return 0;
}
return myPointList->Length();
}
//=======================================================================
//function : PointListValue
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedPointSet::PointListValue(const Standard_Integer theNum) const
{
return myPointList->Value(theNum);
}

70
src/StepVisual/StepVisual_TessellatedPointSet.hxx Normal file
View File

@ -0,0 +1,70 @@
// 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 _StepVisual_TessellatedPointSet_HeaderFile_
#define _StepVisual_TessellatedPointSet_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedItem.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <TColStd_HArray1OfInteger.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedPointSet, StepVisual_TessellatedItem)
//! Representation of STEP entity TessellatedPointSet
class StepVisual_TessellatedPointSet : public StepVisual_TessellatedItem
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedPointSet();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theCoordinates,
const Handle(TColStd_HArray1OfInteger)& thePointList);
//! Returns field Coordinates
Standard_EXPORT Handle(StepVisual_CoordinatesList) Coordinates() const;
//! Sets field Coordinates
Standard_EXPORT void SetCoordinates (const Handle(StepVisual_CoordinatesList)& theCoordinates);
//! Returns field PointList
Standard_EXPORT Handle(TColStd_HArray1OfInteger) PointList() const;
//! Sets field PointList
Standard_EXPORT void SetPointList (const Handle(TColStd_HArray1OfInteger)& thePointList);
//! Returns number of PointList
Standard_EXPORT Standard_Integer NbPointList() const;
//! Returns value of PointList by its num
Standard_EXPORT Standard_Integer PointListValue(const Standard_Integer theNum) const;
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedPointSet, StepVisual_TessellatedItem)
private:
Handle(StepVisual_CoordinatesList) myCoordinates;
Handle(TColStd_HArray1OfInteger) myPointList;
};
#endif // _StepVisual_TessellatedPointSet_HeaderFile_

28
src/StepVisual/StepVisual_TessellatedShapeRepresentation.cxx Normal file
View File

@ -0,0 +1,28 @@
// 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 <StepVisual_TessellatedShapeRepresentation.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedShapeRepresentation, StepShape_ShapeRepresentation)
//=======================================================================
//function : StepVisual_TessellatedShapeRepresentation
//purpose :
//=======================================================================
StepVisual_TessellatedShapeRepresentation::StepVisual_TessellatedShapeRepresentation ()
{
}

40
src/StepVisual/StepVisual_TessellatedShapeRepresentation.hxx Normal file
View File

@ -0,0 +1,40 @@
// 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 _StepVisual_TessellatedShapeRepresentation_HeaderFile_
#define _StepVisual_TessellatedShapeRepresentation_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepShape_ShapeRepresentation.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedShapeRepresentation, StepShape_ShapeRepresentation)
//! Representation of STEP entity TessellatedShapeRepresentation
class StepVisual_TessellatedShapeRepresentation : public StepShape_ShapeRepresentation
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedShapeRepresentation();
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedShapeRepresentation, StepShape_ShapeRepresentation)
};
#endif // _StepVisual_TessellatedShapeRepresentation_HeaderFile_

91
src/StepVisual/StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.cxx Normal file
View File

@ -0,0 +1,91 @@
// 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 <StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters, StepVisual_TessellatedShapeRepresentation)
//=======================================================================
//function : StepVisual_TessellatedShapeRepresentationWithAccuracyParameters
//purpose :
//=======================================================================
StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::StepVisual_TessellatedShapeRepresentationWithAccuracyParameters ()
{
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::Init (const Handle(TCollection_HAsciiString)& theRepresentation_Name,
const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items,
const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems,
const Handle(TColStd_HArray1OfReal)& theTessellationAccuracyParameters)
{
StepVisual_TessellatedShapeRepresentation::Init(theRepresentation_Name,
theRepresentation_Items,
theRepresentation_ContextOfItems);
myTessellationAccuracyParameters = theTessellationAccuracyParameters;
}
//=======================================================================
//function : TessellationAccuracyParameters
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfReal) StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::TessellationAccuracyParameters () const
{
return myTessellationAccuracyParameters;
}
//=======================================================================
//function : SetTessellationAccuracyParameters
//purpose :
//=======================================================================
void StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::SetTessellationAccuracyParameters(const Handle(TColStd_HArray1OfReal)& theTessellationAccuracyParameters)
{
myTessellationAccuracyParameters = theTessellationAccuracyParameters;
}
//=======================================================================
//function : NbTessellationAccuracyParameters
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::NbTessellationAccuracyParameters() const
{
if (myTessellationAccuracyParameters.IsNull())
{
return 0;
}
return myTessellationAccuracyParameters->Length();
}
//=======================================================================
//function : TessellationAccuracyParametersValue
//purpose :
//=======================================================================
const Standard_Real& StepVisual_TessellatedShapeRepresentationWithAccuracyParameters::TessellationAccuracyParametersValue(const Standard_Integer theNum) const
{
return myTessellationAccuracyParameters->Value(theNum);
}

62
src/StepVisual/StepVisual_TessellatedShapeRepresentationWithAccuracyParameters.hxx Normal file
View File

@ -0,0 +1,62 @@
// 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 _StepVisual_TessellatedShapeRepresentationWithAccuracyParameters_HeaderFile_
#define _StepVisual_TessellatedShapeRepresentationWithAccuracyParameters_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <StepVisual_TessellatedShapeRepresentation.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters, StepVisual_TessellatedShapeRepresentation)
//! Representation of STEP entity TessellatedShapeRepresentationWithAccuracyParameters
class StepVisual_TessellatedShapeRepresentationWithAccuracyParameters : public StepVisual_TessellatedShapeRepresentation
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedShapeRepresentationWithAccuracyParameters();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentation_Name,
const Handle(StepRepr_HArray1OfRepresentationItem)& theRepresentation_Items,
const Handle(StepRepr_RepresentationContext)& theRepresentation_ContextOfItems,
const Handle(TColStd_HArray1OfReal)& theTessellationAccuracyParameters);
//! Returns field TessellationAccuracyParameters
Standard_EXPORT Handle(TColStd_HArray1OfReal) TessellationAccuracyParameters() const;
//! Sets field TessellationAccuracyParameters
Standard_EXPORT void SetTessellationAccuracyParameters (const Handle(TColStd_HArray1OfReal)& theTessellationAccuracyParameters);
//! Returns number of TessellationAccuracyParameters
Standard_EXPORT Standard_Integer NbTessellationAccuracyParameters() const;
//! Returns value of TessellationAccuracyParameters by its num
Standard_EXPORT const Standard_Real& TessellationAccuracyParametersValue(const Standard_Integer theNum) const;
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedShapeRepresentationWithAccuracyParameters, StepVisual_TessellatedShapeRepresentation)
private:
Handle(TColStd_HArray1OfReal) myTessellationAccuracyParameters;
};
#endif // _StepVisual_TessellatedShapeRepresentationWithAccuracyParameters_HeaderFile_

130
src/StepVisual/StepVisual_TessellatedShell.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 <StepVisual_TessellatedShell.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedShell, StepVisual_TessellatedItem)
//=======================================================================
//function : StepVisual_TessellatedShell
//purpose :
//=======================================================================
StepVisual_TessellatedShell::StepVisual_TessellatedShell ()
{
myHasTopologicalLink = Standard_False;
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TessellatedShell::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_HArray1OfTessellatedStructuredItem)& theItems,
const Standard_Boolean theHasTopologicalLink,
const Handle(StepShape_ConnectedFaceSet)& theTopologicalLink)
{
StepVisual_TessellatedItem::Init(theRepresentationItem_Name);
myItems = theItems;
myHasTopologicalLink = theHasTopologicalLink;
if (myHasTopologicalLink)
{
myTopologicalLink = theTopologicalLink;
}
else
{
myTopologicalLink.Nullify();
}
}
//=======================================================================
//function : Items
//purpose :
//=======================================================================
Handle(StepVisual_HArray1OfTessellatedStructuredItem) StepVisual_TessellatedShell::Items () const
{
return myItems;
}
//=======================================================================
//function : SetItems
//purpose :
//=======================================================================
void StepVisual_TessellatedShell::SetItems(const Handle(StepVisual_HArray1OfTessellatedStructuredItem)& theItems)
{
myItems = theItems;
}
//=======================================================================
//function : NbItems
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedShell::NbItems() const
{
if (myItems.IsNull())
{
return 0;
}
return myItems->Length();
}
//=======================================================================
//function : ItemsValue
//purpose :
//=======================================================================
Handle(StepVisual_TessellatedStructuredItem) StepVisual_TessellatedShell::ItemsValue(const Standard_Integer theNum) const
{
return myItems->Value(theNum);
}
//=======================================================================
//function : TopologicalLink
//purpose :
//=======================================================================
Handle(StepShape_ConnectedFaceSet) StepVisual_TessellatedShell::TopologicalLink () const
{
return myTopologicalLink;
}
//=======================================================================
//function : SetTopologicalLink
//purpose :
//=======================================================================
void StepVisual_TessellatedShell::SetTopologicalLink(const Handle(StepShape_ConnectedFaceSet)& theTopologicalLink)
{
myTopologicalLink = theTopologicalLink;
}
//=======================================================================
//function : HasTopologicalLink
//purpose :
//=======================================================================
Standard_Boolean StepVisual_TessellatedShell::HasTopologicalLink () const
{
return myHasTopologicalLink;
}

75
src/StepVisual/StepVisual_TessellatedShell.hxx Normal file
View File

@ -0,0 +1,75 @@
// 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 _StepVisual_TessellatedShell_HeaderFile_
#define _StepVisual_TessellatedShell_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedItem.hxx>
#include <StepVisual_HArray1OfTessellatedStructuredItem.hxx>
#include <StepShape_ConnectedFaceSet.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedShell, StepVisual_TessellatedItem)
//! Representation of STEP entity TessellatedShell
class StepVisual_TessellatedShell : public StepVisual_TessellatedItem
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedShell();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_HArray1OfTessellatedStructuredItem)& theItems,
const Standard_Boolean theHasTopologicalLink,
const Handle(StepShape_ConnectedFaceSet)& theTopologicalLink);
//! Returns field Items
Standard_EXPORT Handle(StepVisual_HArray1OfTessellatedStructuredItem) Items() const;
//! Sets field Items
Standard_EXPORT void SetItems (const Handle(StepVisual_HArray1OfTessellatedStructuredItem)& theItems);
//! Returns number of Items
Standard_EXPORT Standard_Integer NbItems() const;
//! Returns value of Items by its num
Standard_EXPORT Handle(StepVisual_TessellatedStructuredItem) ItemsValue(const Standard_Integer theNum) const;
//! Returns field TopologicalLink
Standard_EXPORT Handle(StepShape_ConnectedFaceSet) TopologicalLink() const;
//! Sets field TopologicalLink
Standard_EXPORT void SetTopologicalLink (const Handle(StepShape_ConnectedFaceSet)& theTopologicalLink);
//! Returns True if optional field TopologicalLink is defined
Standard_EXPORT Standard_Boolean HasTopologicalLink() const;
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedShell, StepVisual_TessellatedItem)
private:
Handle(StepVisual_HArray1OfTessellatedStructuredItem) myItems;
Handle(StepShape_ConnectedFaceSet) myTopologicalLink; //!< optional
Standard_Boolean myHasTopologicalLink; //!< flag "is TopologicalLink defined"
};
#endif // _StepVisual_TessellatedShell_HeaderFile_

130
src/StepVisual/StepVisual_TessellatedSolid.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 <StepVisual_TessellatedSolid.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedSolid, StepVisual_TessellatedItem)
//=======================================================================
//function : StepVisual_TessellatedSolid
//purpose :
//=======================================================================
StepVisual_TessellatedSolid::StepVisual_TessellatedSolid ()
{
myHasGeometricLink = Standard_False;
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TessellatedSolid::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_HArray1OfTessellatedStructuredItem)& theItems,
const Standard_Boolean theHasGeometricLink,
const Handle(StepShape_ManifoldSolidBrep)& theGeometricLink)
{
StepVisual_TessellatedItem::Init(theRepresentationItem_Name);
myItems = theItems;
myHasGeometricLink = theHasGeometricLink;
if (myHasGeometricLink)
{
myGeometricLink = theGeometricLink;
}
else
{
myGeometricLink.Nullify();
}
}
//=======================================================================
//function : Items
//purpose :
//=======================================================================
Handle(StepVisual_HArray1OfTessellatedStructuredItem) StepVisual_TessellatedSolid::Items () const
{
return myItems;
}
//=======================================================================
//function : SetItems
//purpose :
//=======================================================================
void StepVisual_TessellatedSolid::SetItems(const Handle(StepVisual_HArray1OfTessellatedStructuredItem)& theItems)
{
myItems = theItems;
}
//=======================================================================
//function : NbItems
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedSolid::NbItems() const
{
if (myItems.IsNull())
{
return 0;
}
return myItems->Length();
}
//=======================================================================
//function : ItemsValue
//purpose :
//=======================================================================
Handle(StepVisual_TessellatedStructuredItem) StepVisual_TessellatedSolid::ItemsValue(const Standard_Integer theNum) const
{
return myItems->Value(theNum);
}
//=======================================================================
//function : GeometricLink
//purpose :
//=======================================================================
Handle(StepShape_ManifoldSolidBrep) StepVisual_TessellatedSolid::GeometricLink () const
{
return myGeometricLink;
}
//=======================================================================
//function : SetGeometricLink
//purpose :
//=======================================================================
void StepVisual_TessellatedSolid::SetGeometricLink(const Handle(StepShape_ManifoldSolidBrep)& theGeometricLink)
{
myGeometricLink = theGeometricLink;
}
//=======================================================================
//function : HasGeometricLink
//purpose :
//=======================================================================
Standard_Boolean StepVisual_TessellatedSolid::HasGeometricLink () const
{
return myHasGeometricLink;
}

75
src/StepVisual/StepVisual_TessellatedSolid.hxx Normal file
View File

@ -0,0 +1,75 @@
// 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 _StepVisual_TessellatedSolid_HeaderFile_
#define _StepVisual_TessellatedSolid_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedItem.hxx>
#include <StepVisual_HArray1OfTessellatedStructuredItem.hxx>
#include <StepShape_ManifoldSolidBrep.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedSolid, StepVisual_TessellatedItem)
//! Representation of STEP entity TessellatedSolid
class StepVisual_TessellatedSolid : public StepVisual_TessellatedItem
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedSolid();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_HArray1OfTessellatedStructuredItem)& theItems,
const Standard_Boolean theHasGeometricLink,
const Handle(StepShape_ManifoldSolidBrep)& theGeometricLink);
//! Returns field Items
Standard_EXPORT Handle(StepVisual_HArray1OfTessellatedStructuredItem) Items() const;
//! Sets field Items
Standard_EXPORT void SetItems (const Handle(StepVisual_HArray1OfTessellatedStructuredItem)& theItems);
//! Returns number of Items
Standard_EXPORT Standard_Integer NbItems() const;
//! Returns value of Items by its num
Standard_EXPORT Handle(StepVisual_TessellatedStructuredItem) ItemsValue(const Standard_Integer theNum) const;
//! Returns field GeometricLink
Standard_EXPORT Handle(StepShape_ManifoldSolidBrep) GeometricLink() const;
//! Sets field GeometricLink
Standard_EXPORT void SetGeometricLink (const Handle(StepShape_ManifoldSolidBrep)& theGeometricLink);
//! Returns True if optional field GeometricLink is defined
Standard_EXPORT Standard_Boolean HasGeometricLink() const;
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedSolid, StepVisual_TessellatedItem)
private:
Handle(StepVisual_HArray1OfTessellatedStructuredItem) myItems;
Handle(StepShape_ManifoldSolidBrep) myGeometricLink; //!< optional
Standard_Boolean myHasGeometricLink; //!< flag "is GeometricLink defined"
};
#endif // _StepVisual_TessellatedSolid_HeaderFile_

28
src/StepVisual/StepVisual_TessellatedStructuredItem.cxx Normal file
View File

@ -0,0 +1,28 @@
// 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 <StepVisual_TessellatedStructuredItem.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedStructuredItem, StepVisual_TessellatedItem)
//=======================================================================
//function : StepVisual_TessellatedStructuredItem
//purpose :
//=======================================================================
StepVisual_TessellatedStructuredItem::StepVisual_TessellatedStructuredItem ()
{
}

40
src/StepVisual/StepVisual_TessellatedStructuredItem.hxx Normal file
View File

@ -0,0 +1,40 @@
// 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 _StepVisual_TessellatedStructuredItem_HeaderFile_
#define _StepVisual_TessellatedStructuredItem_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedItem.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedStructuredItem, StepVisual_TessellatedItem)
//! Representation of STEP entity TessellatedStructuredItem
class StepVisual_TessellatedStructuredItem : public StepVisual_TessellatedItem
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedStructuredItem();
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedStructuredItem, StepVisual_TessellatedItem)
};
#endif // _StepVisual_TessellatedStructuredItem_HeaderFile_

121
src/StepVisual/StepVisual_TessellatedSurfaceSet.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 <StepVisual_TessellatedSurfaceSet.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedSurfaceSet, StepVisual_TessellatedItem)
//=======================================================================
//function : StepVisual_TessellatedSurfaceSet
//purpose :
//=======================================================================
StepVisual_TessellatedSurfaceSet::StepVisual_TessellatedSurfaceSet ()
{
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TessellatedSurfaceSet::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theCoordinates,
const Standard_Integer thePnmax,
const Handle(TColStd_HArray2OfReal)& theNormals)
{
StepVisual_TessellatedItem::Init(theRepresentationItem_Name);
myCoordinates = theCoordinates;
myPnmax = thePnmax;
myNormals = theNormals;
}
//=======================================================================
//function : Coordinates
//purpose :
//=======================================================================
Handle(StepVisual_CoordinatesList) StepVisual_TessellatedSurfaceSet::Coordinates () const
{
return myCoordinates;
}
//=======================================================================
//function : SetCoordinates
//purpose :
//=======================================================================
void StepVisual_TessellatedSurfaceSet::SetCoordinates(const Handle(StepVisual_CoordinatesList)& theCoordinates)
{
myCoordinates = theCoordinates;
}
//=======================================================================
//function : Pnmax
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedSurfaceSet::Pnmax () const
{
return myPnmax;
}
//=======================================================================
//function : SetPnmax
//purpose :
//=======================================================================
void StepVisual_TessellatedSurfaceSet::SetPnmax(const Standard_Integer thePnmax)
{
myPnmax = thePnmax;
}
//=======================================================================
//function : Normals
//purpose :
//=======================================================================
Handle(TColStd_HArray2OfReal) StepVisual_TessellatedSurfaceSet::Normals () const
{
return myNormals;
}
//=======================================================================
//function : SetNormals
//purpose :
//=======================================================================
void StepVisual_TessellatedSurfaceSet::SetNormals(const Handle(TColStd_HArray2OfReal)& theNormals)
{
myNormals = theNormals;
}
//=======================================================================
//function : NbNormals
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedSurfaceSet::NbNormals() const
{
if (myNormals.IsNull())
{
return 0;
}
return myNormals->ColLength();
}

75
src/StepVisual/StepVisual_TessellatedSurfaceSet.hxx Normal file
View File

@ -0,0 +1,75 @@
// 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 _StepVisual_TessellatedSurfaceSet_HeaderFile_
#define _StepVisual_TessellatedSurfaceSet_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedItem.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <TColStd_HArray2OfReal.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedSurfaceSet, StepVisual_TessellatedItem)
//! Representation of STEP entity TessellatedSurfaceSet
class StepVisual_TessellatedSurfaceSet : public StepVisual_TessellatedItem
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedSurfaceSet();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theCoordinates,
const Standard_Integer thePnmax,
const Handle(TColStd_HArray2OfReal)& theNormals);
//! Returns field Coordinates
Standard_EXPORT Handle(StepVisual_CoordinatesList) Coordinates() const;
//! Sets field Coordinates
Standard_EXPORT void SetCoordinates (const Handle(StepVisual_CoordinatesList)& theCoordinates);
//! Returns field Pnmax
Standard_EXPORT Standard_Integer Pnmax() const;
//! Sets field Pnmax
Standard_EXPORT void SetPnmax (const Standard_Integer thePnmax);
//! Returns field Normals
Standard_EXPORT Handle(TColStd_HArray2OfReal) Normals() const;
//! Sets field Normals
Standard_EXPORT void SetNormals (const Handle(TColStd_HArray2OfReal)& theNormals);
//! Returns number of Normals
Standard_EXPORT Standard_Integer NbNormals() const;
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedSurfaceSet, StepVisual_TessellatedItem)
private:
Handle(StepVisual_CoordinatesList) myCoordinates;
Standard_Integer myPnmax;
Handle(TColStd_HArray2OfReal) myNormals;
};
#endif // _StepVisual_TessellatedSurfaceSet_HeaderFile_

128
src/StepVisual/StepVisual_TessellatedVertex.cxx Normal file
View File

@ -0,0 +1,128 @@
// 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 <StepVisual_TessellatedVertex.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedVertex, StepVisual_TessellatedStructuredItem)
//=======================================================================
//function : StepVisual_TessellatedVertex
//purpose :
//=======================================================================
StepVisual_TessellatedVertex::StepVisual_TessellatedVertex ()
{
myPointIndex = 0;
myHasTopologicalLink = Standard_False;
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TessellatedVertex::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theCoordinates,
const Standard_Boolean theHasTopologicalLink,
const Handle(StepShape_VertexPoint)& theTopologicalLink,
const Standard_Integer thePointIndex)
{
StepVisual_TessellatedStructuredItem::Init(theRepresentationItem_Name);
myCoordinates = theCoordinates;
myHasTopologicalLink = theHasTopologicalLink;
if (myHasTopologicalLink)
{
myTopologicalLink = theTopologicalLink;
}
else
{
myTopologicalLink.Nullify();
}
myPointIndex = thePointIndex;
}
//=======================================================================
//function : Coordinates
//purpose :
//=======================================================================
Handle(StepVisual_CoordinatesList) StepVisual_TessellatedVertex::Coordinates () const
{
return myCoordinates;
}
//=======================================================================
//function : SetCoordinates
//purpose :
//=======================================================================
void StepVisual_TessellatedVertex::SetCoordinates(const Handle(StepVisual_CoordinatesList)& theCoordinates)
{
myCoordinates = theCoordinates;
}
//=======================================================================
//function : TopologicalLink
//purpose :
//=======================================================================
Handle(StepShape_VertexPoint) StepVisual_TessellatedVertex::TopologicalLink () const
{
return myTopologicalLink;
}
//=======================================================================
//function : SetTopologicalLink
//purpose :
//=======================================================================
void StepVisual_TessellatedVertex::SetTopologicalLink(const Handle(StepShape_VertexPoint)& theTopologicalLink)
{
myTopologicalLink = theTopologicalLink;
}
//=======================================================================
//function : HasTopologicalLink
//purpose :
//=======================================================================
Standard_Boolean StepVisual_TessellatedVertex::HasTopologicalLink () const
{
return myHasTopologicalLink;
}
//=======================================================================
//function : PointIndex
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedVertex::PointIndex () const
{
return myPointIndex;
}
//=======================================================================
//function : SetPointIndex
//purpose :
//=======================================================================
void StepVisual_TessellatedVertex::SetPointIndex(const Standard_Integer thePointIndex)
{
myPointIndex = thePointIndex;
}

77
src/StepVisual/StepVisual_TessellatedVertex.hxx Normal file
View File

@ -0,0 +1,77 @@
// 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 _StepVisual_TessellatedVertex_HeaderFile_
#define _StepVisual_TessellatedVertex_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedStructuredItem.hxx>
#include <StepVisual_CoordinatesList.hxx>
#include <StepShape_VertexPoint.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedVertex, StepVisual_TessellatedStructuredItem)
//! Representation of STEP entity TessellatedVertex
class StepVisual_TessellatedVertex : public StepVisual_TessellatedStructuredItem
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedVertex();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theCoordinates,
const Standard_Boolean theHasTopologicalLink,
const Handle(StepShape_VertexPoint)& theTopologicalLink,
const Standard_Integer thePointIndex);
//! Returns field Coordinates
Standard_EXPORT Handle(StepVisual_CoordinatesList) Coordinates() const;
//! Sets field Coordinates
Standard_EXPORT void SetCoordinates (const Handle(StepVisual_CoordinatesList)& theCoordinates);
//! Returns field TopologicalLink
Standard_EXPORT Handle(StepShape_VertexPoint) TopologicalLink() const;
//! Sets field TopologicalLink
Standard_EXPORT void SetTopologicalLink (const Handle(StepShape_VertexPoint)& theTopologicalLink);
//! Returns True if optional field TopologicalLink is defined
Standard_EXPORT Standard_Boolean HasTopologicalLink() const;
//! Returns field PointIndex
Standard_EXPORT Standard_Integer PointIndex() const;
//! Sets field PointIndex
Standard_EXPORT void SetPointIndex (const Standard_Integer thePointIndex);
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedVertex, StepVisual_TessellatedStructuredItem)
private:
Handle(StepVisual_CoordinatesList) myCoordinates;
Handle(StepShape_VertexPoint) myTopologicalLink; //!< optional
Standard_Integer myPointIndex;
Standard_Boolean myHasTopologicalLink; //!< flag "is TopologicalLink defined"
};
#endif // _StepVisual_TessellatedVertex_HeaderFile_

130
src/StepVisual/StepVisual_TessellatedWire.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 <StepVisual_TessellatedWire.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TessellatedWire, StepVisual_TessellatedItem)
//=======================================================================
//function : StepVisual_TessellatedWire
//purpose :
//=======================================================================
StepVisual_TessellatedWire::StepVisual_TessellatedWire ()
{
myHasGeometricModelLink = Standard_False;
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TessellatedWire::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_HArray1OfTessellatedEdgeOrVertex)& theItems,
const Standard_Boolean theHasGeometricModelLink,
const StepVisual_PathOrCompositeCurve& theGeometricModelLink)
{
StepVisual_TessellatedItem::Init(theRepresentationItem_Name);
myItems = theItems;
myHasGeometricModelLink = theHasGeometricModelLink;
if (myHasGeometricModelLink)
{
myGeometricModelLink = theGeometricModelLink;
}
else
{
myGeometricModelLink = StepVisual_PathOrCompositeCurve();
}
}
//=======================================================================
//function : Items
//purpose :
//=======================================================================
Handle(StepVisual_HArray1OfTessellatedEdgeOrVertex) StepVisual_TessellatedWire::Items () const
{
return myItems;
}
//=======================================================================
//function : SetItems
//purpose :
//=======================================================================
void StepVisual_TessellatedWire::SetItems(const Handle(StepVisual_HArray1OfTessellatedEdgeOrVertex)& theItems)
{
myItems = theItems;
}
//=======================================================================
//function : NbItems
//purpose :
//=======================================================================
Standard_Integer StepVisual_TessellatedWire::NbItems() const
{
if (myItems.IsNull())
{
return 0;
}
return myItems->Length();
}
//=======================================================================
//function : ItemsValue
//purpose :
//=======================================================================
const StepVisual_TessellatedEdgeOrVertex& StepVisual_TessellatedWire::ItemsValue(const Standard_Integer theNum) const
{
return myItems->Value(theNum);
}
//=======================================================================
//function : GeometricModelLink
//purpose :
//=======================================================================
StepVisual_PathOrCompositeCurve StepVisual_TessellatedWire::GeometricModelLink () const
{
return myGeometricModelLink;
}
//=======================================================================
//function : SetGeometricModelLink
//purpose :
//=======================================================================
void StepVisual_TessellatedWire::SetGeometricModelLink(const StepVisual_PathOrCompositeCurve& theGeometricModelLink)
{
myGeometricModelLink = theGeometricModelLink;
}
//=======================================================================
//function : HasGeometricModelLink
//purpose :
//=======================================================================
Standard_Boolean StepVisual_TessellatedWire::HasGeometricModelLink () const
{
return myHasGeometricModelLink;
}

75
src/StepVisual/StepVisual_TessellatedWire.hxx Normal file
View File

@ -0,0 +1,75 @@
// 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 _StepVisual_TessellatedWire_HeaderFile_
#define _StepVisual_TessellatedWire_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedItem.hxx>
#include <StepVisual_HArray1OfTessellatedEdgeOrVertex.hxx>
#include <StepVisual_PathOrCompositeCurve.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TessellatedWire, StepVisual_TessellatedItem)
//! Representation of STEP entity TessellatedWire
class StepVisual_TessellatedWire : public StepVisual_TessellatedItem
{
public :
//! default constructor
Standard_EXPORT StepVisual_TessellatedWire();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_HArray1OfTessellatedEdgeOrVertex)& theItems,
const Standard_Boolean theHasGeometricModelLink,
const StepVisual_PathOrCompositeCurve& theGeometricModelLink);
//! Returns field Items
Standard_EXPORT Handle(StepVisual_HArray1OfTessellatedEdgeOrVertex) Items() const;
//! Sets field Items
Standard_EXPORT void SetItems (const Handle(StepVisual_HArray1OfTessellatedEdgeOrVertex)& theItems);
//! Returns number of Items
Standard_EXPORT Standard_Integer NbItems() const;
//! Returns value of Items by its num
Standard_EXPORT const StepVisual_TessellatedEdgeOrVertex& ItemsValue(const Standard_Integer theNum) const;
//! Returns field GeometricModelLink
Standard_EXPORT StepVisual_PathOrCompositeCurve GeometricModelLink() const;
//! Sets field GeometricModelLink
Standard_EXPORT void SetGeometricModelLink (const StepVisual_PathOrCompositeCurve& theGeometricModelLink);
//! Returns True if optional field GeometricModelLink is defined
Standard_EXPORT Standard_Boolean HasGeometricModelLink() const;
DEFINE_STANDARD_RTTIEXT(StepVisual_TessellatedWire, StepVisual_TessellatedItem)
private:
Handle(StepVisual_HArray1OfTessellatedEdgeOrVertex) myItems;
StepVisual_PathOrCompositeCurve myGeometricModelLink; //!< optional
Standard_Boolean myHasGeometricModelLink; //!< flag "is GeometricModelLink defined"
};
#endif // _StepVisual_TessellatedWire_HeaderFile_

134
src/StepVisual/StepVisual_TriangulatedFace.cxx Normal file
View File

@ -0,0 +1,134 @@
// 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 <StepVisual_TriangulatedFace.hxx>
IMPLEMENT_STANDARD_RTTIEXT(StepVisual_TriangulatedFace, StepVisual_TessellatedFace)
//=======================================================================
//function : StepVisual_TriangulatedFace
//purpose :
//=======================================================================
StepVisual_TriangulatedFace::StepVisual_TriangulatedFace ()
{
}
//=======================================================================
//function : Init
//purpose :
//=======================================================================
void StepVisual_TriangulatedFace::Init (const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theTessellatedFace_Coordinates,
const Standard_Integer theTessellatedFace_Pnmax,
const Handle(TColStd_HArray2OfReal)& theTessellatedFace_Normals,
const Standard_Boolean theHasTessellatedFace_GeometricLink,
const StepVisual_FaceOrSurface& theTessellatedFace_GeometricLink,
const Handle(TColStd_HArray1OfInteger)& thePnindex,
const Handle(TColStd_HArray2OfInteger)& theTriangles)
{
StepVisual_TessellatedFace::Init(theRepresentationItem_Name,
theTessellatedFace_Coordinates,
theTessellatedFace_Pnmax,
theTessellatedFace_Normals,
theHasTessellatedFace_GeometricLink,
theTessellatedFace_GeometricLink);
myPnindex = thePnindex;
myTriangles = theTriangles;
}
//=======================================================================
//function : Pnindex
//purpose :
//=======================================================================
Handle(TColStd_HArray1OfInteger) StepVisual_TriangulatedFace::Pnindex () const
{
return myPnindex;
}
//=======================================================================
//function : SetPnindex
//purpose :
//=======================================================================
void StepVisual_TriangulatedFace::SetPnindex(const Handle(TColStd_HArray1OfInteger)& thePnindex)
{
myPnindex = thePnindex;
}
//=======================================================================
//function : NbPnindex
//purpose :
//=======================================================================
Standard_Integer StepVisual_TriangulatedFace::NbPnindex() const
{
if (myPnindex.IsNull())
{
return 0;
}
return myPnindex->Length();
}
//=======================================================================
//function : PnindexValue
//purpose :
//=======================================================================
Standard_Integer StepVisual_TriangulatedFace::PnindexValue(const Standard_Integer theNum) const
{
return myPnindex->Value(theNum);
}
//=======================================================================
//function : Triangles
//purpose :
//=======================================================================
Handle(TColStd_HArray2OfInteger) StepVisual_TriangulatedFace::Triangles () const
{
return myTriangles;
}
//=======================================================================
//function : NbTriangles
//purpose :
//=======================================================================
Standard_Integer StepVisual_TriangulatedFace::NbTriangles() const
{
if (myTriangles.IsNull())
{
return 0;
}
return myTriangles->ColLength();
}
//=======================================================================
//function : SetTriangles
//purpose :
//=======================================================================
void StepVisual_TriangulatedFace::SetTriangles(const Handle(TColStd_HArray2OfInteger)& theTriangles)
{
myTriangles = theTriangles;
}

78
src/StepVisual/StepVisual_TriangulatedFace.hxx Normal file
View File

@ -0,0 +1,78 @@
// 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 _StepVisual_TriangulatedFace_HeaderFile_
#define _StepVisual_TriangulatedFace_HeaderFile_
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <StepVisual_TessellatedFace.hxx>
#include <TColStd_HArray1OfInteger.hxx>
#include <TColStd_HArray2OfInteger.hxx>
DEFINE_STANDARD_HANDLE(StepVisual_TriangulatedFace, StepVisual_TessellatedFace)
//! Representation of STEP entity TriangulatedFace
class StepVisual_TriangulatedFace : public StepVisual_TessellatedFace
{
public :
//! default constructor
Standard_EXPORT StepVisual_TriangulatedFace();
//! Initialize all fields (own and inherited)
Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theRepresentationItem_Name,
const Handle(StepVisual_CoordinatesList)& theTessellatedFace_Coordinates,
const Standard_Integer theTessellatedFace_Pnmax,
const Handle(TColStd_HArray2OfReal)& theTessellatedFace_Normals,
const Standard_Boolean theHasTessellatedFace_GeometricLink,
const StepVisual_FaceOrSurface& theTessellatedFace_GeometricLink,
const Handle(TColStd_HArray1OfInteger)& thePnindex,
const Handle(TColStd_HArray2OfInteger)& theTriangles);
//! Returns field Pnindex
Standard_EXPORT Handle(TColStd_HArray1OfInteger) Pnindex() const;
//! Sets field Pnindex
Standard_EXPORT void SetPnindex (const Handle(TColStd_HArray1OfInteger)& thePnindex);
//! Returns number of Pnindex
Standard_EXPORT Standard_Integer NbPnindex() const;
//! Returns value of Pnindex by its num
Standard_EXPORT Standard_Integer PnindexValue(const Standard_Integer theNum) const;
//! Returns field Triangles
Standard_EXPORT Handle(TColStd_HArray2OfInteger) Triangles() const;
//! Sets field Triangles
Standard_EXPORT void SetTriangles (const Handle(TColStd_HArray2OfInteger)& theTriangles);
//! Returns number of Triangles
Standard_EXPORT Standard_Integer NbTriangles() const;
DEFINE_STANDARD_RTTIEXT(StepVisual_TriangulatedFace, StepVisual_TessellatedFace)
private:
Handle(TColStd_HArray1OfInteger) myPnindex;
Handle(TColStd_HArray2OfInteger) myTriangles;
};
#endif // _StepVisual_TriangulatedFace_HeaderFile_

2
src/TopoDSToStep/FILES
View File

@ -36,3 +36,5 @@ TopoDSToStep_Tool.cxx
TopoDSToStep_Tool.hxx
TopoDSToStep_WireframeBuilder.cxx
TopoDSToStep_WireframeBuilder.hxx
TopoDSToStep_MakeTessellatedItem.cxx
TopoDSToStep_MakeTessellatedItem.hxx

281
src/TopoDSToStep/TopoDSToStep_Builder.cxx
View File

@ -33,6 +33,7 @@
#include <TopoDS_Shell.hxx>
#include <TopoDSToStep_Builder.hxx>
#include <TopoDSToStep_MakeStepFace.hxx>
#include <TopoDSToStep_MakeTessellatedItem.hxx>
#include <TopoDSToStep_Tool.hxx>
#include <Transfer_FinderProcess.hxx>
#include <TransferBRep_ShapeMapper.hxx>
@ -54,12 +55,13 @@ TopoDSToStep_Builder::TopoDSToStep_Builder()
TopoDSToStep_Builder::TopoDSToStep_Builder
(const TopoDS_Shape& aShape,
TopoDSToStep_Tool& aTool,
const Handle(Transfer_FinderProcess)& FP,
const Message_ProgressRange& theProgress)
TopoDSToStep_Tool& aTool,
const Handle(Transfer_FinderProcess)& FP,
const Standard_Integer theTessellatedGeomParam,
const Message_ProgressRange& theProgress)
{
done = Standard_False;
Init(aShape, aTool, FP, theProgress);
Init(aShape, aTool, FP, theTessellatedGeomParam, theProgress);
}
// ============================================================================
@ -68,143 +70,168 @@ TopoDSToStep_Builder::TopoDSToStep_Builder
// ============================================================================
void TopoDSToStep_Builder::Init(const TopoDS_Shape& aShape,
TopoDSToStep_Tool& myTool,
const Handle(Transfer_FinderProcess)& FP,
const Message_ProgressRange& theProgress)
TopoDSToStep_Tool& myTool,
const Handle(Transfer_FinderProcess)& FP,
const Standard_Integer theTessellatedGeomParam,
const Message_ProgressRange& theProgress)
{
if (myTool.IsBound(aShape)) {
myError = TopoDSToStep_BuilderDone;
done = Standard_True;
if (myTool.IsBound(aShape)) {
myError = TopoDSToStep_BuilderDone;
done = Standard_True;
myResult = myTool.Find(aShape);
return;
}
switch (aShape.ShapeType())
{
case TopAbs_SHELL:
{
TopoDS_Shell myShell = TopoDS::Shell(aShape);
myTool.SetCurrentShell(myShell);
Handle(StepShape_FaceSurface) FS;
Handle(StepShape_TopologicalRepresentationItem) Fpms;
TColStd_SequenceOfTransient mySeq;
// const TopoDS_Shell ForwardShell =
// TopoDS::Shell(myShell.Oriented(TopAbs_FORWARD));
switch (aShape.ShapeType())
{
case TopAbs_SHELL:
{
TopoDS_Shell myShell = TopoDS::Shell(aShape);
myTool.SetCurrentShell(myShell);
// TopExp_Explorer myExp(ForwardShell, TopAbs_FACE);
// CKY 9-DEC-1997 (PRO9824 et consorts)
// Pour passer les orientations : ELLES SONT DONNEES EN RELATIF
// Donc, pour SHELL, on doit l ecrire en direct en STEP (pas le choix)
// -> il faut repercuter en dessous, donc explorer le Shell TEL QUEL
// Pour FACE WIRE, d une part on ECRIT SON ORIENTATION relative au contenant
// (puisqu on peut), d autre part on EXPLORE EN FORWARD : ainsi les
// orientations des sous-shapes sont relatives a leur contenant immediat
// et la recombinaison en lecture est sans malice
// Il reste ici et la du code relatif a "en Faceted on combine differemment"
// -> reste encore du menage a faire
Handle(StepShape_FaceSurface) FS;
Handle(StepShape_TopologicalRepresentationItem) Fpms;
TColStd_SequenceOfTransient mySeq;
// const TopoDS_Shell ForwardShell =
// TopoDS::Shell(myShell.Oriented(TopAbs_FORWARD));
// TopExp_Explorer myExp(ForwardShell, TopAbs_FACE);
// CKY 9-DEC-1997 (PRO9824 et consorts)
// Pour passer les orientations : ELLES SONT DONNEES EN RELATIF
// Donc, pour SHELL, on doit l ecrire en direct en STEP (pas le choix)
// -> il faut repercuter en dessous, donc explorer le Shell TEL QUEL
// Pour FACE WIRE, d une part on ECRIT SON ORIENTATION relative au contenant
// (puisqu on peut), d autre part on EXPLORE EN FORWARD : ainsi les
// orientations des sous-shapes sont relatives a leur contenant immediat
// et la recombinaison en lecture est sans malice
// Il reste ici et la du code relatif a "en Faceted on combine differemment"
// -> reste encore du menage a faire
TopExp_Explorer anExp;
TopExp_Explorer anExp;
TopoDSToStep_MakeStepFace MkFace;
TopoDSToStep_MakeStepFace MkFace;
Standard_Integer nbshapes = 0;
for (anExp.Init(myShell, TopAbs_FACE); anExp.More(); anExp.Next())
nbshapes++;
Message_ProgressScope aPS(theProgress, NULL, nbshapes);
for (anExp.Init(myShell, TopAbs_FACE); anExp.More() && aPS.More(); anExp.Next(), aPS.Next())
{
const TopoDS_Face Face = TopoDS::Face(anExp.Current());
MkFace.Init(Face, myTool, FP);
Message_ProgressScope aPS(theProgress, NULL, (theTessellatedGeomParam != 0) ? 2 : 1);
if (MkFace.IsDone()) {
FS = Handle(StepShape_FaceSurface)::DownCast(MkFace.Value());
Fpms = FS;
mySeq.Append(Fpms);
}
else {
// MakeFace Error Handling : warning only
// std::cout << "Warning : one Face has not been mapped" << std::endl;
// Handle(TransferBRep_ShapeMapper) errShape =
// new TransferBRep_ShapeMapper(Face);
// FP->AddWarning(errShape, " a Face from a Shell has not been mapped");
}
}
if (!aPS.More())
return;
Standard_Integer nbshapes = 0;
for (anExp.Init(myShell, TopAbs_FACE); anExp.More(); anExp.Next())
nbshapes++;
Message_ProgressScope aPS1(aPS.Next(), NULL, nbshapes);
for (anExp.Init(myShell, TopAbs_FACE); anExp.More() && aPS1.More(); anExp.Next(), aPS1.Next())
{
const TopoDS_Face Face = TopoDS::Face(anExp.Current());
Standard_Integer nbFaces = mySeq.Length();
if ( nbFaces >= 1) {
Handle(StepShape_HArray1OfFace) aSet =
new StepShape_HArray1OfFace(1,nbFaces);
for (Standard_Integer i=1; i<=nbFaces; i++ ) {
aSet->SetValue(i, Handle(StepShape_Face)::DownCast(mySeq.Value(i)));
}
Handle(StepShape_ConnectedFaceSet) CFSpms;
if (myShell.Closed())
CFSpms = new StepShape_ClosedShell();
else
CFSpms = new StepShape_OpenShell();
Handle(TCollection_HAsciiString) aName =
new TCollection_HAsciiString("");
CFSpms->Init(aName, aSet);
MkFace.Init(Face, myTool, FP);
// --------------------------------------------------------------
// To add later : if not facetted context & shell is reversed
// then shall create an oriented_shell with
// orientation flag to false.
// --------------------------------------------------------------
myTool.Bind(aShape, CFSpms);
myResult = CFSpms;
done = Standard_True;
}
else {
// Builder Error handling;
myError = TopoDSToStep_NoFaceMapped;
done = Standard_False;
}
break;
if (MkFace.IsDone()) {
FS = Handle(StepShape_FaceSurface)::DownCast(MkFace.Value());
Fpms = FS;
mySeq.Append(Fpms);
}
case TopAbs_FACE:
{
const TopoDS_Face Face = TopoDS::Face(aShape);
Handle(StepShape_FaceSurface) FS;
Handle(StepShape_TopologicalRepresentationItem) Fpms;
TopoDSToStep_MakeStepFace MkFace(Face, myTool, FP);
if (MkFace.IsDone()) {
FS = Handle(StepShape_FaceSurface)::DownCast(MkFace.Value());
Fpms = FS;
myResult = Fpms;
myError = TopoDSToStep_BuilderDone;
done = Standard_True;
}
else {
// MakeFace Error Handling : Face not Mapped
myError = TopoDSToStep_BuilderOther;
// Handle(TransferBRep_ShapeMapper) errShape =
// new TransferBRep_ShapeMapper(Face);
// FP->AddWarning(errShape, " the Face has not been mapped");
done = Standard_False;
}
break;
else {
// MakeFace Error Handling : warning only
// std::cout << "Warning : one Face has not been mapped" << std::endl;
// Handle(TransferBRep_ShapeMapper) errShape =
// new TransferBRep_ShapeMapper(Face);
// FP->AddWarning(errShape, " a Face from a Shell has not been mapped");
}
default: break;
}
if (!aPS1.More())
return;
Standard_Integer nbFaces = mySeq.Length();
if (nbFaces >= 1) {
Handle(StepShape_HArray1OfFace) aSet =
new StepShape_HArray1OfFace(1, nbFaces);
for (Standard_Integer i = 1; i <= nbFaces; i++) {
aSet->SetValue(i, Handle(StepShape_Face)::DownCast(mySeq.Value(i)));
}
Handle(StepShape_ConnectedFaceSet) CFSpms;
if (myShell.Closed())
CFSpms = new StepShape_ClosedShell();
else
CFSpms = new StepShape_OpenShell();
Handle(TCollection_HAsciiString) aName =
new TCollection_HAsciiString("");
CFSpms->Init(aName, aSet);
// --------------------------------------------------------------
// To add later : if not facetted context & shell is reversed
// then shall create an oriented_shell with
// orientation flag to false.
// --------------------------------------------------------------
myTool.Bind(aShape, CFSpms);
myResult = CFSpms;
done = Standard_True;
}
else {
// Builder Error handling;
myError = TopoDSToStep_NoFaceMapped;
done = Standard_False;
}
if (theTessellatedGeomParam == 1 || (theTessellatedGeomParam == 2 && myResult.IsNull())) {
TopoDSToStep_MakeTessellatedItem MkTessShell(myShell, myTool, FP, aPS.Next());
if (MkTessShell.IsDone()) {
myTessellatedResult = MkTessShell.Value();
myError = TopoDSToStep_BuilderDone;
done = Standard_True;
}
}
break;
}
case TopAbs_FACE:
{
const TopoDS_Face Face = TopoDS::Face(aShape);
Handle(StepShape_FaceSurface) FS;
Handle(StepShape_TopologicalRepresentationItem) Fpms;
TopoDSToStep_MakeStepFace MkFace(Face, myTool, FP);
TopoDSToStep_MakeTessellatedItem MkTessFace;
if (theTessellatedGeomParam == 1 || (theTessellatedGeomParam == 2 && !MkFace.IsDone())) {
Message_ProgressScope aPS(theProgress, NULL, 1);
MkTessFace.Init(Face, myTool, FP, aPS.Next());
}
if (MkFace.IsDone() || MkTessFace.IsDone()) {
if (MkFace.IsDone()) {
FS = Handle(StepShape_FaceSurface)::DownCast(MkFace.Value());
Fpms = FS;
myResult = Fpms;
}
if (MkTessFace.IsDone()) {
myTessellatedResult = MkTessFace.Value();
}
myError = TopoDSToStep_BuilderDone;
done = Standard_True;
}
else {
// MakeFace Error Handling : Face not Mapped
myError = TopoDSToStep_BuilderOther;
// Handle(TransferBRep_ShapeMapper) errShape =
// new TransferBRep_ShapeMapper(Face);
// FP->AddWarning(errShape, " the Face has not been mapped");
done = Standard_False;
}
break;
}
default: break;
}
}
// ============================================================================
// Method : TopoDSToStep_Builder::Value
// Purpose :
// Purpose : Returns TopologicalRepresentationItem as the result
// ============================================================================
const Handle(StepShape_TopologicalRepresentationItem)&
@ -214,9 +241,21 @@ TopoDSToStep_Builder::Value() const
return myResult;
}
// ============================================================================
// Method : TopoDSToStep_Builder::TessellatedValue
// Purpose : Returns TopologicalRepresentationItem as the optional result
// ============================================================================
const Handle(StepVisual_TessellatedItem)&
TopoDSToStep_Builder::TessellatedValue() const
{
StdFail_NotDone_Raise_if(!done, "TopoDSToStep_Builder::TessellatedValue() - no result");
return myTessellatedResult;
}
// ============================================================================
// Method : TopoDSToStep_Builder::Error
// Purpose :
// Purpose : Returns builder error if the process is not done
// ============================================================================
TopoDSToStep_BuilderError TopoDSToStep_Builder::Error() const

5
src/TopoDSToStep/TopoDSToStep_Builder.hxx
View File

@ -26,6 +26,7 @@
#include <Message_ProgressRange.hxx>
class StepShape_TopologicalRepresentationItem;
class StepVisual_TessellatedItem;
class TopoDS_Shape;
class TopoDSToStep_Tool;
class Transfer_FinderProcess;
@ -45,16 +46,19 @@ public:
Standard_EXPORT TopoDSToStep_Builder(const TopoDS_Shape& S,
TopoDSToStep_Tool& T,
const Handle(Transfer_FinderProcess)& FP,
const Standard_Integer theTessellatedGeomParam,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT void Init (const TopoDS_Shape& S,
TopoDSToStep_Tool& T,
const Handle(Transfer_FinderProcess)& FP,
const Standard_Integer theTessellatedGeomParam,
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT TopoDSToStep_BuilderError Error() const;
Standard_EXPORT const Handle(StepShape_TopologicalRepresentationItem)& Value() const;
Standard_EXPORT const Handle(StepVisual_TessellatedItem)& TessellatedValue() const;
@ -70,6 +74,7 @@ private:
Handle(StepShape_TopologicalRepresentationItem) myResult;
Handle(StepVisual_TessellatedItem) myTessellatedResult;
TopoDSToStep_BuilderError myError;

257
src/TopoDSToStep/TopoDSToStep_MakeBrepWithVoids.cxx
View File

@ -16,6 +16,7 @@
#include <BRepClass3d.hxx>
#include <Interface_Static.hxx>
#include <Message_ProgressScope.hxx>
#include <MoniTool_DataMapOfShapeTransient.hxx>
#include <StdFail_NotDone.hxx>
@ -25,6 +26,9 @@
#include <StepShape_OpenShell.hxx>
#include <StepShape_OrientedClosedShell.hxx>
#include <StepShape_TopologicalRepresentationItem.hxx>
#include <StepVisual_HArray1OfTessellatedStructuredItem.hxx>
#include <StepVisual_TessellatedShell.hxx>
#include <StepVisual_TessellatedSolid.hxx>
#include <TCollection_HAsciiString.hxx>
#include <TColStd_SequenceOfTransient.hxx>
#include <TopoDS.hxx>
@ -53,115 +57,162 @@ TopoDSToStep_MakeBrepWithVoids::
const Handle(Transfer_FinderProcess)& FP,
const Message_ProgressRange& theProgress)
{
done = Standard_False ;
TopoDS_Iterator It;
MoniTool_DataMapOfShapeTransient aMap;
TColStd_SequenceOfTransient S;
TopoDS_Shell aOutShell;
done = Standard_False;
TopoDS_Iterator It;
MoniTool_DataMapOfShapeTransient aMap;
TColStd_SequenceOfTransient S;
TopoDS_Shell aOutShell;
Handle(StepShape_TopologicalRepresentationItem) aItem;
Handle(StepShape_ClosedShell) aOuter, aCShell;
Handle(StepShape_OrientedClosedShell) aOCShell;
Handle(StepShape_HArray1OfOrientedClosedShell) aVoids;
TColStd_SequenceOfTransient aTessShells;
aOutShell = BRepClass3d::OuterShell(aSolid);
const Standard_Integer aWriteTessGeom = Interface_Static::IVal("write.step.tessellated");
try
{
// BRepClass3d::OuterShell requires geometry when the solid has voids
aOutShell = BRepClass3d::OuterShell(aSolid);
}
catch (...)
{
}
TopoDSToStep_Builder StepB;
TopoDSToStep_Tool aTool;
if (!aOutShell.IsNull()) {
Standard_Integer nbshapes = 0;
for (It.Initialize(aSolid); It.More(); It.Next())
if (It.Value().ShapeType() == TopAbs_SHELL)
nbshapes++;
Message_ProgressScope aPS(theProgress, NULL, nbshapes);
for (It.Initialize(aSolid); It.More() && aPS.More(); It.Next())
{
if (It.Value().ShapeType() == TopAbs_SHELL) {
TopoDS_Shell CurrentShell = TopoDS::Shell(It.Value());
if ( ! aOutShell.IsEqual(CurrentShell) ) //:e0 abv 25 Mar 98: voids should be reversed according to EXPRESS for ABSR
CurrentShell.Reverse();
//:d7 abv 16 Mar 98: try to treat 'open' shells as closed since flag
// IsClosed() is often incorrect (taken from MakeManifoldSolid(Solid))
aTool.Init(aMap, Standard_False);
StepB.Init(CurrentShell, aTool, FP, aPS.Next());
TopoDSToStep::AddResult ( FP, aTool );
if (StepB.IsDone()) {
aCShell = Handle(StepShape_ClosedShell)::DownCast(StepB.Value());
// si OPEN on le force a CLOSED mais que c est une honte !
if (aCShell.IsNull()) {
Handle(StepShape_OpenShell) aOShell = Handle(StepShape_OpenShell)::DownCast(StepB.Value());
if (!aOShell.IsNull()) {
aCShell = new StepShape_ClosedShell;
aCShell->Init (aOShell->Name(),aOShell->CfsFaces());
#ifdef OCCT_DEBUG
std::cout<<"Warning: MakeBRepWithVoids: Open shell in the solid; treated as closed"<<std::endl;
#endif
}
}
if ( ! aCShell.IsNull() ) {
if ( aOutShell.IsEqual(It.Value()) )
aOuter = aCShell;
else
S.Append(aCShell);
}
#ifdef OCCT_DEBUG
else std::cout<<"*** MakeBRepWithVoids : Shell not mapped"<<std::endl;
#endif
}
#ifdef OCCT_DEBUG
else std::cout << "Shell not mapped" << std::endl;
#endif
/* //:d7
if (It.Value().Closed()) {
aTool.Init(aMap, Standard_False);
StepB.Init(CurrentShell, aTool, FP);
TopoDSToStep::AddResult ( FP, aTool );
if (StepB.IsDone()) {
aCShell = Handle(StepShape_ClosedShell)::DownCast(StepB.Value());
if ( aOutShell.IsEqual(It.Value()) )
aOuter = aCShell;
else
S.Append(aCShell);
}
else {
#ifdef OCCT_DEBUG
std::cout << "Shell not mapped" << std::endl;
#endif
done = Standard_False;
}
}
else {
// Error Handling : the Shape is not closed
done = Standard_False;
}
*/
}
}
if (!aPS.More())
return;
Standard_Integer N = S.Length();
if ( N>=1 ) {
Handle(TCollection_HAsciiString) aName =
new TCollection_HAsciiString("");
aVoids = new StepShape_HArray1OfOrientedClosedShell(1,N);
for ( Standard_Integer i=1; i<=N; i++ ) {
aOCShell = new StepShape_OrientedClosedShell;
// Warning : the Oriented Shell Orientation is not always
// TRUE.
// Shall check the TopoDS_Shell orientation.
// => if the Shell is reversed, shall create an OrientedShell.
aOCShell -> Init(aName,Handle(StepShape_ClosedShell)::DownCast(S.Value(i)),
Standard_False); //:e0
//:e0 Standard_True);
aVoids->SetValue(i, aOCShell);
Standard_Integer nbshapes = 0;
for (It.Initialize(aSolid); It.More(); It.Next())
if (It.Value().ShapeType() == TopAbs_SHELL)
nbshapes++;
Message_ProgressScope aPS(theProgress, NULL, nbshapes);
for (It.Initialize(aSolid); It.More() && aPS.More(); It.Next())
{
if (It.Value().ShapeType() == TopAbs_SHELL)
{
TopoDS_Shell CurrentShell = TopoDS::Shell(It.Value());
if (!aOutShell.IsNull() && !aOutShell.IsEqual(CurrentShell)) //:e0 abv 25 Mar 98: voids should be reversed according to EXPRESS for ABSR
CurrentShell.Reverse();
//:d7 abv 16 Mar 98: try to treat 'open' shells as closed since flag
// IsClosed() is often incorrect (taken from MakeManifoldSolid(Solid))
aTool.Init(aMap, Standard_False);
StepB.Init(CurrentShell, aTool, FP, aWriteTessGeom, aPS.Next());
TopoDSToStep::AddResult(FP, aTool);
if (StepB.IsDone())
{
aCShell = Handle(StepShape_ClosedShell)::DownCast(StepB.Value());
// si OPEN on le force a CLOSED mais que c est une honte !
if (aCShell.IsNull())
{
Handle(StepShape_OpenShell) aOShell = Handle(StepShape_OpenShell)::DownCast(StepB.Value());
if (!aOShell.IsNull())
{
aCShell = new StepShape_ClosedShell;
aCShell->Init(aOShell->Name(), aOShell->CfsFaces());
#ifdef OCCT_DEBUG
std::cout << "Warning: MakeBRepWithVoids: Open shell in the solid; treated as closed" << std::endl;
#endif
}
}
Handle(StepVisual_TessellatedItem) aTessShell = StepB.TessellatedValue();
if (!aTessShell.IsNull())
{
aTessShells.Append(aTessShell);
}
if (!aOutShell.IsNull() && !aCShell.IsNull())
{
if (aOutShell.IsEqual(It.Value()))
aOuter = aCShell;
else
S.Append(aCShell);
}
#ifdef OCCT_DEBUG
else std::cout << "*** MakeBRepWithVoids : Shell not mapped" << std::endl;
#endif
}
theBrepWithVoids = new StepShape_BrepWithVoids();
theBrepWithVoids->Init(aName, aOuter, aVoids);
done = Standard_True;
#ifdef OCCT_DEBUG
else std::cout << "Shell not mapped" << std::endl;
#endif
/* //:d7
if (It.Value().Closed()) {
aTool.Init(aMap, Standard_False);
StepB.Init(CurrentShell, aTool, FP);
TopoDSToStep::AddResult ( FP, aTool );
if (StepB.IsDone()) {
aCShell = Handle(StepShape_ClosedShell)::DownCast(StepB.Value());
if ( aOutShell.IsEqual(It.Value()) )
aOuter = aCShell;
else
S.Append(aCShell);
}
else {
#ifdef OCCT_DEBUG
std::cout << "Shell not mapped" << std::endl;
#endif
done = Standard_False;
}
}
else {
// Error Handling : the Shape is not closed
done = Standard_False;
}
*/
}
else done = Standard_False;
}
if (!aPS.More())
return;
Standard_Integer N = S.Length();
if (N >= 1)
{
Handle(TCollection_HAsciiString) aName =
new TCollection_HAsciiString("");
aVoids = new StepShape_HArray1OfOrientedClosedShell(1, N);
for (Standard_Integer i = 1; i <= N; i++) {
aOCShell = new StepShape_OrientedClosedShell;
// Warning : the Oriented Shell Orientation is not always
// TRUE.
// Shall check the TopoDS_Shell orientation.
// => if the Shell is reversed, shall create an OrientedShell.
aOCShell->Init(aName, Handle(StepShape_ClosedShell)::DownCast(S.Value(i)),
Standard_False); //:e0
//:e0 Standard_True);
aVoids->SetValue(i, aOCShell);
}
theBrepWithVoids = new StepShape_BrepWithVoids();
theBrepWithVoids->Init(aName, aOuter, aVoids);
done = Standard_True;
}
if (!aTessShells.IsEmpty())
{
Handle(StepVisual_TessellatedSolid) aTessSolid = new StepVisual_TessellatedSolid();
Handle(TCollection_HAsciiString) aTessName = new TCollection_HAsciiString("");
Standard_Integer aNbItems = 0;
for (TColStd_SequenceOfTransient::Iterator anIt(aTessShells); anIt.More(); anIt.Next())
{
Handle(StepVisual_TessellatedShell) aTessShell = Handle(StepVisual_TessellatedShell)::DownCast(anIt.Value());
aNbItems += aTessShell->NbItems();
}
Handle(StepVisual_HArray1OfTessellatedStructuredItem) anItems
= new StepVisual_HArray1OfTessellatedStructuredItem(1, aNbItems);
Standard_Integer j = 1;
for (TColStd_SequenceOfTransient::Iterator anIt(aTessShells); anIt.More(); anIt.Next())
{
Handle(StepVisual_TessellatedShell) aTessShell = Handle(StepVisual_TessellatedShell)::DownCast(anIt.Value());
for (Standard_Integer i = 1; i <= aTessShell->NbItems(); ++i) {
anItems->SetValue(j++, aTessShell->ItemsValue(i));
}
}
Standard_Boolean aHasGeomLink = !theBrepWithVoids.IsNull();
aTessSolid->Init(aTessName, anItems, aHasGeomLink, theBrepWithVoids);
theTessellatedItem = aTessSolid;
done = Standard_True;
}
}
@ -175,3 +226,15 @@ const Handle(StepShape_BrepWithVoids) &
StdFail_NotDone_Raise_if (!done, "TopoDSToStep_MakeBrepWithVoids::Value() - no result");
return theBrepWithVoids;
}
// ============================================================================
// Method : TopoDSToStep_MakeBrepWithVoids::TessellatedValue
// Purpose : Returns TessellatedItem as the optional result
// ============================================================================
const Handle(StepVisual_TessellatedItem) &
TopoDSToStep_MakeBrepWithVoids::TessellatedValue() const
{
StdFail_NotDone_Raise_if(!done, "TopoDSToStep_MakeBrepWithVoids::TessellatedValue() - no result");
return theTessellatedItem;
}

5
src/TopoDSToStep/TopoDSToStep_MakeBrepWithVoids.hxx
View File

@ -25,6 +25,7 @@
#include <Message_ProgressRange.hxx>
class StepShape_BrepWithVoids;
class StepVisual_TessellatedItem;
class TopoDS_Solid;
class Transfer_FinderProcess;
@ -46,7 +47,7 @@ public:
const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT const Handle(StepShape_BrepWithVoids)& Value() const;
Standard_EXPORT const Handle(StepVisual_TessellatedItem)& TessellatedValue() const;
@ -61,7 +62,7 @@ private:
Handle(StepShape_BrepWithVoids) theBrepWithVoids;
Handle(StepVisual_TessellatedItem) theTessellatedItem;
};

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