mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2024-11-11 16:19:16 +05:00
This commit was generated by cvs2git to create branch 'IMPORT'.
Cherrypick from master 2003-05-19 14:07:00 UTC nri <nri@opencascade.com> 'NRI : First integration.':
idl/SMESH_BasicHypothesis.idl
idl/SMESH_Gen.idl
idl/SMESH_Hypothesis.idl
idl/SMESH_Mesh.idl
src/Driver/Document_Reader.cxx
src/Driver/Document_Reader.h
src/Driver/Document_Writer.cxx
src/Driver/Document_Writer.h
src/Driver/Driver_dl.cxx
src/Driver/Makefile.in
src/Driver/Mesh_Reader.cxx
src/Driver/Mesh_Reader.h
src/Driver/Mesh_Writer.cxx
src/Driver/Mesh_Writer.h
src/Driver/SMESHDriver.cxx
src/Driver/SMESHDriver.h
src/DriverDAT/DriverDAT_R_SMDS_Mesh.cxx
src/DriverDAT/DriverDAT_R_SMDS_Mesh.h
src/DriverDAT/DriverDAT_R_SMESHDS_Document.cxx
src/DriverDAT/DriverDAT_R_SMESHDS_Document.h
src/DriverDAT/DriverDAT_R_SMESHDS_Mesh.cxx
src/DriverDAT/DriverDAT_R_SMESHDS_Mesh.h
src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
src/DriverDAT/DriverDAT_W_SMDS_Mesh.h
src/DriverDAT/DriverDAT_W_SMESHDS_Document.cxx
src/DriverDAT/DriverDAT_W_SMESHDS_Document.h
src/DriverDAT/DriverDAT_W_SMESHDS_Mesh.cxx
src/DriverDAT/DriverDAT_W_SMESHDS_Mesh.h
src/DriverDAT/Makefile.in
src/DriverUNV/DriverUNV_R_SMDS_Mesh.cxx
src/DriverUNV/DriverUNV_R_SMDS_Mesh.h
src/DriverUNV/DriverUNV_R_SMESHDS_Document.cxx
src/DriverUNV/DriverUNV_R_SMESHDS_Document.h
src/DriverUNV/DriverUNV_R_SMESHDS_Mesh.cxx
src/DriverUNV/DriverUNV_R_SMESHDS_Mesh.h
src/DriverUNV/DriverUNV_W_SMDS_Mesh.cxx
src/DriverUNV/DriverUNV_W_SMDS_Mesh.h
src/DriverUNV/DriverUNV_W_SMESHDS_Document.cxx
src/DriverUNV/DriverUNV_W_SMESHDS_Document.h
src/DriverUNV/DriverUNV_W_SMESHDS_Mesh.cxx
src/DriverUNV/DriverUNV_W_SMESHDS_Mesh.h
src/DriverUNV/Makefile.in
src/MEFISTO2/Makefile.in
src/MEFISTO2/Rn.h
src/MEFISTO2/aptrte.cxx
src/MEFISTO2/aptrte.h
src/MEFISTO2/areteideale.f
src/MEFISTO2/trte.f
src/Makefile.in
src/OBJECT/Makefile.in
src/OBJECT/SMESH_Actor.cxx
src/OBJECT/SMESH_Actor.h
src/OBJECT/SMESH_Grid.cxx
src/OBJECT/SMESH_Grid.h
src/SMDS/Handle_SMDSControl_BoundaryEdges.hxx
src/SMDS/Handle_SMDSControl_BoundaryFaces.hxx
src/SMDS/Handle_SMDSControl_MeshBoundary.hxx
src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx
src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx
src/SMDS/Handle_SMDS_EdgePosition.hxx
src/SMDS/Handle_SMDS_FacePosition.hxx
src/SMDS/Handle_SMDS_HSequenceOfMesh.hxx
src/SMDS/Handle_SMDS_ListNodeOfListOfMesh.hxx
src/SMDS/Handle_SMDS_ListNodeOfListOfMeshElement.hxx
src/SMDS/Handle_SMDS_ListNodeOfListOfMeshGroup.hxx
src/SMDS/Handle_SMDS_Mesh.hxx
src/SMDS/Handle_SMDS_MeshEdge.hxx
src/SMDS/Handle_SMDS_MeshElement.hxx
src/SMDS/Handle_SMDS_MeshElementIDFactory.hxx
src/SMDS/Handle_SMDS_MeshFace.hxx
src/SMDS/Handle_SMDS_MeshGroup.hxx
src/SMDS/Handle_SMDS_MeshHexahedron.hxx
src/SMDS/Handle_SMDS_MeshIDFactory.hxx
src/SMDS/Handle_SMDS_MeshNode.hxx
src/SMDS/Handle_SMDS_MeshNodeIDFactory.hxx
src/SMDS/Handle_SMDS_MeshObject.hxx
src/SMDS/Handle_SMDS_MeshPrism.hxx
src/SMDS/Handle_SMDS_MeshPyramid.hxx
src/SMDS/Handle_SMDS_MeshQuadrangle.hxx
src/SMDS/Handle_SMDS_MeshTetrahedron.hxx
src/SMDS/Handle_SMDS_MeshTriangle.hxx
src/SMDS/Handle_SMDS_MeshVolume.hxx
src/SMDS/Handle_SMDS_Position.hxx
src/SMDS/Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx
src/SMDS/Handle_SMDS_SpacePosition.hxx
src/SMDS/Handle_SMDS_StdMapNodeOfExtendedMap.hxx
src/SMDS/Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx
src/SMDS/Handle_SMDS_VertexPosition.hxx
src/SMDS/Makefile.in
src/SMDS/SMDS.cdl
src/SMDS/SMDSAbs.cdl
src/SMDS/SMDSAbs_ElementType.hxx
src/SMDS/SMDSControl.cdl
src/SMDS/SMDSControl.cxx
src/SMDS/SMDSControl.hxx
src/SMDS/SMDSControl.ixx
src/SMDS/SMDSControl.jxx
src/SMDS/SMDSControl_BoundaryEdges.cdl
src/SMDS/SMDSControl_BoundaryEdges.cxx
src/SMDS/SMDSControl_BoundaryEdges.hxx
src/SMDS/SMDSControl_BoundaryEdges.ixx
src/SMDS/SMDSControl_BoundaryEdges.jxx
src/SMDS/SMDSControl_BoundaryFaces.cdl
src/SMDS/SMDSControl_BoundaryFaces.cxx
src/SMDS/SMDSControl_BoundaryFaces.hxx
src/SMDS/SMDSControl_BoundaryFaces.ixx
src/SMDS/SMDSControl_BoundaryFaces.jxx
src/SMDS/SMDSControl_MeshBoundary.cdl
src/SMDS/SMDSControl_MeshBoundary.cxx
src/SMDS/SMDSControl_MeshBoundary.hxx
src/SMDS/SMDSControl_MeshBoundary.ixx
src/SMDS/SMDSControl_MeshBoundary.jxx
src/SMDS/SMDSEdit.cdl
src/SMDS/SMDSEdit_Transform.cdl
src/SMDS/SMDSEdit_Transform.cxx
src/SMDS/SMDSEdit_Transform.hxx
src/SMDS/SMDSEdit_Transform.ixx
src/SMDS/SMDSEdit_Transform.jxx
src/SMDS/SMDS_BasicMap.lxx
src/SMDS/SMDS_BasicMapIterator.lxx
src/SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx
src/SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx
src/SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx
src/SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx
src/SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx
src/SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx
src/SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger.hxx
src/SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx
src/SMDS/SMDS_DataMapOfIntegerMeshElement.hxx
src/SMDS/SMDS_DataMapOfIntegerMeshElement_0.cxx
src/SMDS/SMDS_DataMapOfPntInteger.hxx
src/SMDS/SMDS_DataMapOfPntInteger_0.cxx
src/SMDS/SMDS_EdgePosition.cdl
src/SMDS/SMDS_EdgePosition.cxx
src/SMDS/SMDS_EdgePosition.hxx
src/SMDS/SMDS_EdgePosition.ixx
src/SMDS/SMDS_EdgePosition.jxx
src/SMDS/SMDS_EdgePosition.lxx
src/SMDS/SMDS_ExtendedMap.hxx
src/SMDS/SMDS_ExtendedMap_0.cxx
src/SMDS/SMDS_ExtendedOrientedMap.hxx
src/SMDS/SMDS_ExtendedOrientedMap_0.cxx
src/SMDS/SMDS_FacePosition.cdl
src/SMDS/SMDS_FacePosition.cxx
src/SMDS/SMDS_FacePosition.hxx
src/SMDS/SMDS_FacePosition.ixx
src/SMDS/SMDS_FacePosition.jxx
src/SMDS/SMDS_FacePosition.lxx
src/SMDS/SMDS_HSequenceOfMesh.hxx
src/SMDS/SMDS_HSequenceOfMesh_0.cxx
src/SMDS/SMDS_ListIteratorOfListOfMesh.hxx
src/SMDS/SMDS_ListIteratorOfListOfMeshElement.hxx
src/SMDS/SMDS_ListIteratorOfListOfMeshElement_0.cxx
src/SMDS/SMDS_ListIteratorOfListOfMeshGroup.hxx
src/SMDS/SMDS_ListIteratorOfListOfMeshGroup_0.cxx
src/SMDS/SMDS_ListIteratorOfListOfMesh_0.cxx
src/SMDS/SMDS_ListNodeOfListOfMesh.hxx
src/SMDS/SMDS_ListNodeOfListOfMeshElement.hxx
src/SMDS/SMDS_ListNodeOfListOfMeshElement_0.cxx
src/SMDS/SMDS_ListNodeOfListOfMeshGroup.hxx
src/SMDS/SMDS_ListNodeOfListOfMeshGroup_0.cxx
src/SMDS/SMDS_ListNodeOfListOfMesh_0.cxx
src/SMDS/SMDS_ListOfMesh.hxx
src/SMDS/SMDS_ListOfMeshElement.hxx
src/SMDS/SMDS_ListOfMeshElement_0.cxx
src/SMDS/SMDS_ListOfMeshGroup.hxx
src/SMDS/SMDS_ListOfMeshGroup_0.cxx
src/SMDS/SMDS_ListOfMesh_0.cxx
src/SMDS/SMDS_Map.gxx
src/SMDS/SMDS_MapHasher.gxx
src/SMDS/SMDS_MapIterator.gxx
src/SMDS/SMDS_MapIteratorOfExtendedMap.hxx
src/SMDS/SMDS_MapIteratorOfExtendedMap_0.cxx
src/SMDS/SMDS_MapIteratorOfExtendedOrientedMap.hxx
src/SMDS/SMDS_MapIteratorOfExtendedOrientedMap_0.cxx
src/SMDS/SMDS_MapNode.lxx
src/SMDS/SMDS_MapOfMeshElement.cdl
src/SMDS/SMDS_MapOfMeshElement.cxx
src/SMDS/SMDS_MapOfMeshElement.hxx
src/SMDS/SMDS_MapOfMeshElement.ixx
src/SMDS/SMDS_MapOfMeshElement.jxx
src/SMDS/SMDS_MapOfMeshElement.lxx
src/SMDS/SMDS_MapOfMeshOrientedElement.cdl
src/SMDS/SMDS_MapOfMeshOrientedElement.cxx
src/SMDS/SMDS_MapOfMeshOrientedElement.hxx
src/SMDS/SMDS_MapOfMeshOrientedElement.ixx
src/SMDS/SMDS_MapOfMeshOrientedElement.jxx
src/SMDS/SMDS_MapOfMeshOrientedElement.lxx
src/SMDS/SMDS_Mesh.cdl
src/SMDS/SMDS_Mesh.cxx
src/SMDS/SMDS_Mesh.hxx
src/SMDS/SMDS_Mesh.ixx
src/SMDS/SMDS_Mesh.jxx
src/SMDS/SMDS_Mesh.lxx
src/SMDS/SMDS_MeshEdge.cdl
src/SMDS/SMDS_MeshEdge.cxx
src/SMDS/SMDS_MeshEdge.hxx
src/SMDS/SMDS_MeshEdge.ixx
src/SMDS/SMDS_MeshEdge.jxx
src/SMDS/SMDS_MeshEdge.lxx
src/SMDS/SMDS_MeshEdgesIterator.cdl
src/SMDS/SMDS_MeshEdgesIterator.cxx
src/SMDS/SMDS_MeshEdgesIterator.hxx
src/SMDS/SMDS_MeshEdgesIterator.ixx
src/SMDS/SMDS_MeshEdgesIterator.jxx
src/SMDS/SMDS_MeshElement.cdl
src/SMDS/SMDS_MeshElement.cxx
src/SMDS/SMDS_MeshElement.hxx
src/SMDS/SMDS_MeshElement.ixx
src/SMDS/SMDS_MeshElement.jxx
src/SMDS/SMDS_MeshElement.lxx
src/SMDS/SMDS_MeshElementIDFactory.cdl
src/SMDS/SMDS_MeshElementIDFactory.cxx
src/SMDS/SMDS_MeshElementIDFactory.hxx
src/SMDS/SMDS_MeshElementIDFactory.ixx
src/SMDS/SMDS_MeshElementIDFactory.jxx
src/SMDS/SMDS_MeshElementIDFactory.lxx
src/SMDS/SMDS_MeshElementMapHasher.cdl
src/SMDS/SMDS_MeshElementMapHasher.cxx
src/SMDS/SMDS_MeshElementMapHasher.hxx
src/SMDS/SMDS_MeshElementMapHasher.ixx
src/SMDS/SMDS_MeshElementMapHasher.jxx
src/SMDS/SMDS_MeshElementMapHasher.lxx
src/SMDS/SMDS_MeshElementsIterator.cdl
src/SMDS/SMDS_MeshElementsIterator.cxx
src/SMDS/SMDS_MeshElementsIterator.hxx
src/SMDS/SMDS_MeshElementsIterator.ixx
src/SMDS/SMDS_MeshElementsIterator.jxx
src/SMDS/SMDS_MeshElementsIterator.lxx
src/SMDS/SMDS_MeshFace.cdl
src/SMDS/SMDS_MeshFace.cxx
src/SMDS/SMDS_MeshFace.hxx
src/SMDS/SMDS_MeshFace.ixx
src/SMDS/SMDS_MeshFace.jxx
src/SMDS/SMDS_MeshFace.lxx
src/SMDS/SMDS_MeshFacesIterator.cdl
src/SMDS/SMDS_MeshFacesIterator.cxx
src/SMDS/SMDS_MeshFacesIterator.hxx
src/SMDS/SMDS_MeshFacesIterator.ixx
src/SMDS/SMDS_MeshFacesIterator.jxx
src/SMDS/SMDS_MeshGroup.cdl
src/SMDS/SMDS_MeshGroup.cxx
src/SMDS/SMDS_MeshGroup.hxx
src/SMDS/SMDS_MeshGroup.ixx
src/SMDS/SMDS_MeshGroup.jxx
src/SMDS/SMDS_MeshGroup.lxx
src/SMDS/SMDS_MeshHexahedron.cdl
src/SMDS/SMDS_MeshHexahedron.cxx
src/SMDS/SMDS_MeshHexahedron.hxx
src/SMDS/SMDS_MeshHexahedron.ixx
src/SMDS/SMDS_MeshHexahedron.jxx
src/SMDS/SMDS_MeshHexahedron.lxx
src/SMDS/SMDS_MeshIDFactory.cdl
src/SMDS/SMDS_MeshIDFactory.cxx
src/SMDS/SMDS_MeshIDFactory.hxx
src/SMDS/SMDS_MeshIDFactory.ixx
src/SMDS/SMDS_MeshIDFactory.jxx
src/SMDS/SMDS_MeshIDFactory.lxx
src/SMDS/SMDS_MeshNode.cdl
src/SMDS/SMDS_MeshNode.cxx
src/SMDS/SMDS_MeshNode.hxx
src/SMDS/SMDS_MeshNode.ixx
src/SMDS/SMDS_MeshNode.jxx
src/SMDS/SMDS_MeshNode.lxx
src/SMDS/SMDS_MeshNodeIDFactory.cdl
src/SMDS/SMDS_MeshNodeIDFactory.cxx
src/SMDS/SMDS_MeshNodeIDFactory.hxx
src/SMDS/SMDS_MeshNodeIDFactory.ixx
src/SMDS/SMDS_MeshNodeIDFactory.jxx
src/SMDS/SMDS_MeshNodeIDFactory.lxx
src/SMDS/SMDS_MeshNodesIterator.cdl
src/SMDS/SMDS_MeshNodesIterator.cxx
src/SMDS/SMDS_MeshNodesIterator.hxx
src/SMDS/SMDS_MeshNodesIterator.ixx
src/SMDS/SMDS_MeshNodesIterator.jxx
src/SMDS/SMDS_MeshObject.cdl
src/SMDS/SMDS_MeshObject.cxx
src/SMDS/SMDS_MeshObject.hxx
src/SMDS/SMDS_MeshObject.ixx
src/SMDS/SMDS_MeshObject.jxx
src/SMDS/SMDS_MeshOrientedElementMapHasher.cdl
src/SMDS/SMDS_MeshOrientedElementMapHasher.cxx
src/SMDS/SMDS_MeshOrientedElementMapHasher.hxx
src/SMDS/SMDS_MeshOrientedElementMapHasher.ixx
src/SMDS/SMDS_MeshOrientedElementMapHasher.jxx
src/SMDS/SMDS_MeshOrientedElementMapHasher.lxx
src/SMDS/SMDS_MeshPrism.cdl
src/SMDS/SMDS_MeshPrism.cxx
src/SMDS/SMDS_MeshPrism.hxx
src/SMDS/SMDS_MeshPrism.ixx
src/SMDS/SMDS_MeshPrism.jxx
src/SMDS/SMDS_MeshPrism.lxx
src/SMDS/SMDS_MeshPyramid.cdl
src/SMDS/SMDS_MeshPyramid.cxx
src/SMDS/SMDS_MeshPyramid.hxx
src/SMDS/SMDS_MeshPyramid.ixx
src/SMDS/SMDS_MeshPyramid.jxx
src/SMDS/SMDS_MeshPyramid.lxx
src/SMDS/SMDS_MeshQuadrangle.cdl
src/SMDS/SMDS_MeshQuadrangle.cxx
src/SMDS/SMDS_MeshQuadrangle.hxx
src/SMDS/SMDS_MeshQuadrangle.ixx
src/SMDS/SMDS_MeshQuadrangle.jxx
src/SMDS/SMDS_MeshQuadrangle.lxx
src/SMDS/SMDS_MeshTetrahedron.cdl
src/SMDS/SMDS_MeshTetrahedron.cxx
src/SMDS/SMDS_MeshTetrahedron.hxx
src/SMDS/SMDS_MeshTetrahedron.ixx
src/SMDS/SMDS_MeshTetrahedron.jxx
src/SMDS/SMDS_MeshTetrahedron.lxx
src/SMDS/SMDS_MeshTriangle.cdl
src/SMDS/SMDS_MeshTriangle.cxx
src/SMDS/SMDS_MeshTriangle.hxx
src/SMDS/SMDS_MeshTriangle.ixx
src/SMDS/SMDS_MeshTriangle.jxx
src/SMDS/SMDS_MeshTriangle.lxx
src/SMDS/SMDS_MeshVolume.cdl
src/SMDS/SMDS_MeshVolume.cxx
src/SMDS/SMDS_MeshVolume.hxx
src/SMDS/SMDS_MeshVolume.ixx
src/SMDS/SMDS_MeshVolume.jxx
src/SMDS/SMDS_MeshVolume.lxx
src/SMDS/SMDS_MeshVolumesIterator.cdl
src/SMDS/SMDS_MeshVolumesIterator.cxx
src/SMDS/SMDS_MeshVolumesIterator.hxx
src/SMDS/SMDS_MeshVolumesIterator.ixx
src/SMDS/SMDS_MeshVolumesIterator.jxx
src/SMDS/SMDS_PntHasher.cdl
src/SMDS/SMDS_PntHasher.cxx
src/SMDS/SMDS_PntHasher.hxx
src/SMDS/SMDS_PntHasher.ixx
src/SMDS/SMDS_PntHasher.jxx
src/SMDS/SMDS_PntHasher.lxx
src/SMDS/SMDS_Position.cdl
src/SMDS/SMDS_Position.cxx
src/SMDS/SMDS_Position.hxx
src/SMDS/SMDS_Position.ixx
src/SMDS/SMDS_Position.jxx
src/SMDS/SMDS_Position.lxx
src/SMDS/SMDS_SequenceNodeOfSequenceOfMesh.hxx
src/SMDS/SMDS_SequenceNodeOfSequenceOfMesh_0.cxx
src/SMDS/SMDS_SequenceOfMesh.hxx
src/SMDS/SMDS_SequenceOfMesh_0.cxx
src/SMDS/SMDS_SpacePosition.cdl
src/SMDS/SMDS_SpacePosition.cxx
src/SMDS/SMDS_SpacePosition.hxx
src/SMDS/SMDS_SpacePosition.ixx
src/SMDS/SMDS_SpacePosition.jxx
src/SMDS/SMDS_SpacePosition.lxx
src/SMDS/SMDS_StdMapNode.gxx
src/SMDS/SMDS_StdMapNode.lxx
src/SMDS/SMDS_StdMapNodeOfExtendedMap.hxx
src/SMDS/SMDS_StdMapNodeOfExtendedMap_0.cxx
src/SMDS/SMDS_StdMapNodeOfExtendedOrientedMap.hxx
src/SMDS/SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx
src/SMDS/SMDS_TypeOfPosition.hxx
src/SMDS/SMDS_VertexPosition.cdl
src/SMDS/SMDS_VertexPosition.cxx
src/SMDS/SMDS_VertexPosition.hxx
src/SMDS/SMDS_VertexPosition.ixx
src/SMDS/SMDS_VertexPosition.jxx
src/SMESH/Makefile.in
src/SMESH/SMESH_1D_Algo.cxx
src/SMESH/SMESH_1D_Algo.hxx
src/SMESH/SMESH_2D_Algo.cxx
src/SMESH/SMESH_2D_Algo.hxx
src/SMESH/SMESH_3D_Algo.cxx
src/SMESH/SMESH_3D_Algo.hxx
src/SMESH/SMESH_Algo.cxx
src/SMESH/SMESH_Algo.hxx
src/SMESH/SMESH_Gen.cxx
src/SMESH/SMESH_Gen.hxx
src/SMESH/SMESH_Hexa_3D.cxx
src/SMESH/SMESH_Hexa_3D.hxx
src/SMESH/SMESH_Hypothesis.cxx
src/SMESH/SMESH_Hypothesis.hxx
src/SMESH/SMESH_HypothesisCreator.hxx
src/SMESH/SMESH_HypothesisFactory.cxx
src/SMESH/SMESH_HypothesisFactory.hxx
src/SMESH/SMESH_LengthFromEdges.cxx
src/SMESH/SMESH_LengthFromEdges.hxx
src/SMESH/SMESH_LocalLength.cxx
src/SMESH/SMESH_LocalLength.hxx
src/SMESH/SMESH_MEFISTO_2D.cxx
src/SMESH/SMESH_MEFISTO_2D.hxx
src/SMESH/SMESH_MaxElementArea.cxx
src/SMESH/SMESH_MaxElementArea.hxx
src/SMESH/SMESH_MaxElementVolume.cxx
src/SMESH/SMESH_MaxElementVolume.hxx
src/SMESH/SMESH_Mesh.cxx
src/SMESH/SMESH_Mesh.hxx
src/SMESH/SMESH_NumberOfSegments.cxx
src/SMESH/SMESH_NumberOfSegments.hxx
src/SMESH/SMESH_Quadrangle_2D.cxx
src/SMESH/SMESH_Quadrangle_2D.hxx
src/SMESH/SMESH_Regular_1D.cxx
src/SMESH/SMESH_Regular_1D.hxx
src/SMESH/SMESH_subMesh.cxx
src/SMESH/SMESH_subMesh.hxx
src/SMESHDS/Handle_SMESHDS_Command.hxx
src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx
src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx
src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx
src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx
src/SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx
src/SMESHDS/Handle_SMESHDS_Document.hxx
src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx
src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfCommand.hxx
src/SMESHDS/Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx
src/SMESHDS/Handle_SMESHDS_Mesh.hxx
src/SMESHDS/Handle_SMESHDS_Script.hxx
src/SMESHDS/Handle_SMESHDS_SubMesh.hxx
src/SMESHDS/Makefile.in
src/SMESHDS/SMESHDS.cdl
src/SMESHDS/SMESHDS_Command.cdl
src/SMESHDS/SMESHDS_Command.cxx
src/SMESHDS/SMESHDS_Command.hxx
src/SMESHDS/SMESHDS_Command.ixx
src/SMESHDS/SMESHDS_Command.jxx
src/SMESHDS/SMESHDS_CommandType.hxx
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_0.cxx
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_0.cxx
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_0.cxx
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx
src/SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_0.cxx
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx
src/SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx
src/SMESHDS/SMESHDS_DataMapOfIntegerMesh.hxx
src/SMESHDS/SMESHDS_DataMapOfIntegerMesh_0.cxx
src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis.hxx
src/SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis_0.cxx
src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh.hxx
src/SMESHDS/SMESHDS_DataMapOfIntegerSubMesh_0.cxx
src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx
src/SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx
src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh.hxx
src/SMESHDS/SMESHDS_DataMapOfShapeSubMesh_0.cxx
src/SMESHDS/SMESHDS_Document.cdl
src/SMESHDS/SMESHDS_Document.cxx
src/SMESHDS/SMESHDS_Document.hxx
src/SMESHDS/SMESHDS_Document.ixx
src/SMESHDS/SMESHDS_Document.jxx
src/SMESHDS/SMESHDS_Hypothesis.cxx
src/SMESHDS/SMESHDS_Hypothesis.hxx
src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString.hxx
src/SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString_0.cxx
src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand.hxx
src/SMESHDS/SMESHDS_ListIteratorOfListOfCommand_0.cxx
src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx
src/SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis_0.cxx
src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString.hxx
src/SMESHDS/SMESHDS_ListNodeOfListOfAsciiString_0.cxx
src/SMESHDS/SMESHDS_ListNodeOfListOfCommand.hxx
src/SMESHDS/SMESHDS_ListNodeOfListOfCommand_0.cxx
src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis.hxx
src/SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx
src/SMESHDS/SMESHDS_ListOfAsciiString.hxx
src/SMESHDS/SMESHDS_ListOfAsciiString_0.cxx
src/SMESHDS/SMESHDS_ListOfCommand.hxx
src/SMESHDS/SMESHDS_ListOfCommand_0.cxx
src/SMESHDS/SMESHDS_ListOfPtrHypothesis.hxx
src/SMESHDS/SMESHDS_ListOfPtrHypothesis_0.cxx
src/SMESHDS/SMESHDS_Mesh.cdl
src/SMESHDS/SMESHDS_Mesh.cxx
src/SMESHDS/SMESHDS_Mesh.hxx
src/SMESHDS/SMESHDS_Mesh.ixx
src/SMESHDS/SMESHDS_Mesh.jxx
src/SMESHDS/SMESHDS_PtrHypothesis.hxx
src/SMESHDS/SMESHDS_Script.cdl
src/SMESHDS/SMESHDS_Script.cxx
src/SMESHDS/SMESHDS_Script.hxx
src/SMESHDS/SMESHDS_Script.ixx
src/SMESHDS/SMESHDS_Script.jxx
src/SMESHDS/SMESHDS_SubMesh.cdl
src/SMESHDS/SMESHDS_SubMesh.cxx
src/SMESHDS/SMESHDS_SubMesh.hxx
src/SMESHDS/SMESHDS_SubMesh.ixx
src/SMESHDS/SMESHDS_SubMesh.jxx
src/SMESHFiltersSelection/Handle_SMESH_TypeFilter.hxx
src/SMESHFiltersSelection/Makefile.in
src/SMESHFiltersSelection/SMESH_Type.h
src/SMESHFiltersSelection/SMESH_TypeFilter.cxx
src/SMESHFiltersSelection/SMESH_TypeFilter.hxx
src/SMESHFiltersSelection/SMESH_TypeFilter.ixx
src/SMESHFiltersSelection/SMESH_TypeFilter.jxx
src/SMESHGUI/Makefile.in
src/SMESHGUI/SMESHGUI.cxx
src/SMESHGUI/SMESHGUI.h
src/SMESHGUI/SMESHGUI_AddAlgorithmDlg.cxx
src/SMESHGUI/SMESHGUI_AddAlgorithmDlg.h
src/SMESHGUI/SMESHGUI_AddEdgeDlg.cxx
src/SMESHGUI/SMESHGUI_AddEdgeDlg.h
src/SMESHGUI/SMESHGUI_AddFaceDlg.cxx
src/SMESHGUI/SMESHGUI_AddFaceDlg.h
src/SMESHGUI/SMESHGUI_AddHypothesisDlg.cxx
src/SMESHGUI/SMESHGUI_AddHypothesisDlg.h
src/SMESHGUI/SMESHGUI_AddSubMeshDlg.cxx
src/SMESHGUI/SMESHGUI_AddSubMeshDlg.h
src/SMESHGUI/SMESHGUI_AddVolumeDlg.cxx
src/SMESHGUI/SMESHGUI_AddVolumeDlg.h
src/SMESHGUI/SMESHGUI_ComputeScalarValue.cxx
src/SMESHGUI/SMESHGUI_ComputeScalarValue.h
src/SMESHGUI/SMESHGUI_DiagonalInversionDlg.cxx
src/SMESHGUI/SMESHGUI_DiagonalInversionDlg.h
src/SMESHGUI/SMESHGUI_EdgesConnectivityDlg.cxx
src/SMESHGUI/SMESHGUI_EdgesConnectivityDlg.h
src/SMESHGUI/SMESHGUI_EditHypothesesDlg.cxx
src/SMESHGUI/SMESHGUI_EditHypothesesDlg.h
src/SMESHGUI/SMESHGUI_EditScalarBarDlg.cxx
src/SMESHGUI/SMESHGUI_EditScalarBarDlg.h
src/SMESHGUI/SMESHGUI_InitMeshDlg.cxx
src/SMESHGUI/SMESHGUI_InitMeshDlg.h
src/SMESHGUI/SMESHGUI_LocalLengthDlg.cxx
src/SMESHGUI/SMESHGUI_LocalLengthDlg.h
src/SMESHGUI/SMESHGUI_MaxElementAreaDlg.cxx
src/SMESHGUI/SMESHGUI_MaxElementAreaDlg.h
src/SMESHGUI/SMESHGUI_MaxElementVolumeDlg.cxx
src/SMESHGUI/SMESHGUI_MaxElementVolumeDlg.h
src/SMESHGUI/SMESHGUI_MeshInfosDlg.cxx
src/SMESHGUI/SMESHGUI_MeshInfosDlg.h
src/SMESHGUI/SMESHGUI_MoveNodesDlg.cxx
src/SMESHGUI/SMESHGUI_MoveNodesDlg.h
src/SMESHGUI/SMESHGUI_NbSegmentsDlg.cxx
src/SMESHGUI/SMESHGUI_NbSegmentsDlg.h
src/SMESHGUI/SMESHGUI_NodesDlg.cxx
src/SMESHGUI/SMESHGUI_NodesDlg.h
src/SMESHGUI/SMESHGUI_OrientationElementsDlg.cxx
src/SMESHGUI/SMESHGUI_OrientationElementsDlg.h
src/SMESHGUI/SMESHGUI_Preferences_ColorDlg.cxx
src/SMESHGUI/SMESHGUI_Preferences_ColorDlg.h
src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx
src/SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.h
src/SMESHGUI/SMESHGUI_RemoveElementsDlg.cxx
src/SMESHGUI/SMESHGUI_RemoveElementsDlg.h
src/SMESHGUI/SMESHGUI_RemoveNodesDlg.cxx
src/SMESHGUI/SMESHGUI_RemoveNodesDlg.h
src/SMESHGUI/SMESHGUI_SpinBox.cxx
src/SMESHGUI/SMESHGUI_SpinBox.h
src/SMESHGUI/SMESHGUI_StudyAPI.cxx
src/SMESHGUI/SMESHGUI_StudyAPI.h
src/SMESHGUI/SMESHGUI_Swig.cxx
src/SMESHGUI/SMESHGUI_Swig.hxx
src/SMESHGUI/SMESHGUI_Swig.i
src/SMESHGUI/SMESHGUI_TransparencyDlg.cxx
src/SMESHGUI/SMESHGUI_TransparencyDlg.h
src/SMESHGUI/SMESHGUI_aParameterDlg.cxx
src/SMESHGUI/SMESHGUI_aParameterDlg.h
src/SMESH_I/Makefile.in
src/SMESH_I/SMESH_1D_Algo_i.cxx
src/SMESH_I/SMESH_1D_Algo_i.hxx
src/SMESH_I/SMESH_2D_Algo_i.cxx
src/SMESH_I/SMESH_2D_Algo_i.hxx
src/SMESH_I/SMESH_3D_Algo_i.cxx
src/SMESH_I/SMESH_3D_Algo_i.hxx
src/SMESH_I/SMESH_Algo_i.cxx
src/SMESH_I/SMESH_Algo_i.hxx
src/SMESH_I/SMESH_Gen_i.cxx
src/SMESH_I/SMESH_Gen_i.hxx
src/SMESH_I/SMESH_Hexa_3D_i.cxx
src/SMESH_I/SMESH_Hexa_3D_i.hxx
src/SMESH_I/SMESH_HypothesisFactory_i.cxx
src/SMESH_I/SMESH_HypothesisFactory_i.hxx
src/SMESH_I/SMESH_Hypothesis_i.cxx
src/SMESH_I/SMESH_Hypothesis_i.hxx
src/SMESH_I/SMESH_LocalLength_i.cxx
src/SMESH_I/SMESH_LocalLength_i.hxx
src/SMESH_I/SMESH_MEDFamily_i.cxx
src/SMESH_I/SMESH_MEDFamily_i.hxx
src/SMESH_I/SMESH_MEDMesh_i.cxx
src/SMESH_I/SMESH_MEDMesh_i.hxx
src/SMESH_I/SMESH_MEDSupport_i.cxx
src/SMESH_I/SMESH_MEDSupport_i.hxx
src/SMESH_I/SMESH_MEFISTO_2D_i.cxx
src/SMESH_I/SMESH_MEFISTO_2D_i.hxx
src/SMESH_I/SMESH_MaxElementArea_i.cxx
src/SMESH_I/SMESH_MaxElementArea_i.hxx
src/SMESH_I/SMESH_MaxElementVolume_i.cxx
src/SMESH_I/SMESH_MaxElementVolume_i.hxx
src/SMESH_I/SMESH_MeshEditor_i.cxx
src/SMESH_I/SMESH_MeshEditor_i.hxx
src/SMESH_I/SMESH_Mesh_i.cxx
src/SMESH_I/SMESH_Mesh_i.hxx
src/SMESH_I/SMESH_NumberOfSegments_i.cxx
src/SMESH_I/SMESH_NumberOfSegments_i.hxx
src/SMESH_I/SMESH_Quadrangle_2D_i.cxx
src/SMESH_I/SMESH_Quadrangle_2D_i.hxx
src/SMESH_I/SMESH_Regular_1D_i.cxx
src/SMESH_I/SMESH_Regular_1D_i.hxx
src/SMESH_I/SMESH_subMesh_i.cxx
src/SMESH_I/SMESH_subMesh_i.hxx
src/SMESH_I/SMESH_test.py
src/SMESH_I/SMESH_topo.cxx
src/SMESH_I/SMESH_topo.hxx
src/SMESH_I/smeshpy.py
src/SMESH_I/sstream
src/SMESH_SWIG/Makefile.in
src/SMESH_SWIG/SMESH_fixation.py
src/SMESH_SWIG/SMESH_mechanic.py
src/SMESH_SWIG/SMESH_test0.py
src/SMESH_SWIG/SMESH_test1.py
src/SMESH_SWIG/SMESH_test2.py
src/SMESH_SWIG/SMESH_test3.py
src/SMESH_SWIG/batchmode_smesh.py
src/SMESH_SWIG/libSMESH_Swig.i
This commit is contained in:
admin
parent
1e3a9d05f1
commit
bef9beee88
64
idl/SMESH_BasicHypothesis.idl
Normal file
64
idl/SMESH_BasicHypothesis.idl
Normal file
@ -0,0 +1,64 @@
|
||||
//=============================================================================
|
||||
// File : SMESH_BasicHypothesis.idl
|
||||
// Created : mer mai 15 13:37:18 CEST 2002
|
||||
// Author : Paul RASCLE, EDF
|
||||
// Project : SALOME
|
||||
// Copyright : EDF 2002
|
||||
// $Header$
|
||||
//=============================================================================
|
||||
|
||||
#ifndef _SMESH_BASICHYPOTHESIS_IDL_
|
||||
#define _SMESH_BASICHYPOTHESIS_IDL_
|
||||
|
||||
#include "SALOME_Exception.idl"
|
||||
#include "SMESH_Hypothesis.idl"
|
||||
|
||||
|
||||
module SMESH
|
||||
{
|
||||
interface SMESH_LocalLength : SMESH_Hypothesis
|
||||
{
|
||||
void SetLength(in double length)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
double GetLength();
|
||||
};
|
||||
|
||||
interface SMESH_NumberOfSegments : SMESH_Hypothesis
|
||||
{
|
||||
void SetNumberOfSegments(in long segmentsNumber)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
long GetNumberOfSegments();
|
||||
};
|
||||
|
||||
interface SMESH_MaxElementArea : SMESH_Hypothesis
|
||||
{
|
||||
void SetMaxElementArea(in double area)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
double GetMaxElementArea();
|
||||
};
|
||||
|
||||
interface SMESH_MaxElementVolume : SMESH_Hypothesis
|
||||
{
|
||||
void SetMaxElementVolume(in double volume)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
double GetMaxElementVolume();
|
||||
};
|
||||
|
||||
interface SMESH_Regular_1D : SMESH_1D_Algo
|
||||
{
|
||||
};
|
||||
|
||||
interface SMESH_MEFISTO_2D : SMESH_2D_Algo
|
||||
{
|
||||
};
|
||||
|
||||
interface SMESH_Quadrangle_2D : SMESH_2D_Algo
|
||||
{
|
||||
};
|
||||
|
||||
interface SMESH_Hexa_3D : SMESH_3D_Algo
|
||||
{
|
||||
};
|
||||
};
|
||||
|
||||
#endif
|
||||
96
idl/SMESH_Gen.idl
Normal file
96
idl/SMESH_Gen.idl
Normal file
@ -0,0 +1,96 @@
|
||||
//=============================================================================
|
||||
// File : SMESH_Gen.idl
|
||||
// Created : jeu avr 11 15:26:35 CEST 2002
|
||||
// Author : Paul RASCLE, EDF
|
||||
// Project : SALOME
|
||||
// Copyright : EDF 2002
|
||||
// $Header$
|
||||
//=============================================================================
|
||||
|
||||
#ifndef _SMESH_GEN_IDL_
|
||||
#define _SMESH_GEN_IDL_
|
||||
|
||||
#include "SALOME_Exception.idl"
|
||||
#include "SALOME_Component.idl"
|
||||
#include "SALOMEDS.idl"
|
||||
|
||||
#include "GEOM_Gen.idl"
|
||||
#include "GEOM_Shape.idl"
|
||||
|
||||
#include "SMESH_Mesh.idl"
|
||||
#include "SMESH_Hypothesis.idl"
|
||||
|
||||
module SMESH
|
||||
{
|
||||
typedef sequence<GEOM::GEOM_Shape> shape_array;
|
||||
|
||||
interface SMESH_Gen : Engines::Component, SALOMEDS::Driver
|
||||
{
|
||||
/*!
|
||||
* Create an hypothesis that can be shared by differents parts of the mesh.
|
||||
* An hypothesis is either:
|
||||
* - a method used to generate or modify a part of the mesh (algorithm).
|
||||
* - a parameter or a law used by an algorithm.
|
||||
* Algorithms are 1D, 2D or 3D.
|
||||
*/
|
||||
SMESH_Hypothesis CreateHypothesis( in string anHyp,
|
||||
in long studyId)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Create a Mesh object, given a geometry shape.
|
||||
* Mesh is created empty (no points, no elements).
|
||||
* Shape is explored via GEOM_Client to create local copies.
|
||||
* of TopoDS_Shapes and bind CORBA references of shape & subshapes
|
||||
* with TopoDS_Shapes
|
||||
*/
|
||||
SMESH_Mesh Init(in GEOM::GEOM_Gen geomEngine,
|
||||
in long studyId,
|
||||
in GEOM::GEOM_Shape aShape)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Create a Mesh object, without a geometry shape reference
|
||||
*/
|
||||
// SMESH_Mesh NewEmpty(in GEOM::GEOM_Gen geomEngine,
|
||||
// in long studyId)
|
||||
// raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Mesh a subShape.
|
||||
* First, verify list of hypothesis associated with the subShape,
|
||||
* return NOK if hypothesis are not sufficient
|
||||
*/
|
||||
boolean Compute(in SMESH_Mesh aMesh, in GEOM::GEOM_Shape aSubShape)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
|
||||
boolean IsReadyToCompute(in SMESH_Mesh aMesh, in GEOM::GEOM_Shape aSubShape)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
long_array GetSubShapesId(in GEOM::GEOM_Gen geomEngine,
|
||||
in long studyId,
|
||||
in GEOM::GEOM_Shape mainShape,
|
||||
in shape_array listOfSubShape)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
// long_array GetSubMeshesState(in GEOM::GEOM_Gen geomEngine,
|
||||
// in long studyId,
|
||||
// in shape_array listOfSubShape)
|
||||
// raises (SALOME::SALOME_Exception);
|
||||
|
||||
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
71
idl/SMESH_Hypothesis.idl
Normal file
71
idl/SMESH_Hypothesis.idl
Normal file
@ -0,0 +1,71 @@
|
||||
//=============================================================================
|
||||
// File : SMESH_Hypothesis.idl
|
||||
// Created : jeu avr 11 19:26:16 CEST 2002
|
||||
// Author : Paul RASCLE, EDF
|
||||
// Project : SALOME
|
||||
// Copyright : EDF 2002
|
||||
// $Header$
|
||||
//=============================================================================
|
||||
|
||||
#ifndef _SMESH_HYPOTHESIS_IDL_
|
||||
#define _SMESH_HYPOTHESIS_IDL_
|
||||
|
||||
#include "SALOME_Exception.idl"
|
||||
|
||||
module SMESH
|
||||
{
|
||||
interface SMESH_Hypothesis;
|
||||
|
||||
typedef sequence<SMESH_Hypothesis> ListOfHypothesis;
|
||||
typedef sequence<string> ListOfHypothesisName;
|
||||
|
||||
interface SMESH_Hypothesis
|
||||
{
|
||||
/*!
|
||||
* Get the Hypothesis typeName
|
||||
*/
|
||||
string GetName();
|
||||
|
||||
/*!
|
||||
* Get the internal Id
|
||||
*/
|
||||
long GetId();
|
||||
};
|
||||
|
||||
interface SMESH_Algo : SMESH_Hypothesis
|
||||
{
|
||||
/*!
|
||||
* Get list of hypothesis that can be used with this algorithm
|
||||
*/
|
||||
ListOfHypothesisName GetCompatibleHypothesis();
|
||||
|
||||
};
|
||||
|
||||
interface SMESH_1D_Algo : SMESH_Algo
|
||||
{
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
};
|
||||
|
||||
interface SMESH_2D_Algo : SMESH_Algo
|
||||
{
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
};
|
||||
|
||||
interface SMESH_3D_Algo : SMESH_Algo
|
||||
{
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
};
|
||||
};
|
||||
|
||||
// -----------------------------------------------------------------
|
||||
// Specific Algorithms in separate idl file
|
||||
// -----------------------------------------------------------------
|
||||
|
||||
|
||||
#endif
|
||||
262
idl/SMESH_Mesh.idl
Normal file
262
idl/SMESH_Mesh.idl
Normal file
@ -0,0 +1,262 @@
|
||||
//=============================================================================
|
||||
// File : SMESH_Mesh.idl
|
||||
// Created : jeu avr 11 15:31:39 CEST 2002
|
||||
// Author : Paul RASCLE, EDF
|
||||
// Project : SALOME
|
||||
// Copyright : EDF 2002
|
||||
// $Header$
|
||||
//=============================================================================
|
||||
|
||||
|
||||
#ifndef _SMESH_MESH_IDL_
|
||||
#define _SMESH_MESH_IDL_
|
||||
|
||||
#include "SALOME_Exception.idl"
|
||||
#include "SMESH_Hypothesis.idl"
|
||||
|
||||
#include "GEOM_Shape.idl"
|
||||
#include "MED.idl"
|
||||
|
||||
module SMESH
|
||||
{
|
||||
typedef sequence<double> double_array ;
|
||||
typedef sequence<long> long_array ;
|
||||
typedef sequence<string> string_array ;
|
||||
|
||||
enum log_command
|
||||
{
|
||||
ADD_NODE,
|
||||
ADD_EDGE,
|
||||
ADD_TRIANGLE,
|
||||
ADD_QUADRANGLE,
|
||||
ADD_TETRAHEDRON,
|
||||
ADD_PYRAMID,
|
||||
ADD_PRISM,
|
||||
ADD_HEXAHEDRON,
|
||||
REMOVE_NODE,
|
||||
REMOVE_ELEMENT
|
||||
};
|
||||
|
||||
struct log_block
|
||||
{
|
||||
long commandType;
|
||||
long number;
|
||||
double_array coords;
|
||||
long_array indexes;
|
||||
};
|
||||
|
||||
typedef sequence<log_block> log_array;
|
||||
|
||||
interface SMESH_subMesh;
|
||||
interface SMESH_MeshEditor;
|
||||
interface SMESH_Mesh
|
||||
{
|
||||
/*!
|
||||
* Associate a Shape to a Mesh created with NewEmpty
|
||||
*/
|
||||
|
||||
// boolean SetMesh(in GEOM::GEOM_Shape aShape)
|
||||
// raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Get the subMesh object associated to a subShape. The subMesh object
|
||||
* gives access to nodes and elements IDs.
|
||||
* SubMesh will be used instead of SubShape in a next idl version to
|
||||
* adress a specific subMesh...
|
||||
*/
|
||||
SMESH_subMesh GetElementsOnShape(in GEOM::GEOM_Shape aSubShape)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Create a subMesh without reference to a subShape
|
||||
*/
|
||||
// SMESH_subMesh NewEmpty()
|
||||
// raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Add hypothesis to the mesh, under a particular subShape
|
||||
* (or the main shape itself)
|
||||
* The Add method is only used to prepare the build of the mesh and store
|
||||
* the algorithms and associated parameters.
|
||||
* Actual job of mesh the shape is done by MESH_Gen.
|
||||
* @params
|
||||
* - aSubShape : subShape obtained by a shape explode in GEOM
|
||||
* (or main shape)
|
||||
* - anHyp : hypothesis object
|
||||
* @return
|
||||
* - OK if the hypothesis is compatible with the subShape
|
||||
* (and all previous hypothesis on the subShape)
|
||||
* - NOK if the hypothesis is not compatible with the subShape
|
||||
* (or one previous hypothesis on the subShape)
|
||||
* raises exception if hypothesis has not been created
|
||||
*/
|
||||
boolean AddHypothesis(in GEOM::GEOM_Shape aSubShape, in SMESH_Hypothesis anHyp)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
// boolean AddHypothesis(in SMESH_subMesh aSubMesh, in SMESH_Hypothesis anHyp)
|
||||
// raises (SALOME::SALOME_Exception);
|
||||
|
||||
|
||||
/*!
|
||||
* Remove an hypothesis previouly added with AddHypothesis.
|
||||
*/
|
||||
boolean RemoveHypothesis(in GEOM::GEOM_Shape aSubShape,
|
||||
in SMESH_Hypothesis anHyp)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
// boolean RemoveHypothesis(in SMESH_subMesh aSubMesh,
|
||||
// in SMESH_Hypothesis anHyp)
|
||||
// raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Get the list of hypothesis added on a subShape
|
||||
*/
|
||||
ListOfHypothesis GetHypothesisList(in GEOM::GEOM_Shape aSubShape)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
// ListOfHypothesis GetHypothesisList(in SMESH_subMesh aSubMesh)
|
||||
// raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Get the log of nodes and elements added or removed since previous
|
||||
* clear of the log.
|
||||
* @params
|
||||
* - clearAfterGet : log is emptied after Get (safe if concurrents access)
|
||||
*/
|
||||
// string_array GetLog(in boolean clearAfterGet)
|
||||
// raises (SALOME::SALOME_Exception);
|
||||
log_array GetLog(in boolean clearAfterGet)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Clear the log of nodes and elements added or removed since previous
|
||||
* clear. Must be used immediately after GetLog if clearAfterGet is false.
|
||||
*/
|
||||
void ClearLog()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Get the internal Id
|
||||
*/
|
||||
long GetId();
|
||||
|
||||
/*!
|
||||
* Get the study Id
|
||||
*/
|
||||
long GetStudyId();
|
||||
|
||||
SMESH_MeshEditor GetMeshEditor()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Export Mesh with DAT and MED Formats
|
||||
*/
|
||||
void ExportDAT( in string file )
|
||||
raises (SALOME::SALOME_Exception);
|
||||
void ExportMED( in string file )
|
||||
raises (SALOME::SALOME_Exception);
|
||||
void ExportUNV( in string file )
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Get MED Mesh
|
||||
*/
|
||||
SALOME_MED::MESH GetMEDMesh()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
long NbNodes()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
long NbEdges()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
long NbFaces()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
long NbTriangles()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
long NbQuadrangles()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
long NbVolumes()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
long NbTetras()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
long NbHexas()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
long NbSubMesh()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
};
|
||||
|
||||
interface SMESH_subMesh
|
||||
{
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
long GetNumberOfElements()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
long GetNumberOfNodes()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
long_array GetElementsId()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
*
|
||||
*/
|
||||
long_array GetNodesId()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Get SMESH_Mesh which stores nodes coordinates & elements definition
|
||||
*/
|
||||
SMESH_Mesh GetFather()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
/*!
|
||||
* Get the internal Id
|
||||
*/
|
||||
long GetId();
|
||||
|
||||
/*!
|
||||
* Get MED subMesh
|
||||
*/
|
||||
SALOME_MED::FAMILY GetFamily()
|
||||
raises (SALOME::SALOME_Exception);
|
||||
};
|
||||
|
||||
/*
|
||||
* This interface makes modifications on the Mesh - removing elements and nodes
|
||||
*/
|
||||
interface SMESH_MeshEditor {
|
||||
|
||||
|
||||
boolean RemoveElements(in long_array IDsOfElements)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
boolean RemoveNodes(in long_array IDsOfNodes)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
boolean AddNode(in double x, in double y, in double z)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
boolean AddEdge(in long_array IDsOfNodes)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
boolean AddFace(in long_array IDsOfNodes)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
|
||||
boolean AddVolume(in long_array IDsOfNodes)
|
||||
raises (SALOME::SALOME_Exception);
|
||||
};
|
||||
};
|
||||
|
||||
#endif
|
||||
13
src/Driver/Document_Reader.cxx
Normal file
13
src/Driver/Document_Reader.cxx
Normal file
@ -0,0 +1,13 @@
|
||||
using namespace std;
|
||||
#include "Document_Reader.h"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
void Document_Reader::SetFile(string aFile) {
|
||||
myFile = aFile;
|
||||
}
|
||||
|
||||
void Document_Reader::SetDocument(Handle(SMESHDS_Document)& aDoc) {
|
||||
myDocument = aDoc;
|
||||
}
|
||||
|
||||
18
src/Driver/Document_Reader.h
Normal file
18
src/Driver/Document_Reader.h
Normal file
@ -0,0 +1,18 @@
|
||||
#ifndef _INCLUDE_DOCUMENT_READER
|
||||
#define _INCLUDE_DOCUMENT_READER
|
||||
|
||||
#include "SMESHDS_Document.hxx"
|
||||
#include <string>
|
||||
|
||||
class Document_Reader {
|
||||
|
||||
public :
|
||||
virtual void Read() =0;
|
||||
void SetFile(string);
|
||||
void SetDocument(Handle(SMESHDS_Document)&);
|
||||
|
||||
protected :
|
||||
Handle_SMESHDS_Document myDocument;
|
||||
string myFile;
|
||||
};
|
||||
#endif
|
||||
11
src/Driver/Document_Writer.cxx
Normal file
11
src/Driver/Document_Writer.cxx
Normal file
@ -0,0 +1,11 @@
|
||||
using namespace std;
|
||||
#include "Document_Writer.h"
|
||||
|
||||
void Document_Writer::SetFile(string aFile) {
|
||||
myFile = aFile;
|
||||
}
|
||||
|
||||
void Document_Writer::SetDocument(Handle(SMESHDS_Document)& aDoc) {
|
||||
myDocument = aDoc;
|
||||
}
|
||||
|
||||
19
src/Driver/Document_Writer.h
Normal file
19
src/Driver/Document_Writer.h
Normal file
@ -0,0 +1,19 @@
|
||||
#ifndef _INCLUDE_DOCUMENT_WRITER
|
||||
#define _INCLUDE_DOCUMENT_WRITER
|
||||
|
||||
#include "SMESHDS_Document.hxx"
|
||||
#include <string>
|
||||
|
||||
class Document_Writer {
|
||||
|
||||
public :
|
||||
virtual void Write() =0;
|
||||
void SetFile(string);
|
||||
void SetDocument(Handle(SMESHDS_Document)&);
|
||||
|
||||
protected :
|
||||
Handle_SMESHDS_Document myDocument;
|
||||
string myFile;
|
||||
|
||||
};
|
||||
#endif
|
||||
183
src/Driver/Driver_dl.cxx
Normal file
183
src/Driver/Driver_dl.cxx
Normal file
@ -0,0 +1,183 @@
|
||||
using namespace std;
|
||||
#include "Driver.h"
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <stdio.h>
|
||||
#include <utilities.h>
|
||||
|
||||
#include "DriverDAT_R_SMESHDS_Document.h"
|
||||
#include "Test.h"
|
||||
|
||||
/*! extern "C"
|
||||
{
|
||||
void test() {
|
||||
|
||||
void *handle;
|
||||
double (*cosine)(double);
|
||||
char *error;
|
||||
|
||||
handle = dlopen ("/usr/lib/libm.so", RTLD_LAZY);
|
||||
if (!handle) {
|
||||
fputs (dlerror(), stderr);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
cosine = dlsym(handle, "cos");
|
||||
if ((error = dlerror()) != NULL) {
|
||||
fprintf (stderr, "%s\n", error);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
printf ("%f\n", (*cosine)(2.0));
|
||||
dlclose(handle);
|
||||
|
||||
char* error;
|
||||
string Extension=string("DAT");
|
||||
string Class=string("SMESHDS_Document");
|
||||
string myLibrary = string("/home/barberou/barberou/SALOME_3105/build/lib/libMeshDriver")+Extension+string(".so");
|
||||
SCRUTE(myLibrary);
|
||||
//Document_Reader* myDriver;//a caster ???
|
||||
DriverDAT_R_SMESHDS_Document* myDriver;
|
||||
|
||||
string myClass = string("Driver")+Extension+string("_R_")+Class;
|
||||
SCRUTE(myClass);
|
||||
|
||||
void* handle = dlopen (myLibrary.c_str(), RTLD_LAZY);
|
||||
if (!handle) {
|
||||
fputs (dlerror(), stderr);
|
||||
exit(1);
|
||||
}
|
||||
MESSAGE("Open ok");
|
||||
|
||||
//int* res = (int*)dlsym(handle, "getOne");
|
||||
//SCRUTE(res);
|
||||
SCRUTE(dlsym(handle, "getOne"));
|
||||
//int res2= (*res)();
|
||||
myDriver = (DriverDAT_R_SMESHDS_Document*) dlsym(handle, myClass.c_str());
|
||||
MESSAGE("Reading 1");
|
||||
SCRUTE(myDriver);
|
||||
if ((error = dlerror()) != NULL) {
|
||||
fprintf (stderr, "%s\n", error);
|
||||
exit(1);
|
||||
}
|
||||
MESSAGE("Reading 2");
|
||||
|
||||
dlclose(handle);
|
||||
MESSAGE("after close");
|
||||
|
||||
}
|
||||
}*/
|
||||
|
||||
Document_Reader* Driver::GetDocumentReader(string Extension, string Class) {
|
||||
test();
|
||||
//p-e extern C ?
|
||||
/*!
|
||||
char* error;
|
||||
string myLibrary = string("/home/barberou/barberou/SALOME_3105/build/lib/libMeshDriver")+Extension+string(".so");
|
||||
SCRUTE(myLibrary);
|
||||
//Document_Reader* myDriver;//a caster ???
|
||||
DriverDAT_R_SMESHDS_Document* myDriver;
|
||||
|
||||
string myClass = string("Driver")+Extension+string("_R_")+Class;
|
||||
SCRUTE(myClass);
|
||||
|
||||
void* handle = dlopen (myLibrary.c_str(), RTLD_LAZY);
|
||||
if (!handle) {
|
||||
fputs (dlerror(), stderr);
|
||||
exit(1);
|
||||
}
|
||||
MESSAGE("Open ok");
|
||||
//myDriver = (Document_Reader*) dlsym(handle, myClass.c_str());
|
||||
int* res = (int*) dlsym(handle, "getOne");
|
||||
SCRUTE(res);
|
||||
myDriver = (DriverDAT_R_SMESHDS_Document*) dlsym(handle, myClass.c_str());
|
||||
MESSAGE("Reading 1");
|
||||
SCRUTE(myDriver);
|
||||
if ((error = dlerror()) != NULL) {
|
||||
fprintf (stderr, "%s\n", error);
|
||||
exit(1);
|
||||
}
|
||||
MESSAGE("Reading 2");
|
||||
|
||||
dlclose(handle);
|
||||
MESSAGE("after close");
|
||||
return (myDriver);
|
||||
*/
|
||||
|
||||
}
|
||||
|
||||
Document_Writer* Driver::GetDocumentWriter(string Extension, string Class) {
|
||||
|
||||
char* error;
|
||||
string myLibrary = string("libMeshDriver")+Extension+string(".so");
|
||||
Document_Writer* myDriver;//a caster ???
|
||||
string myClass = string("Driver")+Extension+string("_W_")+Class;
|
||||
|
||||
void* handle = dlopen (myLibrary.c_str(), RTLD_LAZY);
|
||||
if (!handle) {
|
||||
fputs (dlerror(), stderr);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
myDriver = (Document_Writer*) dlsym(handle, myClass.c_str());
|
||||
if ((error = dlerror()) != NULL) {
|
||||
fprintf (stderr, "%s\n", error);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
dlclose(handle);
|
||||
|
||||
return (myDriver);
|
||||
|
||||
}
|
||||
|
||||
Mesh_Reader* Driver::GetMeshReader(string Extension, string Class) {
|
||||
|
||||
char* error;
|
||||
string myLibrary = string("libMeshDriver")+Extension+string(".so");
|
||||
Mesh_Reader* myDriver;//a caster ???
|
||||
string myClass = string("Driver")+Extension+string("_R_")+Class;
|
||||
|
||||
void* handle = dlopen (myLibrary.c_str(), RTLD_LAZY);
|
||||
if (!handle) {
|
||||
fputs (dlerror(), stderr);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
myDriver = (Mesh_Reader*) dlsym(handle, myClass.c_str());
|
||||
if ((error = dlerror()) != NULL) {
|
||||
fprintf (stderr, "%s\n", error);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
dlclose(handle);
|
||||
|
||||
return (myDriver);
|
||||
|
||||
}
|
||||
|
||||
Mesh_Writer* Driver::GetMeshWriter(string Extension, string Class) {
|
||||
|
||||
char* error;
|
||||
string myLibrary = string("libMeshDriver")+Extension+string(".so");
|
||||
Mesh_Writer* myDriver;//a caster ???
|
||||
string myClass = string("Driver")+Extension+string("_W_")+Class;
|
||||
|
||||
void* handle = dlopen (myLibrary.c_str(), RTLD_LAZY);
|
||||
if (!handle) {
|
||||
fputs (dlerror(), stderr);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
myDriver = (Mesh_Writer*) dlsym(handle, myClass.c_str());
|
||||
if ((error = dlerror()) != NULL) {
|
||||
fprintf (stderr, "%s\n", error);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
dlclose(handle);
|
||||
|
||||
return (myDriver);
|
||||
|
||||
}
|
||||
|
||||
39
src/Driver/Makefile.in
Normal file
39
src/Driver/Makefile.in
Normal file
@ -0,0 +1,39 @@
|
||||
# -* Makefile *-
|
||||
#
|
||||
# Author : Marc Tajchman (CEA)
|
||||
# Date : 5/07/2001
|
||||
# $Header$
|
||||
#
|
||||
|
||||
# source path
|
||||
top_srcdir=@top_srcdir@
|
||||
top_builddir=../..
|
||||
srcdir=@srcdir@
|
||||
VPATH=.:@srcdir@
|
||||
|
||||
|
||||
@COMMENCE@
|
||||
|
||||
# header files
|
||||
EXPORT_HEADERS= Document_Reader.h Document_Writer.h Mesh_Reader.h Mesh_Writer.h
|
||||
|
||||
# Libraries targets
|
||||
LIB = libMeshDriver.la
|
||||
LIB_SRC = Document_Reader.cxx Document_Writer.cxx Mesh_Reader.cxx Mesh_Writer.cxx
|
||||
|
||||
LIB_CLIENT_IDL =
|
||||
|
||||
LIB_SERVER_IDL =
|
||||
|
||||
# additionnal information to compil and link file
|
||||
CPPFLAGS += $(OCC_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
|
||||
CXXFLAGS += $(OCC_CXXFLAGS) $(MED2_INCLUDES) -rdynamic -ldl -I${KERNEL_ROOT_DIR}/include/salome
|
||||
LDFLAGS += $(OCC_LIBS) $(MED2_LIBS) -lSMESHDS -lSMDS
|
||||
|
||||
%_moc.cxx: %.h
|
||||
$(MOC) $< -o $@
|
||||
|
||||
@CONCLUDE@
|
||||
|
||||
|
||||
|
||||
3
src/Driver/Mesh_Reader.cxx
Normal file
3
src/Driver/Mesh_Reader.cxx
Normal file
@ -0,0 +1,3 @@
|
||||
using namespace std;
|
||||
#include "Mesh_Reader.h"
|
||||
|
||||
17
src/Driver/Mesh_Reader.h
Normal file
17
src/Driver/Mesh_Reader.h
Normal file
@ -0,0 +1,17 @@
|
||||
#ifndef _INCLUDE_MESH_READER
|
||||
#define _INCLUDE_MESH_READER
|
||||
|
||||
#include <string>
|
||||
#include "Handle_SMDS_Mesh.hxx"
|
||||
|
||||
class Mesh_Reader {
|
||||
|
||||
public :
|
||||
virtual void Add() =0;
|
||||
virtual void Read() =0;
|
||||
virtual void SetMesh(Handle(SMDS_Mesh)&) =0;
|
||||
virtual void SetMeshId(int) =0;
|
||||
virtual void SetFile(string) =0;
|
||||
|
||||
};
|
||||
#endif
|
||||
2
src/Driver/Mesh_Writer.cxx
Normal file
2
src/Driver/Mesh_Writer.cxx
Normal file
@ -0,0 +1,2 @@
|
||||
using namespace std;
|
||||
#include "Mesh_Writer.h"
|
||||
17
src/Driver/Mesh_Writer.h
Normal file
17
src/Driver/Mesh_Writer.h
Normal file
@ -0,0 +1,17 @@
|
||||
#ifndef _INCLUDE_MESH_WRITER
|
||||
#define _INCLUDE_MESH_WRITER
|
||||
|
||||
#include <string>
|
||||
#include "Handle_SMDS_Mesh.hxx"
|
||||
|
||||
class Mesh_Writer {
|
||||
|
||||
public :
|
||||
virtual void Add() =0;
|
||||
virtual void Write() =0;
|
||||
virtual void SetMesh(Handle(SMDS_Mesh)&) =0;
|
||||
virtual void SetFile(string) =0;
|
||||
virtual void SetMeshId(int) =0;
|
||||
|
||||
};
|
||||
#endif
|
||||
113
src/Driver/SMESHDriver.cxx
Normal file
113
src/Driver/SMESHDriver.cxx
Normal file
@ -0,0 +1,113 @@
|
||||
using namespace std;
|
||||
#include "SMESHDriver.h"
|
||||
|
||||
#include <dlfcn.h>
|
||||
#include <utilities.h>
|
||||
|
||||
//A enlever
|
||||
#include "DriverMED_R_SMESHDS_Document.h"
|
||||
#include "DriverMED_R_SMESHDS_Mesh.h"
|
||||
#include "DriverMED_R_SMDS_Mesh.h"
|
||||
#include "DriverMED_W_SMESHDS_Document.h"
|
||||
#include "DriverMED_W_SMESHDS_Mesh.h"
|
||||
#include "DriverMED_W_SMDS_Mesh.h"
|
||||
|
||||
#include "DriverDAT_R_SMESHDS_Document.h"
|
||||
#include "DriverDAT_R_SMESHDS_Mesh.h"
|
||||
#include "DriverDAT_R_SMDS_Mesh.h"
|
||||
#include "DriverDAT_W_SMESHDS_Document.h"
|
||||
#include "DriverDAT_W_SMESHDS_Mesh.h"
|
||||
#include "DriverDAT_W_SMDS_Mesh.h"
|
||||
//
|
||||
|
||||
Document_Reader* SMESHDriver::GetDocumentReader(string Extension, string Class) {
|
||||
if (Extension==string("MED")) {
|
||||
DriverMED_R_SMESHDS_Document* myDriver = new DriverMED_R_SMESHDS_Document();
|
||||
return (myDriver);
|
||||
}
|
||||
else if (Extension==string("DAT")) {
|
||||
DriverDAT_R_SMESHDS_Document* myDriver = new DriverDAT_R_SMESHDS_Document();
|
||||
return (myDriver);
|
||||
}
|
||||
else {
|
||||
MESSAGE("No driver known for this extension");
|
||||
return (Document_Reader*)NULL;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
Document_Writer* SMESHDriver::GetDocumentWriter(string Extension, string Class) {
|
||||
if (Extension==string("MED")) {
|
||||
DriverMED_W_SMESHDS_Document* myDriver = new DriverMED_W_SMESHDS_Document();
|
||||
return (myDriver);
|
||||
}
|
||||
else if (Extension==string("DAT")) {
|
||||
DriverDAT_W_SMESHDS_Document* myDriver = new DriverDAT_W_SMESHDS_Document();
|
||||
return (myDriver);
|
||||
}
|
||||
else {
|
||||
MESSAGE("No driver known for this extension");
|
||||
return (Document_Writer*)NULL;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
Mesh_Reader* SMESHDriver::GetMeshReader(string Extension, string Class) {
|
||||
if (Extension==string("MED")) {
|
||||
|
||||
if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
|
||||
DriverMED_R_SMESHDS_Mesh* myDriver = new DriverMED_R_SMESHDS_Mesh();
|
||||
return (myDriver);
|
||||
}
|
||||
else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
|
||||
DriverMED_R_SMDS_Mesh* myDriver = new DriverMED_R_SMDS_Mesh();
|
||||
return (myDriver);
|
||||
}
|
||||
|
||||
}
|
||||
else if (Extension==string("DAT")) {
|
||||
|
||||
if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
|
||||
DriverDAT_R_SMESHDS_Mesh* myDriver = new DriverDAT_R_SMESHDS_Mesh();
|
||||
return (myDriver);
|
||||
}
|
||||
else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
|
||||
DriverDAT_R_SMDS_Mesh* myDriver = new DriverDAT_R_SMDS_Mesh();
|
||||
return (myDriver);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
Mesh_Writer* SMESHDriver::GetMeshWriter(string Extension, string Class) {
|
||||
if (Extension==string("MED")) {
|
||||
|
||||
if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
|
||||
DriverMED_W_SMESHDS_Mesh* myDriver = new DriverMED_W_SMESHDS_Mesh();
|
||||
return (myDriver);
|
||||
}
|
||||
else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
|
||||
DriverMED_W_SMDS_Mesh* myDriver = new DriverMED_W_SMDS_Mesh();
|
||||
return (myDriver);
|
||||
}
|
||||
|
||||
}
|
||||
else if (Extension==string("DAT")) {
|
||||
|
||||
if (strcmp(Class.c_str(),"SMESHDS_Mesh")==0) {
|
||||
DriverDAT_W_SMESHDS_Mesh* myDriver = new DriverDAT_W_SMESHDS_Mesh();
|
||||
return (myDriver);
|
||||
}
|
||||
else if (strcmp(Class.c_str(),"SMDS_Mesh")==0) {
|
||||
DriverDAT_W_SMDS_Mesh* myDriver = new DriverDAT_W_SMDS_Mesh();
|
||||
return (myDriver);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
19
src/Driver/SMESHDriver.h
Normal file
19
src/Driver/SMESHDriver.h
Normal file
@ -0,0 +1,19 @@
|
||||
#ifndef _INCLUDE_SMESHDRIVER
|
||||
#define _INCLUDE_SMESHDRIVER
|
||||
|
||||
#include "Document_Reader.h"
|
||||
#include "Document_Writer.h"
|
||||
#include "Mesh_Reader.h"
|
||||
#include "Mesh_Writer.h"
|
||||
|
||||
class SMESHDriver {
|
||||
|
||||
public :
|
||||
static Document_Reader* GetDocumentReader(string Extension, string Class);
|
||||
static Document_Writer* GetDocumentWriter(string Extension, string Class);
|
||||
|
||||
static Mesh_Reader* GetMeshReader(string Extension, string Class);
|
||||
static Mesh_Writer* GetMeshWriter(string Extension, string Class);
|
||||
|
||||
};
|
||||
#endif
|
||||
175
src/DriverDAT/DriverDAT_R_SMDS_Mesh.cxx
Normal file
175
src/DriverDAT/DriverDAT_R_SMDS_Mesh.cxx
Normal file
@ -0,0 +1,175 @@
|
||||
using namespace std;
|
||||
#include "DriverDAT_R_SMDS_Mesh.h"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
DriverDAT_R_SMDS_Mesh::DriverDAT_R_SMDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
DriverDAT_R_SMDS_Mesh::~DriverDAT_R_SMDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMDS_Mesh::SetMesh(Handle(SMDS_Mesh)& aMesh) {
|
||||
myMesh = aMesh;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMDS_Mesh::SetFile(string aFile) {
|
||||
myFile = aFile;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMDS_Mesh::SetFileId(FILE* aFileId) {
|
||||
myFileId = aFileId;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMDS_Mesh::SetMeshId(int aMeshId) {
|
||||
myMeshId = aMeshId;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMDS_Mesh::Add() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMDS_Mesh::Read() {
|
||||
|
||||
int i,j;
|
||||
int nbNodes,nbCells;
|
||||
int intNumPoint;
|
||||
float coordX, coordY, coordZ;
|
||||
int nbNoeuds;
|
||||
|
||||
int intNumMaille,Degre;
|
||||
int ValElement;
|
||||
int ValDegre;
|
||||
int NoeudsMaille[20];
|
||||
int NoeudMaille;
|
||||
|
||||
bool ok;
|
||||
|
||||
MESSAGE("in DriverDAT_R_SMDS_Mesh::Read()");
|
||||
/****************************************************************************
|
||||
* OUVERTURE DU FICHIER EN LECTURE *
|
||||
****************************************************************************/
|
||||
char* file2Read = (char*)myFile.c_str();
|
||||
myFileId = fopen(file2Read,"r");
|
||||
if (myFileId < 0)
|
||||
{
|
||||
fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Read);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
fscanf(myFileId,"%d %d\n",&nbNodes,&nbCells);
|
||||
|
||||
/****************************************************************************
|
||||
* LECTURE DES NOEUDS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(************************)\n");
|
||||
fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
|
||||
fprintf(stdout,"(************************)\n");
|
||||
|
||||
for (i=0;i<nbNodes;i++) {
|
||||
fscanf(myFileId,"%d %e %e %e\n",&intNumPoint,&coordX,&coordY,&coordZ);
|
||||
ok = myMesh->AddNodeWithID(coordX,coordY,coordZ,intNumPoint);
|
||||
}
|
||||
|
||||
fprintf(stdout,"%d noeuds\n",myMesh->NbNodes());
|
||||
/****************************************************************************
|
||||
* LECTURE DES ELEMENTS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(**************************)\n");
|
||||
fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
|
||||
fprintf(stdout,"(**************************)");
|
||||
|
||||
fprintf(stdout,"%d elements\n",nbCells);
|
||||
|
||||
for (i=0; i<nbCells; i++) {
|
||||
fscanf(myFileId,"%d %d",&intNumMaille,&ValElement);
|
||||
Degre=abs(ValElement/100);
|
||||
nbNoeuds=ValElement-(Degre*100);
|
||||
|
||||
// Recuperation des noeuds de la maille
|
||||
for (j=0; j<nbNoeuds; j++) {
|
||||
fscanf(myFileId,"%d",&NoeudMaille);
|
||||
NoeudsMaille[j]=NoeudMaille;
|
||||
}
|
||||
|
||||
// Analyse des cas de cellules
|
||||
switch (ValElement) {
|
||||
case 102 : ;
|
||||
case 103 : ;
|
||||
{
|
||||
ValDegre=3;
|
||||
nbNoeuds=2;
|
||||
ok = myMesh->AddEdgeWithID(NoeudsMaille[0],NoeudsMaille[1],intNumMaille);
|
||||
break;
|
||||
}
|
||||
case 204 : ;
|
||||
case 208 : ;
|
||||
{
|
||||
ValDegre=9;
|
||||
nbNoeuds=4;
|
||||
ok = myMesh->AddFaceWithID(NoeudsMaille[0],NoeudsMaille[1],NoeudsMaille[2],NoeudsMaille[3],intNumMaille);
|
||||
break;
|
||||
}
|
||||
case 203 : ;
|
||||
case 206 : ;
|
||||
{
|
||||
ValDegre=5;
|
||||
nbNoeuds=3;
|
||||
ok = myMesh->AddFaceWithID(NoeudsMaille[0],NoeudsMaille[1],NoeudsMaille[2],intNumMaille);
|
||||
break;
|
||||
}
|
||||
case 308 : ;
|
||||
case 320 : ;
|
||||
{
|
||||
ValDegre=12;
|
||||
nbNoeuds=8;
|
||||
if (ValElement==320) {
|
||||
//A voir, correspondance VTK
|
||||
NoeudsMaille[4]=NoeudsMaille[8];
|
||||
NoeudsMaille[5]=NoeudsMaille[9];
|
||||
NoeudsMaille[6]=NoeudsMaille[10];
|
||||
NoeudsMaille[7]=NoeudsMaille[11];
|
||||
}
|
||||
ok = myMesh->AddVolumeWithID(NoeudsMaille[0],NoeudsMaille[1],NoeudsMaille[2],NoeudsMaille[3],NoeudsMaille[4],NoeudsMaille[5],NoeudsMaille[6],NoeudsMaille[7],intNumMaille);
|
||||
break;
|
||||
}
|
||||
case 304 : ;
|
||||
case 310 : ;
|
||||
{
|
||||
ValDegre=10;
|
||||
nbNoeuds=4;
|
||||
if (ValElement==310)
|
||||
NoeudsMaille[3]=NoeudsMaille[6];
|
||||
ok = myMesh->AddVolumeWithID(NoeudsMaille[0],NoeudsMaille[1],NoeudsMaille[2],NoeudsMaille[3],intNumMaille);
|
||||
break;
|
||||
}
|
||||
case 306 : ;
|
||||
case 315 : ;
|
||||
{
|
||||
ValDegre=12;
|
||||
nbNoeuds=8;
|
||||
if (ValElement==315) {
|
||||
NoeudsMaille[3]=NoeudsMaille[6];
|
||||
NoeudsMaille[4]=NoeudsMaille[7];
|
||||
NoeudsMaille[5]=NoeudsMaille[8];
|
||||
}
|
||||
NoeudsMaille[7]=NoeudsMaille[5];
|
||||
NoeudsMaille[6]=NoeudsMaille[5];
|
||||
NoeudsMaille[5]=NoeudsMaille[4];
|
||||
NoeudsMaille[4]=NoeudsMaille[3];
|
||||
NoeudsMaille[3]=NoeudsMaille[2];
|
||||
ok = myMesh->AddVolumeWithID(NoeudsMaille[0],NoeudsMaille[1],NoeudsMaille[2],NoeudsMaille[3],NoeudsMaille[4],NoeudsMaille[5],intNumMaille);
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* FERMETURE DU FICHIER *
|
||||
****************************************************************************/
|
||||
fclose(myFileId);
|
||||
|
||||
}
|
||||
30
src/DriverDAT/DriverDAT_R_SMDS_Mesh.h
Normal file
30
src/DriverDAT/DriverDAT_R_SMDS_Mesh.h
Normal file
@ -0,0 +1,30 @@
|
||||
#ifndef _INCLUDE_DRIVERDAT_R_SMDS_MESH
|
||||
#define _INCLUDE_DRIVERDAT_R_SMDS_MESH
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#include "Mesh_Reader.h"
|
||||
|
||||
class DriverDAT_R_SMDS_Mesh : public Mesh_Reader {
|
||||
|
||||
public :
|
||||
DriverDAT_R_SMDS_Mesh();
|
||||
~DriverDAT_R_SMDS_Mesh();
|
||||
|
||||
void Add();
|
||||
void Read();
|
||||
void SetMesh(Handle(SMDS_Mesh)& aMesh);
|
||||
void SetFile(string);
|
||||
|
||||
void SetFileId(FILE*);
|
||||
void SetMeshId(int);
|
||||
|
||||
private :
|
||||
Handle_SMDS_Mesh myMesh;
|
||||
string myFile;
|
||||
FILE* myFileId;
|
||||
int myMeshId;
|
||||
|
||||
};
|
||||
#endif
|
||||
86
src/DriverDAT/DriverDAT_R_SMESHDS_Document.cxx
Normal file
86
src/DriverDAT/DriverDAT_R_SMESHDS_Document.cxx
Normal file
@ -0,0 +1,86 @@
|
||||
using namespace std;
|
||||
#include "DriverDAT_R_SMESHDS_Document.h"
|
||||
#include "DriverDAT_R_SMESHDS_Mesh.h"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
int getOne() {
|
||||
printf("in getOne");
|
||||
return (1);
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
// Document_Reader* maker() {
|
||||
DriverDAT_R_SMESHDS_Document* maker() {
|
||||
fprintf(stdout,"here in maker\n");
|
||||
return new DriverDAT_R_SMESHDS_Document;
|
||||
}
|
||||
}
|
||||
|
||||
DriverDAT_R_SMESHDS_Document::DriverDAT_R_SMESHDS_Document() {
|
||||
myFile = string("");
|
||||
}
|
||||
|
||||
DriverDAT_R_SMESHDS_Document::~DriverDAT_R_SMESHDS_Document() {
|
||||
;
|
||||
}
|
||||
|
||||
//void DriverDAT_R_SMESHDS_Document::SetFile(string aFile) {
|
||||
//myFile = aFile;
|
||||
//}
|
||||
|
||||
//void DriverDAT_R_SMESHDS_Document::SetDocument(Handle(SMESHDS_Document)& aDoc) {
|
||||
//myDocument = aDoc;
|
||||
//}
|
||||
|
||||
void DriverDAT_R_SMESHDS_Document::Read() {
|
||||
|
||||
int myMeshId;
|
||||
MESSAGE("in read");
|
||||
SCRUTE(myFile);
|
||||
//Handle(SMESHDS_Document) myDocument = new SMESHDS_Document(1);
|
||||
|
||||
/****************************************************************************
|
||||
* OUVERTURE DU FICHIER EN LECTURE *
|
||||
****************************************************************************/
|
||||
char* file2Read = (char*)myFile.c_str();
|
||||
FILE* fid = fopen(file2Read,"r");
|
||||
if (fid < 0)
|
||||
{
|
||||
fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Read);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* COMBIEN DE MAILLAGES ? *
|
||||
****************************************************************************/
|
||||
int nmaa = 1;
|
||||
|
||||
/****************************************************************************
|
||||
* FERMETURE DU FICHIER *
|
||||
****************************************************************************/
|
||||
fclose(fid);
|
||||
|
||||
printf("Nombre de maillages = %d\n",nmaa);
|
||||
|
||||
string myClass = string("SMESHDS_Mesh");
|
||||
string myExtension = string("DAT");
|
||||
|
||||
for (int meshIt=1;meshIt<=nmaa;meshIt++) {
|
||||
myMeshId = myDocument->NewMesh();
|
||||
|
||||
Handle(SMDS_Mesh) myMesh = myDocument->GetMesh(myMeshId);
|
||||
|
||||
DriverDAT_R_SMESHDS_Mesh* myReader = new DriverDAT_R_SMESHDS_Mesh;
|
||||
|
||||
|
||||
myReader->SetMesh(myMesh);
|
||||
myReader->SetFile(myFile);
|
||||
//myReader->SetFileId(fid);
|
||||
|
||||
myReader->Read();
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
24
src/DriverDAT/DriverDAT_R_SMESHDS_Document.h
Normal file
24
src/DriverDAT/DriverDAT_R_SMESHDS_Document.h
Normal file
@ -0,0 +1,24 @@
|
||||
#ifndef _INCLUDE_DRIVERDAT_R_SMESHDS_DOCUMENT
|
||||
#define _INCLUDE_DRIVERDAT_R_SMESHDS_DOCUMENT
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "SMESHDS_Document.hxx"
|
||||
#include "Document_Reader.h"
|
||||
|
||||
class DriverDAT_R_SMESHDS_Document : public Document_Reader {
|
||||
|
||||
public :
|
||||
DriverDAT_R_SMESHDS_Document();
|
||||
~DriverDAT_R_SMESHDS_Document();
|
||||
|
||||
void Read();
|
||||
//void SetFile(string);
|
||||
//void SetDocument(Handle_SMESHDS_Document&);
|
||||
|
||||
private :
|
||||
//Handle_SMESHDS_Document myDocument;
|
||||
//string myFile;
|
||||
|
||||
};
|
||||
#endif
|
||||
52
src/DriverDAT/DriverDAT_R_SMESHDS_Mesh.cxx
Normal file
52
src/DriverDAT/DriverDAT_R_SMESHDS_Mesh.cxx
Normal file
@ -0,0 +1,52 @@
|
||||
using namespace std;
|
||||
#include "DriverDAT_R_SMESHDS_Mesh.h"
|
||||
#include "DriverDAT_R_SMDS_Mesh.h"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
DriverDAT_R_SMESHDS_Mesh::DriverDAT_R_SMESHDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
DriverDAT_R_SMESHDS_Mesh::~DriverDAT_R_SMESHDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMESHDS_Mesh::SetMesh(Handle(SMDS_Mesh)& aMesh) {
|
||||
//myMesh = Handle(SMESHDS_Mesh)::DownCast(aMesh);
|
||||
myMesh = aMesh;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMESHDS_Mesh::SetFile(string aFile) {
|
||||
myFile = aFile;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMESHDS_Mesh::SetFileId(FILE* aFileId) {
|
||||
myFileId = aFileId;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMESHDS_Mesh::SetMeshId(int aMeshId) {
|
||||
myMeshId = aMeshId;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMESHDS_Mesh::Add() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverDAT_R_SMESHDS_Mesh::Read() {
|
||||
string myClass = string("SMDS_Mesh");
|
||||
string myExtension = string("DAT");
|
||||
|
||||
MESSAGE("in DriverDAT_R_SMESHDS_Mesh::Read() 1");
|
||||
DriverDAT_R_SMDS_Mesh* myReader = new DriverDAT_R_SMDS_Mesh;
|
||||
|
||||
MESSAGE("in DriverDAT_R_SMESHDS_Mesh::Read() 2");
|
||||
myReader->SetMesh(myMesh);
|
||||
MESSAGE("in DriverDAT_R_SMESHDS_Mesh::Read() 3");
|
||||
myReader->SetFile(myFile);
|
||||
//myReader->SetFileId(myFileId);
|
||||
|
||||
MESSAGE("in DriverDAT_R_SMESHDS_Mesh::Read() 4");
|
||||
myReader->Read();
|
||||
|
||||
}
|
||||
30
src/DriverDAT/DriverDAT_R_SMESHDS_Mesh.h
Normal file
30
src/DriverDAT/DriverDAT_R_SMESHDS_Mesh.h
Normal file
@ -0,0 +1,30 @@
|
||||
#ifndef _INCLUDE_DRIVERDAT_R_SMESHDS_MESH
|
||||
#define _INCLUDE_DRIVERDAT_R_SMESHDS_MESH
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "SMESHDS_Mesh.hxx"
|
||||
#include "Mesh_Reader.h"
|
||||
|
||||
class DriverDAT_R_SMESHDS_Mesh : public Mesh_Reader {
|
||||
|
||||
public :
|
||||
DriverDAT_R_SMESHDS_Mesh();
|
||||
~DriverDAT_R_SMESHDS_Mesh();
|
||||
|
||||
void Add();
|
||||
void Read();
|
||||
void SetMesh(Handle(SMDS_Mesh)& aMesh);
|
||||
void SetFile(string);
|
||||
|
||||
void SetFileId(FILE*);
|
||||
void SetMeshId(int);
|
||||
|
||||
private :
|
||||
Handle_SMDS_Mesh myMesh;
|
||||
string myFile;
|
||||
FILE* myFileId;
|
||||
int myMeshId;
|
||||
|
||||
};
|
||||
#endif
|
||||
164
src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
Normal file
164
src/DriverDAT/DriverDAT_W_SMDS_Mesh.cxx
Normal file
@ -0,0 +1,164 @@
|
||||
using namespace std;
|
||||
#include "DriverDAT_W_SMDS_Mesh.h"
|
||||
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#include "SMDS_MeshNode.hxx"
|
||||
#include "SMDS_MeshEdgesIterator.hxx"
|
||||
#include "SMDS_MeshFacesIterator.hxx"
|
||||
#include "SMDS_MeshNodesIterator.hxx"
|
||||
#include "SMDS_MeshVolumesIterator.hxx"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
DriverDAT_W_SMDS_Mesh::DriverDAT_W_SMDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
DriverDAT_W_SMDS_Mesh::~DriverDAT_W_SMDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMDS_Mesh::SetMesh(Handle(SMDS_Mesh)& aMesh) {
|
||||
myMesh = aMesh;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMDS_Mesh::SetFile(string aFile) {
|
||||
myFile = aFile;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMDS_Mesh::SetFileId(FILE* aFileId) {
|
||||
myFileId = aFileId;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMDS_Mesh::SetMeshId(int aMeshId) {
|
||||
myMeshId = aMeshId;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMDS_Mesh::Add() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMDS_Mesh::Write() {
|
||||
|
||||
int nbNodes,nbCells;
|
||||
int i;
|
||||
|
||||
char* file2Read = (char*)myFile.c_str();
|
||||
myFileId = fopen(file2Read,"w+");
|
||||
if (myFileId < 0)
|
||||
{
|
||||
fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Read);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
SCRUTE(myMesh);
|
||||
/****************************************************************************
|
||||
* NOMBRES D'OBJETS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(****************************)\n");
|
||||
fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
|
||||
fprintf(stdout,"(****************************)\n");
|
||||
|
||||
/* Combien de noeuds ? */
|
||||
nbNodes = myMesh->NbNodes();
|
||||
|
||||
/* Combien de mailles, faces ou aretes ? */
|
||||
Standard_Integer nb_of_nodes, nb_of_edges,nb_of_faces, nb_of_volumes;
|
||||
nb_of_edges = myMesh->NbEdges();
|
||||
nb_of_faces = myMesh->NbFaces();
|
||||
nb_of_volumes = myMesh->NbVolumes();
|
||||
nbCells = nb_of_edges + nb_of_faces + nb_of_volumes;
|
||||
SCRUTE(nb_of_edges);
|
||||
SCRUTE(nb_of_faces);
|
||||
SCRUTE(nb_of_volumes);
|
||||
|
||||
fprintf(stdout,"%d %d\n",nbNodes,nbCells);
|
||||
fprintf(myFileId,"%d %d\n",nbNodes,nbCells);
|
||||
|
||||
/****************************************************************************
|
||||
* ECRITURE DES NOEUDS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(************************)\n");
|
||||
fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
|
||||
fprintf(stdout,"(************************)\n");
|
||||
|
||||
SMDS_MeshNodesIterator itNodes(myMesh);
|
||||
for (;itNodes.More();itNodes.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itNodes.Value();
|
||||
const Handle(SMDS_MeshNode)& node = myMesh->GetNode(1,elem);
|
||||
|
||||
fprintf(myFileId,"%d %e %e %e\n",node->GetID(),node->X(),node->Y(),node->Z());
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* ECRITURE DES ELEMENTS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(**************************)\n");
|
||||
fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
|
||||
fprintf(stdout,"(**************************)");
|
||||
/* Ecriture des connectivites, noms, numeros des mailles */
|
||||
|
||||
SMDS_MeshEdgesIterator itEdges(myMesh);
|
||||
for (;itEdges.More();itEdges.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itEdges.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 2 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),102);
|
||||
break;
|
||||
}
|
||||
case 3 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),103);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (i=0;i<elem->NbNodes();i++)
|
||||
fprintf(myFileId,"%d ",elem->GetConnection(i+1));
|
||||
|
||||
fprintf(myFileId,"\n");
|
||||
}
|
||||
|
||||
SMDS_MeshFacesIterator itFaces(myMesh);
|
||||
for (;itFaces.More();itFaces.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itFaces.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 3 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),203);
|
||||
break;
|
||||
}
|
||||
case 4 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),204);
|
||||
break;
|
||||
}
|
||||
case 6 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),206);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (i=0;i<elem->NbNodes();i++)
|
||||
fprintf(myFileId,"%d ",elem->GetConnection(i+1));
|
||||
|
||||
fprintf(myFileId,"\n");
|
||||
}
|
||||
|
||||
SMDS_MeshVolumesIterator itVolumes(myMesh);
|
||||
for (;itVolumes.More();itVolumes.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itVolumes.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 8 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),308);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (i=0;i<elem->NbNodes();i++)
|
||||
fprintf(myFileId,"%d ",elem->GetConnection(i+1));
|
||||
|
||||
fprintf(myFileId,"\n");
|
||||
}
|
||||
|
||||
fclose (myFileId);
|
||||
}
|
||||
31
src/DriverDAT/DriverDAT_W_SMDS_Mesh.h
Normal file
31
src/DriverDAT/DriverDAT_W_SMDS_Mesh.h
Normal file
@ -0,0 +1,31 @@
|
||||
#ifndef _INCLUDE_DRIVERDAT_W_SMDS_MESH
|
||||
#define _INCLUDE_DRIVERDAT_W_SMDS_MESH
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string>
|
||||
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#include "Mesh_Writer.h"
|
||||
|
||||
class DriverDAT_W_SMDS_Mesh : public Mesh_Writer {
|
||||
|
||||
public :
|
||||
DriverDAT_W_SMDS_Mesh();
|
||||
~DriverDAT_W_SMDS_Mesh();
|
||||
|
||||
void Add();
|
||||
void Write();
|
||||
void SetMesh(Handle(SMDS_Mesh)& aMesh);
|
||||
void SetFile(string);
|
||||
|
||||
void SetFileId(FILE*);
|
||||
void SetMeshId(int);
|
||||
|
||||
private :
|
||||
Handle_SMDS_Mesh myMesh;
|
||||
string myFile;
|
||||
FILE* myFileId;
|
||||
int myMeshId;
|
||||
|
||||
};
|
||||
#endif
|
||||
78
src/DriverDAT/DriverDAT_W_SMESHDS_Document.cxx
Normal file
78
src/DriverDAT/DriverDAT_W_SMESHDS_Document.cxx
Normal file
@ -0,0 +1,78 @@
|
||||
using namespace std;
|
||||
#include "DriverDAT_W_SMESHDS_Document.h"
|
||||
#include "DriverDAT_W_SMESHDS_Mesh.h"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
extern "C"
|
||||
{
|
||||
Document_Writer* Wmaker() {
|
||||
return new DriverDAT_W_SMESHDS_Document;
|
||||
}
|
||||
}
|
||||
|
||||
DriverDAT_W_SMESHDS_Document::DriverDAT_W_SMESHDS_Document() {
|
||||
;
|
||||
}
|
||||
|
||||
DriverDAT_W_SMESHDS_Document::~DriverDAT_W_SMESHDS_Document() {
|
||||
;
|
||||
}
|
||||
|
||||
//void DriverDAT_W_SMESHDS_Document::SetFile(string aFile) {
|
||||
//myFile = aFile;
|
||||
//}
|
||||
|
||||
//void DriverDAT_W_SMESHDS_Document::SetDocument(Handle(SMESHDS_Document)& aDocument) {
|
||||
//myDocument = aDocument;
|
||||
//}
|
||||
|
||||
void DriverDAT_W_SMESHDS_Document::Write() {
|
||||
|
||||
Handle(SMESHDS_Mesh) myMesh;
|
||||
|
||||
/****************************************************************************
|
||||
* OUVERTURE DU FICHIER EN ECRITURE *
|
||||
****************************************************************************/
|
||||
char* file2Write = (char*)myFile.c_str();
|
||||
FILE* fid = fopen(file2Write,"w+");
|
||||
if (fid < 0)
|
||||
{
|
||||
fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Write);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* FERMETURE DU FICHIER *
|
||||
****************************************************************************/
|
||||
|
||||
fclose(fid);
|
||||
|
||||
/******** Nombre de maillages ********/
|
||||
int nb_of_meshes = myDocument->NbMeshes(); //voir avec Yves
|
||||
//nb_of_meshes = 1;
|
||||
int numero = 0;
|
||||
|
||||
string myClass = string("SMESHDS_Mesh");
|
||||
string myExtension = string("DAT");
|
||||
|
||||
//while (numero<nb_of_meshes) {
|
||||
//numero++;
|
||||
//myMesh = myDocument->GetMesh(numero);
|
||||
myDocument->InitMeshesIterator();
|
||||
for (;myDocument->MoreMesh();myDocument->NextMesh()) {
|
||||
numero++;
|
||||
myMesh = myDocument->CurrentMesh();
|
||||
|
||||
DriverDAT_W_SMESHDS_Mesh* myWriter = new DriverDAT_W_SMESHDS_Mesh;
|
||||
//Mesh_Writer* myWriter = Driver::GetMeshWriter(myExtension, myClass);
|
||||
|
||||
myWriter->SetMesh(myMesh);
|
||||
myWriter->SetFile(myFile);
|
||||
SCRUTE(myMesh);
|
||||
//myWriter->SetFileId(fid);
|
||||
myWriter->SetMeshId(numero);
|
||||
myWriter->Write();
|
||||
}
|
||||
|
||||
}
|
||||
25
src/DriverDAT/DriverDAT_W_SMESHDS_Document.h
Normal file
25
src/DriverDAT/DriverDAT_W_SMESHDS_Document.h
Normal file
@ -0,0 +1,25 @@
|
||||
#ifndef _INCLUDE_DRIVERDAT_W_SMESHDS_DOCUMENT
|
||||
#define _INCLUDE_DRIVERDAT_W_SMESHDS_DOCUMENT
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string>
|
||||
|
||||
#include "SMESHDS_Document.hxx"
|
||||
#include "Document_Writer.h"
|
||||
|
||||
class DriverDAT_W_SMESHDS_Document : public Document_Writer {
|
||||
|
||||
public :
|
||||
DriverDAT_W_SMESHDS_Document();
|
||||
~DriverDAT_W_SMESHDS_Document();
|
||||
|
||||
void Write();
|
||||
//void SetFile(string);
|
||||
//void SetDocument(Handle(SMESHDS_Document)&);
|
||||
|
||||
private :
|
||||
//Handle_SMESHDS_Document myDocument;
|
||||
//string myFile;
|
||||
|
||||
};
|
||||
#endif
|
||||
175
src/DriverDAT/DriverDAT_W_SMESHDS_Mesh.cxx
Normal file
175
src/DriverDAT/DriverDAT_W_SMESHDS_Mesh.cxx
Normal file
@ -0,0 +1,175 @@
|
||||
using namespace std;
|
||||
#include "DriverDAT_W_SMESHDS_Mesh.h"
|
||||
#include "DriverDAT_W_SMDS_Mesh.h"
|
||||
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#include "SMDS_MeshNode.hxx"
|
||||
#include "SMDS_MeshEdgesIterator.hxx"
|
||||
#include "SMDS_MeshFacesIterator.hxx"
|
||||
#include "SMDS_MeshNodesIterator.hxx"
|
||||
#include "SMDS_MeshVolumesIterator.hxx"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
DriverDAT_W_SMESHDS_Mesh::DriverDAT_W_SMESHDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
DriverDAT_W_SMESHDS_Mesh::~DriverDAT_W_SMESHDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMESHDS_Mesh::SetMesh(Handle(SMDS_Mesh)& aMesh) {
|
||||
//myMesh = Handle(SMESHDS_Mesh)::DownCast(aMesh);
|
||||
myMesh = aMesh;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMESHDS_Mesh::SetFile(string aFile) {
|
||||
myFile = aFile;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMESHDS_Mesh::SetFileId(FILE* aFileId) {
|
||||
myFileId = aFileId;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMESHDS_Mesh::SetMeshId(int aMeshId) {
|
||||
myMeshId = aMeshId;
|
||||
}
|
||||
|
||||
void DriverDAT_W_SMESHDS_Mesh::Write() {
|
||||
|
||||
string myClass = string("SMDS_Mesh");
|
||||
string myExtension = string("DAT");
|
||||
|
||||
DriverDAT_W_SMDS_Mesh* myWriter = new DriverDAT_W_SMDS_Mesh;
|
||||
|
||||
myWriter->SetMesh(myMesh);
|
||||
myWriter->SetFile(myFile);
|
||||
myWriter->SetMeshId(myMeshId);
|
||||
//myWriter->SetFileId(myFileId);
|
||||
|
||||
myWriter->Write();
|
||||
|
||||
|
||||
}
|
||||
void DriverDAT_W_SMESHDS_Mesh::Add() {
|
||||
int nbNodes,nbCells;
|
||||
int i;
|
||||
|
||||
char* file2Read = (char*)myFile.c_str();
|
||||
myFileId = fopen(file2Read,"w+");
|
||||
if (myFileId < 0)
|
||||
{
|
||||
fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Read);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* NOMBRES D'OBJETS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(****************************)\n");
|
||||
fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
|
||||
fprintf(stdout,"(****************************)\n");
|
||||
|
||||
/* Combien de noeuds ? */
|
||||
nbNodes = myMesh->NbNodes();
|
||||
|
||||
/* Combien de mailles, faces ou aretes ? */
|
||||
Standard_Integer nb_of_nodes, nb_of_edges,nb_of_faces, nb_of_volumes;
|
||||
nb_of_edges = myMesh->NbEdges();
|
||||
nb_of_faces = myMesh->NbFaces();
|
||||
nb_of_volumes = myMesh->NbVolumes();
|
||||
nbCells = nb_of_edges + nb_of_faces + nb_of_volumes;
|
||||
|
||||
fprintf(stdout,"%d %d\n",nbNodes,nbCells);
|
||||
fprintf(myFileId,"%d %d\n",nbNodes,nbCells);
|
||||
|
||||
/****************************************************************************
|
||||
* ECRITURE DES NOEUDS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(************************)\n");
|
||||
fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
|
||||
fprintf(stdout,"(************************)\n");
|
||||
|
||||
SMDS_MeshNodesIterator itNodes(myMesh);
|
||||
for (;itNodes.More();itNodes.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itNodes.Value();
|
||||
const Handle(SMDS_MeshNode)& node = myMesh->GetNode(1,elem);
|
||||
|
||||
fprintf(myFileId,"%d %e %e %e\n",node->GetID(),node->X(),node->Y(),node->Z());
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* ECRITURE DES ELEMENTS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(**************************)\n");
|
||||
fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
|
||||
fprintf(stdout,"(**************************)");
|
||||
/* Ecriture des connectivites, noms, numeros des mailles */
|
||||
|
||||
SMDS_MeshEdgesIterator itEdges(myMesh);
|
||||
for (;itEdges.More();itEdges.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itEdges.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 2 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),102);
|
||||
break;
|
||||
}
|
||||
case 3 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),103);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (i=0;i<elem->NbNodes();i++)
|
||||
fprintf(myFileId,"%d ",elem->GetConnection(i+1));
|
||||
|
||||
fprintf(myFileId,"\n");
|
||||
}
|
||||
|
||||
SMDS_MeshFacesIterator itFaces(myMesh);
|
||||
for (;itFaces.More();itFaces.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itFaces.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 3 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),203);
|
||||
break;
|
||||
}
|
||||
case 4 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),204);
|
||||
break;
|
||||
}
|
||||
case 6 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),206);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (i=0;i<elem->NbNodes();i++)
|
||||
fprintf(myFileId,"%d ",elem->GetConnection(i+1));
|
||||
|
||||
fprintf(myFileId,"\n");
|
||||
}
|
||||
|
||||
SMDS_MeshVolumesIterator itVolumes(myMesh);
|
||||
for (;itVolumes.More();itVolumes.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itVolumes.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 8 : {
|
||||
fprintf(myFileId,"%d %d ",elem->GetID(),308);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
for (i=0;i<elem->NbNodes();i++)
|
||||
fprintf(myFileId,"%d ",elem->GetConnection(i+1));
|
||||
|
||||
fprintf(myFileId,"\n");
|
||||
}
|
||||
|
||||
fclose (myFileId);
|
||||
}
|
||||
|
||||
31
src/DriverDAT/DriverDAT_W_SMESHDS_Mesh.h
Normal file
31
src/DriverDAT/DriverDAT_W_SMESHDS_Mesh.h
Normal file
@ -0,0 +1,31 @@
|
||||
#ifndef _INCLUDE_DRIVERDAT_W_SMESHDS_MESH
|
||||
#define _INCLUDE_DRIVERDAT_W_SMESHDS_MESH
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string>
|
||||
|
||||
#include "SMESHDS_Mesh.hxx"
|
||||
#include "Mesh_Writer.h"
|
||||
|
||||
class DriverDAT_W_SMESHDS_Mesh : public Mesh_Writer {
|
||||
|
||||
public :
|
||||
DriverDAT_W_SMESHDS_Mesh();
|
||||
~DriverDAT_W_SMESHDS_Mesh();
|
||||
|
||||
void Add();
|
||||
void Write();
|
||||
void SetMesh(Handle(SMDS_Mesh)& aMesh);
|
||||
void SetFile(string);
|
||||
|
||||
void SetFileId(FILE*);
|
||||
void SetMeshId(int);
|
||||
|
||||
private :
|
||||
Handle_SMDS_Mesh myMesh;
|
||||
string myFile;
|
||||
FILE* myFileId;
|
||||
int myMeshId;
|
||||
|
||||
};
|
||||
#endif
|
||||
39
src/DriverDAT/Makefile.in
Normal file
39
src/DriverDAT/Makefile.in
Normal file
@ -0,0 +1,39 @@
|
||||
# -* Makefile *-
|
||||
#
|
||||
# Author : Marc Tajchman (CEA)
|
||||
# Date : 5/07/2001
|
||||
# $Header$
|
||||
#
|
||||
|
||||
# source path
|
||||
top_srcdir=@top_srcdir@
|
||||
top_builddir=../..
|
||||
srcdir=@srcdir@
|
||||
VPATH=.:@srcdir@
|
||||
|
||||
|
||||
@COMMENCE@
|
||||
|
||||
# header files
|
||||
EXPORT_HEADERS= DriverDAT_R_SMDS_Mesh.h DriverDAT_R_SMESHDS_Mesh.h DriverDAT_R_SMESHDS_Document.h DriverDAT_W_SMDS_Mesh.h DriverDAT_W_SMESHDS_Mesh.h DriverDAT_W_SMESHDS_Document.h
|
||||
|
||||
# Libraries targets
|
||||
LIB = libMeshDriverDAT.la
|
||||
LIB_SRC = DriverDAT_R_SMDS_Mesh.cxx DriverDAT_R_SMESHDS_Mesh.cxx DriverDAT_R_SMESHDS_Document.cxx DriverDAT_W_SMDS_Mesh.cxx DriverDAT_W_SMESHDS_Mesh.cxx DriverDAT_W_SMESHDS_Document.cxx
|
||||
|
||||
LIB_CLIENT_IDL =
|
||||
|
||||
LIB_SERVER_IDL =
|
||||
|
||||
# additionnal information to compil and link file
|
||||
CPPFLAGS += $(OCC_INCLUDES)
|
||||
CXXFLAGS += $(OCC_CXXFLAGS) $(MED2_INCLUDES)
|
||||
LDFLAGS += $(OCC_LIBS) $(MED2_LIBS) -lMeshDriver
|
||||
|
||||
%_moc.cxx: %.h
|
||||
$(MOC) $< -o $@
|
||||
|
||||
@CONCLUDE@
|
||||
|
||||
|
||||
|
||||
153
src/DriverUNV/DriverUNV_R_SMDS_Mesh.cxx
Normal file
153
src/DriverUNV/DriverUNV_R_SMDS_Mesh.cxx
Normal file
@ -0,0 +1,153 @@
|
||||
using namespace std;
|
||||
#include "DriverUNV_R_SMDS_Mesh.h"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
DriverUNV_R_SMDS_Mesh::DriverUNV_R_SMDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
DriverUNV_R_SMDS_Mesh::~DriverUNV_R_SMDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMDS_Mesh::SetMesh(Handle(SMDS_Mesh)& aMesh) {
|
||||
myMesh = aMesh;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMDS_Mesh::SetFile(string aFile) {
|
||||
myFile = aFile;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMDS_Mesh::SetFileId(FILE* aFileId) {
|
||||
myFileId = aFileId;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMDS_Mesh::SetMeshId(int aMeshId) {
|
||||
myMeshId = aMeshId;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMDS_Mesh::Add() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMDS_Mesh::Read() {
|
||||
|
||||
int cell=0,node=0,n1,n2,n3,n4,n_nodes,nodes[6],blockId,i;
|
||||
char *s1,*s2,*s3;
|
||||
string str1,str2,str3;
|
||||
int i1=0;
|
||||
bool ok, found_block2411, found_block2412;
|
||||
|
||||
/****************************************************************************
|
||||
* OUVERTURE DU FICHIER EN LECTURE *
|
||||
****************************************************************************/
|
||||
char* file2Read = (char*)myFile.c_str();
|
||||
myFileId = fopen(file2Read,"r");
|
||||
if (myFileId < 0)
|
||||
{
|
||||
fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Read);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
s1 = (char*) malloc(sizeof(char)*100);
|
||||
s2 = (char*) malloc(sizeof(char)*100);
|
||||
s3 = (char*) malloc(sizeof(char)*100);
|
||||
|
||||
found_block2411 = false;
|
||||
found_block2412 = false;
|
||||
|
||||
do {
|
||||
|
||||
while (i1==-1) {
|
||||
fscanf(myFileId,"%d\n",&blockId);
|
||||
switch (blockId) {
|
||||
case 2411 : {
|
||||
MESSAGE("BlockId "<<blockId);
|
||||
fscanf(myFileId,"%d",&node);
|
||||
//MESSAGE("Node "<<node);
|
||||
while (node!=-1) {
|
||||
fscanf(myFileId,"%d %d %d\n",&n1,&n2,&n3);
|
||||
fscanf(myFileId,"%s %s %s\n",s1,s2,s3);
|
||||
str1=string(s1);
|
||||
str2=string(s2);
|
||||
str3=string(s3);
|
||||
if (str1.find("D")!=string::npos) str1.replace(str1.find("D"),1,"E");
|
||||
if (str2.find("D")!=string::npos) str2.replace(str2.find("D"),1,"E");
|
||||
if (str3.find("D")!=string::npos) str3.replace(str3.find("D"),1,"E");
|
||||
ok = myMesh->AddNodeWithID(atof(str1.c_str()),atof(str2.c_str()),atof(str3.c_str()),node);
|
||||
fscanf(myFileId,"%d",&node);
|
||||
}
|
||||
i1=0;
|
||||
found_block2411 = true;
|
||||
break;
|
||||
}
|
||||
case 2412 : {
|
||||
MESSAGE("BlockId "<<blockId);
|
||||
fscanf(myFileId,"%d",&cell);
|
||||
//MESSAGE("Cell "<<cell);
|
||||
while (cell!=-1) {
|
||||
fscanf(myFileId,"%d %d %d %d %d\n",&n1,&n2,&n3,&n4,&n_nodes);
|
||||
|
||||
if ((n1==71)||(n1==72)||(n1==74)||(n1==91)||(n1==92)) {//203
|
||||
if (n_nodes==3) {
|
||||
for (i=1;i<=n_nodes;i++)
|
||||
fscanf(myFileId,"%d",&nodes[i-1]);
|
||||
ok = myMesh->AddFaceWithID(nodes[0],nodes[1],nodes[2],cell);
|
||||
}
|
||||
else if (n_nodes==6) {//206
|
||||
for (i=1;i<=n_nodes;i++)
|
||||
fscanf(myFileId,"%d",&nodes[i-1]);
|
||||
ok = myMesh->AddFaceWithID(nodes[0],nodes[2],nodes[4],cell);
|
||||
}
|
||||
}
|
||||
|
||||
else if ((n1==11)||(n1==21)||(n1==24)||(n1==25)) {//103
|
||||
fgets(s2,100,myFileId);
|
||||
if (n_nodes==3) {
|
||||
for (i=1;i<=n_nodes;i++)
|
||||
fscanf(myFileId,"%d",&nodes[i-1]);
|
||||
ok = myMesh->AddEdgeWithID(nodes[0],nodes[1],cell);
|
||||
//MESSAGE("in 103 "<<cell);
|
||||
}
|
||||
else if (n_nodes==2) {//102
|
||||
for (i=1;i<=n_nodes;i++)
|
||||
fscanf(myFileId,"%d",&nodes[i-1]);
|
||||
ok = myMesh->AddEdgeWithID(nodes[0],nodes[1],cell);
|
||||
//MESSAGE("in 102 "<<cell);
|
||||
}
|
||||
}
|
||||
|
||||
fscanf(myFileId,"\n");
|
||||
fscanf(myFileId,"%d",&cell);
|
||||
}
|
||||
|
||||
i1=0;
|
||||
found_block2412 = true;
|
||||
break;
|
||||
}
|
||||
case -1 : {
|
||||
break;
|
||||
}
|
||||
default:
|
||||
MESSAGE("BlockId "<<blockId);
|
||||
i1=0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
fscanf(myFileId,"%s\n",s1);
|
||||
i1 = atoi(s1);
|
||||
|
||||
}
|
||||
while ((!feof(myFileId))&&((!found_block2411)||(!found_block2412)));
|
||||
|
||||
/****************************************************************************
|
||||
* FERMETURE DU FICHIER *
|
||||
****************************************************************************/
|
||||
free(s1);
|
||||
free(s2);
|
||||
free(s3);
|
||||
fclose(myFileId);
|
||||
|
||||
}
|
||||
30
src/DriverUNV/DriverUNV_R_SMDS_Mesh.h
Normal file
30
src/DriverUNV/DriverUNV_R_SMDS_Mesh.h
Normal file
@ -0,0 +1,30 @@
|
||||
#ifndef _INCLUDE_DRIVERUNV_R_SMDS_MESH
|
||||
#define _INCLUDE_DRIVERUNV_R_SMDS_MESH
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#include "Mesh_Reader.h"
|
||||
|
||||
class DriverUNV_R_SMDS_Mesh : public Mesh_Reader {
|
||||
|
||||
public :
|
||||
DriverUNV_R_SMDS_Mesh();
|
||||
~DriverUNV_R_SMDS_Mesh();
|
||||
|
||||
void Add();
|
||||
void Read();
|
||||
void SetMesh(Handle(SMDS_Mesh)& aMesh);
|
||||
void SetFile(string);
|
||||
|
||||
void SetFileId(FILE*);
|
||||
void SetMeshId(int);
|
||||
|
||||
private :
|
||||
Handle_SMDS_Mesh myMesh;
|
||||
string myFile;
|
||||
FILE* myFileId;
|
||||
int myMeshId;
|
||||
|
||||
};
|
||||
#endif
|
||||
85
src/DriverUNV/DriverUNV_R_SMESHDS_Document.cxx
Normal file
85
src/DriverUNV/DriverUNV_R_SMESHDS_Document.cxx
Normal file
@ -0,0 +1,85 @@
|
||||
using namespace std;
|
||||
#include "DriverUNV_R_SMESHDS_Document.h"
|
||||
#include "DriverUNV_R_SMESHDS_Mesh.h"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
int getOne() {
|
||||
printf("in getOne");
|
||||
return (1);
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
// Document_Reader* maker() {
|
||||
DriverUNV_R_SMESHDS_Document* maker() {
|
||||
fprintf(stdout,"here in maker\n");
|
||||
return new DriverUNV_R_SMESHDS_Document;
|
||||
}
|
||||
}
|
||||
|
||||
DriverUNV_R_SMESHDS_Document::DriverUNV_R_SMESHDS_Document() {
|
||||
myFile = string("");
|
||||
}
|
||||
|
||||
DriverUNV_R_SMESHDS_Document::~DriverUNV_R_SMESHDS_Document() {
|
||||
;
|
||||
}
|
||||
|
||||
//void DriverUNV_R_SMESHDS_Document::SetFile(string aFile) {
|
||||
//myFile = aFile;
|
||||
//}
|
||||
|
||||
//void DriverUNV_R_SMESHDS_Document::SetDocument(Handle(SMESHDS_Document)& aDoc) {
|
||||
//myDocument = aDoc;
|
||||
//}
|
||||
|
||||
void DriverUNV_R_SMESHDS_Document::Read() {
|
||||
|
||||
int myMeshId;
|
||||
SCRUTE(myFile);
|
||||
//Handle(SMESHDS_Document) myDocument = new SMESHDS_Document(1);
|
||||
|
||||
/****************************************************************************
|
||||
* OUVERTURE DU FICHIER EN LECTURE *
|
||||
****************************************************************************/
|
||||
char* file2Read = (char*)myFile.c_str();
|
||||
FILE* fid = fopen(file2Read,"r");
|
||||
if (fid < 0)
|
||||
{
|
||||
fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Read);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* COMBIEN DE MAILLAGES ? *
|
||||
****************************************************************************/
|
||||
int nmaa = 1;
|
||||
|
||||
/****************************************************************************
|
||||
* FERMETURE DU FICHIER *
|
||||
****************************************************************************/
|
||||
fclose(fid);
|
||||
|
||||
printf("Nombre de maillages = %d\n",nmaa);
|
||||
|
||||
string myClass = string("SMESHDS_Mesh");
|
||||
string myExtension = string("UNV");
|
||||
|
||||
for (int meshIt=1;meshIt<=nmaa;meshIt++) {
|
||||
myMeshId = myDocument->NewMesh();
|
||||
|
||||
Handle(SMDS_Mesh) myMesh = myDocument->GetMesh(myMeshId);
|
||||
|
||||
DriverUNV_R_SMESHDS_Mesh* myReader = new DriverUNV_R_SMESHDS_Mesh;
|
||||
|
||||
|
||||
myReader->SetMesh(myMesh);
|
||||
myReader->SetFile(myFile);
|
||||
//myReader->SetFileId(fid);
|
||||
|
||||
myReader->Read();
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
24
src/DriverUNV/DriverUNV_R_SMESHDS_Document.h
Normal file
24
src/DriverUNV/DriverUNV_R_SMESHDS_Document.h
Normal file
@ -0,0 +1,24 @@
|
||||
#ifndef _INCLUDE_DRIVERUNV_R_SMESHDS_DOCUMENT
|
||||
#define _INCLUDE_DRIVERUNV_R_SMESHDS_DOCUMENT
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "SMESHDS_Document.hxx"
|
||||
#include "Document_Reader.h"
|
||||
|
||||
class DriverUNV_R_SMESHDS_Document : public Document_Reader {
|
||||
|
||||
public :
|
||||
DriverUNV_R_SMESHDS_Document();
|
||||
~DriverUNV_R_SMESHDS_Document();
|
||||
|
||||
void Read();
|
||||
//void SetFile(string);
|
||||
//void SetDocument(Handle_SMESHDS_Document&);
|
||||
|
||||
private :
|
||||
//Handle_SMESHDS_Document myDocument;
|
||||
//string myFile;
|
||||
|
||||
};
|
||||
#endif
|
||||
48
src/DriverUNV/DriverUNV_R_SMESHDS_Mesh.cxx
Normal file
48
src/DriverUNV/DriverUNV_R_SMESHDS_Mesh.cxx
Normal file
@ -0,0 +1,48 @@
|
||||
using namespace std;
|
||||
#include "DriverUNV_R_SMESHDS_Mesh.h"
|
||||
#include "DriverUNV_R_SMDS_Mesh.h"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
DriverUNV_R_SMESHDS_Mesh::DriverUNV_R_SMESHDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
DriverUNV_R_SMESHDS_Mesh::~DriverUNV_R_SMESHDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMESHDS_Mesh::SetMesh(Handle(SMDS_Mesh)& aMesh) {
|
||||
//myMesh = Handle(SMESHDS_Mesh)::DownCast(aMesh);
|
||||
myMesh = aMesh;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMESHDS_Mesh::SetFile(string aFile) {
|
||||
myFile = aFile;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMESHDS_Mesh::SetFileId(FILE* aFileId) {
|
||||
myFileId = aFileId;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMESHDS_Mesh::SetMeshId(int aMeshId) {
|
||||
myMeshId = aMeshId;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMESHDS_Mesh::Add() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverUNV_R_SMESHDS_Mesh::Read() {
|
||||
string myClass = string("SMDS_Mesh");
|
||||
string myExtension = string("UNV");
|
||||
|
||||
DriverUNV_R_SMDS_Mesh* myReader = new DriverUNV_R_SMDS_Mesh;
|
||||
|
||||
myReader->SetMesh(myMesh);
|
||||
myReader->SetFile(myFile);
|
||||
//myReader->SetFileId(myFileId);
|
||||
|
||||
myReader->Read();
|
||||
|
||||
}
|
||||
30
src/DriverUNV/DriverUNV_R_SMESHDS_Mesh.h
Normal file
30
src/DriverUNV/DriverUNV_R_SMESHDS_Mesh.h
Normal file
@ -0,0 +1,30 @@
|
||||
#ifndef _INCLUDE_DRIVERUNV_R_SMESHDS_MESH
|
||||
#define _INCLUDE_DRIVERUNV_R_SMESHDS_MESH
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "SMESHDS_Mesh.hxx"
|
||||
#include "Mesh_Reader.h"
|
||||
|
||||
class DriverUNV_R_SMESHDS_Mesh : public Mesh_Reader {
|
||||
|
||||
public :
|
||||
DriverUNV_R_SMESHDS_Mesh();
|
||||
~DriverUNV_R_SMESHDS_Mesh();
|
||||
|
||||
void Add();
|
||||
void Read();
|
||||
void SetMesh(Handle(SMDS_Mesh)& aMesh);
|
||||
void SetFile(string);
|
||||
|
||||
void SetFileId(FILE*);
|
||||
void SetMeshId(int);
|
||||
|
||||
private :
|
||||
Handle_SMDS_Mesh myMesh;
|
||||
string myFile;
|
||||
FILE* myFileId;
|
||||
int myMeshId;
|
||||
|
||||
};
|
||||
#endif
|
||||
196
src/DriverUNV/DriverUNV_W_SMDS_Mesh.cxx
Normal file
196
src/DriverUNV/DriverUNV_W_SMDS_Mesh.cxx
Normal file
@ -0,0 +1,196 @@
|
||||
using namespace std;
|
||||
#include "DriverUNV_W_SMDS_Mesh.h"
|
||||
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#include "SMDS_MeshNode.hxx"
|
||||
#include "SMDS_MeshEdgesIterator.hxx"
|
||||
#include "SMDS_MeshFacesIterator.hxx"
|
||||
#include "SMDS_MeshNodesIterator.hxx"
|
||||
#include "SMDS_MeshVolumesIterator.hxx"
|
||||
|
||||
#include <utilities.h>
|
||||
|
||||
#define sNODE_UNV_ID " 2411"
|
||||
#define sELT_UNV_ID " 2412"
|
||||
#define sUNV_SEPARATOR " -1"
|
||||
#define sNODE_UNV_DESCR "%10d 1 1 11\n"
|
||||
#define sELT_SURF_DESC "%10d %2d 1 1 11 %1d\n"
|
||||
#define sELT_VOLU_DESC "%10d %2d 1 1 9 %1d\n"
|
||||
#define sELT_BEAM_DESC1 "%10d %2d 1 1 7 %1d\n"
|
||||
#define sELT_BEAM_DESC2 " 0 1 1\n"
|
||||
|
||||
DriverUNV_W_SMDS_Mesh::DriverUNV_W_SMDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
DriverUNV_W_SMDS_Mesh::~DriverUNV_W_SMDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMDS_Mesh::SetMesh(Handle(SMDS_Mesh)& aMesh) {
|
||||
myMesh = aMesh;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMDS_Mesh::SetFile(string aFile) {
|
||||
myFile = aFile;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMDS_Mesh::SetFileId(FILE* aFileId) {
|
||||
myFileId = aFileId;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMDS_Mesh::SetMeshId(int aMeshId) {
|
||||
myMeshId = aMeshId;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMDS_Mesh::Add() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMDS_Mesh::Write() {
|
||||
|
||||
int nbNodes,nbCells;
|
||||
int i;
|
||||
|
||||
char* file2Read = (char*)myFile.c_str();
|
||||
myFileId = fopen(file2Read,"w+");
|
||||
if (myFileId < 0)
|
||||
{
|
||||
fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Read);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
SCRUTE(myMesh);
|
||||
/****************************************************************************
|
||||
* NOMBRES D'OBJETS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(****************************)\n");
|
||||
fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
|
||||
fprintf(stdout,"(****************************)\n");
|
||||
|
||||
/* Combien de noeuds ? */
|
||||
nbNodes = myMesh->NbNodes();
|
||||
|
||||
/* Combien de mailles, faces ou aretes ? */
|
||||
Standard_Integer nb_of_nodes, nb_of_edges,nb_of_faces, nb_of_volumes;
|
||||
nb_of_edges = myMesh->NbEdges();
|
||||
nb_of_faces = myMesh->NbFaces();
|
||||
nb_of_volumes = myMesh->NbVolumes();
|
||||
nbCells = nb_of_edges + nb_of_faces + nb_of_volumes;
|
||||
SCRUTE(nb_of_edges);
|
||||
SCRUTE(nb_of_faces);
|
||||
SCRUTE(nb_of_volumes);
|
||||
|
||||
fprintf(stdout,"%d %d\n",nbNodes,nbCells);
|
||||
fprintf(myFileId,"%d %d\n",nbNodes,nbCells);
|
||||
|
||||
/****************************************************************************
|
||||
* ECRITURE DES NOEUDS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(************************)\n");
|
||||
fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
|
||||
fprintf(stdout,"(************************)\n");
|
||||
|
||||
SMDS_MeshNodesIterator itNodes(myMesh);
|
||||
|
||||
fprintf(myFileId,"%s\n", sUNV_SEPARATOR);
|
||||
fprintf(myFileId,"%s\n", sNODE_UNV_ID );
|
||||
|
||||
for (;itNodes.More();itNodes.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itNodes.Value();
|
||||
const Handle(SMDS_MeshNode )& node = myMesh->GetNode(1, elem);
|
||||
|
||||
fprintf(myFileId, sNODE_UNV_DESCR, node->GetID());
|
||||
fprintf(myFileId, "%25.16E%25.16E%25.16E\n", node->X(), node->Y(), node->Z());
|
||||
}
|
||||
fprintf(myFileId,"%s\n", sUNV_SEPARATOR);
|
||||
|
||||
/****************************************************************************
|
||||
* ECRITURE DES ELEMENTS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(**************************)\n");
|
||||
fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
|
||||
fprintf(stdout,"(**************************)");
|
||||
/* Ecriture des connectivites, noms, numeros des mailles */
|
||||
|
||||
fprintf(myFileId,"%s\n", sUNV_SEPARATOR);
|
||||
fprintf(myFileId,"%s\n", sELT_UNV_ID );
|
||||
|
||||
SMDS_MeshEdgesIterator itEdges(myMesh);
|
||||
for (;itEdges.More();itEdges.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itEdges.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 2 : {
|
||||
fprintf(myFileId, sELT_BEAM_DESC1, elem->GetID(), 21, elem->NbNodes());
|
||||
fprintf(myFileId, sELT_BEAM_DESC2);
|
||||
fprintf(myFileId, "%10d%10d\n", elem->GetConnection(1), elem->GetConnection(2));
|
||||
break;
|
||||
}
|
||||
case 3 : {
|
||||
fprintf(myFileId, sELT_BEAM_DESC1, elem->GetID(), 24, elem->NbNodes());
|
||||
fprintf(myFileId, sELT_BEAM_DESC2);
|
||||
fprintf(myFileId, "%10d%10d%10d\n",elem->GetConnection(1), elem->GetConnection(2), elem->GetConnection(3));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SMDS_MeshFacesIterator itFaces(myMesh);
|
||||
for (;itFaces.More();itFaces.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itFaces.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 3 :
|
||||
// linear triangle
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 74, elem->NbNodes());
|
||||
break;
|
||||
case 4 :
|
||||
// linear quadrilateral
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 71, elem->NbNodes());
|
||||
break;
|
||||
case 6 :
|
||||
// parabolic triangle
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 72, elem->NbNodes());
|
||||
break;
|
||||
case 8 :
|
||||
// parabolic quadrilateral
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 75, elem->NbNodes());
|
||||
break;
|
||||
default:
|
||||
fprintf(myFileId, "element not registered\n");
|
||||
}
|
||||
|
||||
for (i=0;i<elem->NbNodes();i++)
|
||||
fprintf(myFileId,"%10d",elem->GetConnection(i+1));
|
||||
|
||||
fprintf(myFileId,"\n");
|
||||
}
|
||||
|
||||
SMDS_MeshVolumesIterator itVolumes(myMesh);
|
||||
for (;itVolumes.More();itVolumes.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itVolumes.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 4 :
|
||||
// linear tetrahedron
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 111, elem->NbNodes());
|
||||
break;
|
||||
case 6 :
|
||||
// linear tetrahedron
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 112, elem->NbNodes());
|
||||
break;
|
||||
case 8 :
|
||||
// linear brick
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 115, elem->NbNodes());
|
||||
break;
|
||||
}
|
||||
|
||||
for (i=0;i<elem->NbNodes();i++)
|
||||
fprintf(myFileId,"%10d",elem->GetConnection(i+1));
|
||||
|
||||
fprintf(myFileId,"\n");
|
||||
}
|
||||
fprintf(myFileId,"%s\n", sUNV_SEPARATOR);
|
||||
|
||||
fclose (myFileId);
|
||||
}
|
||||
31
src/DriverUNV/DriverUNV_W_SMDS_Mesh.h
Normal file
31
src/DriverUNV/DriverUNV_W_SMDS_Mesh.h
Normal file
@ -0,0 +1,31 @@
|
||||
#ifndef _INCLUDE_DRIVERUNV_W_SMDS_MESH
|
||||
#define _INCLUDE_DRIVERUNV_W_SMDS_MESH
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string>
|
||||
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#include "Mesh_Writer.h"
|
||||
|
||||
class DriverUNV_W_SMDS_Mesh : public Mesh_Writer {
|
||||
|
||||
public :
|
||||
DriverUNV_W_SMDS_Mesh();
|
||||
~DriverUNV_W_SMDS_Mesh();
|
||||
|
||||
void Add();
|
||||
void Write();
|
||||
void SetMesh(Handle(SMDS_Mesh)& aMesh);
|
||||
void SetFile(string);
|
||||
|
||||
void SetFileId(FILE*);
|
||||
void SetMeshId(int);
|
||||
|
||||
private :
|
||||
Handle_SMDS_Mesh myMesh;
|
||||
string myFile;
|
||||
FILE* myFileId;
|
||||
int myMeshId;
|
||||
|
||||
};
|
||||
#endif
|
||||
78
src/DriverUNV/DriverUNV_W_SMESHDS_Document.cxx
Normal file
78
src/DriverUNV/DriverUNV_W_SMESHDS_Document.cxx
Normal file
@ -0,0 +1,78 @@
|
||||
using namespace std;
|
||||
#include "DriverUNV_W_SMESHDS_Document.h"
|
||||
#include "DriverUNV_W_SMESHDS_Mesh.h"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
extern "C"
|
||||
{
|
||||
Document_Writer* Wmaker() {
|
||||
return new DriverUNV_W_SMESHDS_Document;
|
||||
}
|
||||
}
|
||||
|
||||
DriverUNV_W_SMESHDS_Document::DriverUNV_W_SMESHDS_Document() {
|
||||
;
|
||||
}
|
||||
|
||||
DriverUNV_W_SMESHDS_Document::~DriverUNV_W_SMESHDS_Document() {
|
||||
;
|
||||
}
|
||||
|
||||
//void DriverUNV_W_SMESHDS_Document::SetFile(string aFile) {
|
||||
//myFile = aFile;
|
||||
//}
|
||||
|
||||
//void DriverUNV_W_SMESHDS_Document::SetDocument(Handle(SMESHDS_Document)& aDocument) {
|
||||
//myDocument = aDocument;
|
||||
//}
|
||||
|
||||
void DriverUNV_W_SMESHDS_Document::Write() {
|
||||
|
||||
Handle(SMESHDS_Mesh) myMesh;
|
||||
|
||||
/****************************************************************************
|
||||
* OUVERTURE DU FICHIER EN ECRITURE *
|
||||
****************************************************************************/
|
||||
char* file2Write = (char*)myFile.c_str();
|
||||
FILE* fid = fopen(file2Write,"w+");
|
||||
if (fid < 0)
|
||||
{
|
||||
fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Write);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* FERMETURE DU FICHIER *
|
||||
****************************************************************************/
|
||||
|
||||
fclose(fid);
|
||||
|
||||
/******** Nombre de maillages ********/
|
||||
int nb_of_meshes = myDocument->NbMeshes(); //voir avec Yves
|
||||
//nb_of_meshes = 1;
|
||||
int numero = 0;
|
||||
|
||||
string myClass = string("SMESHDS_Mesh");
|
||||
string myExtension = string("UNV");
|
||||
|
||||
//while (numero<nb_of_meshes) {
|
||||
//numero++;
|
||||
//myMesh = myDocument->GetMesh(numero);
|
||||
myDocument->InitMeshesIterator();
|
||||
for (;myDocument->MoreMesh();myDocument->NextMesh()) {
|
||||
numero++;
|
||||
myMesh = myDocument->CurrentMesh();
|
||||
|
||||
DriverUNV_W_SMESHDS_Mesh* myWriter = new DriverUNV_W_SMESHDS_Mesh;
|
||||
//Mesh_Writer* myWriter = Driver::GetMeshWriter(myExtension, myClass);
|
||||
|
||||
myWriter->SetMesh(myMesh);
|
||||
myWriter->SetFile(myFile);
|
||||
SCRUTE(myMesh);
|
||||
//myWriter->SetFileId(fid);
|
||||
myWriter->SetMeshId(numero);
|
||||
myWriter->Write();
|
||||
}
|
||||
|
||||
}
|
||||
25
src/DriverUNV/DriverUNV_W_SMESHDS_Document.h
Normal file
25
src/DriverUNV/DriverUNV_W_SMESHDS_Document.h
Normal file
@ -0,0 +1,25 @@
|
||||
#ifndef _INCLUDE_DRIVERUNV_W_SMESHDS_DOCUMENT
|
||||
#define _INCLUDE_DRIVERUNV_W_SMESHDS_DOCUMENT
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string>
|
||||
|
||||
#include "SMESHDS_Document.hxx"
|
||||
#include "Document_Writer.h"
|
||||
|
||||
class DriverUNV_W_SMESHDS_Document : public Document_Writer {
|
||||
|
||||
public :
|
||||
DriverUNV_W_SMESHDS_Document();
|
||||
~DriverUNV_W_SMESHDS_Document();
|
||||
|
||||
void Write();
|
||||
//void SetFile(string);
|
||||
//void SetDocument(Handle(SMESHDS_Document)&);
|
||||
|
||||
private :
|
||||
//Handle_SMESHDS_Document myDocument;
|
||||
//string myFile;
|
||||
|
||||
};
|
||||
#endif
|
||||
207
src/DriverUNV/DriverUNV_W_SMESHDS_Mesh.cxx
Normal file
207
src/DriverUNV/DriverUNV_W_SMESHDS_Mesh.cxx
Normal file
@ -0,0 +1,207 @@
|
||||
using namespace std;
|
||||
#include "DriverUNV_W_SMESHDS_Mesh.h"
|
||||
#include "DriverUNV_W_SMDS_Mesh.h"
|
||||
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#include "SMDS_MeshNode.hxx"
|
||||
#include "SMDS_MeshEdgesIterator.hxx"
|
||||
#include "SMDS_MeshFacesIterator.hxx"
|
||||
#include "SMDS_MeshNodesIterator.hxx"
|
||||
#include "SMDS_MeshVolumesIterator.hxx"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
#define sNODE_UNV_ID " 2411"
|
||||
#define sELT_UNV_ID " 2412"
|
||||
#define sUNV_SEPARATOR " -1"
|
||||
#define sNODE_UNV_DESCR "%10d 1 1 11\n"
|
||||
#define sELT_SURF_DESC "%10d %2d 1 1 11 %1d\n"
|
||||
#define sELT_VOLU_DESC "%10d %2d 1 1 9 %1d\n"
|
||||
#define sELT_BEAM_DESC1 "%10d %2d 1 1 7 %1d\n"
|
||||
#define sELT_BEAM_DESC2 " 0 1 1\n"
|
||||
|
||||
DriverUNV_W_SMESHDS_Mesh::DriverUNV_W_SMESHDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
DriverUNV_W_SMESHDS_Mesh::~DriverUNV_W_SMESHDS_Mesh() {
|
||||
;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMESHDS_Mesh::SetMesh(Handle(SMDS_Mesh)& aMesh) {
|
||||
//myMesh = Handle(SMESHDS_Mesh)::DownCast(aMesh);
|
||||
myMesh = aMesh;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMESHDS_Mesh::SetFile(string aFile) {
|
||||
myFile = aFile;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMESHDS_Mesh::SetFileId(FILE* aFileId) {
|
||||
myFileId = aFileId;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMESHDS_Mesh::SetMeshId(int aMeshId) {
|
||||
myMeshId = aMeshId;
|
||||
}
|
||||
|
||||
void DriverUNV_W_SMESHDS_Mesh::Write() {
|
||||
|
||||
string myClass = string("SMDS_Mesh");
|
||||
string myExtension = string("UNV");
|
||||
|
||||
DriverUNV_W_SMDS_Mesh* myWriter = new DriverUNV_W_SMDS_Mesh;
|
||||
|
||||
myWriter->SetMesh(myMesh);
|
||||
myWriter->SetFile(myFile);
|
||||
myWriter->SetMeshId(myMeshId);
|
||||
//myWriter->SetFileId(myFileId);
|
||||
|
||||
myWriter->Write();
|
||||
|
||||
|
||||
}
|
||||
void DriverUNV_W_SMESHDS_Mesh::Add() {
|
||||
int nbNodes,nbCells;
|
||||
int i;
|
||||
|
||||
char* file2Read = (char*)myFile.c_str();
|
||||
myFileId = fopen(file2Read,"w+");
|
||||
if (myFileId < 0)
|
||||
{
|
||||
fprintf(stderr,">> ERREUR : ouverture du fichier %s \n",file2Read);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
/****************************************************************************
|
||||
* NOMBRES D'OBJETS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(****************************)\n");
|
||||
fprintf(stdout,"(* INFORMATIONS GENERALES : *)\n");
|
||||
fprintf(stdout,"(****************************)\n");
|
||||
|
||||
/* Combien de noeuds ? */
|
||||
nbNodes = myMesh->NbNodes();
|
||||
|
||||
/* Combien de mailles, faces ou aretes ? */
|
||||
Standard_Integer nb_of_nodes, nb_of_edges,nb_of_faces, nb_of_volumes;
|
||||
nb_of_edges = myMesh->NbEdges();
|
||||
nb_of_faces = myMesh->NbFaces();
|
||||
nb_of_volumes = myMesh->NbVolumes();
|
||||
nbCells = nb_of_edges + nb_of_faces + nb_of_volumes;
|
||||
|
||||
fprintf(stdout,"%d %d\n",nbNodes,nbCells);
|
||||
//fprintf(myFileId,"%d %d\n",nbNodes,nbCells);
|
||||
|
||||
/****************************************************************************
|
||||
* ECRITURE DES NOEUDS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(************************)\n");
|
||||
fprintf(stdout,"(* NOEUDS DU MAILLAGE : *)\n");
|
||||
fprintf(stdout,"(************************)\n");
|
||||
|
||||
SMDS_MeshNodesIterator itNodes(myMesh);
|
||||
|
||||
fprintf(myFileId,"%s\n", sUNV_SEPARATOR);
|
||||
fprintf(myFileId,"%s\n", sNODE_UNV_ID );
|
||||
|
||||
for (;itNodes.More();itNodes.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itNodes.Value();
|
||||
const Handle(SMDS_MeshNode )& node = myMesh->GetNode(1, elem);
|
||||
|
||||
fprintf(myFileId, sNODE_UNV_DESCR, node->GetID());
|
||||
fprintf(myFileId, "%25.16E%25.16E%25.16E\n", node->X(), node->Y(), node->Z());
|
||||
}
|
||||
fprintf(myFileId,"%s\n", sUNV_SEPARATOR);
|
||||
|
||||
/****************************************************************************
|
||||
* ECRITURE DES ELEMENTS *
|
||||
****************************************************************************/
|
||||
fprintf(stdout,"\n(**************************)\n");
|
||||
fprintf(stdout,"(* ELEMENTS DU MAILLAGE : *)\n");
|
||||
fprintf(stdout,"(**************************)");
|
||||
/* Ecriture des connectivites, noms, numeros des mailles */
|
||||
|
||||
fprintf(myFileId,"%s\n", sUNV_SEPARATOR);
|
||||
fprintf(myFileId,"%s\n", sELT_UNV_ID );
|
||||
|
||||
SMDS_MeshEdgesIterator itEdges(myMesh);
|
||||
for (;itEdges.More();itEdges.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itEdges.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 2 : {
|
||||
fprintf(myFileId, sELT_BEAM_DESC1, elem->GetID(), 21, elem->NbNodes());
|
||||
fprintf(myFileId, sELT_BEAM_DESC2);
|
||||
fprintf(myFileId, "%10d%10d\n", elem->GetConnection(1), elem->GetConnection(2));
|
||||
break;
|
||||
}
|
||||
case 3 : {
|
||||
fprintf(myFileId, sELT_BEAM_DESC1, elem->GetID(), 24, elem->NbNodes());
|
||||
fprintf(myFileId, sELT_BEAM_DESC2);
|
||||
fprintf(myFileId, "%10d%10d%10d\n",elem->GetConnection(1), elem->GetConnection(2), elem->GetConnection(3));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
SMDS_MeshFacesIterator itFaces(myMesh);
|
||||
for (;itFaces.More();itFaces.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itFaces.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 3 :
|
||||
// linear triangle
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 74, elem->NbNodes());
|
||||
break;
|
||||
case 4 :
|
||||
// linear quadrilateral
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 71, elem->NbNodes());
|
||||
break;
|
||||
case 6 :
|
||||
// parabolic triangle
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 72, elem->NbNodes());
|
||||
break;
|
||||
case 8 :
|
||||
// parabolic quadrilateral
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 75, elem->NbNodes());
|
||||
break;
|
||||
default:
|
||||
fprintf(myFileId, "element not registered\n");
|
||||
}
|
||||
|
||||
for (i=0;i<elem->NbNodes();i++)
|
||||
fprintf(myFileId,"%10d",elem->GetConnection(i+1));
|
||||
|
||||
fprintf(myFileId,"\n");
|
||||
}
|
||||
|
||||
SMDS_MeshVolumesIterator itVolumes(myMesh);
|
||||
for (;itVolumes.More();itVolumes.Next()) {
|
||||
const Handle(SMDS_MeshElement)& elem = itVolumes.Value();
|
||||
|
||||
switch (elem->NbNodes()) {
|
||||
case 4 :
|
||||
// linear tetrahedron
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 111, elem->NbNodes());
|
||||
break;
|
||||
case 6 :
|
||||
// linear tetrahedron
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 112, elem->NbNodes());
|
||||
break;
|
||||
case 8 :
|
||||
// linear brick
|
||||
fprintf(myFileId, sELT_SURF_DESC, elem->GetID(), 115, elem->NbNodes());
|
||||
break;
|
||||
}
|
||||
|
||||
for (i=0;i<elem->NbNodes();i++)
|
||||
fprintf(myFileId,"%10d",elem->GetConnection(i+1));
|
||||
|
||||
fprintf(myFileId,"\n");
|
||||
}
|
||||
fprintf(myFileId,"%s\n", sUNV_SEPARATOR);
|
||||
|
||||
fclose (myFileId);
|
||||
}
|
||||
|
||||
31
src/DriverUNV/DriverUNV_W_SMESHDS_Mesh.h
Normal file
31
src/DriverUNV/DriverUNV_W_SMESHDS_Mesh.h
Normal file
@ -0,0 +1,31 @@
|
||||
#ifndef _INCLUDE_DRIVERUNV_W_SMESHDS_MESH
|
||||
#define _INCLUDE_DRIVERUNV_W_SMESHDS_MESH
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string>
|
||||
|
||||
#include "SMESHDS_Mesh.hxx"
|
||||
#include "Mesh_Writer.h"
|
||||
|
||||
class DriverUNV_W_SMESHDS_Mesh : public Mesh_Writer {
|
||||
|
||||
public :
|
||||
DriverUNV_W_SMESHDS_Mesh();
|
||||
~DriverUNV_W_SMESHDS_Mesh();
|
||||
|
||||
void Add();
|
||||
void Write();
|
||||
void SetMesh(Handle(SMDS_Mesh)& aMesh);
|
||||
void SetFile(string);
|
||||
|
||||
void SetFileId(FILE*);
|
||||
void SetMeshId(int);
|
||||
|
||||
private :
|
||||
Handle_SMDS_Mesh myMesh;
|
||||
string myFile;
|
||||
FILE* myFileId;
|
||||
int myMeshId;
|
||||
|
||||
};
|
||||
#endif
|
||||
41
src/DriverUNV/Makefile.in
Normal file
41
src/DriverUNV/Makefile.in
Normal file
@ -0,0 +1,41 @@
|
||||
# -* Makefile *-
|
||||
#
|
||||
# Author : Marc Tajchman (CEA)
|
||||
# Date : 5/07/2001
|
||||
# $Header$
|
||||
#
|
||||
|
||||
# source path
|
||||
top_srcdir=@top_srcdir@
|
||||
top_builddir=../..
|
||||
srcdir=@srcdir@
|
||||
VPATH=.:@srcdir@
|
||||
|
||||
|
||||
@COMMENCE@
|
||||
|
||||
# header files
|
||||
EXPORT_HEADERS= DriverUNV_R_SMDS_Mesh.h DriverUNV_R_SMESHDS_Mesh.h DriverUNV_R_SMESHDS_Document.h \
|
||||
DriverUNV_W_SMDS_Mesh.h DriverUNV_W_SMESHDS_Mesh.h DriverUNV_W_SMESHDS_Document.h
|
||||
|
||||
# Libraries targets
|
||||
LIB = libMeshDriverUNV.la
|
||||
LIB_SRC = DriverUNV_R_SMDS_Mesh.cxx DriverUNV_R_SMESHDS_Mesh.cxx DriverUNV_R_SMESHDS_Document.cxx \
|
||||
DriverUNV_W_SMDS_Mesh.cxx DriverUNV_W_SMESHDS_Mesh.cxx DriverUNV_W_SMESHDS_Document.cxx
|
||||
|
||||
LIB_CLIENT_IDL =
|
||||
|
||||
LIB_SERVER_IDL =
|
||||
|
||||
# additionnal information to compil and link file
|
||||
CPPFLAGS += $(OCC_INCLUDES)
|
||||
CXXFLAGS += $(OCC_CXXFLAGS) $(MED2_INCLUDES)
|
||||
LDFLAGS += $(OCC_LIBS) $(MED2_LIBS) -lMeshDriver
|
||||
|
||||
%_moc.cxx: %.h
|
||||
$(MOC) $< -o $@
|
||||
|
||||
@CONCLUDE@
|
||||
|
||||
|
||||
|
||||
36
src/MEFISTO2/Makefile.in
Normal file
36
src/MEFISTO2/Makefile.in
Normal file
@ -0,0 +1,36 @@
|
||||
# -* Makefile *-
|
||||
#
|
||||
# Author :
|
||||
# Date : 29/01/2001
|
||||
#
|
||||
#
|
||||
|
||||
# source path
|
||||
top_srcdir=@top_srcdir@
|
||||
top_builddir=../..
|
||||
srcdir=@srcdir@
|
||||
VPATH=.:@srcdir@
|
||||
|
||||
|
||||
@COMMENCE@
|
||||
|
||||
# header files
|
||||
EXPORT_HEADERS = aptrte.h Rn.h
|
||||
|
||||
# Libraries targets
|
||||
LIB = libMEFISTO2D.la
|
||||
LIB_SRC = aptrte.cxx trte.f
|
||||
# areteideale.f
|
||||
|
||||
LIB_CLIENT_IDL =
|
||||
|
||||
LIB_SERVER_IDL =
|
||||
|
||||
# additionnal information to compil and link file
|
||||
CPPFLAGS += $(OCC_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
|
||||
CXXFLAGS += $(OCC_CXXFLAGS) -I${KERNEL_ROOT_DIR}/include/salome
|
||||
|
||||
LDFLAGS += $(OCC_LIBS) -lg2c
|
||||
|
||||
@CONCLUDE@
|
||||
|
||||
204
src/MEFISTO2/Rn.h
Executable file
204
src/MEFISTO2/Rn.h
Executable file
@ -0,0 +1,204 @@
|
||||
#ifndef Rn__h
|
||||
#define Rn__h
|
||||
|
||||
#include <gp_Pnt.hxx> //Dans OpenCascade
|
||||
#include <gp_Vec.hxx> //Dans OpenCascade
|
||||
#include <gp_Dir.hxx> //Dans OpenCascade
|
||||
|
||||
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
// BUT: Definir les espaces affines R R2 R3 R4 soit Rn pour n=1,2,3,4
|
||||
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
// AUTEUR : Frederic HECHT ANALYSE NUMERIQUE UPMC PARIS OCTOBRE 2000
|
||||
// MODIFS : Alain PERRONNET ANALYSE NUMERIQUE UPMC PARIS NOVEMBRE 2000
|
||||
//...............................................................................
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
|
||||
using namespace std;
|
||||
|
||||
template<class T> inline T Abs (const T &a){return a <0 ? -a : a;}
|
||||
template<class T> inline void Echange (T& a,T& b) {T c=a;a=b;b=c;}
|
||||
|
||||
template<class T> inline T Min (const T &a,const T &b) {return a < b ? a : b;}
|
||||
template<class T> inline T Max (const T &a,const T & b) {return a > b ? a : b;}
|
||||
|
||||
template<class T> inline T Max (const T &a,const T & b,const T & c){return Max(Max(a,b),c);}
|
||||
template<class T> inline T Min (const T &a,const T & b,const T & c){return Min(Min(a,b),c);}
|
||||
|
||||
template<class T> inline T Max (const T &a,const T & b,const T & c,const T & d)
|
||||
{return Max(Max(a,b),Max(c,d));}
|
||||
template<class T> inline T Min (const T &a,const T & b,const T & c,const T & d)
|
||||
{return Min(Min(a,b),Min(c,d));}
|
||||
|
||||
//le type Nom des entites geometriques P L S V O
|
||||
//===========
|
||||
typedef char Nom[1+24];
|
||||
|
||||
//le type N des nombres entiers positifs
|
||||
//=========
|
||||
typedef unsigned long int N;
|
||||
|
||||
//le type Z des nombres entiers relatifs
|
||||
//=========
|
||||
typedef long int Z;
|
||||
|
||||
//le type R des nombres "reels"
|
||||
//=========
|
||||
typedef double R;
|
||||
|
||||
//le type XPoint des coordonnees d'un pixel dans une fenetre
|
||||
//==============
|
||||
//typedef struct { short int x,y } XPoint; //en fait ce type est defini dans X11-Window
|
||||
// #include <X11/Xlib.h>
|
||||
//la classe R2
|
||||
//============
|
||||
class R2
|
||||
{
|
||||
friend ostream& operator << (ostream& f, const R2 & P)
|
||||
{ f << P.x << ' ' << P.y ; return f; }
|
||||
friend istream& operator >> (istream& f, R2 & P)
|
||||
{ f >> P.x >> P.y ; return f; }
|
||||
|
||||
friend ostream& operator << (ostream& f, const R2 * P)
|
||||
{ f << P->x << ' ' << P->y ; return f; }
|
||||
friend istream& operator >> (istream& f, R2 * P)
|
||||
{ f >> P->x >> P->y ; return f; }
|
||||
|
||||
public:
|
||||
R x,y; //les donnees
|
||||
|
||||
R2 () :x(0),y(0) {} //les constructeurs
|
||||
R2 (R a,R b) :x(a),y(b) {}
|
||||
R2 (R2 A,R2 B) :x(B.x-A.x),y(B.y-A.y) {} //vecteur defini par 2 points
|
||||
|
||||
R2 operator+(R2 P) const {return R2(x+P.x,y+P.y);} // Q+P possible
|
||||
R2 operator+=(R2 P) {x += P.x;y += P.y; return *this;}// Q+=P;
|
||||
R2 operator-(R2 P) const {return R2(x-P.x,y-P.y);} // Q-P
|
||||
R2 operator-=(R2 P) {x -= P.x;y -= P.y; return *this;} // Q-=P;
|
||||
R2 operator-()const {return R2(-x,-y);} // -Q
|
||||
R2 operator+()const {return *this;} // +Q
|
||||
R operator,(R2 P)const {return x*P.x+y*P.y;} // produit scalaire (Q,P)
|
||||
R operator^(R2 P)const {return x*P.y-y*P.x;} // produit vectoriel Q^P
|
||||
R2 operator*(R c)const {return R2(x*c,y*c);} // produit a droite P*c
|
||||
R2 operator*=(R c) {x *= c; y *= c; return *this;}
|
||||
R2 operator/(R c)const {return R2(x/c,y/c);} // division par un reel
|
||||
R2 operator/=(R c) {x /= c; y /= c; return *this;}
|
||||
R & operator[](int i) {return (&x)[i];} // la coordonnee i
|
||||
R2 orthogonal() {return R2(-y,x);} //le vecteur orthogonal dans R2
|
||||
friend R2 operator*(R c,R2 P) {return P*c;} // produit a gauche c*P
|
||||
};
|
||||
|
||||
|
||||
//la classe R3
|
||||
//============
|
||||
class R3
|
||||
{
|
||||
friend ostream& operator << (ostream& f, const R3 & P)
|
||||
{ f << P.x << ' ' << P.y << ' ' << P.z ; return f; }
|
||||
friend istream& operator >> (istream& f, R3 & P)
|
||||
{ f >> P.x >> P.y >> P.z ; return f; }
|
||||
|
||||
friend ostream& operator << (ostream& f, const R3 * P)
|
||||
{ f << P->x << ' ' << P->y << ' ' << P->z ; return f; }
|
||||
friend istream& operator >> (istream& f, R3 * P)
|
||||
{ f >> P->x >> P->y >> P->z ; return f; }
|
||||
|
||||
public:
|
||||
R x,y,z; //les 3 coordonnees
|
||||
|
||||
R3 () :x(0),y(0),z(0) {} //les constructeurs
|
||||
R3 (R a,R b,R c):x(a),y(b),z(c) {} //Point ou Vecteur (a,b,c)
|
||||
R3 (R3 A,R3 B):x(B.x-A.x),y(B.y-A.y),z(B.z-A.z) {} //Vecteur AB
|
||||
|
||||
R3 (gp_Pnt P) : x(P.X()), y(P.Y()), z(P.Z()) {} //Point d'OpenCascade
|
||||
R3 (gp_Vec V) : x(V.X()), y(V.Y()), z(V.Z()) {} //Vecteur d'OpenCascade
|
||||
R3 (gp_Dir P) : x(P.X()), y(P.Y()), z(P.Z()) {} //Direction d'OpenCascade
|
||||
|
||||
R3 operator+(R3 P)const {return R3(x+P.x,y+P.y,z+P.z);}
|
||||
R3 operator+=(R3 P) {x += P.x; y += P.y; z += P.z; return *this;}
|
||||
R3 operator-(R3 P)const {return R3(x-P.x,y-P.y,z-P.z);}
|
||||
R3 operator-=(R3 P) {x -= P.x; y -= P.y; z -= P.z; return *this;}
|
||||
R3 operator-()const {return R3(-x,-y,-z);}
|
||||
R3 operator+()const {return *this;}
|
||||
R operator,(R3 P)const {return x*P.x+y*P.y+z*P.z;} // produit scalaire
|
||||
R3 operator^(R3 P)const {return R3(y*P.z-z*P.y ,P.x*z-x*P.z, x*P.y-y*P.x);} // produit vectoriel
|
||||
R3 operator*(R c)const {return R3(x*c,y*c,z*c);}
|
||||
R3 operator*=(R c) {x *= c; y *= c; z *= c; return *this;}
|
||||
R3 operator/(R c)const {return R3(x/c,y/c,z/c);}
|
||||
R3 operator/=(R c) {x /= c; y /= c; z /= c; return *this;}
|
||||
R & operator[](int i) {return (&x)[i];}
|
||||
friend R3 operator*(R c,R3 P) {return P*c;}
|
||||
|
||||
R3 operator=(gp_Pnt P) {return R3(P.X(),P.Y(),P.Z());}
|
||||
R3 operator=(gp_Dir P) {return R3(P.X(),P.Y(),P.Z());}
|
||||
|
||||
friend gp_Pnt gp_pnt(R3 xyz) { return gp_Pnt(xyz.x,xyz.y,xyz.z); }
|
||||
//friend gp_Pnt operator=() { return gp_Pnt(x,y,z); }
|
||||
friend gp_Dir gp_dir(R3 xyz) { return gp_Dir(xyz.x,xyz.y,xyz.z); }
|
||||
|
||||
bool DansPave( R3 & xyzMin, R3 & xyzMax )
|
||||
{ return xyzMin.x<=x && x<=xyzMax.x &&
|
||||
xyzMin.y<=y && y<=xyzMax.y &&
|
||||
xyzMin.z<=z && z<=xyzMax.z; }
|
||||
};
|
||||
|
||||
//la classe R4
|
||||
//============
|
||||
class R4: public R3
|
||||
{
|
||||
friend ostream& operator <<(ostream& f, const R4 & P )
|
||||
{ f << P.x << ' ' << P.y << ' ' << P.z << ' ' << P.omega; return f; }
|
||||
friend istream& operator >>(istream& f, R4 & P)
|
||||
{ f >> P.x >> P.y >> P.z >> P.omega ; return f; }
|
||||
|
||||
friend ostream& operator <<(ostream& f, const R4 * P )
|
||||
{ f << P->x << ' ' << P->y << ' ' << P->z << ' ' << P->omega; return f; }
|
||||
friend istream& operator >>(istream& f, R4 * P)
|
||||
{ f >> P->x >> P->y >> P->z >> P->omega ; return f; }
|
||||
|
||||
public:
|
||||
R omega; //la donnee du poids supplementaire
|
||||
|
||||
R4 () :omega(1.0) {} //les constructeurs
|
||||
R4 (R a,R b,R c,R d):R3(a,b,c),omega(d) {}
|
||||
R4 (R4 A,R4 B) :R3(B.x-A.x,B.y-A.y,B.z-A.z),omega(B.omega-A.omega) {}
|
||||
|
||||
R4 operator+(R4 P)const {return R4(x+P.x,y+P.y,z+P.z,omega+P.omega);}
|
||||
R4 operator+=(R4 P) {x += P.x;y += P.y;z += P.z;omega += P.omega;return *this;}
|
||||
R4 operator-(R4 P)const {return R4(x-P.x,y-P.y,z-P.z,omega-P.omega);}
|
||||
R4 operator-=(R4 P) {x -= P.x;y -= P.y;z -= P.z;omega -= P.omega;return *this;}
|
||||
R4 operator-()const {return R4(-x,-y,-z,-omega);}
|
||||
R4 operator+()const {return *this;}
|
||||
R operator,(R4 P)const {return x*P.x+y*P.y+z*P.z+omega*P.omega;} // produit scalaire
|
||||
R4 operator*(R c)const {return R4(x*c,y*c,z*c,omega*c);}
|
||||
R4 operator*=(R c) {x *= c; y *= c; z *= c; omega *= c; return *this;}
|
||||
R4 operator/(R c)const {return R4(x/c,y/c,z/c,omega/c);}
|
||||
R4 operator/=(R c) {x /= c; y /= c; z /= c; omega /= c; return *this;}
|
||||
R & operator[](int i) {return (&x)[i];}
|
||||
friend R4 operator*(R c,R4 P) {return P*c;}
|
||||
};
|
||||
|
||||
//quelques fonctions supplementaires sur ces classes
|
||||
//==================================================
|
||||
inline R Aire2d(const R2 A,const R2 B,const R2 C){return (B-A)^(C-A);}
|
||||
inline R Angle2d(R2 P){ return atan2(P.y,P.x);}
|
||||
|
||||
inline R Norme2_2(const R2 & A){ return (A,A);}
|
||||
inline R Norme2(const R2 & A){ return sqrt((A,A));}
|
||||
inline R NormeInfinie(const R2 & A){return Max(Abs(A.x),Abs(A.y));}
|
||||
|
||||
inline R Norme2_2(const R3 & A){ return (A,A);}
|
||||
inline R Norme2(const R3 & A){ return sqrt((A,A));}
|
||||
inline R NormeInfinie(const R3 & A){return Max(Abs(A.x),Abs(A.y),Abs(A.z));}
|
||||
|
||||
inline R Norme2_2(const R4 & A){ return (A,A);}
|
||||
inline R Norme2(const R4 & A){ return sqrt((A,A));}
|
||||
inline R NormeInfinie(const R4 & A){return Max(Abs(A.x),Abs(A.y),Abs(A.z),Abs(A.omega));}
|
||||
|
||||
inline R2 XY(R3 P) {return R2(P.x, P.y);} //restriction a R2 d'un R3 par perte de z
|
||||
inline R3 Min(R3 P, R3 Q)
|
||||
{return R3(P.x<Q.x ? P.x : Q.x, P.y<Q.y ? P.y : Q.y, P.z<Q.z ? P.z : Q.z);} //Pt de xyz Min
|
||||
inline R3 Max(R3 P, R3 Q)
|
||||
{return R3(P.x>Q.x ? P.x : Q.x, P.y>Q.y ? P.y : Q.y, P.z>Q.z ? P.z : Q.z);} //Pt de xyz Max
|
||||
|
||||
#endif
|
||||
760
src/MEFISTO2/aptrte.cxx
Executable file
760
src/MEFISTO2/aptrte.cxx
Executable file
@ -0,0 +1,760 @@
|
||||
using namespace std;
|
||||
#include "Rn.h"
|
||||
#include "aptrte.h"
|
||||
#include "utilities.h"
|
||||
|
||||
extern "C"
|
||||
{
|
||||
R aretemaxface_;
|
||||
R areteideale_( R3 xyz, R3 direction )
|
||||
{
|
||||
return aretemaxface_;
|
||||
}
|
||||
}
|
||||
//calcul de la longueur ideale de l'arete au sommet xyz (z ici inactif)
|
||||
//dans la direction donnee
|
||||
//a ajuster pour chaque surface plane et selon l'entier notysu (voir plus bas)
|
||||
|
||||
|
||||
static double cpunew, cpuold=0;
|
||||
|
||||
void tempscpu_( double & tempsec )
|
||||
//Retourne le temps CPU utilise en secondes
|
||||
{
|
||||
tempsec = ( (double) clock() ) / CLOCKS_PER_SEC;
|
||||
//MESSAGE( "temps cpu=" << tempsec );
|
||||
}
|
||||
|
||||
|
||||
void deltacpu_( R & dtcpu )
|
||||
//Retourne le temps CPU utilise en secondes depuis le precedent appel
|
||||
{
|
||||
tempscpu_( cpunew );
|
||||
dtcpu = R( cpunew - cpuold );
|
||||
cpuold = cpunew;
|
||||
//MESSAGE( "delta temps cpu=" << dtcpu );
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
void aptrte( Z nutysu, R aretmx,
|
||||
Z nblf, Z * nudslf, R2 * uvslf,
|
||||
Z nbpti, R2 *uvpti,
|
||||
Z & nbst, R2 * & uvst, Z & nbt, Z * & nust,
|
||||
Z & ierr )
|
||||
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
// but : appel de la triangulation par un arbre-4 recouvrant
|
||||
// ----- de triangles equilateraux
|
||||
// le contour du domaine plan est defini par des lignes fermees
|
||||
// la premiere ligne etant l'enveloppe de toutes les autres
|
||||
// la fonction areteideale(s,d) donne la taille d'arete
|
||||
// au point s dans la direction (actuellement inactive) d
|
||||
// des lors toute arete issue d'un sommet s devrait avoir une longueur
|
||||
// comprise entre 0.65 areteideale_(s,d) et 1.3 areteideale_(s,d)
|
||||
//
|
||||
//Attention:
|
||||
// Les tableaux uvslf et uvpti sont supposes ne pas avoir de sommets identiques!
|
||||
// De meme, un sommet d'une ligne fermee ne peut appartenir a une autre ligne fermee
|
||||
//
|
||||
// entrees:
|
||||
// --------
|
||||
// nutysu : numero de traitement de areteideale_(s,d) selon le type de surface
|
||||
// 0 pas d'emploi de la fonction areteideale_() et aretmx est active
|
||||
// 1 il existe une fonction areteideale_(s,d)
|
||||
// dont seules les 2 premieres composantes de uv sont actives
|
||||
// ... autres options a definir ...
|
||||
// aretmx : longueur maximale des aretes de la future triangulation
|
||||
// nblf : nombre de lignes fermees de la surface
|
||||
// nudslf : numero du dernier sommet de chacune des nblf lignes fermees
|
||||
// nudslf(0)=0 pour permettre la difference sans test
|
||||
// Attention le dernier sommet de chaque ligne est raccorde au premier
|
||||
// tous les sommets et les points internes ont des coordonnees
|
||||
// UV differentes <=> Pas de point double!
|
||||
// uvslf : uv des nudslf(nblf) sommets des lignes fermees
|
||||
// nbpti : nombre de points internes futurs sommets de la triangulation
|
||||
// uvpti : uv des points internes futurs sommets de la triangulation
|
||||
//
|
||||
// sorties:
|
||||
// --------
|
||||
// nbst : nombre de sommets de la triangulation finale
|
||||
// uvst : coordonnees uv des nbst sommets de la triangulation
|
||||
// nbt : nombre de triangles de la triangulation finale
|
||||
// nust : 4 numeros dans uvst des sommets des nbt triangles
|
||||
// s1, s2, s3, 0: no dans uvst des 3 sommets et 0 car quadrangle!
|
||||
// ierr : 0 si pas d'erreur
|
||||
// > 0 sinon
|
||||
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
// auteur : Alain Perronnet Analyse Numerique Paris UPMC decembre 2001
|
||||
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
{
|
||||
R d, tcpu=0;
|
||||
R3 direction=R3(0,0,0); //direction pour areteideale() inactive ici!
|
||||
Z nbarfr=nudslf[nblf]; //nombre total d'aretes des lignes fermees
|
||||
Z mxtrou = Max( 1024, nblf ); //nombre maximal de trous dans la surface
|
||||
|
||||
R3 *mnpxyd=NULL;
|
||||
Z *mnsoar=NULL, mosoar=7, mxsoar, n1soar; //le hachage des aretes
|
||||
Z *mnartr=NULL, moartr=3, mxartr, n1artr; //le no des 3 aretes des triangles
|
||||
Z *mntree=NULL, motree=9, mxtree; //L'arbre 4 de TE et nombre d'entiers par TE
|
||||
Z *mnqueu=NULL, mxqueu;
|
||||
Z *mn1arcf=NULL;
|
||||
Z *mnarcf=NULL, mxarcf;
|
||||
Z *mnarcf1=NULL;
|
||||
Z *mnarcf2=NULL;
|
||||
Z *mnarcf3=NULL;
|
||||
Z *mntrsu=NULL;
|
||||
Z *mndalf=NULL;
|
||||
Z *mnslig=NULL;
|
||||
Z *mnarst=NULL;
|
||||
Z *mnlftr=NULL;
|
||||
|
||||
R3 comxmi[2]; //coordonnees UV Min et Maximales
|
||||
R aremin, aremax; //longueur minimale et maximale des aretes
|
||||
R quamoy, quamin;
|
||||
|
||||
Z noar0, noar, na;
|
||||
Z i, l, n, ns, ns0, ns1, ns2, nosotr[3], nt;
|
||||
Z mxsomm, nbsomm, nbarpi, nbarli, ndtri0, mn;
|
||||
Z moins1=-1;
|
||||
|
||||
aretemaxface_ = aretmx;
|
||||
|
||||
// initialisation du temps cpu
|
||||
deltacpu_( d );
|
||||
ierr = 0;
|
||||
|
||||
// quelques reservations de tableaux pour faire les calculs
|
||||
// ========================================================
|
||||
// le tableau pointeur sur la premiere arete de chaque ligne fermee
|
||||
if( mndalf!=NULL ) delete [] mndalf;
|
||||
mndalf = new Z[1+nblf];
|
||||
if( mndalf==NULL ) goto ERREUR;
|
||||
mndalf[0]=0;
|
||||
|
||||
// declaration du tableau des coordonnees des sommets de la frontiere
|
||||
// puis des sommets internes ajoutes
|
||||
// majoration empirique du nombre de sommets de la triangulation
|
||||
i = 4*nbarfr/10;
|
||||
mxsomm = Max( 20000, 64*nbpti+i*i );
|
||||
MESSAGE( "APTRTE: Depart de la triangulation avec " );
|
||||
MESSAGE( "nutysu=" << nutysu << " aretmx=" << aretmx << " mxsomm=" << mxsomm );
|
||||
|
||||
NEWDEPART:
|
||||
//mnpxyd( 3, mxsomm ) les coordonnees UV des sommets et la taille d'arete aux sommets
|
||||
if( mnpxyd!=NULL ) delete [] mnpxyd;
|
||||
mnpxyd = new R3[mxsomm];
|
||||
if( mnpxyd==NULL ) goto ERREUR;
|
||||
|
||||
// le tableau mnsoar des aretes des triangles
|
||||
// 1: sommet 1 dans pxyd,
|
||||
// 2: sommet 2 dans pxyd,
|
||||
// 3: numero de 1 a nblf de la ligne qui supporte l'arete
|
||||
// 4: numero dans mnartr du triangle 1 partageant cette arete,
|
||||
// 5: numero dans mnartr du triangle 2 partageant cette arete,
|
||||
// 6: chainage des aretes frontalieres ou internes ou
|
||||
// des aretes simples des etoiles de triangles,
|
||||
// 7: chainage du hachage des aretes
|
||||
// nombre d'aretes = 3 ( nombre de sommets - 1 + nombre de trous )
|
||||
// pour le hachage des aretes mxsoar doit etre > 3*mxsomm!
|
||||
// h(ns1,ns2) = min( ns1, ns2 )
|
||||
if( mnsoar!=NULL ) delete [] mnsoar;
|
||||
mxsoar = 3 * ( mxsomm + mxtrou );
|
||||
mnsoar = new Z[mosoar*mxsoar];
|
||||
if( mnsoar==NULL ) goto ERREUR;
|
||||
//initialiser le tableau mnsoar pour le hachage des aretes
|
||||
insoar_( mxsomm, mosoar, mxsoar, n1soar, mnsoar );
|
||||
|
||||
// mnarst( mxsomm ) numero mnsoar d'une arete pour chacun des sommets
|
||||
if( mnarst!=NULL ) delete [] mnarst;
|
||||
mnarst = new Z[1+mxsomm];
|
||||
if( mnarst==NULL ) goto ERREUR;
|
||||
n = 1+mxsomm;
|
||||
azeroi_( n, mnarst );
|
||||
|
||||
// mnslig( mxsomm ) no de sommet dans sa ligne pour chaque sommet frontalier
|
||||
// ou no du point si interne forc'e par l'utilisateur
|
||||
// ou 0 si interne cree par le module
|
||||
if( mnslig!=NULL ) delete [] mnslig;
|
||||
mnslig = new Z[mxsomm];
|
||||
if( mnslig==NULL ) goto ERREUR;
|
||||
azeroi_( mxsomm, mnslig );
|
||||
|
||||
// initialisation des aretes frontalieres de la triangulation future
|
||||
// renumerotation des sommets des aretes des lignes pour la triangulation
|
||||
// mise a l'echelle des coordonnees des sommets pour obtenir une
|
||||
// meilleure precision lors des calculs + quelques verifications
|
||||
// boucle sur les lignes fermees qui forment la frontiere
|
||||
// ======================================================================
|
||||
noar = 0;
|
||||
aremin = 1e100;
|
||||
aremax = 0;
|
||||
|
||||
for (n=1; n<=nblf; n++)
|
||||
{
|
||||
//l'initialisation de la premiere arete de la ligne n dans la triangulation
|
||||
//-------------------------------------------------------------------------
|
||||
//le sommet ns0 est le numero de l'origine de la ligne
|
||||
ns0 = nudslf[n-1];
|
||||
mnpxyd[ns0].x = uvslf[ns0].x;
|
||||
mnpxyd[ns0].y = uvslf[ns0].y;
|
||||
mnpxyd[ns0].z = areteideale_( mnpxyd[ns0], direction );
|
||||
// cout << "Sommet " << ns0 << ": " << mnpxyd[ns0].x
|
||||
// << " " << mnpxyd[ns0].y << " longueur arete=" << mnpxyd[ns0].z << endl;
|
||||
|
||||
//carre de la longueur de l'arete 1 de la ligne fermee n
|
||||
d = pow( uvslf[ns0+1].x - uvslf[ns0].x, 2 )
|
||||
+ pow( uvslf[ns0+1].y - uvslf[ns0].y, 2 ) ;
|
||||
aremin = Min( aremin, d );
|
||||
aremax = Max( aremax, d );
|
||||
|
||||
//le numero des 2 sommets (ns1,ns2) de la premiere arete de la ligne
|
||||
//initialisation de la 1-ere arete ns1-ns1+1 de cette ligne fermee n
|
||||
//le numero des 2 sommets ns1 ns2 de la 1-ere arete
|
||||
//Attention: les numeros ns debutent a 1 (ils ont >0)
|
||||
// les tableaux c++ demarrent a zero!
|
||||
// les tableaux fortran demarrent ou l'on veut!
|
||||
ns0++;
|
||||
ns1 = ns0;
|
||||
ns2 = ns1+1;
|
||||
|
||||
//le numero n de la ligne du sommet et son numero ns1 dans la ligne
|
||||
mnslig[ns0-1] = 1000000 * n + ns1-nudslf[n-1];
|
||||
fasoar_( ns1, ns2, moins1, moins1, n,
|
||||
mosoar, mxsoar, n1soar, mnsoar, mnarst,
|
||||
noar0, ierr );
|
||||
//pas de test sur ierr car pas de saturation possible a ce niveau
|
||||
|
||||
//le pointeur dans le hachage sur la premiere arete de la ligne fermee n
|
||||
mndalf[n] = noar0;
|
||||
|
||||
//la nouvelle arete est la suivante de l'arete definie juste avant
|
||||
if( noar > 0 )
|
||||
mnsoar[mosoar * noar - mosoar + 5] = noar0;
|
||||
|
||||
//l'initialisation des aretes suivantes de la ligne dans la triangulation
|
||||
//-----------------------------------------------------------------------
|
||||
nbarli = nudslf[n] - nudslf[n-1]; //nombre d'aretes=sommets de la ligne n
|
||||
for (i=2; i<=nbarli; i++)
|
||||
{
|
||||
ns1 = ns2; //le numero de l'arete et le numero du premier sommet de l'arete
|
||||
if( i < nbarli )
|
||||
//nbs+1 est le 2-eme sommet de l'arete i de la ligne fermee n
|
||||
ns2 = ns1+1;
|
||||
else
|
||||
//le 2-eme sommet de la derniere arete est le premier sommet de la ligne
|
||||
ns2 = ns0;
|
||||
|
||||
//l'arete precedente est dotee de sa suivante:celle cree ensuite
|
||||
//les 2 coordonnees du sommet ns2 de la ligne
|
||||
ns = ns1 - 1;
|
||||
mnpxyd[ns].x = uvslf[ns].x;
|
||||
mnpxyd[ns].y = uvslf[ns].y;
|
||||
mnpxyd[ns].z = areteideale_( mnpxyd[ns], direction );
|
||||
// cout << "Sommet " << ns << ": " << mnpxyd[ns].x
|
||||
// << " " << mnpxyd[ns].y << " longueur arete=" << mnpxyd[ns].z << endl;
|
||||
|
||||
//carre de la longueur de l'arete
|
||||
d = pow( uvslf[ns2-1].x - uvslf[ns1-1].x, 2)
|
||||
+ pow( uvslf[ns2-1].y - uvslf[ns1-1].y, 2);
|
||||
aremin = Min( aremin, d );
|
||||
aremax = Max( aremax, d );
|
||||
|
||||
//le numero n de la ligne du sommet et son numero ns1 dans la ligne
|
||||
mnslig[ns] = 1000000 * n + ns1-nudslf[n-1];
|
||||
|
||||
//ajout de l'arete dans la liste
|
||||
fasoar_( ns1, ns2, moins1, moins1, n,
|
||||
mosoar, mxsoar, n1soar, mnsoar,
|
||||
mnarst, noar, ierr );
|
||||
//pas de test sur ierr car pas de saturation possible a ce niveau
|
||||
|
||||
//chainage des aretes frontalieres en position 6 du tableau mnsoar
|
||||
//la nouvelle arete est la suivante de l'arete definie juste avant
|
||||
mnsoar[ mosoar * noar0 - mosoar + 5 ] = noar;
|
||||
noar0 = noar;
|
||||
}
|
||||
//attention: la derniere arete de la ligne fermee enveloppe
|
||||
// devient en fait la premiere arete de cette ligne
|
||||
// dans le chainage des aretes de la frontiere!
|
||||
}
|
||||
if( ierr != 0 ) goto ERREUR;
|
||||
|
||||
aremin = sqrt( aremin ); //longueur minimale d'une arete des lignes fermees
|
||||
aremax = sqrt( aremax ); //longueur maximale d'une arete
|
||||
|
||||
aretmx = Min( aretmx, aremax ); //pour homogeneiser
|
||||
cout << "nutysu=" << nutysu << " aretmx=" << aretmx
|
||||
<< " arete min=" << aremin << " arete max=" << aremax << endl;
|
||||
|
||||
//chainage des aretes frontalieres : la derniere arete frontaliere
|
||||
mnsoar[ mosoar * noar - mosoar + 5 ] = 0;
|
||||
|
||||
//tous les sommets et aretes frontaliers sont numerotes de 1 a nbarfr
|
||||
//reservation du tableau des numeros des 3 aretes de chaque triangle
|
||||
//mnartr( moartr, mxartr )
|
||||
//En nombre: Triangles = Aretes Internes + Aretes Frontalieres - Sommets + 1-Trous
|
||||
// 3Triangles = 2 Aretes internes + Aretes frontalieres
|
||||
// d'ou 3T/2 < AI + AF => T < 3T/2 - Sommets + 1-Trous
|
||||
//nombre de triangles < 2 ( nombre de sommets - 1 + nombre de trous )
|
||||
if( mnartr!=NULL ) delete [] mnartr;
|
||||
mxartr = 2 * ( mxsomm + mxtrou );
|
||||
mnartr = new Z[moartr*mxartr];
|
||||
if( mnartr==NULL ) goto ERREUR;
|
||||
|
||||
//Ajout des points internes
|
||||
ns1 = nudslf[ nblf ];
|
||||
for (i=0; i<nbpti; i++)
|
||||
{
|
||||
//les 2 coordonnees du point i de sommet nbs
|
||||
mnpxyd[ns1].x = uvpti[i].x;
|
||||
mnpxyd[ns1].y = uvpti[i].y;
|
||||
mnpxyd[ns1].z = areteideale_( mnpxyd[ns1], direction );
|
||||
//le numero i du point interne
|
||||
mnslig[ns1] = i+1;
|
||||
ns1++;
|
||||
}
|
||||
|
||||
//nombre de sommets de la frontiere et internes
|
||||
nbarpi = ns1;
|
||||
|
||||
// creation de l'arbre-4 des te (tableau letree)
|
||||
// ajout dans les te des sommets des lignes et des points internes imposes
|
||||
// =======================================================================
|
||||
// premiere estimation de mxtree
|
||||
mxtree = 2 * mxsomm;
|
||||
|
||||
NEWTREE: //en cas de saturation de l'un des tableaux, on boucle
|
||||
MESSAGE( "Debut triangulation avec mxsomm=" << mxsomm );
|
||||
if( mntree != NULL ) delete [] mntree;
|
||||
nbsomm = nbarpi;
|
||||
mntree = new Z[motree*(1+mxtree)];
|
||||
if( mntree==NULL ) goto ERREUR;
|
||||
|
||||
//initialisation du tableau letree et ajout dans letree des sommets 1 a nbsomm
|
||||
teajte_( mxsomm, nbsomm, mnpxyd, comxmi, aretmx, mxtree, mntree, ierr );
|
||||
comxmi[0].z=0;
|
||||
comxmi[1].z=0;
|
||||
|
||||
if( ierr == 51 )
|
||||
{
|
||||
//saturation de letree => sa taille est augmentee et relance
|
||||
mxtree = mxtree * 2;
|
||||
ierr = 0;
|
||||
MESSAGE( "Nouvelle valeur de mxtree=" << mxtree );
|
||||
goto NEWTREE;
|
||||
}
|
||||
|
||||
deltacpu_( d );
|
||||
tcpu += d;
|
||||
MESSAGE( "Temps de l'ajout arbre-4 des Triangles Equilateraux=" << d << " secondes" );
|
||||
if( ierr != 0 ) goto ERREUR;
|
||||
//ici le tableau mnpxyd contient les sommets des te et les points frontaliers et internes
|
||||
|
||||
// homogeneisation de l'arbre des te a un saut de taille au plus
|
||||
// prise en compte des tailles d'aretes souhaitees autour des sommets initiaux
|
||||
// ===========================================================================
|
||||
// reservation de la queue pour parcourir les te de l'arbre
|
||||
if( mnqueu != NULL ) delete [] mnqueu;
|
||||
mxqueu = mxtree;
|
||||
mnqueu = new Z[mxqueu];
|
||||
if( mnqueu==NULL) goto ERREUR;
|
||||
|
||||
tehote_( nutysu, nbarpi, mxsomm, nbsomm, mnpxyd,
|
||||
comxmi, aretmx,
|
||||
mntree, mxqueu, mnqueu,
|
||||
ierr );
|
||||
|
||||
deltacpu_( d );
|
||||
tcpu += d;
|
||||
cout << "Temps de l'adaptation et l'homogeneisation de l'arbre-4 des TE="
|
||||
<< d << " secondes" << endl;
|
||||
if( ierr != 0 )
|
||||
{
|
||||
//destruction du tableau auxiliaire et de l'arbre
|
||||
if( ierr == 51 )
|
||||
{
|
||||
//letree sature
|
||||
mxtree = mxtree * 2;
|
||||
MESSAGE( "Redemarrage avec la valeur de mxtree=" << mxtree );
|
||||
ierr = 0;
|
||||
goto NEWTREE;
|
||||
}
|
||||
else
|
||||
goto ERREUR;
|
||||
}
|
||||
|
||||
// trianguler les triangles equilateraux feuilles a partir de leurs 3 sommets
|
||||
// et des points de la frontiere, des points internes imposes interieurs
|
||||
// ==========================================================================
|
||||
tetrte_( comxmi, aretmx, nbarpi, mxsomm, mnpxyd,
|
||||
mxqueu, mnqueu, mntree, mosoar, mxsoar, n1soar, mnsoar,
|
||||
moartr, mxartr, n1artr, mnartr, mnarst,
|
||||
ierr );
|
||||
|
||||
// destruction de la queue et de l'arbre devenus inutiles
|
||||
delete [] mnqueu; mnqueu=NULL;
|
||||
delete [] mntree; mntree=NULL;
|
||||
|
||||
//Temps calcul
|
||||
deltacpu_( d );
|
||||
tcpu += d;
|
||||
MESSAGE( "Temps de la triangulation des TE=" << d << " secondes" );
|
||||
|
||||
// ierr =0 si pas d'erreur
|
||||
// =1 si le tableau mnsoar est sature
|
||||
// =2 si le tableau mnartr est sature
|
||||
// =3 si aucun des triangles ne contient l'un des points internes
|
||||
// =5 si saturation de la queue de parcours de l'arbre des te
|
||||
if( ierr != 0 ) goto ERREUR;
|
||||
|
||||
//qualites de la triangulation actuelle
|
||||
qualitetrte( mnpxyd, mosoar, mxsoar, mnsoar, moartr, mxartr, mnartr,
|
||||
nbt, quamoy, quamin );
|
||||
|
||||
// boucle sur les aretes internes (non sur une ligne de la frontiere)
|
||||
// avec echange des 2 diagonales afin de rendre la triangulation delaunay
|
||||
// ======================================================================
|
||||
// formation du chainage 6 des aretes internes a echanger eventuellement
|
||||
aisoar_( mosoar, mxsoar, mnsoar, na );
|
||||
tedela_( mnpxyd, mnarst,
|
||||
mosoar, mxsoar, n1soar, mnsoar, na,
|
||||
moartr, mxartr, n1artr, mnartr, n );
|
||||
|
||||
MESSAGE( "Nombre d'echanges des diagonales de 2 triangles=" << n );
|
||||
deltacpu_( d );
|
||||
tcpu += d;
|
||||
cout << "Temps de la triangulation Delaunay par echange des diagonales="
|
||||
<< d << " secondes" << endl;
|
||||
|
||||
//qualites de la triangulation actuelle
|
||||
qualitetrte( mnpxyd, mosoar, mxsoar, mnsoar, moartr, mxartr, mnartr,
|
||||
nbt, quamoy, quamin );
|
||||
|
||||
// detection des aretes frontalieres initiales perdues
|
||||
// triangulation frontale pour les restaurer
|
||||
// ===================================================
|
||||
mxarcf = mxsomm/5;
|
||||
if( mn1arcf != NULL ) delete [] mn1arcf;
|
||||
if( mnarcf != NULL ) delete [] mnarcf;
|
||||
if( mnarcf1 != NULL ) delete [] mnarcf1;
|
||||
if( mnarcf2 != NULL ) delete [] mnarcf2;
|
||||
mn1arcf = new Z[1+mxarcf];
|
||||
if( mn1arcf == NULL ) goto ERREUR;
|
||||
mnarcf = new Z[3*mxarcf];
|
||||
if( mnarcf == NULL ) goto ERREUR;
|
||||
mnarcf1 = new Z[mxarcf];
|
||||
if( mnarcf1 == NULL ) goto ERREUR;
|
||||
mnarcf2 = new Z[mxarcf];
|
||||
if( mnarcf2 == NULL ) goto ERREUR;
|
||||
|
||||
terefr_( nbarpi, mnpxyd,
|
||||
mosoar, mxsoar, n1soar, mnsoar,
|
||||
moartr, n1artr, mnartr, mnarst,
|
||||
mxarcf, mn1arcf, mnarcf, mnarcf1, mnarcf2,
|
||||
n, ierr );
|
||||
|
||||
MESSAGE( "Restauration de " << n << " aretes perdues de la frontiere" );
|
||||
deltacpu_( d );
|
||||
tcpu += d;
|
||||
cout << "Temps de la recuperation des aretes perdues de la frontiere="
|
||||
<< d << " secondes" << endl;
|
||||
|
||||
if( ierr != 0 ) goto ERREUR;
|
||||
|
||||
//qualites de la triangulation actuelle
|
||||
qualitetrte( mnpxyd, mosoar, mxsoar, mnsoar, moartr, mxartr, mnartr,
|
||||
nbt, quamoy, quamin );
|
||||
|
||||
// fin de la triangulation avec respect des aretes initiales frontalieres
|
||||
|
||||
// suppression des triangles externes a la surface
|
||||
// ===============================================
|
||||
// recherche du dernier triangle utilise
|
||||
mn = mxartr * moartr;
|
||||
for ( ndtri0=mxartr; ndtri0<=1; ndtri0-- )
|
||||
{
|
||||
mn -= moartr;
|
||||
if( mnartr[mn] != 0 ) break;
|
||||
}
|
||||
|
||||
if( mntrsu != NULL ) delete [] mntrsu;
|
||||
mntrsu = new Z[ndtri0];
|
||||
if( mntrsu == NULL ) goto ERREUR;
|
||||
|
||||
if( mnlftr != NULL ) delete [] mnlftr;
|
||||
mnlftr = new Z[nblf];
|
||||
if( mnlftr == NULL ) goto ERREUR;
|
||||
|
||||
for (n=0; n<nblf; n++) //numero de la ligne fermee de 1 a nblf
|
||||
mnlftr[n] = n+1;
|
||||
|
||||
tesuex_( nblf, mnlftr,
|
||||
ndtri0, nbsomm, mnpxyd, mnslig,
|
||||
mosoar, mxsoar, mnsoar,
|
||||
moartr, mxartr, n1artr, mnartr, mnarst,
|
||||
nbt, mntrsu, ierr );
|
||||
|
||||
delete [] mnlftr; mnlftr=NULL;
|
||||
delete [] mntrsu; mntrsu=NULL;
|
||||
|
||||
deltacpu_( d );
|
||||
tcpu += d;
|
||||
MESSAGE( "Temps de la suppression des triangles externes=" << d );
|
||||
if( ierr != 0 ) goto ERREUR;
|
||||
|
||||
//qualites de la triangulation actuelle
|
||||
qualitetrte( mnpxyd, mosoar, mxsoar, mnsoar, moartr, mxartr, mnartr,
|
||||
nbt, quamoy, quamin );
|
||||
|
||||
// amelioration de la qualite de la triangulation par
|
||||
// barycentrage des sommets internes a la triangulation
|
||||
// suppression des aretes trop longues ou trop courtes
|
||||
// modification de la topologie des groupes de triangles
|
||||
// mise en delaunay de la triangulation
|
||||
// =====================================================
|
||||
mnarcf3 = new Z[mxarcf];
|
||||
if( mnarcf3 == NULL ) goto ERREUR;
|
||||
|
||||
teamqt_( nutysu,
|
||||
mnarst, mosoar, mxsoar, n1soar, mnsoar,
|
||||
moartr, mxartr, n1artr, mnartr,
|
||||
mxarcf, mnarcf2, mnarcf3,
|
||||
mn1arcf, mnarcf, mnarcf1,
|
||||
comxmi, nbarpi, nbsomm, mxsomm, mnpxyd, mnslig,
|
||||
ierr );
|
||||
if( mn1arcf != NULL ) {delete [] mn1arcf; mn1arcf=NULL;}
|
||||
if( mnarcf != NULL ) {delete [] mnarcf; mnarcf =NULL;}
|
||||
if( mnarcf1 != NULL ) {delete [] mnarcf1; mnarcf1=NULL;}
|
||||
if( mnarcf2 != NULL ) {delete [] mnarcf2; mnarcf2=NULL;}
|
||||
if( mnarcf3 != NULL ) {delete [] mnarcf3; mnarcf3=NULL;}
|
||||
|
||||
deltacpu_( d );
|
||||
tcpu += d;
|
||||
MESSAGE( "Temps de l'amelioration de la qualite de la triangulation=" << d );
|
||||
if( ierr != 0 ) goto ERREUR;
|
||||
|
||||
//qualites de la triangulation finale
|
||||
qualitetrte( mnpxyd, mosoar, mxsoar, mnsoar, moartr, mxartr, mnartr,
|
||||
nbt, quamoy, quamin );
|
||||
|
||||
// renumerotation des sommets internes: mnarst(i)=numero final du sommet
|
||||
// ===================================
|
||||
for (i=0; i<=nbsomm; i++)
|
||||
mnarst[i] = 0;
|
||||
|
||||
for (nt=1; nt<=mxartr; nt++)
|
||||
{
|
||||
if( mnartr[nt*moartr-moartr] != 0 )
|
||||
{
|
||||
//le numero des 3 sommets du triangle nt
|
||||
nusotr_( nt, mosoar, mnsoar, moartr, mnartr, nosotr );
|
||||
//les 3 sommets du triangle sont actifs
|
||||
mnarst[ nosotr[0] ] = 1;
|
||||
mnarst[ nosotr[1] ] = 1;
|
||||
mnarst[ nosotr[2] ] = 1;
|
||||
}
|
||||
}
|
||||
nbst = 0;
|
||||
for (i=1; i<=nbsomm; i++)
|
||||
{
|
||||
if( mnarst[i] >0 )
|
||||
mnarst[i] = ++nbst;
|
||||
}
|
||||
|
||||
// generation du tableau uvst de la surface triangulee
|
||||
// ---------------------------------------------------
|
||||
if( uvst != NULL ) delete [] uvst;
|
||||
uvst = new R2[nbst];
|
||||
if( uvst == NULL ) goto ERREUR;
|
||||
|
||||
nbst=-1;
|
||||
for (i=0; i<nbsomm; i++ )
|
||||
{
|
||||
if( mnarst[i+1]>0 )
|
||||
{
|
||||
nbst++;
|
||||
uvst[nbst].x = mnpxyd[i].x;
|
||||
uvst[nbst].y = mnpxyd[i].y;
|
||||
|
||||
//si le sommet est un point ou appartient a une ligne
|
||||
//ses coordonnees initiales sont restaurees
|
||||
n = mnslig[i];
|
||||
if( n > 0 )
|
||||
{
|
||||
if( n >= 1000000 )
|
||||
{
|
||||
//sommet d'une ligne
|
||||
//retour aux coordonnees initiales dans uvslf
|
||||
l = n / 1000000;
|
||||
n = n - 1000000 * l + nudslf[l-1] - 1;
|
||||
uvst[nbst].x = uvslf[n].x;
|
||||
uvst[nbst].y = uvslf[n].y;
|
||||
}
|
||||
else
|
||||
{
|
||||
//point utilisateur n interne impose
|
||||
//retour aux coordonnees initiales dans uvpti
|
||||
uvst[nbst].x = uvpti[n-1].x;
|
||||
uvst[nbst].y = uvpti[n-1].y;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
nbst++;
|
||||
|
||||
// generation du tableau 'nsef' de la surface triangulee
|
||||
// -----------------------------------------------------
|
||||
// boucle sur les triangles occupes (internes et externes)
|
||||
if( nust != NULL ) delete [] nust;
|
||||
nust = new Z[4*nbt];
|
||||
if( nust == NULL ) goto ERREUR;
|
||||
nbt = 0;
|
||||
for (i=1; i<=mxartr; i++)
|
||||
{
|
||||
//le triangle i de mnartr
|
||||
if( mnartr[i*moartr-moartr] != 0 )
|
||||
{
|
||||
//le triangle i est interne => nosotr numero de ses 3 sommets
|
||||
nusotr_( i, mosoar, mnsoar, moartr, mnartr, nosotr );
|
||||
nust[nbt++] = mnarst[ nosotr[0] ];
|
||||
nust[nbt++] = mnarst[ nosotr[1] ];
|
||||
nust[nbt++] = mnarst[ nosotr[2] ];
|
||||
nust[nbt++] = 0;
|
||||
}
|
||||
}
|
||||
nbt /= 4; //le nombre final de triangles de la surface
|
||||
cout << "Nombre de sommets=" << nbst
|
||||
<< " Nombre de triangles=" << nbt << endl;
|
||||
|
||||
deltacpu_( d );
|
||||
tcpu += d;
|
||||
MESSAGE( "Temps total de la triangulation=" << tcpu << " secondes" );
|
||||
|
||||
// destruction des tableaux auxiliaires
|
||||
// ------------------------------------
|
||||
NETTOYAGE:
|
||||
if( mnarst != NULL ) delete [] mnarst;
|
||||
if( mnartr != NULL ) delete [] mnartr;
|
||||
if( mnslig != NULL ) delete [] mnslig;
|
||||
if( mnsoar != NULL ) delete [] mnsoar;
|
||||
if( mnpxyd != NULL ) delete [] mnpxyd;
|
||||
if( mndalf != NULL ) delete [] mndalf;
|
||||
if( mntree != NULL ) delete [] mntree;
|
||||
if( mnqueu != NULL ) delete [] mnqueu;
|
||||
if( mntrsu != NULL ) delete [] mntrsu;
|
||||
if( mnlftr != NULL ) delete [] mnlftr;
|
||||
if( mn1arcf != NULL ) delete [] mn1arcf;
|
||||
if( mnarcf != NULL ) delete [] mnarcf;
|
||||
if( mnarcf1 != NULL ) delete [] mnarcf1;
|
||||
if( mnarcf2 != NULL ) delete [] mnarcf2;
|
||||
if( mnarcf3 != NULL ) delete [] mnarcf3;
|
||||
return;
|
||||
|
||||
ERREUR:
|
||||
if( ierr == 51 || ierr == 52 )
|
||||
{
|
||||
//saturation des sommets => redepart avec 2 fois plus de sommets
|
||||
mxsomm = 2 * mxsomm;
|
||||
ierr = 0;
|
||||
goto NEWDEPART;
|
||||
}
|
||||
else
|
||||
{
|
||||
MESSAGE( "Triangulation non realisee " << ierr );
|
||||
if( ierr == 0 ) ierr=1;
|
||||
goto NETTOYAGE;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void qualitetrte( R3 *mnpxyd,
|
||||
Z & mosoar, Z & mxsoar, Z *mnsoar,
|
||||
Z & moartr, Z & mxartr, Z *mnartr,
|
||||
Z & nbtria, R & quamoy, R & quamin )
|
||||
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
// but : calculer la qualite moyenne et minimale de la triangulation
|
||||
// ----- actuelle definie par les tableaux mnsoar et mnartr
|
||||
// entrees:
|
||||
// --------
|
||||
// mnpxyd : tableau des coordonnees 2d des points
|
||||
// par point : x y distance_souhaitee
|
||||
// mosoar : nombre maximal d'entiers par arete et
|
||||
// indice dans mnsoar de l'arete suivante dans le hachage
|
||||
// mxsoar : nombre maximal d'aretes stockables dans le tableau mnsoar
|
||||
// attention: mxsoar>3*mxsomm obligatoire!
|
||||
// mnsoar : numero des 2 sommets , no ligne, 2 triangles de l'arete,
|
||||
// chainage des aretes frontalieres, chainage du hachage des aretes
|
||||
// hachage des aretes = mnsoar(1)+mnsoar(2)*2
|
||||
// avec mxsoar>=3*mxsomm
|
||||
// une arete i de mnsoar est vide <=> mnsoar(1,i)=0 et
|
||||
// mnsoar(2,arete vide)=l'arete vide qui precede
|
||||
// mnsoar(3,arete vide)=l'arete vide qui suit
|
||||
// moartr : nombre maximal d'entiers par arete du tableau mnartr
|
||||
// mxartr : nombre maximal de triangles declarables
|
||||
// mnartr : les 3 aretes des triangles +-arete1, +-arete2, +-arete3
|
||||
// arete1 = 0 si triangle vide => arete2 = triangle vide suivant
|
||||
// sorties:
|
||||
// --------
|
||||
// nbtria : nombre de triangles internes au domaine
|
||||
// quamoy : qualite moyenne des triangles actuels
|
||||
// quamin : qualite minimale des triangles actuels
|
||||
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
{
|
||||
R d, aire, qualite;
|
||||
Z nosotr[3], mn, nbtrianeg, nt;
|
||||
|
||||
aire = 0;
|
||||
quamoy = 0;
|
||||
quamin = 2.0;
|
||||
nbtria = 0;
|
||||
nbtrianeg = 0;
|
||||
|
||||
mn = -moartr;
|
||||
for ( nt=1; nt<=mxartr; nt++ )
|
||||
{
|
||||
mn += moartr;
|
||||
if( mnartr[mn]!=0 )
|
||||
{
|
||||
//un triangle occupe de plus
|
||||
nbtria++;
|
||||
|
||||
//le numero des 3 sommets du triangle nt
|
||||
nusotr_( nt, mosoar, mnsoar, moartr, mnartr, nosotr );
|
||||
|
||||
//la qualite du triangle ns1 ns2 ns3
|
||||
qutr2d_( mnpxyd[nosotr[0]-1], mnpxyd[nosotr[1]-1], mnpxyd[nosotr[2]-1],
|
||||
qualite );
|
||||
|
||||
//la qualite moyenne
|
||||
quamoy += qualite;
|
||||
|
||||
//la qualite minimale
|
||||
quamin = Min( quamin, qualite );
|
||||
|
||||
//aire signee du triangle nt
|
||||
d = surtd2_( mnpxyd[nosotr[0]-1], mnpxyd[nosotr[1]-1], mnpxyd[nosotr[2]-1] );
|
||||
if( d<0 )
|
||||
{
|
||||
//un triangle d'aire negative de plus
|
||||
nbtrianeg++;
|
||||
cout << "ATTENTION: le triangle " << nt << " de sommets:"
|
||||
<< nosotr[0] << " " << nosotr[1] << " " << nosotr[2]
|
||||
<< " a une aire " << d <<"<=0" << endl;
|
||||
}
|
||||
|
||||
//aire des triangles actuels
|
||||
aire += Abs(d);
|
||||
}
|
||||
}
|
||||
|
||||
//les affichages
|
||||
quamoy /= nbtria;
|
||||
cout << "Qualite moyenne=" << quamoy
|
||||
<< " Qualite minimale=" << quamin
|
||||
<< " des " << nbtria << " triangles de surface totale="
|
||||
<< aire << endl;
|
||||
|
||||
if( nbtrianeg>0 )
|
||||
MESSAGE( "ATTENTION: nombre de triangles d'aire negative=" << nbtrianeg );
|
||||
return;
|
||||
}
|
||||
229
src/MEFISTO2/aptrte.h
Executable file
229
src/MEFISTO2/aptrte.h
Executable file
@ -0,0 +1,229 @@
|
||||
#ifndef aptrte__h
|
||||
#define aptrte__h
|
||||
|
||||
#include <limits.h> // limites min max int long real ...
|
||||
#include <unistd.h> // gethostname, ...
|
||||
#include <stdio.h>
|
||||
#include <iostream.h> // pour cout cin ...
|
||||
#include <iomanip.h> // pour le format des io setw, stx, setfill, ...
|
||||
#include <string.h> // pour les fonctions sur les chaines de caracteres
|
||||
#include <ctype.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h> // pour les fonctions mathematiques
|
||||
#include <time.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/time.h>
|
||||
|
||||
void qualitetrte( R3 *mnpxyd,
|
||||
Z & mosoar, Z & mxsoar, Z *mnsoar,
|
||||
Z & moartr, Z & mxartr, Z *mnartr,
|
||||
Z & nbtria, R & quamoy, R & quamin );
|
||||
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
// but : calculer la qualite moyenne et minimale de la triangulation
|
||||
// ----- actuelle definie par les tableaux nosoar et noartr
|
||||
// entrees:
|
||||
// --------
|
||||
// mnpxyd : tableau des coordonnees 2d des points
|
||||
// par point : x y distance_souhaitee
|
||||
// mosoar : nombre maximal d'entiers par arete et
|
||||
// indice dans nosoar de l'arete suivante dans le hachage
|
||||
// mxsoar : nombre maximal d'aretes stockables dans le tableau nosoar
|
||||
// attention: mxsoar>3*mxsomm obligatoire!
|
||||
// nosoar : numero des 2 sommets , no ligne, 2 triangles de l'arete,
|
||||
// chainage des aretes frontalieres, chainage du hachage des aretes
|
||||
// hachage des aretes = nosoar(1)+nosoar(2)*2
|
||||
// avec mxsoar>=3*mxsomm
|
||||
// une arete i de nosoar est vide <=> nosoar(1,i)=0 et
|
||||
// nosoar(2,arete vide)=l'arete vide qui precede
|
||||
// nosoar(3,arete vide)=l'arete vide qui suit
|
||||
// moartr : nombre maximal d'entiers par arete du tableau noartr
|
||||
// mxartr : nombre maximal de triangles declarables
|
||||
// noartr : les 3 aretes des triangles +-arete1, +-arete2, +-arete3
|
||||
// arete1 = 0 si triangle vide => arete2 = triangle vide suivant
|
||||
// sorties:
|
||||
// --------
|
||||
// nbtria : nombre de triangles internes au domaine
|
||||
// quamoy : qualite moyenne des triangles actuels
|
||||
// quamin : qualite minimale des triangles actuels
|
||||
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
|
||||
void aptrte( Z nutysu, R aretmx,
|
||||
Z nblf, Z *nudslf, R2 *uvslf,
|
||||
Z nbpti, R2 *uvpti,
|
||||
Z & nbst, R2 * & uvst, Z & nbt, Z * & nust,
|
||||
Z & ierr );
|
||||
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
// but : appel de la triangulation par un arbre-4 recouvrant
|
||||
// ----- de triangles equilateraux
|
||||
// le contour du domaine plan est defini par des lignes fermees
|
||||
// la premiere ligne etant l'enveloppe de toutes les autres
|
||||
// la fonction areteideale_(s,d) donne la taille d'arete
|
||||
// au point s dans la direction d (direction inactive pour l'instant)
|
||||
// des lors toute arete issue d'un sommet s devrait avoir une longueur
|
||||
// comprise entre 0.65 areteideale_(s,d) et 1.3 areteideale_(s,d)
|
||||
//
|
||||
//Attention:
|
||||
// Les tableaux uvslf et uvpti sont supposes ne pas avoir de sommets identiques!
|
||||
// De meme, un sommet d'une ligne fermee ne peut appartenir a une autre ligne fermee
|
||||
//
|
||||
// entrees:
|
||||
// --------
|
||||
// nutysu : numero de traitement de areteideale_() selon le type de surface
|
||||
// 0 pas d'emploi de la fonction areteideale_() et aretmx est active
|
||||
// 1 il existe une fonction areteideale_(s,d)
|
||||
// dont seules les 2 premieres composantes de uv sont actives
|
||||
// ... autres options a definir ...
|
||||
// aretmx : longueur maximale des aretes de la future triangulation
|
||||
// nblf : nombre de lignes fermees de la surface
|
||||
// nudslf : numero du dernier sommet de chacune des nblf lignes fermees
|
||||
// nudslf(0)=0 pour permettre la difference sans test
|
||||
// Attention le dernier sommet de chaque ligne est raccorde au premier
|
||||
// tous les sommets et les points internes ont des coordonnees
|
||||
// UV differentes <=> Pas de point double!
|
||||
// uvslf : uv des nudslf(nblf) sommets des lignes fermees
|
||||
// nbpti : nombre de points internes futurs sommets de la triangulation
|
||||
// uvpti : uv des points internes futurs sommets de la triangulation
|
||||
//
|
||||
// sorties:
|
||||
// --------
|
||||
// nbst : nombre de sommets de la triangulation finale
|
||||
// uvst : coordonnees uv des nbst sommets de la triangulation
|
||||
// nbt : nombre de triangles de la triangulation finale
|
||||
// nust : 3 numeros dans uvst des sommets des nbt triangles
|
||||
// ierr : 0 si pas d'erreur
|
||||
// > 0 sinon
|
||||
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
// auteur : Alain Perronnet Analyse Numerique Paris UPMC decembre 2001
|
||||
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
extern "C" { void tempscpu_( double & tempsec ); }
|
||||
//Retourne le temps CPU utilise en secondes
|
||||
|
||||
extern "C" { void deltacpu_( R & dtcpu ); }
|
||||
//Retourne le temps CPU utilise en secondes depuis le precedent appel
|
||||
|
||||
//initialiser le tableau mnsoar pour le hachage des aretes
|
||||
extern "C" {void insoar_( Z & mxsomm, Z & mosoar, Z & mxsoar, Z & n1soar, Z * mnsoar );}
|
||||
|
||||
//mettre a zero les nb entiers de tab
|
||||
extern "C" {void azeroi_( Z & nb, Z * tab );}
|
||||
|
||||
extern "C" {void fasoar_( Z & ns1, Z & ns2, Z & nt1, Z & nt2, Z & nolign,
|
||||
Z & mosoar, Z & mxsoar, Z & n1soar, Z * mnsoar, Z * mnarst,
|
||||
Z & noar, Z & ierr );}
|
||||
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
// but : former l'arete de sommet ns1-ns2 dans le hachage du tableau
|
||||
// ----- nosoar des aretes de la triangulation
|
||||
// entrees:
|
||||
// --------
|
||||
// ns1 ns2: numero pxyd des 2 sommets de l'arete
|
||||
// nt1 : numero du triangle auquel appartient l'arete
|
||||
// nt1=-1 si numero inconnu
|
||||
// nt2 : numero de l'eventuel second triangle de l'arete si connu
|
||||
// nt2=-1 si numero inconnu
|
||||
// nolign : numero de la ligne fermee de l'arete
|
||||
// =0 si l'arete n'est une arete de ligne
|
||||
// ce numero est ajoute seulement si l'arete est creee
|
||||
// mosoar : nombre maximal d'entiers par arete du tableau nosoar
|
||||
// mxsoar : nombre maximal d'aretes stockables dans le tableau nosoar
|
||||
// modifies:
|
||||
// ---------
|
||||
// n1soar : numero de la premiere arete vide dans le tableau nosoar
|
||||
// une arete i de nosoar est vide <=> nosoar(1,i)=0
|
||||
// chainage des aretes vides amont et aval
|
||||
// l'arete vide qui precede=nosoar(4,i)
|
||||
// l'arete vide qui suit =nosoar(5,i)
|
||||
// nosoar : numero des 2 sommets, no ligne, 2 triangles de l'arete,
|
||||
// chainage momentan'e d'aretes, chainage du hachage des aretes
|
||||
// hachage des aretes = min( nosoar(1), nosoar(2) )
|
||||
// noarst : noarst(np) numero d'une arete du sommet np
|
||||
|
||||
// ierr : si < 0 en entree pas d'affichage en cas d'erreur du type
|
||||
// "arete appartenant a plus de 2 triangles et a creer!"
|
||||
// si >=0 en entree affichage de ce type d'erreur
|
||||
// sorties:
|
||||
// --------
|
||||
// noar : >0 numero de l'arete retrouvee ou ajoutee
|
||||
// ierr : =0 si pas d'erreur
|
||||
// =1 si le tableau nosoar est sature
|
||||
// =2 si arete a creer et appartenant a 2 triangles distincts
|
||||
// des triangles nt1 et nt2
|
||||
// =3 si arete appartenant a 2 triangles distincts
|
||||
// differents des triangles nt1 et nt2
|
||||
// =4 si arete appartenant a 2 triangles distincts
|
||||
// dont le second n'est pas le triangle nt2
|
||||
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
|
||||
//initialisation du tableau letree et ajout dans letree des sommets 1 a nbsomm
|
||||
extern "C" {void teajte_( Z & mxsomm, Z & nbsomm, R3 * mnpxyd, R3 * comxmi,
|
||||
R & aretmx, Z & mxtree, Z * letree,
|
||||
Z & ierr );}
|
||||
|
||||
|
||||
extern "C" {void tehote_( Z & nutysu, Z & nbarpi, Z & mxsomm, Z & nbsomm, R3 * mnpxyd,
|
||||
R3 * comxmi, R & aretmx,
|
||||
Z * letree, Z & mxqueu, Z * mnqueu,
|
||||
Z & ierr );}
|
||||
// homogeneisation de l'arbre des te a un saut de taille au plus
|
||||
// prise en compte des tailles d'aretes souhaitees autour des sommets initiaux
|
||||
|
||||
extern "C" {void tetrte_( R3 * comxmi, R & aretmx, Z & nbarpi, Z & mxsomm, R3 * mnpxyd,
|
||||
Z & mxqueu, Z * mnqueu, Z * mntree,
|
||||
Z & mosoar, Z & mxsoar, Z & n1soar, Z * mnsoar,
|
||||
Z & moartr, Z & mxartr, Z & n1artr, Z * mnartr, Z * mnarst,
|
||||
Z & ierr );}
|
||||
// trianguler les triangles equilateraux feuilles a partir de leurs 3 sommets
|
||||
// et des points de la frontiere, des points internes imposes interieurs
|
||||
|
||||
extern "C" {void aisoar_( Z & mosoar, Z & mxsoar, Z * mnsoar, Z & na );}
|
||||
// formation du chainage 6 des aretes internes a echanger eventuellement
|
||||
|
||||
extern "C" {void tedela_( R3 * mnpxyd, Z * mnarst,
|
||||
Z & mosoar, Z & mxsoar, Z & n1soar, Z * mnsoar, Z & na,
|
||||
Z & moartr, Z & mxartr, Z & n1artr, Z * mnartr, Z & n );}
|
||||
// boucle sur les aretes internes (non sur une ligne de la frontiere)
|
||||
// avec echange des 2 diagonales afin de rendre la triangulation delaunay
|
||||
|
||||
extern "C" {void terefr_( Z & nbarpi, R3 * mnpxyd,
|
||||
Z & mosoar, Z & mxsoar, Z & n1soar, Z * mnsoar,
|
||||
Z & moartr, Z & n1artr, Z * mnartr, Z * mnarst,
|
||||
Z & mxarcf, Z * mnarc1, Z * mnarc2,
|
||||
Z * mnarc3, Z * mnarc4,
|
||||
Z & n, Z & ierr );}
|
||||
// detection des aretes frontalieres initiales perdues
|
||||
// triangulation frontale pour les restaurer
|
||||
|
||||
extern "C" {void tesuex_( Z & nblf, Z * nulftr,
|
||||
Z & ndtri0, Z & nbsomm, R3 * mnpxyd, Z * mnslig,
|
||||
Z & mosoar, Z & mxsoar, Z * mnsoar,
|
||||
Z & moartr, Z & mxartr, Z & n1artr, Z * mnartr, Z * mnarst,
|
||||
Z & nbtria, Z * mntrsu, Z & ierr );}
|
||||
// suppression des triangles externes a la surface
|
||||
|
||||
extern "C" {void teamqt_( Z & nutysu,
|
||||
Z * mnarst, Z & mosoar, Z & mxsoar, Z & n1soar, Z * mnsoar,
|
||||
Z & moartr, Z & mxartr, Z & n1artr, Z * mnartr,
|
||||
Z & mxarcf, Z * mntrcf, Z * mnstbo,
|
||||
Z * n1arcf, Z * mnarcf, Z * mnarc1,
|
||||
R3 * comxmi, Z & nbarpi, Z & nbsomm, Z & mxsomm,
|
||||
R3 * mnpxyd, Z * mnslig,
|
||||
Z & ierr );}
|
||||
// amelioration de la qualite de la triangulation par
|
||||
// barycentrage des sommets internes a la triangulation
|
||||
// suppression des aretes trop longues ou trop courtes
|
||||
// modification de la topologie des groupes de triangles
|
||||
// mise en delaunay de la triangulation
|
||||
|
||||
extern "C" {void nusotr_( Z & nt, Z & mosoar, Z * mnsoar, Z & moartr, Z * mnartr,
|
||||
Z * nosotr );}
|
||||
//retrouver les numero des 3 sommets du triangle nt
|
||||
|
||||
extern "C" {void qutr2d_( R3 & p1, R3 & p2, R3 & p3, R & qualite );}
|
||||
//calculer la qualite d'un triangle de R2 de sommets p1, p2, p3
|
||||
|
||||
extern "C" { R surtd2_( R3 & p1, R3 & p2, R3 & p3 ); }
|
||||
//calcul de la surface d'un triangle defini par 3 points de r**2
|
||||
|
||||
#endif
|
||||
5
src/MEFISTO2/areteideale.f
Executable file
5
src/MEFISTO2/areteideale.f
Executable file
@ -0,0 +1,5 @@
|
||||
double precision function areteideale( xyz, direction )
|
||||
double precision xyz(3), direction(3)
|
||||
areteideale = 10
|
||||
return
|
||||
end
|
||||
8319
src/MEFISTO2/trte.f
Executable file
8319
src/MEFISTO2/trte.f
Executable file
File diff suppressed because it is too large
Load Diff
22
src/Makefile.in
Normal file
22
src/Makefile.in
Normal file
@ -0,0 +1,22 @@
|
||||
#==============================================================================
|
||||
# File : Makefile.in
|
||||
# Created : ven déc 7 13:32:20 CET 2001
|
||||
# Author : Paul RASCLE, EDF
|
||||
# Project : SALOME
|
||||
# Copyright : EDF 2001
|
||||
# $Header$
|
||||
#==============================================================================
|
||||
|
||||
# source path
|
||||
top_srcdir=@top_srcdir@
|
||||
top_builddir=..
|
||||
srcdir=@srcdir@
|
||||
VPATH=.:@srcdir@
|
||||
|
||||
@COMMENCE@
|
||||
|
||||
SUBDIRS = OBJECT SMDS SMESHDS Driver DriverMED DriverDAT DriverUNV MEFISTO2 \
|
||||
SMESH SMESH_I SMESHFiltersSelection SMESHGUI \
|
||||
SMESH_SWIG
|
||||
|
||||
@MODULE@
|
||||
33
src/OBJECT/Makefile.in
Normal file
33
src/OBJECT/Makefile.in
Normal file
@ -0,0 +1,33 @@
|
||||
# source path
|
||||
top_srcdir=@top_srcdir@
|
||||
top_builddir=../..
|
||||
srcdir=@srcdir@
|
||||
VPATH=.:@srcdir@:@top_srcdir@/idl:$(top_builddir)/idl:${KERNEL_ROOT_DIR}/idl/salome:${MED_ROOT_DIR}/idl/salome
|
||||
|
||||
|
||||
@COMMENCE@
|
||||
|
||||
EXPORT_HEADERS = SMESH_Actor.h \
|
||||
SMESH_Grid.h
|
||||
|
||||
|
||||
# Libraries targets
|
||||
|
||||
LIB = libSMESHObject.la
|
||||
LIB_SRC = SMESH_Actor.cxx \
|
||||
SMESH_Grid.cxx
|
||||
|
||||
LIB_CLIENT_IDL =
|
||||
|
||||
# Executables targets
|
||||
BIN =
|
||||
BIN_SRC =
|
||||
|
||||
CPPFLAGS+=$(QT_INCLUDES) $(PYTHON_INCLUDES) $(OCC_INCLUDES) $(VTK_INCLUDES) $(OGL_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
|
||||
LDFLAGS+=$(QT_MT_LIBS) $(OCC_LIBS) $(VTK_LIBS) $(OGL_LIBS) $(PYTHON_LIBS) -lSalomeObject -L${KERNEL_ROOT_DIR}/lib/salome
|
||||
|
||||
%_moc.cxx: %.h
|
||||
$(MOC) $< -o $@
|
||||
|
||||
|
||||
@CONCLUDE@
|
||||
598
src/OBJECT/SMESH_Actor.cxx
Normal file
598
src/OBJECT/SMESH_Actor.cxx
Normal file
@ -0,0 +1,598 @@
|
||||
using namespace std;
|
||||
// File : SMESH_Actor.cxx
|
||||
// Created : Mon May 13 22:31:18 2002
|
||||
// Author : Nicolas REJNERI
|
||||
|
||||
// Project : SALOME
|
||||
// Module : SMESH
|
||||
// Copyright : Open CASCADE 2002
|
||||
// $Header$
|
||||
|
||||
/*!
|
||||
\class SMESH_Actor SMESH_Actor.h
|
||||
\brief ...
|
||||
*/
|
||||
|
||||
#include "SMESH_Actor.h"
|
||||
#include "SMESH_Grid.h"
|
||||
#include "utilities.h"
|
||||
|
||||
// VTK Includes
|
||||
#include <vtkObjectFactory.h>
|
||||
#include <vtkMergePoints.h>
|
||||
#include <vtkDataSetMapper.h>
|
||||
#include <vtkFeatureEdges.h>
|
||||
#include <vtkGeometryFilter.h>
|
||||
|
||||
//-------------------------------------------------------------
|
||||
// Main methods
|
||||
//-------------------------------------------------------------
|
||||
|
||||
SMESH_Actor* SMESH_Actor::New()
|
||||
{
|
||||
// First try to create the object from the vtkObjectFactory
|
||||
vtkObject* ret = vtkObjectFactory::CreateInstance("SMESH_Actor");
|
||||
if(ret)
|
||||
{
|
||||
return (SMESH_Actor*)ret;
|
||||
}
|
||||
// If the factory was unable to create the object, then create it here.
|
||||
return new SMESH_Actor;
|
||||
}
|
||||
|
||||
|
||||
SMESH_Actor::SMESH_Actor()
|
||||
{
|
||||
this->Device = vtkActor::New();
|
||||
|
||||
this->EdgeDevice = vtkActor::New();
|
||||
EdgeDevice->VisibilityOff();
|
||||
EdgeDevice->PickableOff();
|
||||
|
||||
this->EdgeShrinkDevice = vtkActor::New();
|
||||
EdgeShrinkDevice->VisibilityOff();
|
||||
EdgeShrinkDevice->PickableOff();
|
||||
|
||||
myIO = NULL;
|
||||
myName = "";
|
||||
myDisplayMode = 0;
|
||||
|
||||
ishighlighted = false;
|
||||
ispreselected = false;
|
||||
|
||||
edgeColor.r = 0.;
|
||||
edgeColor.g = 0.;
|
||||
edgeColor.b = 0.;
|
||||
|
||||
edgeHighlightColor.r = 1.;
|
||||
edgeHighlightColor.g = 1.;
|
||||
edgeHighlightColor.b = 1.;
|
||||
|
||||
edgePreselectedColor.r = 0.;
|
||||
edgePreselectedColor.g = 1.;
|
||||
edgePreselectedColor.b = 1.;
|
||||
|
||||
actorColor.r = 1.;
|
||||
actorColor.g = 1.;
|
||||
actorColor.b = 0.;
|
||||
|
||||
actorHighlightColor.r = 1.;
|
||||
actorHighlightColor.g = 1.;
|
||||
actorHighlightColor.b = 1.;
|
||||
|
||||
actorPreselectedColor.r = 0.;
|
||||
actorPreselectedColor.g = 1.;
|
||||
actorPreselectedColor.b = 1.;
|
||||
|
||||
actorNodeColor.r = 1.;
|
||||
actorNodeColor.g = 1.;
|
||||
actorNodeColor.b = 0.;
|
||||
|
||||
actorNodeSize = 2 ;
|
||||
|
||||
}
|
||||
|
||||
SMESH_Actor::~SMESH_Actor()
|
||||
{
|
||||
this->EdgeDevice->Delete();
|
||||
this->EdgeShrinkDevice->Delete();
|
||||
}
|
||||
|
||||
void SMESH_Actor::setReader(vtkUnstructuredGridReader* r) {
|
||||
myReader=r;
|
||||
}
|
||||
|
||||
vtkUnstructuredGridReader* SMESH_Actor::getReader() {
|
||||
return (myReader);
|
||||
}
|
||||
|
||||
vtkMapper* SMESH_Actor::getMapper() {
|
||||
return (this->Mapper);
|
||||
}
|
||||
|
||||
void SMESH_Actor::ShallowCopy(vtkProp *prop)
|
||||
{
|
||||
SMESH_Actor *f = SMESH_Actor::SafeDownCast(prop);
|
||||
if ( f != NULL )
|
||||
{
|
||||
this->setName( f->getName() );
|
||||
if ( f->hasIO() )
|
||||
this->setIO( f->getIO() );
|
||||
this->setDisplayMode( f->getDisplayMode() );
|
||||
|
||||
// Copy devices
|
||||
vtkActor* tempDev = vtkActor::New();
|
||||
tempDev->ShallowCopy(f->Device);
|
||||
vtkProperty* prp = vtkProperty::New();
|
||||
prp->DeepCopy(f->Device->GetProperty());
|
||||
tempDev->SetProperty(prp);
|
||||
prp = vtkProperty::New();
|
||||
prp->DeepCopy(f->Device->GetBackfaceProperty());
|
||||
tempDev->SetBackfaceProperty(prp);
|
||||
this->Device = tempDev;
|
||||
|
||||
tempDev = vtkActor::New();
|
||||
tempDev->ShallowCopy(f->EdgeDevice);
|
||||
prp = vtkProperty::New();
|
||||
prp->DeepCopy(f->EdgeDevice->GetProperty());
|
||||
tempDev->SetProperty(prp);
|
||||
prp = vtkProperty::New();
|
||||
prp->DeepCopy(f->EdgeDevice->GetBackfaceProperty());
|
||||
tempDev->SetBackfaceProperty(prp);
|
||||
this->EdgeDevice = tempDev;
|
||||
|
||||
tempDev = vtkActor::New();
|
||||
tempDev->ShallowCopy(f->EdgeShrinkDevice);
|
||||
prp = vtkProperty::New();
|
||||
prp->DeepCopy(f->EdgeShrinkDevice->GetProperty());
|
||||
tempDev->SetProperty(prp);
|
||||
prp = vtkProperty::New();
|
||||
prp->DeepCopy(f->EdgeShrinkDevice->GetBackfaceProperty());
|
||||
tempDev->SetBackfaceProperty(prp);
|
||||
this->EdgeShrinkDevice = tempDev;
|
||||
|
||||
// Copy data source
|
||||
this->DataSource = f->DataSource;
|
||||
|
||||
this->myReader = f->myReader;
|
||||
}
|
||||
|
||||
// Now do superclass
|
||||
this->SALOME_Actor::ShallowCopy(prop);
|
||||
|
||||
// Here we need to modify default ShallowCopy() results
|
||||
// Create copies of properties
|
||||
if ( f != NULL ) {
|
||||
vtkProperty* prp = vtkProperty::New();
|
||||
prp->DeepCopy(f->GetProperty());
|
||||
this->SetProperty(prp);
|
||||
|
||||
prp = vtkProperty::New();
|
||||
prp->DeepCopy(f->GetBackfaceProperty());
|
||||
this->SetBackfaceProperty(prp);
|
||||
|
||||
// Copy the mapper
|
||||
vtkDataSetMapper* mpr = vtkDataSetMapper::New();
|
||||
mpr->ShallowCopy(f->GetMapper());
|
||||
mpr->SetInput(f->DataSource);
|
||||
this->SetMapper(mpr);
|
||||
}
|
||||
}
|
||||
|
||||
void SMESH_Actor::Render(vtkRenderer *ren, vtkMapper *Mapper )
|
||||
{
|
||||
if (this->Mapper == NULL) {
|
||||
MESSAGE ("No mapper for actor.")
|
||||
return;
|
||||
}
|
||||
|
||||
if ( myDisplayMode == 1 ) {
|
||||
EdgeDevice->VisibilityOn();
|
||||
EdgeShrinkDevice->VisibilityOff();
|
||||
} else if ( myDisplayMode == 2 ) {
|
||||
EdgeShrinkDevice->VisibilityOn();
|
||||
EdgeDevice->VisibilityOff();
|
||||
} else {
|
||||
EdgeShrinkDevice->VisibilityOff();
|
||||
EdgeDevice->VisibilityOff();
|
||||
}
|
||||
|
||||
|
||||
vtkMapper *bestMapper;
|
||||
bestMapper = this->Mapper;
|
||||
|
||||
/* render the property */
|
||||
if (!this->Property) {
|
||||
// force creation of a property
|
||||
this->GetProperty();
|
||||
}
|
||||
|
||||
if ( ishighlighted ) {
|
||||
if ( myDisplayMode == 1 ) {
|
||||
EdgeDevice->GetProperty()->SetColor(edgeHighlightColor.r,edgeHighlightColor.g,edgeHighlightColor.b);
|
||||
this->GetProperty()->SetColor(actorColor.r,actorColor.g,actorColor.b);
|
||||
} else if ( myDisplayMode == 2 ) {
|
||||
EdgeShrinkDevice->GetProperty()->SetColor(edgeHighlightColor.r,edgeHighlightColor.g,edgeHighlightColor.b);
|
||||
} else {
|
||||
this->GetProperty()->SetColor(actorHighlightColor.r,actorHighlightColor.g,actorHighlightColor.b);
|
||||
}
|
||||
} else if (! ispreselected ) {
|
||||
if ( myDisplayMode == 1 ) {
|
||||
EdgeDevice->GetProperty()->SetColor(edgeColor.r,edgeColor.g,edgeColor.b);
|
||||
this->GetProperty()->SetColor(actorColor.r,actorColor.g,actorColor.b);
|
||||
}
|
||||
else if ( myDisplayMode == 2 )
|
||||
EdgeShrinkDevice->GetProperty()->SetColor(edgeColor.r,edgeColor.g,edgeColor.b);
|
||||
else
|
||||
this->GetProperty()->SetColor(actorColor.r,actorColor.g,actorColor.b);
|
||||
}
|
||||
else {
|
||||
if ( myDisplayMode == 1 )
|
||||
EdgeDevice->GetProperty()->SetColor(edgePreselectedColor.r,edgePreselectedColor.g,edgePreselectedColor.b);
|
||||
else if ( myDisplayMode == 2 )
|
||||
EdgeShrinkDevice->GetProperty()->SetColor(edgePreselectedColor.r,edgePreselectedColor.g,edgePreselectedColor.b);
|
||||
else
|
||||
this->GetProperty()->SetColor(actorPreselectedColor.r,actorPreselectedColor.g,actorPreselectedColor.b);
|
||||
}
|
||||
|
||||
this->Property->Render(this, ren);
|
||||
if (this->BackfaceProperty) {
|
||||
this->BackfaceProperty->BackfaceRender(this, ren);
|
||||
this->Device->SetBackfaceProperty(this->BackfaceProperty);
|
||||
}
|
||||
this->Device->SetProperty(this->Property);
|
||||
|
||||
/* render the texture */
|
||||
if (this->Texture) {
|
||||
this->Texture->Render(ren);
|
||||
}
|
||||
|
||||
|
||||
// Store information on time it takes to render.
|
||||
// We might want to estimate time from the number of polygons in mapper.
|
||||
this->Device->Render(ren,bestMapper);
|
||||
this->EstimatedRenderTime = bestMapper->GetTimeToDraw();
|
||||
}
|
||||
|
||||
int SMESH_Actor::RenderOpaqueGeometry(vtkViewport *vp)
|
||||
{
|
||||
int renderedSomething = 0;
|
||||
vtkRenderer *ren = (vtkRenderer *)vp;
|
||||
|
||||
if ( ! this->Mapper ) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// make sure we have a property
|
||||
if (!this->Property) {
|
||||
// force creation of a property
|
||||
this->GetProperty();
|
||||
}
|
||||
|
||||
if ( ishighlighted ) {
|
||||
if ( myDisplayMode == 1 ) {
|
||||
EdgeDevice->GetProperty()->SetColor(edgeHighlightColor.r,edgeHighlightColor.g,edgeHighlightColor.b);
|
||||
} else if ( myDisplayMode == 2 ) {
|
||||
EdgeShrinkDevice->GetProperty()->SetColor(edgeHighlightColor.r,edgeHighlightColor.g,edgeHighlightColor.b);
|
||||
} else {
|
||||
this->GetProperty()->SetColor(actorHighlightColor.r,actorHighlightColor.g,actorHighlightColor.b);
|
||||
}
|
||||
} else if (! ispreselected ) {
|
||||
if ( myDisplayMode == 1 )
|
||||
EdgeDevice->GetProperty()->SetColor(edgeColor.r,edgeColor.g,edgeColor.b);
|
||||
else if ( myDisplayMode == 2 )
|
||||
EdgeShrinkDevice->GetProperty()->SetColor(edgeColor.r,edgeColor.g,edgeColor.b);
|
||||
else
|
||||
this->GetProperty()->SetColor(actorColor.r,actorColor.g,actorColor.b);
|
||||
}
|
||||
else {
|
||||
if ( myDisplayMode == 1 )
|
||||
EdgeDevice->GetProperty()->SetColor(edgePreselectedColor.r,edgePreselectedColor.g,edgePreselectedColor.b);
|
||||
else if ( myDisplayMode == 2 )
|
||||
EdgeShrinkDevice->GetProperty()->SetColor(edgePreselectedColor.r,edgePreselectedColor.g,edgePreselectedColor.b);
|
||||
else
|
||||
this->GetProperty()->SetColor(actorPreselectedColor.r,actorPreselectedColor.g,actorPreselectedColor.b);
|
||||
}
|
||||
|
||||
// is this actor opaque ?
|
||||
if (this->GetIsOpaque()) {
|
||||
this->Property->Render(this, ren);
|
||||
|
||||
// render the backface property
|
||||
if (this->BackfaceProperty) {
|
||||
this->BackfaceProperty->BackfaceRender(this, ren);
|
||||
}
|
||||
|
||||
// render the texture
|
||||
if (this->Texture) {
|
||||
this->Texture->Render(ren);
|
||||
}
|
||||
this->Render(ren,this->Mapper);
|
||||
|
||||
renderedSomething = 1;
|
||||
}
|
||||
|
||||
return renderedSomething;
|
||||
}
|
||||
|
||||
|
||||
void SMESH_Actor::SetColor(float r,float g,float b)
|
||||
{
|
||||
actorColor.r = r;
|
||||
actorColor.g = g;
|
||||
actorColor.b = b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::GetColor(float& r,float& g,float& b)
|
||||
{
|
||||
r = actorColor.r;
|
||||
g = actorColor.g;
|
||||
b = actorColor.b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::SetPreselectedColor(float r,float g,float b)
|
||||
{
|
||||
actorPreselectedColor.r = r;
|
||||
actorPreselectedColor.g = g;
|
||||
actorPreselectedColor.b = b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::GetPreselectedColor(float& r,float& g,float& b)
|
||||
{
|
||||
r = actorPreselectedColor.r;
|
||||
g = actorPreselectedColor.g;
|
||||
b = actorPreselectedColor.b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::SetHighlightColor(float r,float g,float b)
|
||||
{
|
||||
actorHighlightColor.r = r;
|
||||
actorHighlightColor.g = g;
|
||||
actorHighlightColor.b = b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::GetHighlightColor(float& r,float& g,float& b)
|
||||
{
|
||||
r = actorHighlightColor.r;
|
||||
g = actorHighlightColor.g;
|
||||
b = actorHighlightColor.b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::SetEdgeColor(float r,float g,float b)
|
||||
{
|
||||
edgeColor.r = r;
|
||||
edgeColor.g = g;
|
||||
edgeColor.b = b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::GetEdgeColor(float& r,float& g,float& b)
|
||||
{
|
||||
r = edgeColor.r;
|
||||
g = edgeColor.g;
|
||||
b = edgeColor.b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::SetEdgeHighlightColor(float r,float g,float b)
|
||||
{
|
||||
edgeHighlightColor.r = r;
|
||||
edgeHighlightColor.g = g;
|
||||
edgeHighlightColor.b = b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::GetEdgeHighlightColor(float& r,float& g,float& b)
|
||||
{
|
||||
r = edgeHighlightColor.r;
|
||||
g = edgeHighlightColor.g;
|
||||
b = edgeHighlightColor.b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::SetEdgePreselectedColor(float r,float g,float b)
|
||||
{
|
||||
edgePreselectedColor.r = r;
|
||||
edgePreselectedColor.g = g;
|
||||
edgePreselectedColor.b = b;
|
||||
}
|
||||
|
||||
void SMESH_Actor::GetEdgePreselectedColor(float& r,float& g,float& b)
|
||||
{
|
||||
r = edgePreselectedColor.r;
|
||||
g = edgePreselectedColor.g;
|
||||
b = edgePreselectedColor.b;
|
||||
}
|
||||
|
||||
|
||||
void SMESH_Actor::SetNodeColor(float r,float g,float b)
|
||||
{
|
||||
actorNodeColor.r = r ;
|
||||
actorNodeColor.g = g ;
|
||||
actorNodeColor.b = b ;
|
||||
}
|
||||
|
||||
void SMESH_Actor::GetNodeColor(float& r,float& g,float& b)
|
||||
{
|
||||
r = actorNodeColor.r ;
|
||||
g = actorNodeColor.g ;
|
||||
b = actorNodeColor.b ;
|
||||
}
|
||||
|
||||
void SMESH_Actor::SetNodeSize(int size)
|
||||
{
|
||||
actorNodeSize = size ;
|
||||
}
|
||||
|
||||
int SMESH_Actor::GetNodeSize()
|
||||
{
|
||||
return actorNodeSize ;
|
||||
}
|
||||
|
||||
|
||||
void SMESH_Actor::AddNode(int idSMESHDSnode,int idVTKnode)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
((SMESH_Grid*)DataSource)->AddNode(idSMESHDSnode, idVTKnode);
|
||||
} else
|
||||
MESSAGE("AddNode() method has been moved to SMESH_Grid class");
|
||||
}
|
||||
void SMESH_Actor::AddElement(int idSMESHDSelement, int idVTKelement)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
((SMESH_Grid*)DataSource)->AddElement(idSMESHDSelement, idVTKelement);
|
||||
} else
|
||||
MESSAGE("AddElement() method has been moved to SMESH_Grid class");
|
||||
}
|
||||
|
||||
void SMESH_Actor::SetIdsVTKNode(const TColStd_DataMapOfIntegerInteger& mapVTK)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
((SMESH_Grid*)DataSource)->SetIdsVTKNode(mapVTK);
|
||||
} else
|
||||
MESSAGE("SetIdsVTKNode() method has been moved to SMESH_Grid class");
|
||||
}
|
||||
void SMESH_Actor::SetIdsSMESHDSNode(const TColStd_DataMapOfIntegerInteger& mapSMESHDS)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
((SMESH_Grid*)DataSource)->SetIdsSMESHDSNode(mapSMESHDS);
|
||||
} else
|
||||
MESSAGE("SetIdsSMESHDSNode() method has been moved to SMESH_Grid class");
|
||||
}
|
||||
|
||||
void SMESH_Actor::SetIdsVTKElement(const TColStd_DataMapOfIntegerInteger& mapVTK)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
((SMESH_Grid*)DataSource)->SetIdsVTKElement(mapVTK);
|
||||
} else
|
||||
MESSAGE("SetIdsVTKElement() method has been moved to SMESH_Grid class");
|
||||
}
|
||||
void SMESH_Actor::SetIdsSMESHDSElement(const TColStd_DataMapOfIntegerInteger& mapSMESHDS)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
((SMESH_Grid*)DataSource)->SetIdsSMESHDSElement(mapSMESHDS);
|
||||
} else
|
||||
MESSAGE("SetIdsSMESHDSElement() method has been moved to SMESH_Grid class");
|
||||
}
|
||||
|
||||
int SMESH_Actor::GetIdVTKNode(int idSMESHDSnode)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
return ((SMESH_Grid*)DataSource)->GetIdVTKNode(idSMESHDSnode);
|
||||
} else {
|
||||
MESSAGE("GetIdVTKNode() method has been moved to SMESH_Grid class");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
int SMESH_Actor::GetIdVTKElement(int idSMESHDSelement)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
return ((SMESH_Grid*)DataSource)->GetIdVTKElement(idSMESHDSelement);
|
||||
} else {
|
||||
MESSAGE("GetIdVTKElement() method has been moved to SMESH_Grid class");
|
||||
return -1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int SMESH_Actor::GetIdSMESHDSNode(int idVTKnode)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
return ((SMESH_Grid*)DataSource)->GetIdSMESHDSNode(idVTKnode);
|
||||
} else {
|
||||
MESSAGE("GetIdSMESHDSNode() method has been moved to SMESH_Grid class");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int SMESH_Actor::GetIdSMESHDSElement(int idVTKelement)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
return ((SMESH_Grid*)DataSource)->GetIdSMESHDSElement(idVTKelement);
|
||||
} else {
|
||||
MESSAGE("AddNode() method has been moved to SMESH_Grid class");
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
void SMESH_Actor::ClearNode()
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
((SMESH_Grid*)DataSource)->ClearNode();
|
||||
} else
|
||||
MESSAGE("ClearNode() method has been moved to SMESH_Grid class");
|
||||
}
|
||||
|
||||
void SMESH_Actor::ClearElement()
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
((SMESH_Grid*)DataSource)->ClearElement();
|
||||
} else
|
||||
MESSAGE("ClearElement() method has been moved to SMESH_Grid class");
|
||||
}
|
||||
|
||||
void SMESH_Actor::RemoveNode(int id)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
((SMESH_Grid*)DataSource)->RemoveNode(id);
|
||||
} else
|
||||
MESSAGE("RemoveNode() method has been moved to SMESH_Grid class");
|
||||
}
|
||||
void SMESH_Actor::RemoveElement(int id)
|
||||
{
|
||||
if (DataSource->IsA("SMESH_Grid")) {
|
||||
((SMESH_Grid*)DataSource)->RemoveElement(id);
|
||||
} else
|
||||
MESSAGE("RemoveElement() method has been moved to SMESH_Grid class");
|
||||
}
|
||||
|
||||
void SMESH_Actor::setDisplayMode(int thenewmode) {
|
||||
myDisplayMode = thenewmode;
|
||||
if ( myDisplayMode == 1 ) {
|
||||
EdgeDevice->VisibilityOn();
|
||||
EdgeShrinkDevice->VisibilityOff();
|
||||
} else if ( myDisplayMode == 2 ) {
|
||||
EdgeDevice->VisibilityOff();
|
||||
EdgeShrinkDevice->VisibilityOn();
|
||||
} else {
|
||||
EdgeDevice->VisibilityOff();
|
||||
EdgeShrinkDevice->VisibilityOff();
|
||||
}
|
||||
}
|
||||
|
||||
float SMESH_Actor::GetShrinkFactor()
|
||||
{
|
||||
return myShrinkFactor;
|
||||
}
|
||||
|
||||
void SMESH_Actor::SetShrinkFactor(float value )
|
||||
{
|
||||
if ( value <= 0.1 )
|
||||
value = 0.8;
|
||||
|
||||
myShrinkFactor = value;
|
||||
}
|
||||
|
||||
void SMESH_Actor::GetChildActors(vtkActorCollection* actors)
|
||||
{
|
||||
actors->AddItem(EdgeDevice);
|
||||
actors->AddItem(EdgeShrinkDevice);
|
||||
}
|
||||
|
||||
void SMESH_Actor::SetVisibility(bool visibility)
|
||||
{
|
||||
if ( visibility ) {
|
||||
this->VisibilityOn();
|
||||
if ( myDisplayMode == 1 ) {
|
||||
EdgeDevice->VisibilityOn();
|
||||
EdgeShrinkDevice->VisibilityOff();
|
||||
} else if ( myDisplayMode == 2 ) {
|
||||
EdgeDevice->VisibilityOff();
|
||||
EdgeShrinkDevice->VisibilityOn();
|
||||
} else {
|
||||
EdgeDevice->VisibilityOff();
|
||||
EdgeShrinkDevice->VisibilityOff();
|
||||
}
|
||||
} else {
|
||||
this->VisibilityOff();
|
||||
EdgeDevice->VisibilityOff();
|
||||
EdgeShrinkDevice->VisibilityOff();
|
||||
}
|
||||
}
|
||||
|
||||
137
src/OBJECT/SMESH_Actor.h
Normal file
137
src/OBJECT/SMESH_Actor.h
Normal file
@ -0,0 +1,137 @@
|
||||
// File : SMESH_Actor.h
|
||||
// Created : Mon May 13 22:30:51 2002
|
||||
// Author : Nicolas REJNERI
|
||||
|
||||
// Project : SALOME
|
||||
// Module : SMESH
|
||||
// Copyright : Open CASCADE 2002
|
||||
// $Header$
|
||||
|
||||
|
||||
#ifndef SMESH_ACTOR_H
|
||||
#define SMESH_ACTOR_H
|
||||
|
||||
#include "SALOME_Actor.h"
|
||||
|
||||
// VTK Includes
|
||||
#include <vtkActor.h>
|
||||
#include <vtkDataSetMapper.h>
|
||||
#include <vtkUnstructuredGridReader.h>
|
||||
|
||||
// Open CASCADE Includes
|
||||
#include <TColStd_IndexedMapOfInteger.hxx>
|
||||
#include <TColStd_DataMapOfIntegerInteger.hxx>
|
||||
|
||||
typedef struct rgbStruct
|
||||
{
|
||||
float r;
|
||||
float g;
|
||||
float b;
|
||||
} RGBStruct;
|
||||
|
||||
class SMESH_Actor : public SALOME_Actor {
|
||||
|
||||
public:
|
||||
vtkTypeMacro(SMESH_Actor,SALOME_Actor);
|
||||
|
||||
static SMESH_Actor* New();
|
||||
|
||||
// Description:
|
||||
// This causes the actor to be rendered. It, in turn, will render the actor`s
|
||||
// property and then mapper.
|
||||
virtual void Render(vtkRenderer *, vtkMapper *);
|
||||
|
||||
// Description:
|
||||
// This method is used internally by the rendering process.
|
||||
// We overide the superclass method to properly set the estimated render time.
|
||||
int RenderOpaqueGeometry(vtkViewport *viewport);
|
||||
|
||||
void ShallowCopy(vtkProp *prop);
|
||||
|
||||
void setReader(vtkUnstructuredGridReader* r) ;
|
||||
vtkUnstructuredGridReader* getReader();
|
||||
|
||||
// Highlight
|
||||
virtual bool hasHighlight() { return true; }
|
||||
|
||||
vtkMapper* getMapper();
|
||||
|
||||
void setDisplayMode(int);
|
||||
|
||||
void SetColor(float r,float g,float b);
|
||||
void GetColor(float& r,float& g,float& b);
|
||||
void SetHighlightColor(float r,float g,float b);
|
||||
void GetHighlightColor(float& r,float& g,float& b);
|
||||
void SetPreselectedColor(float r,float g,float b);
|
||||
void GetPreselectedColor(float& r,float& g,float& b);
|
||||
|
||||
void SetEdgeColor(float r,float g,float b);
|
||||
void GetEdgeColor(float& r,float& g,float& b);
|
||||
void SetEdgeHighlightColor(float r,float g,float b);
|
||||
void GetEdgeHighlightColor(float& r,float& g,float& b);
|
||||
void SetEdgePreselectedColor(float r,float g,float b);
|
||||
void GetEdgePreselectedColor(float& r,float& g,float& b);
|
||||
|
||||
void SetNodeColor(float r,float g,float b);
|
||||
void GetNodeColor(float& r,float& g,float& b);
|
||||
|
||||
void SetNodeSize(int size) ;
|
||||
int GetNodeSize() ;
|
||||
|
||||
|
||||
void ClearNode();
|
||||
void ClearElement();
|
||||
|
||||
void RemoveNode(int idSMESHDSnode);
|
||||
void RemoveElement(int idSMESHDSelement);
|
||||
|
||||
void AddNode(int idSMESHDSnode, int idVTKnode);
|
||||
void AddElement(int idSMESHDSelement, int idVTKelement);
|
||||
|
||||
int GetIdVTKNode(int idSMESHDSnode);
|
||||
int GetIdVTKElement(int idSMESHDSelement);
|
||||
|
||||
int GetIdSMESHDSNode(int idVTKnode);
|
||||
int GetIdSMESHDSElement(int idVTKelement);
|
||||
|
||||
void SetIdsVTKNode(const TColStd_DataMapOfIntegerInteger& mapVTK);
|
||||
void SetIdsSMESHDSNode(const TColStd_DataMapOfIntegerInteger& mapSMESHDS);
|
||||
|
||||
void SetIdsVTKElement(const TColStd_DataMapOfIntegerInteger& mapVTK);
|
||||
void SetIdsSMESHDSElement(const TColStd_DataMapOfIntegerInteger& mapSMESHDS);
|
||||
|
||||
vtkDataSet* DataSource;
|
||||
vtkActor* EdgeDevice;
|
||||
vtkActor* EdgeShrinkDevice;
|
||||
|
||||
float GetShrinkFactor();
|
||||
void SetShrinkFactor(float value );
|
||||
|
||||
void GetChildActors(vtkActorCollection*);
|
||||
|
||||
void SetVisibility(bool visibility);
|
||||
|
||||
protected:
|
||||
|
||||
SMESH_Actor();
|
||||
~SMESH_Actor();
|
||||
SMESH_Actor(const SMESH_Actor&) {};
|
||||
void operator=(const SMESH_Actor&) {};
|
||||
|
||||
vtkUnstructuredGridReader* myReader;
|
||||
|
||||
float myShrinkFactor;
|
||||
|
||||
RGBStruct edgeColor;
|
||||
RGBStruct edgeHighlightColor;
|
||||
RGBStruct edgePreselectedColor;
|
||||
|
||||
RGBStruct actorColor;
|
||||
RGBStruct actorHighlightColor;
|
||||
RGBStruct actorPreselectedColor;
|
||||
|
||||
RGBStruct actorNodeColor; // LPN
|
||||
int actorNodeSize; // LPN
|
||||
|
||||
};
|
||||
#endif //SMESH_ACTOR_H
|
||||
141
src/OBJECT/SMESH_Grid.cxx
Normal file
141
src/OBJECT/SMESH_Grid.cxx
Normal file
@ -0,0 +1,141 @@
|
||||
using namespace std;
|
||||
// File: SMESH_Grid.cxx
|
||||
// Created: Fri Sep 27 15:47:42 2002
|
||||
// Author: Nicolas REJNERI
|
||||
|
||||
#include "SMESH_Grid.h"
|
||||
|
||||
#include "utilities.h"
|
||||
|
||||
// VTK Includes
|
||||
#include <vtkObjectFactory.h>
|
||||
|
||||
SMESH_Grid* SMESH_Grid::New()
|
||||
{
|
||||
// First try to create the object from the vtkObjectFactory
|
||||
vtkObject* ret = vtkObjectFactory::CreateInstance("SMESH_Grid");
|
||||
if(ret)
|
||||
{
|
||||
return (SMESH_Grid*)ret;
|
||||
}
|
||||
// If the factory was unable to create the object, then create it here.
|
||||
return new SMESH_Grid;
|
||||
}
|
||||
|
||||
void SMESH_Grid::AddNode(int idSMESHDSnode,int idVTKnode)
|
||||
{
|
||||
myMapNodeSMDStoVTK.Bind(idSMESHDSnode, idVTKnode);
|
||||
myMapNodeVTKtoSMDS.Bind(idVTKnode, idSMESHDSnode);
|
||||
}
|
||||
void SMESH_Grid::AddElement(int idSMESHDSelement, int idVTKelement)
|
||||
{
|
||||
myMapElementSMDStoVTK.Bind(idSMESHDSelement, idVTKelement);
|
||||
myMapElementVTKtoSMDS.Bind(idVTKelement, idSMESHDSelement);
|
||||
}
|
||||
|
||||
void SMESH_Grid::SetIdsVTKNode(const TColStd_DataMapOfIntegerInteger& mapVTK)
|
||||
{
|
||||
myMapNodeVTKtoSMDS = mapVTK;
|
||||
}
|
||||
void SMESH_Grid::SetIdsSMESHDSNode(const TColStd_DataMapOfIntegerInteger& mapSMESHDS)
|
||||
{
|
||||
myMapNodeSMDStoVTK = mapSMESHDS;
|
||||
}
|
||||
|
||||
void SMESH_Grid::SetIdsVTKElement(const TColStd_DataMapOfIntegerInteger& mapVTK)
|
||||
{
|
||||
myMapElementVTKtoSMDS = mapVTK;
|
||||
}
|
||||
void SMESH_Grid::SetIdsSMESHDSElement(const TColStd_DataMapOfIntegerInteger& mapSMESHDS)
|
||||
{
|
||||
myMapElementSMDStoVTK = mapSMESHDS;
|
||||
}
|
||||
|
||||
int SMESH_Grid::GetIdVTKNode(int idSMESHDSnode)
|
||||
{
|
||||
if ( myMapNodeSMDStoVTK.IsBound( idSMESHDSnode ) )
|
||||
return myMapNodeSMDStoVTK.Find(idSMESHDSnode);
|
||||
else {
|
||||
MESSAGE("GetIdVTKNode(): SMDS node not found: " << idSMESHDSnode);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
int SMESH_Grid::GetIdVTKElement(int idSMESHDSelement)
|
||||
{
|
||||
if ( myMapElementSMDStoVTK.IsBound( idSMESHDSelement ) )
|
||||
return myMapElementSMDStoVTK.Find(idSMESHDSelement);
|
||||
else {
|
||||
MESSAGE("GetIdVTKElement(): SMDS element not found: " << idSMESHDSelement);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int SMESH_Grid::GetIdSMESHDSNode(int idVTKnode)
|
||||
{
|
||||
if ( myMapNodeVTKtoSMDS.IsBound( idVTKnode ) )
|
||||
return myMapNodeVTKtoSMDS.Find(idVTKnode);
|
||||
else {
|
||||
MESSAGE("GetIdSMESHDSNode(): VTK node not found: " << idVTKnode);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
int SMESH_Grid::GetIdSMESHDSElement(int idVTKelement)
|
||||
{
|
||||
if ( myMapElementVTKtoSMDS.IsBound( idVTKelement ) )
|
||||
return myMapElementVTKtoSMDS.Find(idVTKelement);
|
||||
else {
|
||||
MESSAGE("GetIdSMESHDSElement(): VTK element not found: " << idVTKelement);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
void SMESH_Grid::ClearNode()
|
||||
{
|
||||
myMapNodeVTKtoSMDS.Clear();
|
||||
myMapNodeSMDStoVTK.Clear();
|
||||
}
|
||||
void SMESH_Grid::ClearElement()
|
||||
{
|
||||
myMapElementVTKtoSMDS.Clear();
|
||||
myMapElementSMDStoVTK.Clear();
|
||||
}
|
||||
|
||||
void SMESH_Grid::RemoveNode(int id)
|
||||
{
|
||||
if ( myMapNodeSMDStoVTK.IsBound( id ) ) {
|
||||
int idVTK = myMapNodeSMDStoVTK.Find(id);
|
||||
myMapNodeSMDStoVTK.UnBind(id);
|
||||
if ( myMapNodeVTKtoSMDS.IsBound( idVTK ) ) {
|
||||
myMapNodeVTKtoSMDS.UnBind(idVTK);
|
||||
}
|
||||
}
|
||||
}
|
||||
void SMESH_Grid::RemoveElement(int id)
|
||||
{
|
||||
if ( myMapElementSMDStoVTK.IsBound( id ) ) {
|
||||
int idVTK = myMapElementSMDStoVTK.Find(id);
|
||||
myMapElementSMDStoVTK.UnBind(id);
|
||||
if ( myMapElementVTKtoSMDS.IsBound( idVTK ) ) {
|
||||
myMapElementVTKtoSMDS.UnBind(idVTK);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void SMESH_Grid::DeepCopy(vtkDataObject *src)
|
||||
{
|
||||
SMESH_Grid* srcGrid = SMESH_Grid::SafeDownCast(src);
|
||||
|
||||
if (srcGrid != NULL) {
|
||||
CopyMaps(srcGrid);
|
||||
}
|
||||
|
||||
vtkUnstructuredGrid::DeepCopy(src);
|
||||
}
|
||||
|
||||
void SMESH_Grid::CopyMaps(SMESH_Grid *srcGrid)
|
||||
{
|
||||
this->myMapNodeVTKtoSMDS = srcGrid->myMapNodeVTKtoSMDS;
|
||||
this->myMapNodeSMDStoVTK = srcGrid->myMapNodeSMDStoVTK;
|
||||
this->myMapElementVTKtoSMDS = srcGrid->myMapElementVTKtoSMDS;
|
||||
this->myMapElementSMDStoVTK = srcGrid->myMapElementSMDStoVTK;
|
||||
}
|
||||
61
src/OBJECT/SMESH_Grid.h
Normal file
61
src/OBJECT/SMESH_Grid.h
Normal file
@ -0,0 +1,61 @@
|
||||
// File : SMESH_Grid.h
|
||||
// Created : Fri Sep 27 15:30:51 2002
|
||||
// Author : Nicolas REJNERI
|
||||
|
||||
// Project : SALOME
|
||||
// Module : SMESH
|
||||
// Copyright : Open CASCADE 2002
|
||||
// $Header$
|
||||
|
||||
|
||||
#ifndef SMESH_GRID_H
|
||||
#define SMESH_GRID_H
|
||||
|
||||
// VTK Includes
|
||||
#include <vtkUnstructuredGrid.h>
|
||||
|
||||
// Open CASCADE Includes
|
||||
#include <TColStd_DataMapOfIntegerInteger.hxx>
|
||||
|
||||
class SMESH_Grid : public vtkUnstructuredGrid {
|
||||
|
||||
public:
|
||||
vtkTypeMacro(SMESH_Grid, vtkUnstructuredGrid);
|
||||
|
||||
static SMESH_Grid* New();
|
||||
|
||||
void ClearNode();
|
||||
void ClearElement();
|
||||
|
||||
void RemoveNode(int idSMESHDSnode);
|
||||
void RemoveElement(int idSMESHDSelement);
|
||||
|
||||
void AddNode(int idSMESHDSnode, int idVTKnode);
|
||||
void AddElement(int idSMESHDSelement, int idVTKelement);
|
||||
|
||||
int GetIdVTKNode(int idSMESHDSnode);
|
||||
int GetIdVTKElement(int idSMESHDSelement);
|
||||
|
||||
int GetIdSMESHDSNode(int idVTKnode);
|
||||
int GetIdSMESHDSElement(int idVTKelement);
|
||||
|
||||
void SetIdsVTKNode(const TColStd_DataMapOfIntegerInteger& mapVTK);
|
||||
void SetIdsSMESHDSNode(const TColStd_DataMapOfIntegerInteger& mapSMESHDS);
|
||||
|
||||
void SetIdsVTKElement(const TColStd_DataMapOfIntegerInteger& mapVTK);
|
||||
void SetIdsSMESHDSElement(const TColStd_DataMapOfIntegerInteger& mapSMESHDS);
|
||||
|
||||
virtual void DeepCopy (vtkDataObject *src);
|
||||
void CopyMaps(SMESH_Grid *src);
|
||||
|
||||
protected:
|
||||
SMESH_Grid() : vtkUnstructuredGrid() {};
|
||||
|
||||
TColStd_DataMapOfIntegerInteger myMapNodeVTKtoSMDS;
|
||||
TColStd_DataMapOfIntegerInteger myMapNodeSMDStoVTK;
|
||||
|
||||
TColStd_DataMapOfIntegerInteger myMapElementVTKtoSMDS;
|
||||
TColStd_DataMapOfIntegerInteger myMapElementSMDStoVTK;
|
||||
};
|
||||
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDSControl_BoundaryEdges.hxx
Normal file
89
src/SMDS/Handle_SMDSControl_BoundaryEdges.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDSControl_BoundaryEdges_HeaderFile
|
||||
#define _Handle_SMDSControl_BoundaryEdges_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDSControl_MeshBoundary_HeaderFile
|
||||
#include "Handle_SMDSControl_MeshBoundary.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDSControl_MeshBoundary);
|
||||
class SMDSControl_BoundaryEdges;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDSControl_BoundaryEdges);
|
||||
|
||||
class Handle(SMDSControl_BoundaryEdges) : public Handle(SMDSControl_MeshBoundary) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDSControl_BoundaryEdges)():Handle(SMDSControl_MeshBoundary)() {}
|
||||
Handle(SMDSControl_BoundaryEdges)(const Handle(SMDSControl_BoundaryEdges)& aHandle) : Handle(SMDSControl_MeshBoundary)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryEdges)(const SMDSControl_BoundaryEdges* anItem) : Handle(SMDSControl_MeshBoundary)((SMDSControl_MeshBoundary *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryEdges)& operator=(const Handle(SMDSControl_BoundaryEdges)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryEdges)& operator=(const SMDSControl_BoundaryEdges* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDSControl_BoundaryEdges* operator->()
|
||||
{
|
||||
return (SMDSControl_BoundaryEdges *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDSControl_BoundaryEdges* operator->() const
|
||||
{
|
||||
return (SMDSControl_BoundaryEdges *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDSControl_BoundaryEdges)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDSControl_BoundaryEdges) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDSControl_BoundaryFaces.hxx
Normal file
89
src/SMDS/Handle_SMDSControl_BoundaryFaces.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDSControl_BoundaryFaces_HeaderFile
|
||||
#define _Handle_SMDSControl_BoundaryFaces_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDSControl_MeshBoundary_HeaderFile
|
||||
#include "Handle_SMDSControl_MeshBoundary.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDSControl_MeshBoundary);
|
||||
class SMDSControl_BoundaryFaces;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDSControl_BoundaryFaces);
|
||||
|
||||
class Handle(SMDSControl_BoundaryFaces) : public Handle(SMDSControl_MeshBoundary) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDSControl_BoundaryFaces)():Handle(SMDSControl_MeshBoundary)() {}
|
||||
Handle(SMDSControl_BoundaryFaces)(const Handle(SMDSControl_BoundaryFaces)& aHandle) : Handle(SMDSControl_MeshBoundary)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryFaces)(const SMDSControl_BoundaryFaces* anItem) : Handle(SMDSControl_MeshBoundary)((SMDSControl_MeshBoundary *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryFaces)& operator=(const Handle(SMDSControl_BoundaryFaces)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDSControl_BoundaryFaces)& operator=(const SMDSControl_BoundaryFaces* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDSControl_BoundaryFaces* operator->()
|
||||
{
|
||||
return (SMDSControl_BoundaryFaces *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDSControl_BoundaryFaces* operator->() const
|
||||
{
|
||||
return (SMDSControl_BoundaryFaces *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDSControl_BoundaryFaces)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDSControl_BoundaryFaces) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDSControl_MeshBoundary.hxx
Normal file
89
src/SMDS/Handle_SMDSControl_MeshBoundary.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDSControl_MeshBoundary_HeaderFile
|
||||
#define _Handle_SMDSControl_MeshBoundary_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_MMgt_TShared_HeaderFile
|
||||
#include <Handle_MMgt_TShared.hxx>
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(MMgt_TShared);
|
||||
class SMDSControl_MeshBoundary;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDSControl_MeshBoundary);
|
||||
|
||||
class Handle(SMDSControl_MeshBoundary) : public Handle(MMgt_TShared) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDSControl_MeshBoundary)():Handle(MMgt_TShared)() {}
|
||||
Handle(SMDSControl_MeshBoundary)(const Handle(SMDSControl_MeshBoundary)& aHandle) : Handle(MMgt_TShared)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_MeshBoundary)(const SMDSControl_MeshBoundary* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDSControl_MeshBoundary)& operator=(const Handle(SMDSControl_MeshBoundary)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDSControl_MeshBoundary)& operator=(const SMDSControl_MeshBoundary* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDSControl_MeshBoundary* operator->()
|
||||
{
|
||||
return (SMDSControl_MeshBoundary *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDSControl_MeshBoundary* operator->() const
|
||||
{
|
||||
return (SMDSControl_MeshBoundary *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDSControl_MeshBoundary)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDSControl_MeshBoundary) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
#define _Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_TCollection_MapNode_HeaderFile
|
||||
#include <Handle_TCollection_MapNode.hxx>
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(TCollection_MapNode);
|
||||
class SMDS_DataMapNodeOfDataMapOfIntegerMeshElement;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement);
|
||||
|
||||
class Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)(const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)(const SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& operator=(const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)& operator=(const SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* operator->()
|
||||
{
|
||||
return (SMDS_DataMapNodeOfDataMapOfIntegerMeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_DataMapNodeOfDataMapOfIntegerMeshElement* operator->() const
|
||||
{
|
||||
return (SMDS_DataMapNodeOfDataMapOfIntegerMeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_DataMapNodeOfDataMapOfIntegerMeshElement) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx
Normal file
89
src/SMDS/Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile
|
||||
#define _Handle_SMDS_DataMapNodeOfDataMapOfPntInteger_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_TCollection_MapNode_HeaderFile
|
||||
#include <Handle_TCollection_MapNode.hxx>
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(TCollection_MapNode);
|
||||
class SMDS_DataMapNodeOfDataMapOfPntInteger;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_DataMapNodeOfDataMapOfPntInteger);
|
||||
|
||||
class Handle(SMDS_DataMapNodeOfDataMapOfPntInteger) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)(const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)(const SMDS_DataMapNodeOfDataMapOfPntInteger* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& operator=(const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)& operator=(const SMDS_DataMapNodeOfDataMapOfPntInteger* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_DataMapNodeOfDataMapOfPntInteger* operator->()
|
||||
{
|
||||
return (SMDS_DataMapNodeOfDataMapOfPntInteger *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_DataMapNodeOfDataMapOfPntInteger* operator->() const
|
||||
{
|
||||
return (SMDS_DataMapNodeOfDataMapOfPntInteger *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_DataMapNodeOfDataMapOfPntInteger)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_DataMapNodeOfDataMapOfPntInteger) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_EdgePosition.hxx
Normal file
89
src/SMDS/Handle_SMDS_EdgePosition.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_EdgePosition_HeaderFile
|
||||
#define _Handle_SMDS_EdgePosition_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_Position_HeaderFile
|
||||
#include "Handle_SMDS_Position.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_Position);
|
||||
class SMDS_EdgePosition;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_EdgePosition);
|
||||
|
||||
class Handle(SMDS_EdgePosition) : public Handle(SMDS_Position) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_EdgePosition)():Handle(SMDS_Position)() {}
|
||||
Handle(SMDS_EdgePosition)(const Handle(SMDS_EdgePosition)& aHandle) : Handle(SMDS_Position)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_EdgePosition)(const SMDS_EdgePosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_EdgePosition)& operator=(const Handle(SMDS_EdgePosition)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_EdgePosition)& operator=(const SMDS_EdgePosition* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_EdgePosition* operator->()
|
||||
{
|
||||
return (SMDS_EdgePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_EdgePosition* operator->() const
|
||||
{
|
||||
return (SMDS_EdgePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_EdgePosition)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_EdgePosition) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_FacePosition.hxx
Normal file
89
src/SMDS/Handle_SMDS_FacePosition.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_FacePosition_HeaderFile
|
||||
#define _Handle_SMDS_FacePosition_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_Position_HeaderFile
|
||||
#include "Handle_SMDS_Position.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_Position);
|
||||
class SMDS_FacePosition;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_FacePosition);
|
||||
|
||||
class Handle(SMDS_FacePosition) : public Handle(SMDS_Position) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_FacePosition)():Handle(SMDS_Position)() {}
|
||||
Handle(SMDS_FacePosition)(const Handle(SMDS_FacePosition)& aHandle) : Handle(SMDS_Position)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_FacePosition)(const SMDS_FacePosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_FacePosition)& operator=(const Handle(SMDS_FacePosition)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_FacePosition)& operator=(const SMDS_FacePosition* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_FacePosition* operator->()
|
||||
{
|
||||
return (SMDS_FacePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_FacePosition* operator->() const
|
||||
{
|
||||
return (SMDS_FacePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_FacePosition)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_FacePosition) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_HSequenceOfMesh.hxx
Normal file
89
src/SMDS/Handle_SMDS_HSequenceOfMesh.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_HSequenceOfMesh_HeaderFile
|
||||
#define _Handle_SMDS_HSequenceOfMesh_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_MMgt_TShared_HeaderFile
|
||||
#include <Handle_MMgt_TShared.hxx>
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(MMgt_TShared);
|
||||
class SMDS_HSequenceOfMesh;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_HSequenceOfMesh);
|
||||
|
||||
class Handle(SMDS_HSequenceOfMesh) : public Handle(MMgt_TShared) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_HSequenceOfMesh)():Handle(MMgt_TShared)() {}
|
||||
Handle(SMDS_HSequenceOfMesh)(const Handle(SMDS_HSequenceOfMesh)& aHandle) : Handle(MMgt_TShared)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_HSequenceOfMesh)(const SMDS_HSequenceOfMesh* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_HSequenceOfMesh)& operator=(const Handle(SMDS_HSequenceOfMesh)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_HSequenceOfMesh)& operator=(const SMDS_HSequenceOfMesh* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_HSequenceOfMesh* operator->()
|
||||
{
|
||||
return (SMDS_HSequenceOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_HSequenceOfMesh* operator->() const
|
||||
{
|
||||
return (SMDS_HSequenceOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_HSequenceOfMesh)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_HSequenceOfMesh) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_ListNodeOfListOfMesh.hxx
Normal file
89
src/SMDS/Handle_SMDS_ListNodeOfListOfMesh.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile
|
||||
#define _Handle_SMDS_ListNodeOfListOfMesh_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_TCollection_MapNode_HeaderFile
|
||||
#include "Handle_TCollection_MapNode.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(TCollection_MapNode);
|
||||
class SMDS_ListNodeOfListOfMesh;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_ListNodeOfListOfMesh);
|
||||
|
||||
class Handle(SMDS_ListNodeOfListOfMesh) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_ListNodeOfListOfMesh)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_ListNodeOfListOfMesh)(const Handle(SMDS_ListNodeOfListOfMesh)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMesh)(const SMDS_ListNodeOfListOfMesh* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMesh)& operator=(const Handle(SMDS_ListNodeOfListOfMesh)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMesh)& operator=(const SMDS_ListNodeOfListOfMesh* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMesh* operator->()
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMesh* operator->() const
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_ListNodeOfListOfMesh)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_ListNodeOfListOfMesh) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_ListNodeOfListOfMeshElement.hxx
Normal file
89
src/SMDS/Handle_SMDS_ListNodeOfListOfMeshElement.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile
|
||||
#define _Handle_SMDS_ListNodeOfListOfMeshElement_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_TCollection_MapNode_HeaderFile
|
||||
#include <Handle_TCollection_MapNode.hxx>
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(TCollection_MapNode);
|
||||
class SMDS_ListNodeOfListOfMeshElement;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_ListNodeOfListOfMeshElement);
|
||||
|
||||
class Handle(SMDS_ListNodeOfListOfMeshElement) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement)(const Handle(SMDS_ListNodeOfListOfMeshElement)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement)(const SMDS_ListNodeOfListOfMeshElement* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement)& operator=(const Handle(SMDS_ListNodeOfListOfMeshElement)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshElement)& operator=(const SMDS_ListNodeOfListOfMeshElement* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMeshElement* operator->()
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMeshElement* operator->() const
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_ListNodeOfListOfMeshElement)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_ListNodeOfListOfMeshElement) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_ListNodeOfListOfMeshGroup.hxx
Normal file
89
src/SMDS/Handle_SMDS_ListNodeOfListOfMeshGroup.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile
|
||||
#define _Handle_SMDS_ListNodeOfListOfMeshGroup_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_TCollection_MapNode_HeaderFile
|
||||
#include <Handle_TCollection_MapNode.hxx>
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(TCollection_MapNode);
|
||||
class SMDS_ListNodeOfListOfMeshGroup;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_ListNodeOfListOfMeshGroup);
|
||||
|
||||
class Handle(SMDS_ListNodeOfListOfMeshGroup) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup)(const Handle(SMDS_ListNodeOfListOfMeshGroup)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup)(const SMDS_ListNodeOfListOfMeshGroup* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup)& operator=(const Handle(SMDS_ListNodeOfListOfMeshGroup)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_ListNodeOfListOfMeshGroup)& operator=(const SMDS_ListNodeOfListOfMeshGroup* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMeshGroup* operator->()
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMeshGroup *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_ListNodeOfListOfMeshGroup* operator->() const
|
||||
{
|
||||
return (SMDS_ListNodeOfListOfMeshGroup *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_ListNodeOfListOfMeshGroup)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_ListNodeOfListOfMeshGroup) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_Mesh.hxx
Normal file
89
src/SMDS/Handle_SMDS_Mesh.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_Mesh_HeaderFile
|
||||
#define _Handle_SMDS_Mesh_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshObject_HeaderFile
|
||||
#include "Handle_SMDS_MeshObject.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshObject);
|
||||
class SMDS_Mesh;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_Mesh);
|
||||
|
||||
class Handle(SMDS_Mesh) : public Handle(SMDS_MeshObject) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_Mesh)():Handle(SMDS_MeshObject)() {}
|
||||
Handle(SMDS_Mesh)(const Handle(SMDS_Mesh)& aHandle) : Handle(SMDS_MeshObject)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_Mesh)(const SMDS_Mesh* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_Mesh)& operator=(const Handle(SMDS_Mesh)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_Mesh)& operator=(const SMDS_Mesh* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_Mesh* operator->()
|
||||
{
|
||||
return (SMDS_Mesh *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_Mesh* operator->() const
|
||||
{
|
||||
return (SMDS_Mesh *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_Mesh)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_Mesh) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshEdge.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshEdge.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshEdge_HeaderFile
|
||||
#define _Handle_SMDS_MeshEdge_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshElement);
|
||||
class SMDS_MeshEdge;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshEdge);
|
||||
|
||||
class Handle(SMDS_MeshEdge) : public Handle(SMDS_MeshElement) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshEdge)():Handle(SMDS_MeshElement)() {}
|
||||
Handle(SMDS_MeshEdge)(const Handle(SMDS_MeshEdge)& aHandle) : Handle(SMDS_MeshElement)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshEdge)(const SMDS_MeshEdge* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshEdge)& operator=(const Handle(SMDS_MeshEdge)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshEdge)& operator=(const SMDS_MeshEdge* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshEdge* operator->()
|
||||
{
|
||||
return (SMDS_MeshEdge *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshEdge* operator->() const
|
||||
{
|
||||
return (SMDS_MeshEdge *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshEdge)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshEdge) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshElement.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshElement.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#define _Handle_SMDS_MeshElement_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshObject_HeaderFile
|
||||
#include "Handle_SMDS_MeshObject.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshObject);
|
||||
class SMDS_MeshElement;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshElement);
|
||||
|
||||
class Handle(SMDS_MeshElement) : public Handle(SMDS_MeshObject) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshElement)():Handle(SMDS_MeshObject)() {}
|
||||
Handle(SMDS_MeshElement)(const Handle(SMDS_MeshElement)& aHandle) : Handle(SMDS_MeshObject)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElement)(const SMDS_MeshElement* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElement)& operator=(const Handle(SMDS_MeshElement)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElement)& operator=(const SMDS_MeshElement* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshElement* operator->()
|
||||
{
|
||||
return (SMDS_MeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshElement* operator->() const
|
||||
{
|
||||
return (SMDS_MeshElement *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshElement)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshElement) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshElementIDFactory.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshElementIDFactory.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElementIDFactory_HeaderFile
|
||||
#define _Handle_SMDS_MeshElementIDFactory_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshIDFactory_HeaderFile
|
||||
#include "Handle_SMDS_MeshIDFactory.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshIDFactory);
|
||||
class SMDS_MeshElementIDFactory;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshElementIDFactory);
|
||||
|
||||
class Handle(SMDS_MeshElementIDFactory) : public Handle(SMDS_MeshIDFactory) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshElementIDFactory)():Handle(SMDS_MeshIDFactory)() {}
|
||||
Handle(SMDS_MeshElementIDFactory)(const Handle(SMDS_MeshElementIDFactory)& aHandle) : Handle(SMDS_MeshIDFactory)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElementIDFactory)(const SMDS_MeshElementIDFactory* anItem) : Handle(SMDS_MeshIDFactory)((SMDS_MeshIDFactory *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElementIDFactory)& operator=(const Handle(SMDS_MeshElementIDFactory)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshElementIDFactory)& operator=(const SMDS_MeshElementIDFactory* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshElementIDFactory* operator->()
|
||||
{
|
||||
return (SMDS_MeshElementIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshElementIDFactory* operator->() const
|
||||
{
|
||||
return (SMDS_MeshElementIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshElementIDFactory)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshElementIDFactory) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshFace.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshFace.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshFace_HeaderFile
|
||||
#define _Handle_SMDS_MeshFace_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshElement);
|
||||
class SMDS_MeshFace;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshFace);
|
||||
|
||||
class Handle(SMDS_MeshFace) : public Handle(SMDS_MeshElement) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshFace)():Handle(SMDS_MeshElement)() {}
|
||||
Handle(SMDS_MeshFace)(const Handle(SMDS_MeshFace)& aHandle) : Handle(SMDS_MeshElement)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshFace)(const SMDS_MeshFace* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshFace)& operator=(const Handle(SMDS_MeshFace)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshFace)& operator=(const SMDS_MeshFace* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshFace* operator->()
|
||||
{
|
||||
return (SMDS_MeshFace *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshFace* operator->() const
|
||||
{
|
||||
return (SMDS_MeshFace *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshFace)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshFace) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshGroup.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshGroup.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshGroup_HeaderFile
|
||||
#define _Handle_SMDS_MeshGroup_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshObject_HeaderFile
|
||||
#include "Handle_SMDS_MeshObject.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshObject);
|
||||
class SMDS_MeshGroup;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshGroup);
|
||||
|
||||
class Handle(SMDS_MeshGroup) : public Handle(SMDS_MeshObject) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshGroup)():Handle(SMDS_MeshObject)() {}
|
||||
Handle(SMDS_MeshGroup)(const Handle(SMDS_MeshGroup)& aHandle) : Handle(SMDS_MeshObject)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshGroup)(const SMDS_MeshGroup* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshGroup)& operator=(const Handle(SMDS_MeshGroup)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshGroup)& operator=(const SMDS_MeshGroup* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshGroup* operator->()
|
||||
{
|
||||
return (SMDS_MeshGroup *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshGroup* operator->() const
|
||||
{
|
||||
return (SMDS_MeshGroup *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshGroup)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshGroup) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshHexahedron.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshHexahedron.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshHexahedron_HeaderFile
|
||||
#define _Handle_SMDS_MeshHexahedron_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshVolume_HeaderFile
|
||||
#include "Handle_SMDS_MeshVolume.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshVolume);
|
||||
class SMDS_MeshHexahedron;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshHexahedron);
|
||||
|
||||
class Handle(SMDS_MeshHexahedron) : public Handle(SMDS_MeshVolume) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshHexahedron)():Handle(SMDS_MeshVolume)() {}
|
||||
Handle(SMDS_MeshHexahedron)(const Handle(SMDS_MeshHexahedron)& aHandle) : Handle(SMDS_MeshVolume)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshHexahedron)(const SMDS_MeshHexahedron* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshHexahedron)& operator=(const Handle(SMDS_MeshHexahedron)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshHexahedron)& operator=(const SMDS_MeshHexahedron* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshHexahedron* operator->()
|
||||
{
|
||||
return (SMDS_MeshHexahedron *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshHexahedron* operator->() const
|
||||
{
|
||||
return (SMDS_MeshHexahedron *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshHexahedron)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshHexahedron) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshIDFactory.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshIDFactory.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshIDFactory_HeaderFile
|
||||
#define _Handle_SMDS_MeshIDFactory_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshObject_HeaderFile
|
||||
#include "Handle_SMDS_MeshObject.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshObject);
|
||||
class SMDS_MeshIDFactory;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshIDFactory);
|
||||
|
||||
class Handle(SMDS_MeshIDFactory) : public Handle(SMDS_MeshObject) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshIDFactory)():Handle(SMDS_MeshObject)() {}
|
||||
Handle(SMDS_MeshIDFactory)(const Handle(SMDS_MeshIDFactory)& aHandle) : Handle(SMDS_MeshObject)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshIDFactory)(const SMDS_MeshIDFactory* anItem) : Handle(SMDS_MeshObject)((SMDS_MeshObject *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshIDFactory)& operator=(const Handle(SMDS_MeshIDFactory)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshIDFactory)& operator=(const SMDS_MeshIDFactory* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshIDFactory* operator->()
|
||||
{
|
||||
return (SMDS_MeshIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshIDFactory* operator->() const
|
||||
{
|
||||
return (SMDS_MeshIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshIDFactory)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshIDFactory) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshNode.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshNode.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshNode_HeaderFile
|
||||
#define _Handle_SMDS_MeshNode_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshElement);
|
||||
class SMDS_MeshNode;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshNode);
|
||||
|
||||
class Handle(SMDS_MeshNode) : public Handle(SMDS_MeshElement) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshNode)():Handle(SMDS_MeshElement)() {}
|
||||
Handle(SMDS_MeshNode)(const Handle(SMDS_MeshNode)& aHandle) : Handle(SMDS_MeshElement)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNode)(const SMDS_MeshNode* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNode)& operator=(const Handle(SMDS_MeshNode)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNode)& operator=(const SMDS_MeshNode* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshNode* operator->()
|
||||
{
|
||||
return (SMDS_MeshNode *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshNode* operator->() const
|
||||
{
|
||||
return (SMDS_MeshNode *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshNode)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshNode) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshNodeIDFactory.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshNodeIDFactory.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshNodeIDFactory_HeaderFile
|
||||
#define _Handle_SMDS_MeshNodeIDFactory_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshIDFactory_HeaderFile
|
||||
#include "Handle_SMDS_MeshIDFactory.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshIDFactory);
|
||||
class SMDS_MeshNodeIDFactory;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshNodeIDFactory);
|
||||
|
||||
class Handle(SMDS_MeshNodeIDFactory) : public Handle(SMDS_MeshIDFactory) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshNodeIDFactory)():Handle(SMDS_MeshIDFactory)() {}
|
||||
Handle(SMDS_MeshNodeIDFactory)(const Handle(SMDS_MeshNodeIDFactory)& aHandle) : Handle(SMDS_MeshIDFactory)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNodeIDFactory)(const SMDS_MeshNodeIDFactory* anItem) : Handle(SMDS_MeshIDFactory)((SMDS_MeshIDFactory *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNodeIDFactory)& operator=(const Handle(SMDS_MeshNodeIDFactory)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshNodeIDFactory)& operator=(const SMDS_MeshNodeIDFactory* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshNodeIDFactory* operator->()
|
||||
{
|
||||
return (SMDS_MeshNodeIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshNodeIDFactory* operator->() const
|
||||
{
|
||||
return (SMDS_MeshNodeIDFactory *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshNodeIDFactory)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshNodeIDFactory) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshObject.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshObject.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshObject_HeaderFile
|
||||
#define _Handle_SMDS_MeshObject_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_MMgt_TShared_HeaderFile
|
||||
#include <Handle_MMgt_TShared.hxx>
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(MMgt_TShared);
|
||||
class SMDS_MeshObject;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshObject);
|
||||
|
||||
class Handle(SMDS_MeshObject) : public Handle(MMgt_TShared) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshObject)():Handle(MMgt_TShared)() {}
|
||||
Handle(SMDS_MeshObject)(const Handle(SMDS_MeshObject)& aHandle) : Handle(MMgt_TShared)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshObject)(const SMDS_MeshObject* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshObject)& operator=(const Handle(SMDS_MeshObject)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshObject)& operator=(const SMDS_MeshObject* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshObject* operator->()
|
||||
{
|
||||
return (SMDS_MeshObject *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshObject* operator->() const
|
||||
{
|
||||
return (SMDS_MeshObject *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshObject)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshObject) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshPrism.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshPrism.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshPrism_HeaderFile
|
||||
#define _Handle_SMDS_MeshPrism_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshVolume_HeaderFile
|
||||
#include "Handle_SMDS_MeshVolume.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshVolume);
|
||||
class SMDS_MeshPrism;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshPrism);
|
||||
|
||||
class Handle(SMDS_MeshPrism) : public Handle(SMDS_MeshVolume) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshPrism)():Handle(SMDS_MeshVolume)() {}
|
||||
Handle(SMDS_MeshPrism)(const Handle(SMDS_MeshPrism)& aHandle) : Handle(SMDS_MeshVolume)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPrism)(const SMDS_MeshPrism* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPrism)& operator=(const Handle(SMDS_MeshPrism)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPrism)& operator=(const SMDS_MeshPrism* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshPrism* operator->()
|
||||
{
|
||||
return (SMDS_MeshPrism *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshPrism* operator->() const
|
||||
{
|
||||
return (SMDS_MeshPrism *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshPrism)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshPrism) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshPyramid.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshPyramid.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshPyramid_HeaderFile
|
||||
#define _Handle_SMDS_MeshPyramid_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshVolume_HeaderFile
|
||||
#include "Handle_SMDS_MeshVolume.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshVolume);
|
||||
class SMDS_MeshPyramid;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshPyramid);
|
||||
|
||||
class Handle(SMDS_MeshPyramid) : public Handle(SMDS_MeshVolume) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshPyramid)():Handle(SMDS_MeshVolume)() {}
|
||||
Handle(SMDS_MeshPyramid)(const Handle(SMDS_MeshPyramid)& aHandle) : Handle(SMDS_MeshVolume)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPyramid)(const SMDS_MeshPyramid* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPyramid)& operator=(const Handle(SMDS_MeshPyramid)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshPyramid)& operator=(const SMDS_MeshPyramid* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshPyramid* operator->()
|
||||
{
|
||||
return (SMDS_MeshPyramid *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshPyramid* operator->() const
|
||||
{
|
||||
return (SMDS_MeshPyramid *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshPyramid)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshPyramid) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshQuadrangle.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshQuadrangle.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshQuadrangle_HeaderFile
|
||||
#define _Handle_SMDS_MeshQuadrangle_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshFace_HeaderFile
|
||||
#include "Handle_SMDS_MeshFace.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshFace);
|
||||
class SMDS_MeshQuadrangle;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshQuadrangle);
|
||||
|
||||
class Handle(SMDS_MeshQuadrangle) : public Handle(SMDS_MeshFace) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshQuadrangle)():Handle(SMDS_MeshFace)() {}
|
||||
Handle(SMDS_MeshQuadrangle)(const Handle(SMDS_MeshQuadrangle)& aHandle) : Handle(SMDS_MeshFace)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshQuadrangle)(const SMDS_MeshQuadrangle* anItem) : Handle(SMDS_MeshFace)((SMDS_MeshFace *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshQuadrangle)& operator=(const Handle(SMDS_MeshQuadrangle)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshQuadrangle)& operator=(const SMDS_MeshQuadrangle* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshQuadrangle* operator->()
|
||||
{
|
||||
return (SMDS_MeshQuadrangle *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshQuadrangle* operator->() const
|
||||
{
|
||||
return (SMDS_MeshQuadrangle *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshQuadrangle)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshQuadrangle) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshTetrahedron.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshTetrahedron.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshTetrahedron_HeaderFile
|
||||
#define _Handle_SMDS_MeshTetrahedron_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshVolume_HeaderFile
|
||||
#include "Handle_SMDS_MeshVolume.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshVolume);
|
||||
class SMDS_MeshTetrahedron;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshTetrahedron);
|
||||
|
||||
class Handle(SMDS_MeshTetrahedron) : public Handle(SMDS_MeshVolume) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshTetrahedron)():Handle(SMDS_MeshVolume)() {}
|
||||
Handle(SMDS_MeshTetrahedron)(const Handle(SMDS_MeshTetrahedron)& aHandle) : Handle(SMDS_MeshVolume)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTetrahedron)(const SMDS_MeshTetrahedron* anItem) : Handle(SMDS_MeshVolume)((SMDS_MeshVolume *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTetrahedron)& operator=(const Handle(SMDS_MeshTetrahedron)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTetrahedron)& operator=(const SMDS_MeshTetrahedron* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshTetrahedron* operator->()
|
||||
{
|
||||
return (SMDS_MeshTetrahedron *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshTetrahedron* operator->() const
|
||||
{
|
||||
return (SMDS_MeshTetrahedron *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshTetrahedron)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshTetrahedron) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshTriangle.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshTriangle.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshTriangle_HeaderFile
|
||||
#define _Handle_SMDS_MeshTriangle_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshFace_HeaderFile
|
||||
#include "Handle_SMDS_MeshFace.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshFace);
|
||||
class SMDS_MeshTriangle;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshTriangle);
|
||||
|
||||
class Handle(SMDS_MeshTriangle) : public Handle(SMDS_MeshFace) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshTriangle)():Handle(SMDS_MeshFace)() {}
|
||||
Handle(SMDS_MeshTriangle)(const Handle(SMDS_MeshTriangle)& aHandle) : Handle(SMDS_MeshFace)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTriangle)(const SMDS_MeshTriangle* anItem) : Handle(SMDS_MeshFace)((SMDS_MeshFace *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTriangle)& operator=(const Handle(SMDS_MeshTriangle)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshTriangle)& operator=(const SMDS_MeshTriangle* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshTriangle* operator->()
|
||||
{
|
||||
return (SMDS_MeshTriangle *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshTriangle* operator->() const
|
||||
{
|
||||
return (SMDS_MeshTriangle *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshTriangle)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshTriangle) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_MeshVolume.hxx
Normal file
89
src/SMDS/Handle_SMDS_MeshVolume.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_MeshVolume_HeaderFile
|
||||
#define _Handle_SMDS_MeshVolume_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_MeshElement);
|
||||
class SMDS_MeshVolume;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_MeshVolume);
|
||||
|
||||
class Handle(SMDS_MeshVolume) : public Handle(SMDS_MeshElement) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_MeshVolume)():Handle(SMDS_MeshElement)() {}
|
||||
Handle(SMDS_MeshVolume)(const Handle(SMDS_MeshVolume)& aHandle) : Handle(SMDS_MeshElement)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshVolume)(const SMDS_MeshVolume* anItem) : Handle(SMDS_MeshElement)((SMDS_MeshElement *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshVolume)& operator=(const Handle(SMDS_MeshVolume)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_MeshVolume)& operator=(const SMDS_MeshVolume* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_MeshVolume* operator->()
|
||||
{
|
||||
return (SMDS_MeshVolume *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_MeshVolume* operator->() const
|
||||
{
|
||||
return (SMDS_MeshVolume *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_MeshVolume)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_MeshVolume) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_Position.hxx
Normal file
89
src/SMDS/Handle_SMDS_Position.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_Position_HeaderFile
|
||||
#define _Handle_SMDS_Position_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_MMgt_TShared_HeaderFile
|
||||
#include <Handle_MMgt_TShared.hxx>
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(MMgt_TShared);
|
||||
class SMDS_Position;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_Position);
|
||||
|
||||
class Handle(SMDS_Position) : public Handle(MMgt_TShared) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_Position)():Handle(MMgt_TShared)() {}
|
||||
Handle(SMDS_Position)(const Handle(SMDS_Position)& aHandle) : Handle(MMgt_TShared)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_Position)(const SMDS_Position* anItem) : Handle(MMgt_TShared)((MMgt_TShared *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_Position)& operator=(const Handle(SMDS_Position)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_Position)& operator=(const SMDS_Position* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_Position* operator->()
|
||||
{
|
||||
return (SMDS_Position *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_Position* operator->() const
|
||||
{
|
||||
return (SMDS_Position *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_Position)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_Position) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx
Normal file
89
src/SMDS/Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile
|
||||
#define _Handle_SMDS_SequenceNodeOfSequenceOfMesh_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_TCollection_SeqNode_HeaderFile
|
||||
#include <Handle_TCollection_SeqNode.hxx>
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(TCollection_SeqNode);
|
||||
class SMDS_SequenceNodeOfSequenceOfMesh;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_SequenceNodeOfSequenceOfMesh);
|
||||
|
||||
class Handle(SMDS_SequenceNodeOfSequenceOfMesh) : public Handle(TCollection_SeqNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_SequenceNodeOfSequenceOfMesh)():Handle(TCollection_SeqNode)() {}
|
||||
Handle(SMDS_SequenceNodeOfSequenceOfMesh)(const Handle(SMDS_SequenceNodeOfSequenceOfMesh)& aHandle) : Handle(TCollection_SeqNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_SequenceNodeOfSequenceOfMesh)(const SMDS_SequenceNodeOfSequenceOfMesh* anItem) : Handle(TCollection_SeqNode)((TCollection_SeqNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_SequenceNodeOfSequenceOfMesh)& operator=(const Handle(SMDS_SequenceNodeOfSequenceOfMesh)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_SequenceNodeOfSequenceOfMesh)& operator=(const SMDS_SequenceNodeOfSequenceOfMesh* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_SequenceNodeOfSequenceOfMesh* operator->()
|
||||
{
|
||||
return (SMDS_SequenceNodeOfSequenceOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_SequenceNodeOfSequenceOfMesh* operator->() const
|
||||
{
|
||||
return (SMDS_SequenceNodeOfSequenceOfMesh *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_SequenceNodeOfSequenceOfMesh)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_SequenceNodeOfSequenceOfMesh) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_SpacePosition.hxx
Normal file
89
src/SMDS/Handle_SMDS_SpacePosition.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_SpacePosition_HeaderFile
|
||||
#define _Handle_SMDS_SpacePosition_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_Position_HeaderFile
|
||||
#include "Handle_SMDS_Position.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_Position);
|
||||
class SMDS_SpacePosition;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_SpacePosition);
|
||||
|
||||
class Handle(SMDS_SpacePosition) : public Handle(SMDS_Position) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_SpacePosition)():Handle(SMDS_Position)() {}
|
||||
Handle(SMDS_SpacePosition)(const Handle(SMDS_SpacePosition)& aHandle) : Handle(SMDS_Position)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_SpacePosition)(const SMDS_SpacePosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_SpacePosition)& operator=(const Handle(SMDS_SpacePosition)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_SpacePosition)& operator=(const SMDS_SpacePosition* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_SpacePosition* operator->()
|
||||
{
|
||||
return (SMDS_SpacePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_SpacePosition* operator->() const
|
||||
{
|
||||
return (SMDS_SpacePosition *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_SpacePosition)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_SpacePosition) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_StdMapNodeOfExtendedMap.hxx
Normal file
89
src/SMDS/Handle_SMDS_StdMapNodeOfExtendedMap.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_StdMapNodeOfExtendedMap_HeaderFile
|
||||
#define _Handle_SMDS_StdMapNodeOfExtendedMap_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_TCollection_MapNode_HeaderFile
|
||||
#include "Handle_TCollection_MapNode.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(TCollection_MapNode);
|
||||
class SMDS_StdMapNodeOfExtendedMap;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_StdMapNodeOfExtendedMap);
|
||||
|
||||
class Handle(SMDS_StdMapNodeOfExtendedMap) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_StdMapNodeOfExtendedMap)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_StdMapNodeOfExtendedMap)(const Handle(SMDS_StdMapNodeOfExtendedMap)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedMap)(const SMDS_StdMapNodeOfExtendedMap* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedMap)& operator=(const Handle(SMDS_StdMapNodeOfExtendedMap)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedMap)& operator=(const SMDS_StdMapNodeOfExtendedMap* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_StdMapNodeOfExtendedMap* operator->()
|
||||
{
|
||||
return (SMDS_StdMapNodeOfExtendedMap *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_StdMapNodeOfExtendedMap* operator->() const
|
||||
{
|
||||
return (SMDS_StdMapNodeOfExtendedMap *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_StdMapNodeOfExtendedMap)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_StdMapNodeOfExtendedMap) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx
Normal file
89
src/SMDS/Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile
|
||||
#define _Handle_SMDS_StdMapNodeOfExtendedOrientedMap_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_TCollection_MapNode_HeaderFile
|
||||
#include "Handle_TCollection_MapNode.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(TCollection_MapNode);
|
||||
class SMDS_StdMapNodeOfExtendedOrientedMap;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_StdMapNodeOfExtendedOrientedMap);
|
||||
|
||||
class Handle(SMDS_StdMapNodeOfExtendedOrientedMap) : public Handle(TCollection_MapNode) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_StdMapNodeOfExtendedOrientedMap)():Handle(TCollection_MapNode)() {}
|
||||
Handle(SMDS_StdMapNodeOfExtendedOrientedMap)(const Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& aHandle) : Handle(TCollection_MapNode)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedOrientedMap)(const SMDS_StdMapNodeOfExtendedOrientedMap* anItem) : Handle(TCollection_MapNode)((TCollection_MapNode *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& operator=(const Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_StdMapNodeOfExtendedOrientedMap)& operator=(const SMDS_StdMapNodeOfExtendedOrientedMap* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_StdMapNodeOfExtendedOrientedMap* operator->()
|
||||
{
|
||||
return (SMDS_StdMapNodeOfExtendedOrientedMap *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_StdMapNodeOfExtendedOrientedMap* operator->() const
|
||||
{
|
||||
return (SMDS_StdMapNodeOfExtendedOrientedMap *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_StdMapNodeOfExtendedOrientedMap)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_StdMapNodeOfExtendedOrientedMap) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
89
src/SMDS/Handle_SMDS_VertexPosition.hxx
Normal file
89
src/SMDS/Handle_SMDS_VertexPosition.hxx
Normal file
@ -0,0 +1,89 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _Handle_SMDS_VertexPosition_HeaderFile
|
||||
#define _Handle_SMDS_VertexPosition_HeaderFile
|
||||
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
|
||||
#ifndef _Handle_SMDS_Position_HeaderFile
|
||||
#include "Handle_SMDS_Position.hxx"
|
||||
#endif
|
||||
|
||||
class Standard_Transient;
|
||||
class Handle_Standard_Type;
|
||||
class Handle(SMDS_Position);
|
||||
class SMDS_VertexPosition;
|
||||
Standard_EXPORT Handle_Standard_Type& STANDARD_TYPE(SMDS_VertexPosition);
|
||||
|
||||
class Handle(SMDS_VertexPosition) : public Handle(SMDS_Position) {
|
||||
public:
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
Handle(SMDS_VertexPosition)():Handle(SMDS_Position)() {}
|
||||
Handle(SMDS_VertexPosition)(const Handle(SMDS_VertexPosition)& aHandle) : Handle(SMDS_Position)(aHandle)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_VertexPosition)(const SMDS_VertexPosition* anItem) : Handle(SMDS_Position)((SMDS_Position *)anItem)
|
||||
{
|
||||
}
|
||||
|
||||
Handle(SMDS_VertexPosition)& operator=(const Handle(SMDS_VertexPosition)& aHandle)
|
||||
{
|
||||
Assign(aHandle.Access());
|
||||
return *this;
|
||||
}
|
||||
|
||||
Handle(SMDS_VertexPosition)& operator=(const SMDS_VertexPosition* anItem)
|
||||
{
|
||||
Assign((Standard_Transient *)anItem);
|
||||
return *this;
|
||||
}
|
||||
|
||||
SMDS_VertexPosition* operator->()
|
||||
{
|
||||
return (SMDS_VertexPosition *)ControlAccess();
|
||||
}
|
||||
|
||||
SMDS_VertexPosition* operator->() const
|
||||
{
|
||||
return (SMDS_VertexPosition *)ControlAccess();
|
||||
}
|
||||
|
||||
Standard_EXPORT ~Handle(SMDS_VertexPosition)();
|
||||
|
||||
Standard_EXPORT static const Handle(SMDS_VertexPosition) DownCast(const Handle(Standard_Transient)& AnObject);
|
||||
};
|
||||
#endif
|
||||
263
src/SMDS/Makefile.in
Normal file
263
src/SMDS/Makefile.in
Normal file
@ -0,0 +1,263 @@
|
||||
# -* Makefile *-
|
||||
#
|
||||
# Author : Patrick GOLDBRONN (CEA)
|
||||
# Date : 29/06/2001
|
||||
#
|
||||
|
||||
# source path
|
||||
top_srcdir=@top_srcdir@
|
||||
top_builddir=../..
|
||||
srcdir=@srcdir@
|
||||
VPATH=.:@srcdir@:@top_srcdir@/idl
|
||||
|
||||
|
||||
@COMMENCE@
|
||||
|
||||
# Libraries targets
|
||||
|
||||
LIB = libSMDS.la
|
||||
LIB_SRC = SMDS_BasicMap.lxx \
|
||||
SMDS_BasicMapIterator.lxx \
|
||||
SMDS_EdgePosition.cxx \
|
||||
SMDS_EdgePosition.lxx \
|
||||
SMDS_FacePosition.cxx \
|
||||
SMDS_FacePosition.lxx \
|
||||
SMDS_Map.gxx \
|
||||
SMDS_MapHasher.gxx \
|
||||
SMDS_MapIterator.gxx \
|
||||
SMDS_MapOfMeshElement.cxx \
|
||||
SMDS_MapOfMeshElement.lxx \
|
||||
SMDS_MapOfMeshOrientedElement.cxx \
|
||||
SMDS_MapOfMeshOrientedElement.lxx \
|
||||
SMDS_Mesh.cxx \
|
||||
SMDS_Mesh.lxx \
|
||||
SMDS_MeshEdge.cxx \
|
||||
SMDS_MeshEdge.lxx \
|
||||
SMDS_MeshEdgesIterator.cxx \
|
||||
SMDS_MeshElement.cxx \
|
||||
SMDS_MeshElement.lxx \
|
||||
SMDS_MeshElementIDFactory.cxx \
|
||||
SMDS_MeshElementIDFactory.lxx \
|
||||
SMDS_MeshElementMapHasher.cxx \
|
||||
SMDS_MeshElementMapHasher.lxx \
|
||||
SMDS_MeshElementsIterator.cxx \
|
||||
SMDS_MeshElementsIterator.lxx \
|
||||
SMDS_MeshFace.cxx \
|
||||
SMDS_MeshFace.lxx \
|
||||
SMDS_MeshFacesIterator.cxx \
|
||||
SMDS_MeshHexahedron.cxx \
|
||||
SMDS_MeshHexahedron.lxx \
|
||||
SMDS_MeshIDFactory.cxx \
|
||||
SMDS_MeshIDFactory.lxx \
|
||||
SMDS_MeshNode.cxx \
|
||||
SMDS_MeshNode.lxx \
|
||||
SMDS_MeshNodeIDFactory.cxx \
|
||||
SMDS_MeshNodeIDFactory.lxx \
|
||||
SMDS_MeshNodesIterator.cxx \
|
||||
SMDS_MeshObject.cxx \
|
||||
SMDS_MeshOrientedElementMapHasher.cxx \
|
||||
SMDS_MeshOrientedElementMapHasher.lxx \
|
||||
SMDS_MeshPrism.cxx \
|
||||
SMDS_MeshPrism.lxx \
|
||||
SMDS_MeshPyramid.cxx \
|
||||
SMDS_MeshPyramid.lxx \
|
||||
SMDS_MeshQuadrangle.cxx \
|
||||
SMDS_MeshQuadrangle.lxx \
|
||||
SMDS_MeshTetrahedron.cxx \
|
||||
SMDS_MeshTetrahedron.lxx \
|
||||
SMDS_MeshTriangle.cxx \
|
||||
SMDS_MeshTriangle.lxx \
|
||||
SMDS_MeshVolume.cxx \
|
||||
SMDS_MeshVolume.lxx \
|
||||
SMDS_MeshVolumesIterator.cxx \
|
||||
SMDS_PntHasher.cxx \
|
||||
SMDS_PntHasher.lxx \
|
||||
SMDS_Position.cxx \
|
||||
SMDS_Position.lxx \
|
||||
SMDS_SpacePosition.cxx \
|
||||
SMDS_SpacePosition.lxx \
|
||||
SMDS_StdMapNode.gxx \
|
||||
SMDS_StdMapNode.lxx \
|
||||
SMDS_VertexPosition.cxx \
|
||||
SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx \
|
||||
SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx \
|
||||
SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx \
|
||||
SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx \
|
||||
SMDS_DataMapOfIntegerMeshElement_0.cxx \
|
||||
SMDS_DataMapOfPntInteger_0.cxx \
|
||||
SMDS_ExtendedMap_0.cxx \
|
||||
SMDS_ExtendedOrientedMap_0.cxx \
|
||||
SMDS_ListIteratorOfListOfMeshElement_0.cxx \
|
||||
SMDS_ListIteratorOfListOfMesh_0.cxx \
|
||||
SMDS_ListNodeOfListOfMeshElement_0.cxx \
|
||||
SMDS_ListNodeOfListOfMesh_0.cxx \
|
||||
SMDS_ListOfMeshElement_0.cxx \
|
||||
SMDS_ListOfMesh_0.cxx \
|
||||
SMDS_MapIteratorOfExtendedMap_0.cxx \
|
||||
SMDS_MapIteratorOfExtendedOrientedMap_0.cxx \
|
||||
SMDS_StdMapNodeOfExtendedMap_0.cxx \
|
||||
SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx \
|
||||
SMDSControl.cxx \
|
||||
SMDSControl_BoundaryFaces.cxx \
|
||||
SMDSControl_BoundaryEdges.cxx \
|
||||
SMDSControl_MeshBoundary.cxx \
|
||||
SMDS_ListIteratorOfListOfMeshGroup_0.cxx \
|
||||
SMDS_ListOfMeshGroup_0.cxx \
|
||||
SMDS_ListNodeOfListOfMeshGroup_0.cxx \
|
||||
SMDS_MeshGroup.cxx \
|
||||
SMDSEdit_Transform.cxx \
|
||||
SMDS_HSequenceOfMesh_0.cxx \
|
||||
SMDS_SequenceNodeOfSequenceOfMesh_0.cxx \
|
||||
SMDS_SequenceOfMesh_0.cxx
|
||||
|
||||
|
||||
LIB_CLIENT_IDL =
|
||||
LIB_SERVER_IDL =
|
||||
|
||||
# Executables targets
|
||||
BIN =
|
||||
BIN_SRC =
|
||||
BIN_CLIENT_IDL =
|
||||
BIN_SERVER_IDL =
|
||||
|
||||
# header files
|
||||
EXPORT_HEADERS= Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx \
|
||||
Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx \
|
||||
Handle_SMDS_EdgePosition.hxx \
|
||||
Handle_SMDS_FacePosition.hxx \
|
||||
Handle_SMDS_ListNodeOfListOfMesh.hxx \
|
||||
Handle_SMDS_ListNodeOfListOfMeshElement.hxx \
|
||||
Handle_SMDS_Mesh.hxx \
|
||||
Handle_SMDS_MeshEdge.hxx \
|
||||
Handle_SMDS_MeshElement.hxx \
|
||||
Handle_SMDS_MeshElementIDFactory.hxx \
|
||||
Handle_SMDS_MeshFace.hxx \
|
||||
Handle_SMDS_MeshHexahedron.hxx \
|
||||
Handle_SMDS_MeshIDFactory.hxx \
|
||||
Handle_SMDS_MeshNode.hxx \
|
||||
Handle_SMDS_MeshNodeIDFactory.hxx \
|
||||
Handle_SMDS_MeshObject.hxx \
|
||||
Handle_SMDS_MeshPrism.hxx \
|
||||
Handle_SMDS_MeshPyramid.hxx \
|
||||
Handle_SMDS_MeshQuadrangle.hxx \
|
||||
Handle_SMDS_MeshTetrahedron.hxx \
|
||||
Handle_SMDS_MeshTriangle.hxx \
|
||||
Handle_SMDS_MeshVolume.hxx \
|
||||
Handle_SMDS_Position.hxx \
|
||||
Handle_SMDS_SpacePosition.hxx \
|
||||
Handle_SMDS_StdMapNodeOfExtendedMap.hxx \
|
||||
Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx \
|
||||
Handle_SMDS_VertexPosition.hxx \
|
||||
SMDS_BasicMap.lxx \
|
||||
SMDS_BasicMapIterator.lxx \
|
||||
SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx \
|
||||
SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx \
|
||||
SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx \
|
||||
SMDS_DataMapNodeOfDataMapOfPntInteger.hxx \
|
||||
SMDS_DataMapOfIntegerMeshElement.hxx \
|
||||
SMDS_DataMapOfPntInteger.hxx \
|
||||
SMDS_EdgePosition.hxx \
|
||||
SMDS_EdgePosition.lxx \
|
||||
SMDS_ExtendedMap.hxx \
|
||||
SMDS_ExtendedOrientedMap.hxx \
|
||||
SMDS_FacePosition.hxx \
|
||||
SMDS_FacePosition.lxx \
|
||||
SMDS_ListIteratorOfListOfMesh.hxx \
|
||||
SMDS_ListIteratorOfListOfMeshElement.hxx \
|
||||
SMDS_ListNodeOfListOfMesh.hxx \
|
||||
SMDS_ListNodeOfListOfMeshElement.hxx \
|
||||
SMDS_ListOfMesh.hxx \
|
||||
SMDS_ListOfMeshElement.hxx \
|
||||
SMDS_MapIteratorOfExtendedMap.hxx \
|
||||
SMDS_MapIteratorOfExtendedOrientedMap.hxx \
|
||||
SMDS_MapNode.lxx \
|
||||
SMDS_MapOfMeshElement.hxx \
|
||||
SMDS_MapOfMeshElement.lxx \
|
||||
SMDS_MapOfMeshOrientedElement.hxx \
|
||||
SMDS_MapOfMeshOrientedElement.lxx \
|
||||
SMDS_Mesh.hxx \
|
||||
SMDS_Mesh.lxx \
|
||||
SMDS_MeshEdge.hxx \
|
||||
SMDS_MeshEdge.lxx \
|
||||
SMDS_MeshEdgesIterator.hxx \
|
||||
SMDS_MeshElement.hxx \
|
||||
SMDS_MeshElement.lxx \
|
||||
SMDS_MeshElementIDFactory.hxx \
|
||||
SMDS_MeshElementIDFactory.lxx \
|
||||
SMDS_MeshElementMapHasher.hxx \
|
||||
SMDS_MeshElementMapHasher.lxx \
|
||||
SMDS_MeshElementsIterator.hxx \
|
||||
SMDS_MeshElementsIterator.lxx \
|
||||
SMDS_MeshFace.hxx \
|
||||
SMDS_MeshFace.lxx \
|
||||
SMDS_MeshFacesIterator.hxx \
|
||||
SMDS_MeshHexahedron.hxx \
|
||||
SMDS_MeshHexahedron.lxx \
|
||||
SMDS_MeshIDFactory.hxx \
|
||||
SMDS_MeshIDFactory.lxx \
|
||||
SMDS_MeshNode.hxx \
|
||||
SMDS_MeshNode.lxx \
|
||||
SMDS_MeshNodeIDFactory.hxx \
|
||||
SMDS_MeshNodeIDFactory.lxx \
|
||||
SMDS_MeshNodesIterator.hxx \
|
||||
SMDS_MeshObject.hxx \
|
||||
SMDS_MeshOrientedElementMapHasher.hxx \
|
||||
SMDS_MeshOrientedElementMapHasher.lxx \
|
||||
SMDS_MeshPrism.hxx \
|
||||
SMDS_MeshPrism.lxx \
|
||||
SMDS_MeshPyramid.hxx \
|
||||
SMDS_MeshPyramid.lxx \
|
||||
SMDS_MeshQuadrangle.hxx \
|
||||
SMDS_MeshQuadrangle.lxx \
|
||||
SMDS_MeshTetrahedron.hxx \
|
||||
SMDS_MeshTetrahedron.lxx \
|
||||
SMDS_MeshTriangle.hxx \
|
||||
SMDS_MeshTriangle.lxx \
|
||||
SMDS_MeshVolume.hxx \
|
||||
SMDS_MeshVolume.lxx \
|
||||
SMDS_MeshVolumesIterator.hxx \
|
||||
SMDS_PntHasher.hxx \
|
||||
SMDS_PntHasher.lxx \
|
||||
SMDS_Position.hxx \
|
||||
SMDS_Position.lxx \
|
||||
SMDS_SpacePosition.hxx \
|
||||
SMDS_SpacePosition.lxx \
|
||||
SMDS_StdMapNode.lxx \
|
||||
SMDS_StdMapNodeOfExtendedMap.hxx \
|
||||
SMDS_StdMapNodeOfExtendedOrientedMap.hxx \
|
||||
SMDS_TypeOfPosition.hxx \
|
||||
SMDS_VertexPosition.hxx \
|
||||
Handle_SMDSControl_BoundaryEdges.hxx \
|
||||
SMDSEdit_Transform.hxx \
|
||||
Handle_SMDSControl_BoundaryFaces.hxx \
|
||||
SMDS_HSequenceOfMesh.hxx \
|
||||
Handle_SMDSControl_MeshBoundary.hxx \
|
||||
SMDS_ListIteratorOfListOfMeshGroup.hxx \
|
||||
Handle_SMDS_HSequenceOfMesh.hxx \
|
||||
SMDS_ListNodeOfListOfMeshGroup.hxx \
|
||||
Handle_SMDS_ListNodeOfListOfMeshGroup.hxx \
|
||||
SMDS_ListOfMeshGroup.hxx \
|
||||
Handle_SMDS_MeshGroup.hxx \
|
||||
SMDSAbs_ElementType.hxx \
|
||||
SMDSControl.hxx \
|
||||
SMDS_MeshGroup.hxx \
|
||||
SMDSControl_BoundaryEdges.hxx \
|
||||
SMDS_MeshGroup.lxx \
|
||||
SMDSControl_BoundaryFaces.hxx \
|
||||
SMDS_SequenceNodeOfSequenceOfMesh.hxx \
|
||||
SMDSControl_MeshBoundary.hxx \
|
||||
SMDS_SequenceOfMesh.hxx
|
||||
|
||||
|
||||
# additionnal information to compil and link file
|
||||
CPPFLAGS += $(OCC_INCLUDES) -I${KERNEL_ROOT_DIR}/include/salome
|
||||
CXXFLAGS += $(OCC_CXXFLAGS) -I${KERNEL_ROOT_DIR}/include/salome
|
||||
LDFLAGS += $(OCC_LIBS) -L${KERNEL_ROOT_DIR}/lib/salome
|
||||
|
||||
# additional file to be cleaned
|
||||
MOSTLYCLEAN =
|
||||
CLEAN =
|
||||
DISTCLEAN =
|
||||
|
||||
@CONCLUDE@
|
||||
|
||||
148
src/SMDS/SMDS.cdl
Executable file
148
src/SMDS/SMDS.cdl
Executable file
@ -0,0 +1,148 @@
|
||||
-- File: SMDS.cdl
|
||||
-- Created: Wed Jan 23 11:53:00 2002
|
||||
-- Author: Jean-Michel BOULCOURT
|
||||
-- <jmb@coulox.paris1.matra-dtv.fr>
|
||||
---Copyright: Matra Datavision 2002
|
||||
|
||||
|
||||
package SMDS
|
||||
|
||||
---Purpose: This package provides the classes Mesh and MeshElement
|
||||
--
|
||||
-- class Mesh:
|
||||
-- - contains the main definition of the
|
||||
-- mesh and have access to the MeshElement objects
|
||||
--
|
||||
-- class MeshElement:
|
||||
-- - defines the topological constituants of the Mesh (i.e
|
||||
-- the Node, Edge, Face and Volume entities.
|
||||
--
|
||||
-- These two last classes inherits from an abstract
|
||||
-- class MeshObject.
|
||||
|
||||
uses
|
||||
SMDSAbs,
|
||||
MMgt,
|
||||
TCollection,
|
||||
TColStd,
|
||||
TColgp,
|
||||
gp
|
||||
|
||||
|
||||
is
|
||||
|
||||
---=================================
|
||||
---Category: enumerations
|
||||
--
|
||||
---=================================
|
||||
|
||||
enumeration TypeOfPosition is
|
||||
TOP_UNSPEC,
|
||||
TOP_3DSPACE,
|
||||
TOP_VERTEX,
|
||||
TOP_EDGE,
|
||||
TOP_FACE
|
||||
end TypeOfPosition;
|
||||
---Purpose: defines the type of position of a node (see SMDS_Position)
|
||||
-- TOP_UNSPEC : node position not specfied
|
||||
-- TOP_3DSPACE : just a 3d point in space not related
|
||||
-- to a CAD geometry
|
||||
-- TOP_VERTEX : to characterize a node with a CAD vertex
|
||||
-- TOP_EDGE : to characterize a node with a CAD edge
|
||||
-- TOP_FACE : to characterize a node with a CAD face
|
||||
|
||||
---=====================================
|
||||
---Category: public classes
|
||||
-- Mesh object related classes
|
||||
---=====================================
|
||||
|
||||
class MeshOrientedElementMapHasher;
|
||||
|
||||
class MeshElementMapHasher;
|
||||
|
||||
class PntHasher;
|
||||
|
||||
deferred class MeshObject;
|
||||
|
||||
class Mesh;
|
||||
|
||||
deferred class MeshElement;
|
||||
class MeshNode;
|
||||
class MeshEdge;
|
||||
deferred class MeshFace;
|
||||
class MeshTriangle;
|
||||
class MeshQuadrangle;
|
||||
deferred class MeshVolume;
|
||||
class MeshTetrahedron;
|
||||
class MeshPyramid;
|
||||
class MeshPrism;
|
||||
class MeshHexahedron;
|
||||
|
||||
private deferred class MeshIDFactory;
|
||||
private class MeshNodeIDFactory;
|
||||
private class MeshElementIDFactory;
|
||||
|
||||
deferred class MeshElementsIterator;
|
||||
class MeshVolumesIterator;
|
||||
class MeshFacesIterator;
|
||||
class MeshEdgesIterator;
|
||||
class MeshNodesIterator;
|
||||
|
||||
|
||||
deferred class Position;
|
||||
class SpacePosition;
|
||||
class VertexPosition;
|
||||
class EdgePosition;
|
||||
class FacePosition;
|
||||
|
||||
---=================================
|
||||
---Category: public classes
|
||||
-- Mesh group
|
||||
---=================================
|
||||
|
||||
class MeshGroup;
|
||||
|
||||
---=================================
|
||||
---Category: public classes
|
||||
-- Mesh collection classes
|
||||
---=================================
|
||||
|
||||
class ExtendedMap
|
||||
instantiates Map from TCollection (MeshElement from SMDS,
|
||||
MeshElementMapHasher from SMDS);
|
||||
|
||||
class ExtendedOrientedMap
|
||||
instantiates Map from TCollection (MeshElement from SMDS,
|
||||
MeshOrientedElementMapHasher from SMDS);
|
||||
|
||||
class DataMapOfPntInteger
|
||||
instantiates DataMap from TCollection (Pnt from gp,
|
||||
Integer,
|
||||
PntHasher from SMDS);
|
||||
class DataMapOfIntegerMeshElement instantiates
|
||||
DataMap from TCollection(Integer,MeshElement from SMDS,
|
||||
MapIntegerHasher from TColStd);
|
||||
|
||||
class ListOfMeshElement
|
||||
instantiates List from TCollection (MeshElement from SMDS);
|
||||
|
||||
class ListOfMesh
|
||||
instantiates List from TCollection (Mesh from SMDS);
|
||||
|
||||
class MapOfMeshElement;
|
||||
|
||||
class MapOfMeshOrientedElement;
|
||||
|
||||
class SequenceOfMesh
|
||||
instantiates Sequence from TCollection (Mesh from SMDS);
|
||||
|
||||
class HSequenceOfMesh
|
||||
instantiates HSequence from TCollection (Mesh from SMDS,
|
||||
SequenceOfMesh from SMDS);
|
||||
|
||||
|
||||
class ListOfMeshGroup
|
||||
instantiates List from TCollection(MeshGroup from SMDS);
|
||||
|
||||
end SMDS;
|
||||
|
||||
24
src/SMDS/SMDSAbs.cdl
Normal file
24
src/SMDS/SMDSAbs.cdl
Normal file
@ -0,0 +1,24 @@
|
||||
-- File: SMDSAbs.cdl
|
||||
-- Created: Mon Jun 3 11:57:33 2002
|
||||
-- Author: Jean-Michel BOULCOURT
|
||||
-- <jmb@localhost.localdomain>
|
||||
---Copyright: Matra Datavision 2002
|
||||
|
||||
|
||||
package SMDSAbs
|
||||
|
||||
---Purpose: This package provides enumeration and resources
|
||||
-- for SMDS mesh
|
||||
is
|
||||
|
||||
enumeration ElementType is
|
||||
All,
|
||||
Node,
|
||||
Edge,
|
||||
Face,
|
||||
Volume
|
||||
end ElementType;
|
||||
---Purpose: type of mesh elements
|
||||
|
||||
|
||||
end SMDSAbs;
|
||||
31
src/SMDS/SMDSAbs_ElementType.hxx
Normal file
31
src/SMDS/SMDSAbs_ElementType.hxx
Normal file
@ -0,0 +1,31 @@
|
||||
// File generated by CPPExt (Enum)
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
//
|
||||
#ifndef _SMDSAbs_ElementType_HeaderFile
|
||||
#define _SMDSAbs_ElementType_HeaderFile
|
||||
|
||||
enum SMDSAbs_ElementType {
|
||||
SMDSAbs_All,
|
||||
SMDSAbs_Node,
|
||||
SMDSAbs_Edge,
|
||||
SMDSAbs_Face,
|
||||
SMDSAbs_Volume
|
||||
};
|
||||
|
||||
|
||||
#ifndef _Standard_PrimitiveTypes_HeaderFile
|
||||
#include <Standard_PrimitiveTypes.hxx>
|
||||
#endif
|
||||
|
||||
#endif
|
||||
39
src/SMDS/SMDSControl.cdl
Normal file
39
src/SMDS/SMDSControl.cdl
Normal file
@ -0,0 +1,39 @@
|
||||
-- File: SMDSControl.cdl
|
||||
-- Created: Fri Mar 15 11:05:03 2002
|
||||
-- Author: Jean-Michel BOULCOURT
|
||||
-- <jmb@coulox.paris1.matra-dtv.fr>
|
||||
---Copyright: Matra Datavision 2002
|
||||
|
||||
|
||||
package SMDSControl
|
||||
|
||||
---Purpose: provides classes for controlling the mesh
|
||||
-- according to several criteria
|
||||
|
||||
uses
|
||||
|
||||
SMDS
|
||||
|
||||
is
|
||||
|
||||
---Category: Classes
|
||||
--
|
||||
|
||||
deferred class MeshBoundary;
|
||||
class BoundaryEdges;
|
||||
|
||||
class BoundaryFaces;
|
||||
|
||||
---Category: Package methods
|
||||
--
|
||||
|
||||
ComputeNeighborFaces(M:Mesh from SMDS; ME: MeshElement from SMDS; idnode1,idnode2: Integer)
|
||||
returns Integer;
|
||||
|
||||
ComputeNeighborVolumes(M:Mesh from SMDS; ME: MeshElement from SMDS; idnode1,idnode2,idnode3: Integer)
|
||||
returns Integer;
|
||||
|
||||
ComputeNeighborVolumes(M:Mesh from SMDS; ME: MeshElement from SMDS; idnode1,idnode2,idnode3,idnode4: Integer)
|
||||
returns Integer;
|
||||
|
||||
end SMDSControl;
|
||||
214
src/SMDS/SMDSControl.cxx
Normal file
214
src/SMDS/SMDSControl.cxx
Normal file
@ -0,0 +1,214 @@
|
||||
using namespace std;
|
||||
// File: SMDSControl.cxx
|
||||
// Created: Wed Feb 20 18:33:06 2002
|
||||
// Author: Jean-Michel BOULCOURT
|
||||
// <jmb@localhost.localdomain>
|
||||
|
||||
|
||||
#include "SMDSControl.ixx"
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#include "SMDS_ListOfMeshElement.hxx"
|
||||
#include "SMDS_ListIteratorOfListOfMeshElement.hxx"
|
||||
|
||||
//=======================================================================
|
||||
//function : ComputeNeighborFaces
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
|
||||
Standard_Integer SMDSControl::ComputeNeighborFaces(const Handle(SMDS_Mesh)& M,
|
||||
const Handle(SMDS_MeshElement)& ME,
|
||||
const Standard_Integer idnode1,
|
||||
const Standard_Integer idnode2)
|
||||
{
|
||||
const Handle(SMDS_MeshElement)& node1 = M->FindNode(idnode1);
|
||||
const Handle(SMDS_MeshElement)& node2 = M->FindNode(idnode2);
|
||||
const SMDS_ListOfMeshElement& lstInvFaces1 = node1->InverseElements();
|
||||
const SMDS_ListOfMeshElement& lstInvFaces2 = node2->InverseElements();
|
||||
Standard_Integer neighbor=0;
|
||||
|
||||
SMDS_ListIteratorOfListOfMeshElement it1(lstInvFaces1);
|
||||
for (;it1.More();it1.Next()) {
|
||||
const Handle(SMDS_MeshElement)& face = it1.Value();
|
||||
if (M->Contains(face) && !face->IsSame(ME)) {
|
||||
if (face->IsNodeInElement(idnode1) && face->IsNodeInElement(idnode2)) {
|
||||
neighbor++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (neighbor > 0) {
|
||||
return neighbor;
|
||||
}
|
||||
|
||||
SMDS_ListIteratorOfListOfMeshElement it2(lstInvFaces2);
|
||||
for (;it2.More();it2.Next()) {
|
||||
const Handle(SMDS_MeshElement)& face = it2.Value();
|
||||
if (M->Contains(face) && !face->IsSame(ME)) {
|
||||
if (face->IsNodeInElement(idnode1) && face->IsNodeInElement(idnode2)) {
|
||||
neighbor++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return neighbor;
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : ComputeNeighborVolumes
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
|
||||
Standard_Integer SMDSControl::ComputeNeighborVolumes(const Handle(SMDS_Mesh)& M,
|
||||
const Handle(SMDS_MeshElement)& ME,
|
||||
const Standard_Integer idnode1,
|
||||
const Standard_Integer idnode2,
|
||||
const Standard_Integer idnode3)
|
||||
{
|
||||
|
||||
const Handle(SMDS_MeshElement)& node1 = M->FindNode(idnode1);
|
||||
const Handle(SMDS_MeshElement)& node2 = M->FindNode(idnode2);
|
||||
const Handle(SMDS_MeshElement)& node3 = M->FindNode(idnode3);
|
||||
const SMDS_ListOfMeshElement& lstInvVol1 = node1->InverseElements();
|
||||
const SMDS_ListOfMeshElement& lstInvVol2 = node2->InverseElements();
|
||||
const SMDS_ListOfMeshElement& lstInvVol3 = node3->InverseElements();
|
||||
|
||||
Standard_Integer neighbor=0;
|
||||
|
||||
SMDS_ListIteratorOfListOfMeshElement it1(lstInvVol1);
|
||||
for (;it1.More() && neighbor == 0;it1.Next()) {
|
||||
const Handle(SMDS_MeshElement)& vol = it1.Value();
|
||||
if (M->Contains(vol) && !vol->IsSame(ME)) {
|
||||
if (vol->IsNodeInElement(idnode1)
|
||||
&& vol->IsNodeInElement(idnode2)
|
||||
&& vol->IsNodeInElement(idnode3)) {
|
||||
neighbor++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (neighbor > 0) {
|
||||
return neighbor;
|
||||
}
|
||||
|
||||
SMDS_ListIteratorOfListOfMeshElement it2(lstInvVol2);
|
||||
for (;it2.More() && neighbor == 0;it2.Next()) {
|
||||
const Handle(SMDS_MeshElement)& vol = it2.Value();
|
||||
if (M->Contains(vol) && !vol->IsSame(ME)) {
|
||||
if (vol->IsNodeInElement(idnode1)
|
||||
&& vol->IsNodeInElement(idnode2)
|
||||
&& vol->IsNodeInElement(idnode3)) {
|
||||
neighbor++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (neighbor > 0) {
|
||||
return neighbor;
|
||||
}
|
||||
|
||||
SMDS_ListIteratorOfListOfMeshElement it3(lstInvVol3);
|
||||
for (;it3.More() && neighbor == 0;it3.Next()) {
|
||||
const Handle(SMDS_MeshElement)& vol = it3.Value();
|
||||
if (M->Contains(vol) && !vol->IsSame(ME)) {
|
||||
if (vol->IsNodeInElement(idnode1)
|
||||
&& vol->IsNodeInElement(idnode2)
|
||||
&& vol->IsNodeInElement(idnode3)) {
|
||||
neighbor++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return neighbor;
|
||||
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : ComputeNeighborVolumes
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
|
||||
Standard_Integer SMDSControl::ComputeNeighborVolumes(const Handle(SMDS_Mesh)& M,
|
||||
const Handle(SMDS_MeshElement)& ME,
|
||||
const Standard_Integer idnode1,
|
||||
const Standard_Integer idnode2,
|
||||
const Standard_Integer idnode3,
|
||||
const Standard_Integer idnode4)
|
||||
{
|
||||
|
||||
const Handle(SMDS_MeshElement)& node1 = M->FindNode(idnode1);
|
||||
const Handle(SMDS_MeshElement)& node2 = M->FindNode(idnode2);
|
||||
const Handle(SMDS_MeshElement)& node3 = M->FindNode(idnode3);
|
||||
const Handle(SMDS_MeshElement)& node4 = M->FindNode(idnode4);
|
||||
const SMDS_ListOfMeshElement& lstInvVol1 = node1->InverseElements();
|
||||
const SMDS_ListOfMeshElement& lstInvVol2 = node2->InverseElements();
|
||||
const SMDS_ListOfMeshElement& lstInvVol3 = node3->InverseElements();
|
||||
const SMDS_ListOfMeshElement& lstInvVol4 = node4->InverseElements();
|
||||
Standard_Integer neighbor=0;
|
||||
|
||||
SMDS_ListIteratorOfListOfMeshElement it1(lstInvVol1);
|
||||
for (;it1.More();it1.Next()) {
|
||||
const Handle(SMDS_MeshElement)& vol = it1.Value();
|
||||
if (M->Contains(vol) && !vol->IsSame(ME)) {
|
||||
if ( vol->IsNodeInElement(idnode1)
|
||||
&& vol->IsNodeInElement(idnode2)
|
||||
&& vol->IsNodeInElement(idnode3)
|
||||
&& vol->IsNodeInElement(idnode4)) {
|
||||
neighbor++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (neighbor >= 2) {
|
||||
return neighbor;
|
||||
}
|
||||
|
||||
SMDS_ListIteratorOfListOfMeshElement it2(lstInvVol2);
|
||||
for (;it2.More();it2.Next()) {
|
||||
const Handle(SMDS_MeshElement)& vol = it2.Value();
|
||||
if (M->Contains(vol) && !vol->IsSame(ME)) {
|
||||
if ( vol->IsNodeInElement(idnode1)
|
||||
&& vol->IsNodeInElement(idnode2)
|
||||
&& vol->IsNodeInElement(idnode3)
|
||||
&& vol->IsNodeInElement(idnode4)) {
|
||||
neighbor++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (neighbor >= 2) {
|
||||
return neighbor;
|
||||
}
|
||||
|
||||
SMDS_ListIteratorOfListOfMeshElement it3(lstInvVol3);
|
||||
for (;it3.More();it3.Next()) {
|
||||
const Handle(SMDS_MeshElement)& vol = it3.Value();
|
||||
if (M->Contains(vol) && !vol->IsSame(ME)) {
|
||||
if ( vol->IsNodeInElement(idnode1)
|
||||
&& vol->IsNodeInElement(idnode2)
|
||||
&& vol->IsNodeInElement(idnode3)
|
||||
&& vol->IsNodeInElement(idnode4)) {
|
||||
neighbor++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (neighbor >= 2) {
|
||||
return neighbor;
|
||||
}
|
||||
|
||||
SMDS_ListIteratorOfListOfMeshElement it4(lstInvVol4);
|
||||
for (;it4.More();it4.Next()) {
|
||||
const Handle(SMDS_MeshElement)& vol = it4.Value();
|
||||
if (M->Contains(vol) && !vol->IsSame(ME)) {
|
||||
if ( vol->IsNodeInElement(idnode1)
|
||||
&& vol->IsNodeInElement(idnode2)
|
||||
&& vol->IsNodeInElement(idnode3)
|
||||
&& vol->IsNodeInElement(idnode4)) {
|
||||
neighbor++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return neighbor;
|
||||
}
|
||||
104
src/SMDS/SMDSControl.hxx
Normal file
104
src/SMDS/SMDSControl.hxx
Normal file
@ -0,0 +1,104 @@
|
||||
// File generated by CPPExt (Value)
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
|
||||
#ifndef _SMDSControl_HeaderFile
|
||||
#define _SMDSControl_HeaderFile
|
||||
|
||||
#ifndef _Standard_Integer_HeaderFile
|
||||
#include <Standard_Integer.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_Mesh_HeaderFile
|
||||
#include "Handle_SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_MeshElement_HeaderFile
|
||||
#include "Handle_SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
class SMDS_Mesh;
|
||||
class SMDS_MeshElement;
|
||||
class SMDSControl_MeshBoundary;
|
||||
class SMDSControl_BoundaryEdges;
|
||||
class SMDSControl_BoundaryFaces;
|
||||
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Standard_Macro_HeaderFile
|
||||
#include <Standard_Macro.hxx>
|
||||
#endif
|
||||
|
||||
class SMDSControl {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT static Standard_Integer ComputeNeighborFaces(const Handle(SMDS_Mesh)& M,const Handle(SMDS_MeshElement)& ME,const Standard_Integer idnode1,const Standard_Integer idnode2) ;
|
||||
Standard_EXPORT static Standard_Integer ComputeNeighborVolumes(const Handle(SMDS_Mesh)& M,const Handle(SMDS_MeshElement)& ME,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3) ;
|
||||
Standard_EXPORT static Standard_Integer ComputeNeighborVolumes(const Handle(SMDS_Mesh)& M,const Handle(SMDS_MeshElement)& ME,const Standard_Integer idnode1,const Standard_Integer idnode2,const Standard_Integer idnode3,const Standard_Integer idnode4) ;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
|
||||
friend class SMDSControl_MeshBoundary;
|
||||
friend class SMDSControl_BoundaryEdges;
|
||||
friend class SMDSControl_BoundaryFaces;
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// other inline functions and methods (like "C++: function call" methods)
|
||||
//
|
||||
|
||||
|
||||
#endif
|
||||
19
src/SMDS/SMDSControl.ixx
Normal file
19
src/SMDS/SMDSControl.ixx
Normal file
@ -0,0 +1,19 @@
|
||||
// File generated by CPPExt (Value)
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
//
|
||||
#include "SMDSControl.jxx"
|
||||
|
||||
|
||||
|
||||
|
||||
9
src/SMDS/SMDSControl.jxx
Normal file
9
src/SMDS/SMDSControl.jxx
Normal file
@ -0,0 +1,9 @@
|
||||
#ifndef _SMDS_Mesh_HeaderFile
|
||||
#include "SMDS_Mesh.hxx"
|
||||
#endif
|
||||
#ifndef _SMDS_MeshElement_HeaderFile
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDSControl_HeaderFile
|
||||
#include "SMDSControl.hxx"
|
||||
#endif
|
||||
29
src/SMDS/SMDSControl_BoundaryEdges.cdl
Normal file
29
src/SMDS/SMDSControl_BoundaryEdges.cdl
Normal file
@ -0,0 +1,29 @@
|
||||
-- File: SMDSControl_BoundaryEdges.cdl
|
||||
-- Created: Wed Feb 20 19:17:20 2002
|
||||
-- Author: Jean-Michel BOULCOURT
|
||||
-- <jmb@localhost.localdomain>
|
||||
---Copyright: Matra Datavision 2002
|
||||
|
||||
|
||||
class BoundaryEdges from SMDSControl inherits MeshBoundary from SMDSControl
|
||||
|
||||
---Purpose: compute the boudary edges of a mesh that is the
|
||||
-- edges that are shared by only one face the result
|
||||
-- is a new mesh created in the same factory as the
|
||||
-- original mesh that contains only edges
|
||||
|
||||
uses
|
||||
|
||||
Mesh from SMDS,
|
||||
MapOfMeshElement from SMDS
|
||||
is
|
||||
|
||||
Create(M: Mesh from SMDS) returns BoundaryEdges from SMDSControl;
|
||||
|
||||
Compute(me: mutable) is redefined virtual;
|
||||
|
||||
fields
|
||||
|
||||
myBoundaryEdges : MapOfMeshElement from SMDS;
|
||||
|
||||
end BoundaryEdges;
|
||||
59
src/SMDS/SMDSControl_BoundaryEdges.cxx
Normal file
59
src/SMDS/SMDSControl_BoundaryEdges.cxx
Normal file
@ -0,0 +1,59 @@
|
||||
using namespace std;
|
||||
// File: SMDSControl_BoundaryEdges.cxx
|
||||
// Created: Wed Feb 20 19:28:42 2002
|
||||
// Author: Jean-Michel BOULCOURT
|
||||
// <jmb@localhost.localdomain>
|
||||
|
||||
|
||||
#include "SMDSControl_BoundaryEdges.ixx"
|
||||
#include "SMDSControl.hxx"
|
||||
|
||||
#include "SMDS_MeshFacesIterator.hxx"
|
||||
#include "SMDS_MeshElement.hxx"
|
||||
#include "SMDS_MeshEdge.hxx"
|
||||
#include "SMDS_MapIteratorOfExtendedMap.hxx"
|
||||
|
||||
//=======================================================================
|
||||
//function : SMDSControl_BoundaryEdges
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
|
||||
SMDSControl_BoundaryEdges::SMDSControl_BoundaryEdges(const Handle(SMDS_Mesh)& M)
|
||||
:SMDSControl_MeshBoundary(M)
|
||||
{
|
||||
}
|
||||
|
||||
//=======================================================================
|
||||
//function : Compute
|
||||
//purpose :
|
||||
//=======================================================================
|
||||
|
||||
void SMDSControl_BoundaryEdges::Compute()
|
||||
{
|
||||
Standard_Integer idnode1;
|
||||
Standard_Integer idnode2;
|
||||
Standard_Integer nbedg;
|
||||
|
||||
myBoundaryMesh = myMesh->AddSubMesh();
|
||||
SMDS_MeshFacesIterator itface(myMesh);
|
||||
|
||||
for (;itface.More();itface.Next()) {
|
||||
Handle(SMDS_MeshElement) ME = itface.Value();
|
||||
|
||||
nbedg = ME->NbEdges();
|
||||
|
||||
for (Standard_Integer iedge=1; iedge<=nbedg; ++iedge) {
|
||||
ME->GetEdgeDefinedByNodes(iedge,idnode1,idnode2);
|
||||
Handle(SMDS_MeshElement) edge = new SMDS_MeshEdge(0,idnode1,idnode2);
|
||||
if (!myBoundaryEdges.Add(edge))
|
||||
myBoundaryEdges.Remove(edge);
|
||||
}
|
||||
}
|
||||
|
||||
SMDS_MapIteratorOfExtendedMap itbound(myBoundaryEdges);
|
||||
|
||||
for (;itbound.More();itbound.Next()) {
|
||||
const Handle(SMDS_MeshElement)& edge = itbound.Key();
|
||||
myBoundaryMesh->AddEdge(edge->GetConnection(1),edge->GetConnection(2));
|
||||
}
|
||||
}
|
||||
104
src/SMDS/SMDSControl_BoundaryEdges.hxx
Normal file
104
src/SMDS/SMDSControl_BoundaryEdges.hxx
Normal file
@ -0,0 +1,104 @@
|
||||
// File generated by CPPExt (Transient)
|
||||
//
|
||||
// Copyright (C) 1991,1995 by
|
||||
//
|
||||
// MATRA DATAVISION, FRANCE
|
||||
//
|
||||
// This software is furnished in accordance with the terms and conditions
|
||||
// of the contract and with the inclusion of the above copyright notice.
|
||||
// This software or any other copy thereof may not be provided or otherwise
|
||||
// be made available to any other person. No title to an ownership of the
|
||||
// software is hereby transferred.
|
||||
//
|
||||
// At the termination of the contract, the software and all copies of this
|
||||
// software must be deleted.
|
||||
//
|
||||
#ifndef _SMDSControl_BoundaryEdges_HeaderFile
|
||||
#define _SMDSControl_BoundaryEdges_HeaderFile
|
||||
|
||||
#ifndef _Standard_HeaderFile
|
||||
#include <Standard.hxx>
|
||||
#endif
|
||||
#ifndef _Handle_SMDSControl_BoundaryEdges_HeaderFile
|
||||
#include "Handle_SMDSControl_BoundaryEdges.hxx"
|
||||
#endif
|
||||
|
||||
#ifndef _SMDS_MapOfMeshElement_HeaderFile
|
||||
#include "SMDS_MapOfMeshElement.hxx"
|
||||
#endif
|
||||
#ifndef _SMDSControl_MeshBoundary_HeaderFile
|
||||
#include "SMDSControl_MeshBoundary.hxx"
|
||||
#endif
|
||||
#ifndef _Handle_SMDS_Mesh_HeaderFile
|
||||
#include "Handle_SMDS_Mesh.hxx"
|
||||
#endif
|
||||
class SMDS_Mesh;
|
||||
|
||||
|
||||
class SMDSControl_BoundaryEdges : public SMDSControl_MeshBoundary {
|
||||
|
||||
public:
|
||||
|
||||
inline void* operator new(size_t,void* anAddress)
|
||||
{
|
||||
return anAddress;
|
||||
}
|
||||
inline void* operator new(size_t size)
|
||||
{
|
||||
return Standard::Allocate(size);
|
||||
}
|
||||
inline void operator delete(void *anAddress)
|
||||
{
|
||||
if (anAddress) Standard::Free((Standard_Address&)anAddress);
|
||||
}
|
||||
// inline void operator delete(void *anAddress, size_t size)
|
||||
// {
|
||||
// if (anAddress) Standard::Free((Standard_Address&)anAddress,size);
|
||||
// }
|
||||
// Methods PUBLIC
|
||||
//
|
||||
Standard_EXPORT SMDSControl_BoundaryEdges(const Handle(SMDS_Mesh)& M);
|
||||
Standard_EXPORT virtual void Compute() ;
|
||||
Standard_EXPORT ~SMDSControl_BoundaryEdges();
|
||||
|
||||
|
||||
|
||||
|
||||
// Type management
|
||||
//
|
||||
Standard_EXPORT friend Handle_Standard_Type& SMDSControl_BoundaryEdges_Type_();
|
||||
Standard_EXPORT const Handle(Standard_Type)& DynamicType() const;
|
||||
Standard_EXPORT Standard_Boolean IsKind(const Handle(Standard_Type)&) const;
|
||||
|
||||
protected:
|
||||
|
||||
// Methods PROTECTED
|
||||
//
|
||||
|
||||
|
||||
// Fields PROTECTED
|
||||
//
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// Methods PRIVATE
|
||||
//
|
||||
|
||||
|
||||
// Fields PRIVATE
|
||||
//
|
||||
SMDS_MapOfMeshElement myBoundaryEdges;
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
// other inline functions and methods (like "C++: function call" methods)
|
||||
//
|
||||
|
||||
|
||||
#endif
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user