SET(${PROJECT_NAME_UC}_PATCH_VERSION 0)
SET(${PROJECT_NAME_UC}_VERSION
${${PROJECT_NAME_UC}_MAJOR_VERSION}.${${PROJECT_NAME_UC}_MINOR_VERSION}.${${PROJECT_NAME_UC}_PATCH_VERSION})
-SET(${PROJECT_NAME_UC}_VERSION_DEV 0)
+SET(${PROJECT_NAME_UC}_VERSION_DEV 1)
# Common CMake macros
# ===================
+++ /dev/null
-###############################################################################
-#This is the SMESH change log. Do not modify because it is automatically
-#created with :
-#cvs2cl.pl -l "-b" -U users.cvs2cl --header header.cvs2cl -T -b --utc
-###############################################################################
-
-2004-01-30 13:18 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * doc/html/INPUT/: doxyfile, sources/static/tree.js: NRI : 1.4.0
- version
-
-2004-01-29 17:52 Jerome Robert <jerome.robert@eads.net>
-
- * INSTALL, bin/VERSION: Upgrade to version 1.4.0.
-
-2004-01-29 17:33 Jerome Robert <jerome.robert@eads.net>
-
- * src/: SMESHGUI/SMESHGUI_StudyAPI.cxx, SMESHGUI/SMESHGUI_Swig.cxx,
- SMESH_I/SMESH_Gen_i.cxx: Merge branch merge_1_2_d
-
-2004-01-14 09:24 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * doc/html/Makefile.in: NRI : bug KERNEL5014 fixed.
-
-2004-01-06 15:19 Nadir Bouhamou <nadir.bouhamou@cea.fr>
-
- * src/SMESH_SWIG/SMESH_flight_skin.py: removing the call to the
- tetrahedron generator NETGEN, because I did not yet manage to
- make NETGEN running on the flight geometry.
-
-2004-01-06 15:16 Nadir Bouhamou <nadir.bouhamou@cea.fr>
-
- * resources/SMESH_en.xml, resources/SMESH_fr.xml,
- src/SMESHGUI/SMESHGUI.cxx: Mounting the hypothesis
- LengthFromEdges in th GUI of SMESH. This functionality was only
- in the C++ API, and in the CORBA API.
-
-2004-01-05 16:14 Jerome Robert <jerome.robert@eads.net>
-
- * adm_local/unix/config_files/check_Netgen.m4: Fix a misspelled
- environment variable for idl python
-
-2004-01-05 14:28 tag V1_3_1
-
-2004-01-05 13:53 Jerome Robert <jerome.robert@eads.net>
-
- * src/NETGEN/: ReadMeForNgUsers, netgen43ForSalome.patch: Add a
- patch to make the build of netgen more user-friendly
-
-2004-01-05 13:52 Jerome Robert <jerome.robert@eads.net>
-
- * src/NETGEN/Makefile.in: We do not need OCAF in Netgen
-
-2004-01-05 13:38 Jerome Robert <jerome.robert@eads.net>
-
- * adm_local/unix/config_files/check_Netgen.m4: Fix some quotes
- problems.
-
-2004-01-05 09:05 Jerome Robert <jerome.robert@eads.net>
-
- * src/: SMDS/SMDS_Mesh.cxx, SMESHDS/SMESHDS_Document.cxx: [Bug
- SMESH4830] bug in install with gcc 2.95. Bug fixed. Note: SGI say
- that <algorithm> is requiered to use set_intersection (see
- http://www.sgi.com/tech/stl/set_intersection.html).
-
-2003-12-16 15:27 Nadir Bouhamou <nadir.bouhamou@cea.fr>
-
- * adm_local/unix/config_files/check_Netgen.m4: Since there is an
- idl precompilation directive in SMESH_BasicHypothesis.idl file, a
- -DHAVE_NETGEN idl has to be added when compiling SMESH with
- netgen to the idl c++ flags as well as to the idl python flags.
-
-2003-12-15 13:15 Nadir Bouhamou <nadir.bouhamou@cea.fr>
-
- * src/SMESHDS/SMESHDS_Script.cxx: correct a small bug found by the
- EDF development team (PN and AT) : AddVolume in the case of a
- Tetrahedron.
-
-2003-12-11 09:51 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESHGUI/SMESHGUI.cxx: [Bug SMESH4598] Crash of the session
- when compute and update are not done in the same view. Bug fixed.
-
-2003-12-11 09:49 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESH/SMESH_HypothesisFactory.cxx: HAVE_NETGEN (#define) to
- remove an unresolved symbol when building without netgen
-
-2003-12-10 17:23 Jerome Robert <jerome.robert@eads.net>
-
- * adm_local/unix/config_files/check_Netgen.m4,
- idl/SMESH_BasicHypothesis.idl,
- src/SMESH_I/SMESH_HypothesisFactory_i.cxx: Create and use
- HAVE_NETGEN (#define) to avoid unresolved symbols in libraries.
-
-2003-12-10 16:05 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESHGUI/SMESHGUI.cxx: Cosmetics
-
-2003-12-09 14:13 Nadir Bouhamou <nadir.bouhamou@cea.fr>
-
- * src/SMESH/Makefile.in: Correcting a problem araising when
- building the SMESH module without Netgen.
-
-2003-12-09 10:00 Nadir Bouhamou <nadir.bouhamou@cea.fr>
-
- * doc/: AddNetgenInSalome2.pdf, AddNetgenInSalome2.ps,
- AddNetgenInSalome2.sxw: updating or adding when merging in the
- main trunk with the version in the branch nadir_1_2_2 !! Here a
- document related to the integration of NETGEN in the SMESH module
- has been added for future work in the integration of other
- mesher.
-
-2003-12-08 15:30 Nadir Bouhamou <nadir.bouhamou@cea.fr>
-
- * INSTALL, Makefile.in, configure.in.base,
- adm_local/unix/make_commence.in,
- adm_local/unix/config_files/check_Netgen.m4, bin/VERSION,
- idl/SMESH_BasicHypothesis.idl, resources/SMESH_en.xml,
- resources/SMESH_fr.xml, resources/flight_solid.brep,
- resources/mesh_algo_netgen.png, resources/mesh_algo_tetra.png,
- resources/mesh_tree_algo_netgen.png,
- resources/mesh_tree_algo_tetra.png, src/Makefile.in,
- src/DriverMED/DriverMED_R_SMDS_Mesh.cxx,
- src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx,
- src/DriverMED/DriverMED_W_SMDS_Mesh.cxx,
- src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx,
- src/NETGEN/Makefile.in, src/NETGEN/ReadMeForNgUsers,
- src/SMESH/Makefile.in, src/SMESH/SMESH_HypothesisFactory.cxx,
- src/SMESH/SMESH_MEFISTO_2D.cxx,
- src/SMESH/SMESH_MaxElementVolume.cxx,
- src/SMESH/SMESH_MaxElementVolume.hxx,
- src/SMESH/SMESH_NETGEN_3D.cxx, src/SMESH/SMESH_NETGEN_3D.hxx,
- src/SMESH/SMESH_subMesh.cxx, src/SMESHGUI/SMESHGUI.cxx,
- src/SMESHGUI/SMESHGUI.h, src/SMESHGUI/SMESHGUI_NbSegmentsDlg.cxx,
- src/SMESHGUI/SMESHGUI_icons.po, src/SMESH_I/Makefile.in,
- src/SMESH_I/SMESH_Gen_i.cxx,
- src/SMESH_I/SMESH_HypothesisFactory_i.cxx,
- src/SMESH_I/SMESH_LengthFromEdges_i.cxx,
- src/SMESH_I/SMESH_LengthFromEdges_i.hxx,
- src/SMESH_I/SMESH_MEDMesh_i.cxx,
- src/SMESH_I/SMESH_MEDSupport_i.cxx,
- src/SMESH_I/SMESH_MaxElementVolume_i.cxx,
- src/SMESH_I/SMESH_MaxElementVolume_i.hxx,
- src/SMESH_I/SMESH_NETGEN_3D_i.cxx,
- src/SMESH_I/SMESH_NETGEN_3D_i.hxx, src/SMESH_SWIG/Makefile.in,
- src/SMESH_SWIG/SMESH_Partition1_tetra.py,
- src/SMESH_SWIG/SMESH_box2_tetra.py,
- src/SMESH_SWIG/SMESH_box3_tetra.py,
- src/SMESH_SWIG/SMESH_box_tetra.py,
- src/SMESH_SWIG/SMESH_fixation_hexa.py,
- src/SMESH_SWIG/SMESH_fixation_tetra.py,
- src/SMESH_SWIG/SMESH_flight_skin.py,
- src/SMESH_SWIG/SMESH_mechanic_tetra.py: updating or adding when
- merging in the main trunk with the version in the branch
- nadir_1_2_2 !!
-
-2003-12-05 14:49 Jerome Robert <jerome.robert@eads.net>
-
- * src/MEFISTO2/trte.f: Remove "pause" primitive call.
-
-2003-11-27 11:45 Jerome Robert <jerome.robert@eads.net>
-
- * resources/SMESH_en.xml, resources/SMESH_fr.xml,
- src/SMESHGUI/SMESHGUI.cxx: [Bug SMESH839] Spelling: Hypotheses -
- Hexa?edron (i,j,k). Bug Fixed.
-
-2003-11-25 08:52 tag V1_3_0
-
-2003-11-25 08:52 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * bin/VERSION, INSTALL: NRI: 1.3.0 version.
-
-2003-11-20 12:45 tag V1_3_0_b3
-
-2003-11-20 12:45 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * doc/html/INPUT/sources/static/: doxygen.css, page2.html, tree.js,
- treeview.js: NRI : Add static documentation.
-
-2003-11-20 12:45 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * doc/html/INPUT/sources/: Application-About.png,
- Application-About1.jpg, application.gif, application.jpg,
- bg_salome.gif, bg_salomepro.gif, doxygen.css: NRI : Update
- images.
-
-2003-11-20 12:44 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * doc/html/INPUT/doxyfile: NRI : Generate TreeView.
-
-2003-11-20 12:43 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * doc/html/Makefile.in: NRI : Add static directory.
-
-2003-11-18 15:01 tag V1_3_0b2
-
-2003-11-18 15:01 Jerome Robert <jerome.robert@eads.net>
-
- * ChangeLog, INSTALL, cvs-tags: update for V1_3_0_b2
-
-2003-11-18 09:19 Nadir Bouhamou <nadir.bouhamou@cea.fr>
-
- * src/SMESH_I/: SMESH_MEDFamily_i.cxx, SMESH_MEDFamily_i.hxx,
- SMESH_MEDMesh_i.cxx, SMESH_MEDMesh_i.hxx, SMESH_MEDSupport_i.cxx,
- SMESH_MEDSupport_i.hxx: merge with the branch
- nadir_update_MED_v1_3_0 (branch to build the V1_3_0 version of
- the module.
-
-2003-11-12 13:20 tag V1_3_0_b1
-
-2003-11-12 13:20 Jerome Robert <jerome.robert@eads.net>
-
- * ChangeLog, INSTALL, cvs-tags, bin/VERSION: Update for V1.3.0b1
-
-2003-11-12 11:40 Jerome Robert <jerome.robert@eads.net>
-
- * src/OBJECT/SMESH_Actor.cxx: MergeV1_2c-1
-
-2003-11-06 14:43 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESHGUI/SMESHGUI.cxx: NRI : MergeV1_2c-1.
-
-2003-11-06 14:34 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/MEFISTO2/: areteideale.f, trte.f: NRI : Add licence header.
-
-2003-11-06 11:34 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * LICENCE: NRI : add LICENCE file
-
-2003-11-03 15:50 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * doc/html/Makefile.in: NRI : Relative path !!!!
-
-2003-10-22 15:28 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/: SMDS_Mesh.cxx, SMDS_Mesh.hxx: Fix/implement
- removeNode, removeEdge, removeFace, removeVolume and
- removeElement
-
-2003-10-20 16:26 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESHGUI/SMESHGUI.cxx: When the main window was maximized
- some dialogs were cropped at the bottom of the screen. It's now
- fixed.
-
-2003-10-17 16:31 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/SMDS_Mesh.cxx: Fix a bug. Quadrangles were added as
- triangles.
-
-2003-10-06 10:50 tag MergeV1_2c-1
-
-2003-10-06 10:50 Jerome Robert <jerome.robert@eads.net>
-
- * cvs-tags: Update. Created a new branch for user nadir.
-
-2003-10-02 16:16 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * build_configure: NRI : RedHat 9 compatibility (M. Tajchman).
-
-2003-09-26 15:14 tag V1_2_2
-
-2003-09-26 15:14 Jerome Robert <jerome.robert@eads.net>
-
- * INSTALL, cvs-tags: Add a tag file to track branch and tag. Update
- INSTALL to prepare V1_2_2 tag.
-
-2003-09-26 14:21 tag V1_2_1
-
-2003-09-26 14:21 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * INSTALL: NRI : INSTALL file defined into SALOME2_PRODUCTION_CYCLE
- document.
-
-2003-09-23 14:33 Jerome Robert <jerome.robert@eads.net>
-
- * src/: SMDS/SMDS_FaceOfEdges.hxx, SMESHDS/SMESHDS_Mesh.hxx,
- SMDS/SMDS_FaceOfNodes.hxx, SMDS/SMDS_MeshEdge.hxx,
- SMDS/SMDS_MeshElement.hxx, SMDS/SMDS_Tria3OfNodes.hxx,
- SMDS/SMDS_VolumeOfFaces.hxx: Keep compatible with gcc 2
-
-2003-09-23 11:52 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESHGUI/SMESHGUI_StudyAPI.cxx: NRI : Display Component
- UserName and Icon.
-
-2003-09-22 12:23 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/SMDS_IteratorOfArray.hxx: Freshly added file
-
-2003-09-12 15:12 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/: Makefile.in, SMDS_HexahedronOfNodes.cxx,
- SMDS_HexahedronOfNodes.hxx, SMDS_Mesh.cxx, SMDS_Tria3OfNodes.cxx,
- SMDS_Tria3OfNodes.hxx: Add HexahedronOfNodes and Tria3OfNodes to
- improve performance
-
-2003-09-12 15:11 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/SMDS_VolumeOfNodes.cxx: Fix bug. Was always printing 8
- nodes
-
-2003-09-08 15:04 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/: SMDS_Mesh.cxx, SMDS_VolumeOfNodes.cxx,
- SMDS_VolumeOfNodes.hxx: Add support for tetra, pyramid and prism
-
-2003-09-08 13:41 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/: SMDS_Mesh.cxx, SMDS_MeshElement.cxx: Add some comments
-
-2003-09-05 12:19 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/SMDS_MeshNode.cxx: Some forgotten return statments
-
-2003-09-05 11:45 Jerome Robert <jerome.robert@eads.net>
-
- * src/: DriverDAT/DriverDAT_W_SMESHDS_Mesh.cxx,
- DriverMED/DriverMED_W_SMESHDS_Mesh.cxx, SMESH/SMESH_Hexa_3D.cxx:
- Correct some memory leaks
-
-2003-09-05 10:31 Jerome Robert <jerome.robert@eads.net>
-
- * src/: DriverMED/DriverMED_W_SMESHDS_Mesh.cxx,
- SMESH/SMESH_Hexa_3D.cxx, SMESH/SMESH_Hexa_3D.hxx,
- SMESH/SMESH_MEFISTO_2D.cxx, SMESH/SMESH_MEFISTO_2D.hxx,
- SMESH/SMESH_Quadrangle_2D.cxx, SMESH/SMESH_Quadrangle_2D.hxx,
- SMESH/SMESH_Regular_1D.cxx, SMESH/SMESH_subMesh.cxx,
- SMESHDS/SMESHDS_Mesh.cxx, SMESHDS/SMESHDS_Mesh.hxx,
- SMESHDS/SMESHDS_SubMesh.cxx, SMESHDS/SMESHDS_SubMesh.hxx,
- SMESH_I/SMESH_MEDSupport_i.cxx, SMESH_I/SMESH_MeshEditor_i.cxx:
- Use nodes and elements pointer instead on IDs
-
-2003-09-05 10:20 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/: SMDS_Mesh.cxx, SMDS_Mesh.hxx: Change API to use
- pointer on elements and no longer ID of elements
-
-2003-09-04 15:04 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESHDS/: Handle_SMESHDS_Command.hxx,
- Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx,
- Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx,
- Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx,
- Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx,
- Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx,
- Handle_SMESHDS_Document.hxx,
- Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx,
- Handle_SMESHDS_ListNodeOfListOfCommand.hxx,
- Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx,
- Handle_SMESHDS_Mesh.hxx, Handle_SMESHDS_Script.hxx,
- Handle_SMESHDS_SubMesh.hxx, SMESHDS.cdl, SMESHDS_Command.cdl,
- SMESHDS_Command.ixx, SMESHDS_Command.jxx,
- SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx,
- SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_0.cxx,
- SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx,
- SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx,
- SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_0.cxx,
- SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_0.cxx,
- SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx,
- SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_0.cxx,
- SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx,
- SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx,
- SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx,
- SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx,
- SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx,
- SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx,
- SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx,
- SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx,
- SMESHDS_DataMapOfIntegerMesh.hxx,
- SMESHDS_DataMapOfIntegerMesh_0.cxx,
- SMESHDS_DataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS_DataMapOfIntegerPtrHypothesis_0.cxx,
- SMESHDS_DataMapOfIntegerSubMesh.hxx,
- SMESHDS_DataMapOfIntegerSubMesh_0.cxx,
- SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx,
- SMESHDS_DataMapOfShapeSubMesh.hxx,
- SMESHDS_DataMapOfShapeSubMesh_0.cxx, SMESHDS_Document.cdl,
- SMESHDS_Document.ixx, SMESHDS_Document.jxx,
- SMESHDS_ListIteratorOfListOfAsciiString.hxx,
- SMESHDS_ListIteratorOfListOfAsciiString_0.cxx,
- SMESHDS_ListIteratorOfListOfCommand.hxx,
- SMESHDS_ListIteratorOfListOfCommand_0.cxx,
- SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx,
- SMESHDS_ListIteratorOfListOfPtrHypothesis_0.cxx,
- SMESHDS_ListNodeOfListOfAsciiString.hxx,
- SMESHDS_ListNodeOfListOfAsciiString_0.cxx,
- SMESHDS_ListNodeOfListOfCommand.hxx,
- SMESHDS_ListNodeOfListOfCommand_0.cxx,
- SMESHDS_ListNodeOfListOfPtrHypothesis.hxx,
- SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx,
- SMESHDS_ListOfAsciiString.hxx, SMESHDS_ListOfAsciiString_0.cxx,
- SMESHDS_ListOfCommand.hxx, SMESHDS_ListOfCommand_0.cxx,
- SMESHDS_ListOfPtrHypothesis.hxx,
- SMESHDS_ListOfPtrHypothesis_0.cxx, SMESHDS_Mesh.cdl,
- SMESHDS_Mesh.ixx, SMESHDS_Mesh.jxx, SMESHDS_PtrHypothesis.hxx,
- SMESHDS_Script.cdl, SMESHDS_Script.ixx, SMESHDS_Script.jxx,
- SMESHDS_SubMesh.cdl, SMESHDS_SubMesh.ixx, SMESHDS_SubMesh.jxx:
- Remove no longer needed files
-
-2003-09-04 14:50 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/: Handle_SMDSControl_BoundaryEdges.hxx,
- Handle_SMDSControl_BoundaryFaces.hxx,
- Handle_SMDSControl_MeshBoundary.hxx,
- Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx,
- Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx,
- Handle_SMDS_EdgePosition.hxx, Handle_SMDS_FacePosition.hxx,
- Handle_SMDS_HSequenceOfMesh.hxx,
- Handle_SMDS_ListNodeOfListOfMesh.hxx,
- Handle_SMDS_ListNodeOfListOfMeshElement.hxx,
- Handle_SMDS_ListNodeOfListOfMeshGroup.hxx, Handle_SMDS_Mesh.hxx,
- Handle_SMDS_MeshEdge.hxx, Handle_SMDS_MeshElement.hxx,
- Handle_SMDS_MeshElementIDFactory.hxx, Handle_SMDS_MeshFace.hxx,
- Handle_SMDS_MeshGroup.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_SequenceNodeOfSequenceOfMesh.hxx,
- Handle_SMDS_SpacePosition.hxx,
- Handle_SMDS_StdMapNodeOfExtendedMap.hxx,
- Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx,
- Handle_SMDS_VertexPosition.hxx, SMDS.cdl, SMDSAbs.cdl,
- SMDSControl.cdl, SMDSControl.ixx, SMDSControl.jxx,
- SMDSControl_BoundaryEdges.cdl, SMDSControl_BoundaryEdges.ixx,
- SMDSControl_BoundaryEdges.jxx, SMDSControl_BoundaryFaces.cdl,
- SMDSControl_BoundaryFaces.ixx, SMDSControl_BoundaryFaces.jxx,
- SMDSControl_MeshBoundary.cdl, SMDSControl_MeshBoundary.ixx,
- SMDSControl_MeshBoundary.jxx, SMDSEdit.cdl,
- SMDSEdit_Transform.cdl, SMDSEdit_Transform.ixx,
- SMDSEdit_Transform.jxx, SMDS_BasicMap.lxx,
- SMDS_BasicMapIterator.lxx,
- SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx,
- SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx,
- SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx,
- SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx,
- SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx,
- SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx,
- SMDS_DataMapNodeOfDataMapOfPntInteger.hxx,
- SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx,
- SMDS_DataMapOfIntegerMeshElement.hxx,
- SMDS_DataMapOfIntegerMeshElement_0.cxx,
- SMDS_DataMapOfPntInteger.hxx, SMDS_DataMapOfPntInteger_0.cxx,
- SMDS_EdgePosition.cdl, SMDS_EdgePosition.ixx,
- SMDS_EdgePosition.jxx, SMDS_EdgePosition.lxx,
- SMDS_ExtendedMap.hxx, SMDS_ExtendedMap_0.cxx,
- SMDS_ExtendedOrientedMap.hxx, SMDS_ExtendedOrientedMap_0.cxx,
- SMDS_FacePosition.cdl, SMDS_FacePosition.ixx,
- SMDS_FacePosition.jxx, SMDS_FacePosition.lxx,
- SMDS_HSequenceOfMesh.hxx, SMDS_HSequenceOfMesh_0.cxx,
- SMDS_ListIteratorOfListOfMesh.hxx,
- SMDS_ListIteratorOfListOfMeshElement.hxx,
- SMDS_ListIteratorOfListOfMeshElement_0.cxx,
- SMDS_ListIteratorOfListOfMeshGroup.hxx,
- SMDS_ListIteratorOfListOfMeshGroup_0.cxx,
- SMDS_ListIteratorOfListOfMesh_0.cxx,
- SMDS_ListNodeOfListOfMesh.hxx,
- SMDS_ListNodeOfListOfMeshElement.hxx,
- SMDS_ListNodeOfListOfMeshElement_0.cxx,
- SMDS_ListNodeOfListOfMeshGroup.hxx,
- SMDS_ListNodeOfListOfMeshGroup_0.cxx,
- SMDS_ListNodeOfListOfMesh_0.cxx, SMDS_ListOfMesh.hxx,
- SMDS_ListOfMeshElement.hxx, SMDS_ListOfMeshElement_0.cxx,
- SMDS_ListOfMeshGroup.hxx, SMDS_ListOfMeshGroup_0.cxx,
- SMDS_ListOfMesh_0.cxx, SMDS_Map.gxx, SMDS_MapHasher.gxx,
- SMDS_MapIterator.gxx, SMDS_MapIteratorOfExtendedMap.hxx,
- SMDS_MapIteratorOfExtendedMap_0.cxx,
- SMDS_MapIteratorOfExtendedOrientedMap.hxx,
- SMDS_MapIteratorOfExtendedOrientedMap_0.cxx, SMDS_MapNode.lxx,
- SMDS_MapOfMeshElement.cdl, SMDS_MapOfMeshElement.cxx,
- SMDS_MapOfMeshElement.hxx, SMDS_MapOfMeshElement.ixx,
- SMDS_MapOfMeshElement.jxx, SMDS_MapOfMeshElement.lxx,
- SMDS_MapOfMeshOrientedElement.cdl,
- SMDS_MapOfMeshOrientedElement.cxx,
- SMDS_MapOfMeshOrientedElement.hxx,
- SMDS_MapOfMeshOrientedElement.ixx,
- SMDS_MapOfMeshOrientedElement.jxx,
- SMDS_MapOfMeshOrientedElement.lxx, SMDS_Mesh.cdl, SMDS_Mesh.ixx,
- SMDS_Mesh.jxx, SMDS_Mesh.lxx, SMDS_MeshEdge.cdl,
- SMDS_MeshEdge.ixx, SMDS_MeshEdge.jxx, SMDS_MeshEdge.lxx,
- SMDS_MeshEdgesIterator.cdl, SMDS_MeshEdgesIterator.cxx,
- SMDS_MeshEdgesIterator.hxx, SMDS_MeshEdgesIterator.ixx,
- SMDS_MeshEdgesIterator.jxx, SMDS_MeshElement.cdl,
- SMDS_MeshElement.ixx, SMDS_MeshElement.jxx, SMDS_MeshElement.lxx,
- SMDS_MeshElementIDFactory.cdl, SMDS_MeshElementIDFactory.ixx,
- SMDS_MeshElementIDFactory.jxx, SMDS_MeshElementIDFactory.lxx,
- SMDS_MeshElementMapHasher.cdl, SMDS_MeshElementMapHasher.cxx,
- SMDS_MeshElementMapHasher.hxx, SMDS_MeshElementMapHasher.ixx,
- SMDS_MeshElementMapHasher.jxx, SMDS_MeshElementMapHasher.lxx,
- SMDS_MeshElementsIterator.cdl, SMDS_MeshElementsIterator.cxx,
- SMDS_MeshElementsIterator.hxx, SMDS_MeshElementsIterator.ixx,
- SMDS_MeshElementsIterator.jxx, SMDS_MeshElementsIterator.lxx,
- SMDS_MeshFace.cdl, SMDS_MeshFace.ixx, SMDS_MeshFace.jxx,
- SMDS_MeshFace.lxx, SMDS_MeshFacesIterator.cdl,
- SMDS_MeshFacesIterator.cxx, SMDS_MeshFacesIterator.hxx,
- SMDS_MeshFacesIterator.ixx, SMDS_MeshFacesIterator.jxx,
- SMDS_MeshGroup.cdl, SMDS_MeshGroup.ixx, SMDS_MeshGroup.jxx,
- SMDS_MeshGroup.lxx, SMDS_MeshHexahedron.cdl,
- SMDS_MeshHexahedron.ixx, SMDS_MeshHexahedron.jxx,
- SMDS_MeshHexahedron.lxx, SMDS_MeshIDFactory.cdl,
- SMDS_MeshIDFactory.ixx, SMDS_MeshIDFactory.jxx,
- SMDS_MeshIDFactory.lxx, SMDS_MeshNode.cdl, SMDS_MeshNode.ixx,
- SMDS_MeshNode.jxx, SMDS_MeshNode.lxx, SMDS_MeshNodeIDFactory.cdl,
- SMDS_MeshNodeIDFactory.ixx, SMDS_MeshNodeIDFactory.jxx,
- SMDS_MeshNodeIDFactory.lxx, SMDS_MeshNodesIterator.cdl,
- SMDS_MeshNodesIterator.cxx, SMDS_MeshNodesIterator.hxx,
- SMDS_MeshNodesIterator.ixx, SMDS_MeshNodesIterator.jxx,
- SMDS_MeshObject.cdl, SMDS_MeshObject.ixx, SMDS_MeshObject.jxx,
- SMDS_MeshOrientedElementMapHasher.cdl,
- SMDS_MeshOrientedElementMapHasher.cxx,
- SMDS_MeshOrientedElementMapHasher.hxx,
- SMDS_MeshOrientedElementMapHasher.ixx,
- SMDS_MeshOrientedElementMapHasher.jxx,
- SMDS_MeshOrientedElementMapHasher.lxx, SMDS_MeshPrism.cdl,
- SMDS_MeshPrism.ixx, SMDS_MeshPrism.jxx, SMDS_MeshPrism.lxx,
- SMDS_MeshPyramid.cdl, SMDS_MeshPyramid.ixx, SMDS_MeshPyramid.jxx,
- SMDS_MeshPyramid.lxx, SMDS_MeshQuadrangle.cdl,
- SMDS_MeshQuadrangle.ixx, SMDS_MeshQuadrangle.jxx,
- SMDS_MeshQuadrangle.lxx, SMDS_MeshTetrahedron.cdl,
- SMDS_MeshTetrahedron.ixx, SMDS_MeshTetrahedron.jxx,
- SMDS_MeshTetrahedron.lxx, SMDS_MeshTriangle.cdl,
- SMDS_MeshTriangle.ixx, SMDS_MeshTriangle.jxx,
- SMDS_MeshTriangle.lxx, SMDS_MeshVolume.cdl, SMDS_MeshVolume.ixx,
- SMDS_MeshVolume.jxx, SMDS_MeshVolume.lxx,
- SMDS_MeshVolumesIterator.cdl, SMDS_MeshVolumesIterator.cxx,
- SMDS_MeshVolumesIterator.hxx, SMDS_MeshVolumesIterator.ixx,
- SMDS_MeshVolumesIterator.jxx, SMDS_PntHasher.cdl,
- SMDS_PntHasher.cxx, SMDS_PntHasher.hxx, SMDS_PntHasher.ixx,
- SMDS_PntHasher.jxx, SMDS_PntHasher.lxx, SMDS_Position.cdl,
- SMDS_Position.ixx, SMDS_Position.jxx, SMDS_Position.lxx,
- SMDS_SequenceNodeOfSequenceOfMesh.hxx,
- SMDS_SequenceNodeOfSequenceOfMesh_0.cxx, SMDS_SequenceOfMesh.hxx,
- SMDS_SequenceOfMesh_0.cxx, SMDS_SpacePosition.cdl,
- SMDS_SpacePosition.ixx, SMDS_SpacePosition.jxx,
- SMDS_SpacePosition.lxx, SMDS_StdMapNode.gxx, SMDS_StdMapNode.lxx,
- SMDS_StdMapNodeOfExtendedMap.hxx,
- SMDS_StdMapNodeOfExtendedMap_0.cxx,
- SMDS_StdMapNodeOfExtendedOrientedMap.hxx,
- SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx,
- SMDS_VertexPosition.cdl, SMDS_VertexPosition.ixx,
- SMDS_VertexPosition.jxx: Remove no longer needed files
-
-2003-09-04 13:28 Jerome Robert <jerome.robert@eads.net>
-
- * build_configure: It seems "make_omniorb" and "make_commence" need
- to be before and after "envScript"
-
-2003-09-04 12:57 Jerome Robert <jerome.robert@eads.net>
-
- * build_configure: make_commence and make_omniorb were detected
- twice. Only one is requiered in AC_OUTPUT
-
-2003-09-04 12:03 Jerome Robert <jerome.robert@eads.net>
-
- * src/: DriverDAT/DriverDAT_R_SMDS_Mesh.cxx,
- DriverDAT/DriverDAT_R_SMDS_Mesh.h,
- DriverDAT/DriverDAT_R_SMESHDS_Document.cxx,
- DriverDAT/DriverDAT_R_SMESHDS_Mesh.cxx,
- DriverDAT/DriverDAT_R_SMESHDS_Mesh.h,
- DriverDAT/DriverDAT_W_SMDS_Mesh.cxx,
- DriverDAT/DriverDAT_W_SMDS_Mesh.h,
- DriverDAT/DriverDAT_W_SMESHDS_Document.cxx,
- DriverDAT/DriverDAT_W_SMESHDS_Mesh.cxx,
- DriverDAT/DriverDAT_W_SMESHDS_Mesh.h,
- DriverMED/DriverMED_R_SMDS_Mesh.cxx,
- DriverMED/DriverMED_R_SMDS_Mesh.h,
- DriverMED/DriverMED_R_SMESHDS_Document.cxx,
- DriverMED/DriverMED_R_SMESHDS_Mesh.cxx,
- DriverMED/DriverMED_R_SMESHDS_Mesh.h,
- DriverMED/DriverMED_W_SMDS_Mesh.cxx,
- DriverMED/DriverMED_W_SMDS_Mesh.h,
- DriverMED/DriverMED_W_SMESHDS_Document.cxx,
- DriverMED/DriverMED_W_SMESHDS_Mesh.cxx,
- DriverMED/DriverMED_W_SMESHDS_Mesh.h,
- DriverUNV/DriverUNV_R_SMDS_Mesh.cxx,
- DriverUNV/DriverUNV_R_SMDS_Mesh.h,
- DriverUNV/DriverUNV_R_SMESHDS_Document.cxx,
- DriverUNV/DriverUNV_R_SMESHDS_Mesh.cxx,
- DriverUNV/DriverUNV_R_SMESHDS_Mesh.h,
- DriverUNV/DriverUNV_W_SMDS_Mesh.cxx,
- DriverUNV/DriverUNV_W_SMDS_Mesh.h,
- DriverUNV/DriverUNV_W_SMESHDS_Document.cxx,
- DriverUNV/DriverUNV_W_SMESHDS_Mesh.cxx,
- DriverUNV/DriverUNV_W_SMESHDS_Mesh.h: Update to match the changes
- in SMDS
-
-2003-09-04 11:03 Jerome Robert <jerome.robert@eads.net>
-
- * src/: DriverDAT/Makefile.in, DriverMED/Makefile.in,
- DriverUNV/Makefile.in: Remove OCC_LIBS from LDFLAGS
-
-2003-09-04 10:56 Jerome Robert <jerome.robert@eads.net>
-
- * src/Driver/: Document_Reader.cxx, Document_Reader.h,
- Document_Writer.cxx, Document_Writer.h, Mesh_Reader.h,
- Mesh_Writer.h: Update to mach the changes in SMDS
-
-2003-09-04 10:44 Jerome Robert <jerome.robert@eads.net>
-
- * src/Driver/Makefile.in: Remove OCC_LIBS from LDFLAGS
-
-2003-09-04 10:41 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESH_I/: SMESH_Gen_i.cxx, SMESH_MEDMesh_i.cxx,
- SMESH_MEDMesh_i.hxx, SMESH_MEDSupport_i.cxx,
- SMESH_MEDSupport_i.hxx, SMESH_MeshEditor_i.cxx,
- SMESH_MeshEditor_i.hxx, SMESH_Mesh_i.cxx: Update to match the new
- implementation of SMDS
-
-2003-09-04 10:10 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESH/SMESH_MaxElementArea.cxx: make GetMaxArea const
-
-2003-09-04 10:10 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESH/: SMESH_MEFISTO_2D.hxx, SMESH_Regular_1D.hxx: make
- hypothesis const
-
-2003-09-04 09:55 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESH/SMESH_Hexa_3D.hxx: Update to match the change of SMDS
- (new DS).
-
-2003-09-04 09:51 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESH_I/sstream: Use the file include in gcc instead of this
- one
-
-2003-09-04 09:21 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESH/: SMESH_Algo.cxx, SMESH_Algo.hxx, SMESH_Gen.cxx,
- SMESH_Gen.hxx, SMESH_Hexa_3D.cxx, SMESH_MEFISTO_2D.cxx,
- SMESH_MaxElementArea.hxx, SMESH_Mesh.cxx, SMESH_Mesh.hxx,
- SMESH_Quadrangle_2D.cxx, SMESH_Regular_1D.cxx, SMESH_subMesh.cxx,
- SMESH_subMesh.hxx: Update to match the change of SMDS (new DS).
-
-2003-09-04 09:13 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESH/: SMESH_NumberOfSegments.cxx,
- SMESH_NumberOfSegments.hxx: make GetNumberOfSegments and
- GetScaleFactor const
-
-2003-09-04 09:10 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESH/: SMESH_LocalLength.cxx, SMESH_LocalLength.hxx: make
- GetLength const
-
-2003-09-04 08:09 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESHFiltersSelection/Makefile.in: Change OCC_LIBS to
- OCC_KERNEL_LIBS
-
-2003-09-04 07:55 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESHGUI/Makefile.in: Change OCC_LIBS to OCC_KERNEL_LIBS
-
-2003-09-04 07:39 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESHGUI/: SMESHGUI.cxx, SMESHGUI.h: Change
- Handle(SMESHDS_Document) to SMESHDS_Document*
-
-2003-09-04 07:21 Jerome Robert <jerome.robert@eads.net>
-
- * src/MEFISTO2/Makefile.in: Remove OCC_LIBS from LDFLAGS
-
-2003-09-04 07:14 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMESHDS/: Makefile.in, SMESHDS_Command.cxx,
- SMESHDS_Command.hxx, SMESHDS_Document.cxx, SMESHDS_Document.hxx,
- SMESHDS_Hypothesis.cxx, SMESHDS_Hypothesis.hxx, SMESHDS_Mesh.cxx,
- SMESHDS_Mesh.hxx, SMESHDS_Script.cxx, SMESHDS_Script.hxx,
- SMESHDS_SubMesh.cxx, SMESHDS_SubMesh.hxx: Remove Opencascade
- dependencies. Change to STL.
-
-2003-09-03 17:31 Jerome Robert <jerome.robert@eads.net>
-
- * src/OBJECT/Makefile.in: Change OCC_LIBS to OCC_KERNEL_LIBS
-
-2003-09-03 17:30 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/: SMDS_Mesh.cxx, SMDS_Mesh.hxx, SMDS_MeshEdge.cxx,
- SMDS_MeshEdge.hxx, SMDS_MeshElement.cxx, SMDS_MeshElement.hxx,
- SMDS_MeshNode.cxx, SMDS_MeshNode.hxx, SMDS_MeshVolume.cxx,
- SMDS_MeshVolume.hxx, SMDS_MeshFace.cxx, SMDS_MeshFace.hxx: New DS
- implementation
-
-2003-09-03 17:29 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/: SMDS_EdgePosition.cxx, SMDS_EdgePosition.hxx,
- SMDS_FacePosition.cxx, SMDS_FacePosition.hxx,
- SMDS_MeshElementIDFactory.cxx, SMDS_MeshElementIDFactory.hxx,
- SMDS_MeshGroup.cxx, SMDS_MeshGroup.hxx, SMDS_MeshIDFactory.cxx,
- SMDS_MeshIDFactory.hxx, SMDS_MeshObject.cxx, SMDS_MeshObject.hxx,
- SMDS_Position.cxx, SMDS_Position.hxx, SMDS_SpacePosition.cxx,
- SMDS_SpacePosition.hxx, SMDS_TypeOfPosition.hxx,
- SMDS_VertexPosition.cxx, SMDS_VertexPosition.hxx: Remove
- Opencascade dependencies
-
-2003-09-03 17:21 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/SMDSAbs_ElementType.hxx: comments
-
-2003-09-03 17:21 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/: SMDS_Iterator.hxx, SMDS_IteratorOfElements.cxx,
- SMDS_IteratorOfElements.hxx: Add iterator classes
-
-2003-09-03 17:16 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/Makefile.in: Remove wok files. Comment no longer needed
- files
-
-2003-09-03 17:09 Jerome Robert <jerome.robert@eads.net>
-
- * src/SMDS/: SMDS_FaceOfEdges.cxx, SMDS_FaceOfEdges.hxx,
- SMDS_FaceOfNodes.cxx, SMDS_FaceOfNodes.hxx,
- SMDS_VolumeOfFaces.cxx, SMDS_VolumeOfFaces.hxx,
- SMDS_VolumeOfNodes.cxx, SMDS_VolumeOfNodes.hxx: Add needed class
- for the new DS
-
-2003-07-18 12:19 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESHGUI/SMESHGUI_StudyAPI.cxx: NRI : correction wrong merge.
-
-2003-07-11 07:32 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * bin/VERSION, doc/html/Makefile.in, doc/html/INPUT/doxyfile: NRI :
- Merge from V1_2.
-
-2003-07-10 17:51 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * configure.in.base: NRI : Merge from V1_2.
-
-2003-07-10 16:31 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESHGUI/: SMESHGUI_Swig.cxx, SMESHGUI_Swig.i: NRI : Merge
- from V1_2.
-
-2003-07-10 16:06 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESHGUI/SMESHGUI_Swig.cxx: NRI : Merge from V1_2.
-
-2003-07-10 15:36 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/Driver/Makefile.in: NRI : Merge from V1_2.
-
-2003-07-10 15:03 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESH/Makefile.in, src/SMESH_I/Makefile.in,
- idl/SMESH_BasicHypothesis.idl, idl/SMESH_Gen.idl,
- idl/SMESH_Hypothesis.idl, idl/SMESH_Mesh.idl,
- adm_local/unix/make_commence.in: NRI : Merge from V1_2.
-
-2003-07-10 14:47 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * configure.in.base: NRI : Merge from V1_2.
-
-2003-07-10 14:31 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/Driver/Makefile.in: NRI : Merge from V1_2.
-
-2003-07-10 13:35 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/: SMESH_I/Makefile.in, SMESH_I/SMESH_1D_Algo_i.cxx,
- SMESH_I/SMESH_1D_Algo_i.hxx, SMESH_I/SMESH_2D_Algo_i.cxx,
- SMESH_I/SMESH_2D_Algo_i.hxx, SMESH_I/SMESH_3D_Algo_i.cxx,
- SMESH_I/SMESH_3D_Algo_i.hxx, SMESH_I/SMESH_Algo_i.cxx,
- SMESH_I/SMESH_Algo_i.hxx, SMESH_I/SMESH_Gen_i.cxx,
- SMESH_I/SMESH_Gen_i.hxx, SMESH_I/SMESH_Hexa_3D_i.cxx,
- SMESH_I/SMESH_Hexa_3D_i.hxx,
- SMESH_I/SMESH_HypothesisFactory_i.cxx,
- SMESH_I/SMESH_HypothesisFactory_i.hxx,
- SMESH_I/SMESH_Hypothesis_i.cxx, SMESH_I/SMESH_Hypothesis_i.hxx,
- SMESH_I/SMESH_LocalLength_i.cxx, SMESH_I/SMESH_LocalLength_i.hxx,
- SMESH_I/SMESH_MEDFamily_i.cxx, SMESH_I/SMESH_MEDFamily_i.hxx,
- SMESH_I/SMESH_MEDMesh_i.cxx, SMESH_I/SMESH_MEDMesh_i.hxx,
- SMESH_I/SMESH_MEDSupport_i.cxx, SMESH_I/SMESH_MEDSupport_i.hxx,
- SMESH_I/SMESH_MEFISTO_2D_i.cxx, SMESH_I/SMESH_MEFISTO_2D_i.hxx,
- SMESH_I/SMESH_MaxElementArea_i.cxx,
- SMESH_I/SMESH_MaxElementArea_i.hxx,
- SMESH_I/SMESH_MaxElementVolume_i.cxx,
- SMESH_I/SMESH_MaxElementVolume_i.hxx,
- SMESH_I/SMESH_MeshEditor_i.cxx, SMESH_I/SMESH_MeshEditor_i.hxx,
- SMESH_I/SMESH_Mesh_i.cxx, SMESH_I/SMESH_Mesh_i.hxx,
- SMESH_I/SMESH_NumberOfSegments_i.cxx,
- SMESH_I/SMESH_NumberOfSegments_i.hxx,
- SMESH_I/SMESH_Quadrangle_2D_i.cxx,
- SMESH_I/SMESH_Quadrangle_2D_i.hxx,
- SMESH_I/SMESH_Regular_1D_i.cxx, SMESH_I/SMESH_Regular_1D_i.hxx,
- SMESH_I/SMESH_subMesh_i.cxx, SMESH_I/SMESH_subMesh_i.hxx,
- SMESH_I/SMESH_test.py, SMESH_I/SMESH_topo.cxx,
- SMESH_I/SMESH_topo.hxx, SMESH_I/smeshpy.py,
- SMESH_SWIG/Makefile.in, SMESH_SWIG/SMESH_fixation.py,
- SMESH_SWIG/SMESH_mechanic.py, SMESH_SWIG/SMESH_test0.py,
- SMESH_SWIG/SMESH_test1.py, SMESH_SWIG/SMESH_test2.py,
- SMESH_SWIG/SMESH_test3.py, SMESH_SWIG/batchmode_smesh.py,
- SMESH_SWIG/libSMESH_Swig.i: yfr : merge 1.2
-
-2003-07-10 13:18 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/SMESHGUI/: SMESHGUI.h, SMESHGUI_AddAlgorithmDlg.cxx,
- SMESHGUI_AddAlgorithmDlg.h, SMESHGUI_AddEdgeDlg.cxx,
- SMESHGUI_AddEdgeDlg.h, SMESHGUI_AddFaceDlg.cxx,
- SMESHGUI_AddFaceDlg.h, SMESHGUI_AddHypothesisDlg.cxx,
- SMESHGUI_AddHypothesisDlg.h, SMESHGUI_AddSubMeshDlg.cxx,
- SMESHGUI_AddSubMeshDlg.h, SMESHGUI_AddVolumeDlg.cxx,
- SMESHGUI_AddVolumeDlg.h, SMESHGUI_ComputeScalarValue.cxx,
- SMESHGUI_ComputeScalarValue.h, SMESHGUI_DiagonalInversionDlg.cxx,
- SMESHGUI_DiagonalInversionDlg.h,
- SMESHGUI_EdgesConnectivityDlg.cxx,
- SMESHGUI_EdgesConnectivityDlg.h, SMESHGUI_EditHypothesesDlg.cxx,
- SMESHGUI_EditHypothesesDlg.h, SMESHGUI_EditScalarBarDlg.cxx,
- SMESHGUI_EditScalarBarDlg.h, SMESHGUI_InitMeshDlg.cxx,
- SMESHGUI_InitMeshDlg.h, SMESHGUI_LocalLengthDlg.cxx,
- SMESHGUI_LocalLengthDlg.h, SMESHGUI_MaxElementAreaDlg.cxx,
- SMESHGUI_MaxElementAreaDlg.h, SMESHGUI_MaxElementVolumeDlg.cxx,
- SMESHGUI_MaxElementVolumeDlg.h, SMESHGUI_MeshInfosDlg.cxx,
- SMESHGUI_MeshInfosDlg.h, SMESHGUI_MoveNodesDlg.cxx,
- SMESHGUI_MoveNodesDlg.h, SMESHGUI_NbSegmentsDlg.cxx,
- SMESHGUI_NbSegmentsDlg.h, SMESHGUI_NodesDlg.cxx,
- SMESHGUI_NodesDlg.h, SMESHGUI_OrientationElementsDlg.cxx,
- SMESHGUI_OrientationElementsDlg.h,
- SMESHGUI_Preferences_ColorDlg.cxx,
- SMESHGUI_Preferences_ColorDlg.h,
- SMESHGUI_Preferences_ScalarBarDlg.cxx,
- SMESHGUI_Preferences_ScalarBarDlg.h,
- SMESHGUI_RemoveElementsDlg.cxx, SMESHGUI_RemoveElementsDlg.h,
- SMESHGUI_RemoveNodesDlg.cxx, SMESHGUI_RemoveNodesDlg.h,
- SMESHGUI_SpinBox.cxx, SMESHGUI_SpinBox.h, SMESHGUI_StudyAPI.cxx,
- SMESHGUI_StudyAPI.h, SMESHGUI_Swig.cxx, SMESHGUI_Swig.hxx,
- SMESHGUI_Swig.i, SMESHGUI_TransparencyDlg.cxx,
- SMESHGUI_TransparencyDlg.h, SMESHGUI_aParameterDlg.cxx,
- SMESHGUI_aParameterDlg.h: yfr : merge 1.2
-
-2003-07-10 12:18 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/SMESHGUI/: Makefile.in, SMESHGUI.cxx: yfr : Merge V1.2
-
-2003-07-10 11:35 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/SMESHFiltersSelection/Makefile.in: yfr : Merge with v1.2
-
-2003-07-10 10:04 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/: SMESHDS/Handle_SMESHDS_Command.hxx,
- SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx,
- SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx,
- SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx,
- SMESHDS/Handle_SMESHDS_Document.hxx,
- SMESHDS/Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx,
- SMESHDS/Handle_SMESHDS_ListNodeOfListOfCommand.hxx,
- SMESHDS/Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx,
- SMESHDS/Handle_SMESHDS_Mesh.hxx,
- SMESHDS/Handle_SMESHDS_Script.hxx,
- SMESHDS/Handle_SMESHDS_SubMesh.hxx, SMESHDS/Makefile.in,
- SMESHDS/SMESHDS.cdl, SMESHDS/SMESHDS_Command.cdl,
- SMESHDS/SMESHDS_Command.cxx, SMESHDS/SMESHDS_Command.hxx,
- SMESHDS/SMESHDS_Command.ixx, SMESHDS/SMESHDS_Command.jxx,
- SMESHDS/SMESHDS_CommandType.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapOfIntegerMesh.hxx,
- SMESHDS/SMESHDS_DataMapOfIntegerMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapOfIntegerSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapOfIntegerSubMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapOfShapeSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapOfShapeSubMesh_0.cxx,
- SMESHDS/SMESHDS_Document.cdl, SMESHDS/SMESHDS_Document.cxx,
- SMESHDS/SMESHDS_Document.hxx, SMESHDS/SMESHDS_Document.ixx,
- SMESHDS/SMESHDS_Document.jxx, SMESHDS/SMESHDS_Hypothesis.cxx,
- SMESHDS/SMESHDS_Hypothesis.hxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString.hxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString_0.cxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfCommand.hxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfCommand_0.cxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_ListNodeOfListOfAsciiString.hxx,
- SMESHDS/SMESHDS_ListNodeOfListOfAsciiString_0.cxx,
- SMESHDS/SMESHDS_ListNodeOfListOfCommand.hxx,
- SMESHDS/SMESHDS_ListNodeOfListOfCommand_0.cxx,
- SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_ListOfAsciiString.hxx,
- SMESHDS/SMESHDS_ListOfAsciiString_0.cxx,
- SMESHDS/SMESHDS_ListOfCommand.hxx,
- SMESHDS/SMESHDS_ListOfCommand_0.cxx,
- SMESHDS/SMESHDS_ListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_ListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_Mesh.cdl, SMESHDS/SMESHDS_Mesh.cxx,
- SMESHDS/SMESHDS_Mesh.hxx, SMESHDS/SMESHDS_Mesh.ixx,
- SMESHDS/SMESHDS_Mesh.jxx, SMESHDS/SMESHDS_PtrHypothesis.hxx,
- SMESHDS/SMESHDS_Script.cdl, SMESHDS/SMESHDS_Script.cxx,
- SMESHDS/SMESHDS_Script.hxx, SMESHDS/SMESHDS_Script.ixx,
- SMESHDS/SMESHDS_Script.jxx, SMESHDS/SMESHDS_SubMesh.cdl,
- SMESHDS/SMESHDS_SubMesh.cxx, SMESHDS/SMESHDS_SubMesh.hxx,
- SMESHDS/SMESHDS_SubMesh.ixx, SMESHDS/SMESHDS_SubMesh.jxx,
- SMESH/Makefile.in, SMESH/SMESH_1D_Algo.cxx,
- SMESH/SMESH_1D_Algo.hxx, SMESH/SMESH_2D_Algo.cxx,
- SMESH/SMESH_2D_Algo.hxx, SMESH/SMESH_3D_Algo.cxx,
- SMESH/SMESH_3D_Algo.hxx, SMESH/SMESH_Algo.cxx,
- SMESH/SMESH_Algo.hxx, SMESH/SMESH_Gen.cxx, SMESH/SMESH_Gen.hxx,
- SMESH/SMESH_Hexa_3D.cxx, SMESH/SMESH_Hexa_3D.hxx,
- SMESH/SMESH_Hypothesis.cxx, SMESH/SMESH_Hypothesis.hxx,
- SMESH/SMESH_HypothesisCreator.hxx,
- SMESH/SMESH_HypothesisFactory.cxx,
- SMESH/SMESH_HypothesisFactory.hxx,
- SMESH/SMESH_LengthFromEdges.cxx, SMESH/SMESH_LengthFromEdges.hxx,
- SMESH/SMESH_LocalLength.cxx, SMESH/SMESH_LocalLength.hxx,
- SMESH/SMESH_MEFISTO_2D.cxx, SMESH/SMESH_MEFISTO_2D.hxx,
- SMESH/SMESH_MaxElementArea.cxx, SMESH/SMESH_MaxElementArea.hxx,
- SMESH/SMESH_MaxElementVolume.cxx,
- SMESH/SMESH_MaxElementVolume.hxx, SMESH/SMESH_Mesh.cxx,
- SMESH/SMESH_Mesh.hxx, SMESH/SMESH_NumberOfSegments.cxx,
- SMESH/SMESH_NumberOfSegments.hxx, SMESH/SMESH_Quadrangle_2D.cxx,
- SMESH/SMESH_Quadrangle_2D.hxx, SMESH/SMESH_Regular_1D.cxx,
- SMESH/SMESH_Regular_1D.hxx, SMESH/SMESH_subMesh.cxx,
- SMESH/SMESH_subMesh.hxx: yfr : Merge with v1.2
-
-2003-07-10 09:49 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/SMDS/: Handle_SMDSControl_BoundaryEdges.hxx,
- Handle_SMDSControl_BoundaryFaces.hxx,
- Handle_SMDSControl_MeshBoundary.hxx,
- Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx,
- Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx,
- Handle_SMDS_EdgePosition.hxx, Handle_SMDS_FacePosition.hxx,
- Handle_SMDS_HSequenceOfMesh.hxx,
- Handle_SMDS_ListNodeOfListOfMesh.hxx,
- Handle_SMDS_ListNodeOfListOfMeshElement.hxx,
- Handle_SMDS_ListNodeOfListOfMeshGroup.hxx, Handle_SMDS_Mesh.hxx,
- Handle_SMDS_MeshEdge.hxx, Handle_SMDS_MeshElement.hxx,
- Handle_SMDS_MeshElementIDFactory.hxx, Handle_SMDS_MeshFace.hxx,
- Handle_SMDS_MeshGroup.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_SequenceNodeOfSequenceOfMesh.hxx,
- Handle_SMDS_SpacePosition.hxx,
- Handle_SMDS_StdMapNodeOfExtendedMap.hxx,
- Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx,
- Handle_SMDS_VertexPosition.hxx, Makefile.in, SMDS.cdl,
- SMDSAbs.cdl, SMDSAbs_ElementType.hxx, SMDSControl.cdl,
- SMDSControl.cxx, SMDSControl.hxx, SMDSControl.ixx,
- SMDSControl.jxx, SMDSControl_BoundaryEdges.cdl,
- SMDSControl_BoundaryEdges.cxx, SMDSControl_BoundaryEdges.hxx,
- SMDSControl_BoundaryEdges.ixx, SMDSControl_BoundaryEdges.jxx,
- SMDSControl_BoundaryFaces.cdl, SMDSControl_BoundaryFaces.cxx,
- SMDSControl_BoundaryFaces.hxx, SMDSControl_BoundaryFaces.ixx,
- SMDSControl_BoundaryFaces.jxx, SMDSControl_MeshBoundary.cdl,
- SMDSControl_MeshBoundary.cxx, SMDSControl_MeshBoundary.hxx,
- SMDSControl_MeshBoundary.ixx, SMDSControl_MeshBoundary.jxx,
- SMDSEdit.cdl, SMDSEdit_Transform.cdl, SMDSEdit_Transform.cxx,
- SMDSEdit_Transform.hxx, SMDSEdit_Transform.ixx,
- SMDSEdit_Transform.jxx, SMDS_BasicMap.lxx,
- SMDS_BasicMapIterator.lxx,
- SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx,
- SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx,
- SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx,
- SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx,
- SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx,
- SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx,
- SMDS_DataMapNodeOfDataMapOfPntInteger.hxx,
- SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx,
- SMDS_DataMapOfIntegerMeshElement.hxx,
- SMDS_DataMapOfIntegerMeshElement_0.cxx,
- SMDS_DataMapOfPntInteger.hxx, SMDS_DataMapOfPntInteger_0.cxx,
- SMDS_EdgePosition.cdl, SMDS_EdgePosition.cxx,
- SMDS_EdgePosition.hxx, SMDS_EdgePosition.ixx,
- SMDS_EdgePosition.jxx, SMDS_EdgePosition.lxx,
- SMDS_ExtendedMap.hxx, SMDS_ExtendedMap_0.cxx,
- SMDS_ExtendedOrientedMap.hxx, SMDS_ExtendedOrientedMap_0.cxx,
- SMDS_FacePosition.cdl, SMDS_FacePosition.cxx,
- SMDS_FacePosition.hxx, SMDS_FacePosition.ixx,
- SMDS_FacePosition.jxx, SMDS_FacePosition.lxx,
- SMDS_HSequenceOfMesh.hxx, SMDS_HSequenceOfMesh_0.cxx,
- SMDS_ListIteratorOfListOfMesh.hxx,
- SMDS_ListIteratorOfListOfMeshElement.hxx,
- SMDS_ListIteratorOfListOfMeshElement_0.cxx,
- SMDS_ListIteratorOfListOfMeshGroup.hxx,
- SMDS_ListIteratorOfListOfMeshGroup_0.cxx,
- SMDS_ListIteratorOfListOfMesh_0.cxx,
- SMDS_ListNodeOfListOfMesh.hxx,
- SMDS_ListNodeOfListOfMeshElement.hxx,
- SMDS_ListNodeOfListOfMeshElement_0.cxx,
- SMDS_ListNodeOfListOfMeshGroup.hxx,
- SMDS_ListNodeOfListOfMeshGroup_0.cxx,
- SMDS_ListNodeOfListOfMesh_0.cxx, SMDS_ListOfMesh.hxx,
- SMDS_ListOfMeshElement.hxx, SMDS_ListOfMeshElement_0.cxx,
- SMDS_ListOfMeshGroup.hxx, SMDS_ListOfMeshGroup_0.cxx,
- SMDS_ListOfMesh_0.cxx, SMDS_MapIteratorOfExtendedMap.hxx,
- SMDS_MapIteratorOfExtendedMap_0.cxx,
- SMDS_MapIteratorOfExtendedOrientedMap.hxx,
- SMDS_MapIteratorOfExtendedOrientedMap_0.cxx, SMDS_MapNode.lxx,
- SMDS_MapOfMeshElement.cdl, SMDS_MapOfMeshElement.cxx,
- SMDS_MapOfMeshElement.hxx, SMDS_MapOfMeshElement.ixx,
- SMDS_MapOfMeshElement.jxx, SMDS_MapOfMeshElement.lxx,
- SMDS_MapOfMeshOrientedElement.cdl,
- SMDS_MapOfMeshOrientedElement.cxx,
- SMDS_MapOfMeshOrientedElement.hxx,
- SMDS_MapOfMeshOrientedElement.ixx,
- SMDS_MapOfMeshOrientedElement.jxx,
- SMDS_MapOfMeshOrientedElement.lxx, SMDS_Mesh.cdl, SMDS_Mesh.cxx,
- SMDS_Mesh.hxx, SMDS_Mesh.ixx, SMDS_Mesh.jxx, SMDS_Mesh.lxx,
- SMDS_MeshEdge.cdl, SMDS_MeshEdge.cxx, SMDS_MeshEdge.hxx,
- SMDS_MeshEdge.ixx, SMDS_MeshEdge.jxx, SMDS_MeshEdge.lxx,
- SMDS_MeshEdgesIterator.cdl, SMDS_MeshEdgesIterator.cxx,
- SMDS_MeshEdgesIterator.hxx, SMDS_MeshEdgesIterator.ixx,
- SMDS_MeshEdgesIterator.jxx, SMDS_MeshElement.cdl,
- SMDS_MeshElement.cxx, SMDS_MeshElement.hxx, SMDS_MeshElement.ixx,
- SMDS_MeshElement.jxx, SMDS_MeshElement.lxx,
- SMDS_MeshElementIDFactory.cdl, SMDS_MeshElementIDFactory.cxx,
- SMDS_MeshElementIDFactory.hxx, SMDS_MeshElementIDFactory.ixx,
- SMDS_MeshElementIDFactory.jxx, SMDS_MeshElementIDFactory.lxx,
- SMDS_MeshElementMapHasher.cdl, SMDS_MeshElementMapHasher.cxx,
- SMDS_MeshElementMapHasher.hxx, SMDS_MeshElementMapHasher.ixx,
- SMDS_MeshElementMapHasher.jxx, SMDS_MeshElementMapHasher.lxx,
- SMDS_MeshElementsIterator.cdl, SMDS_MeshElementsIterator.cxx,
- SMDS_MeshElementsIterator.hxx, SMDS_MeshElementsIterator.ixx,
- SMDS_MeshElementsIterator.jxx, SMDS_MeshElementsIterator.lxx,
- SMDS_MeshFace.cdl, SMDS_MeshFace.cxx, SMDS_MeshFace.hxx,
- SMDS_MeshFace.ixx, SMDS_MeshFace.jxx, SMDS_MeshFace.lxx,
- SMDS_MeshFacesIterator.cdl, SMDS_MeshFacesIterator.cxx,
- SMDS_MeshFacesIterator.hxx, SMDS_MeshFacesIterator.ixx,
- SMDS_MeshFacesIterator.jxx, SMDS_MeshGroup.cdl,
- SMDS_MeshGroup.cxx, SMDS_MeshGroup.hxx, SMDS_MeshGroup.ixx,
- SMDS_MeshGroup.jxx, SMDS_MeshGroup.lxx, SMDS_MeshHexahedron.cdl,
- SMDS_MeshHexahedron.cxx, SMDS_MeshHexahedron.hxx,
- SMDS_MeshHexahedron.ixx, SMDS_MeshHexahedron.jxx,
- SMDS_MeshHexahedron.lxx, SMDS_MeshIDFactory.cdl,
- SMDS_MeshIDFactory.cxx, SMDS_MeshIDFactory.hxx,
- SMDS_MeshIDFactory.ixx, SMDS_MeshIDFactory.jxx,
- SMDS_MeshIDFactory.lxx, SMDS_MeshNode.cdl, SMDS_MeshNode.cxx,
- SMDS_MeshNode.hxx, SMDS_MeshNode.ixx, SMDS_MeshNode.jxx,
- SMDS_MeshNode.lxx, SMDS_MeshNodeIDFactory.cdl,
- SMDS_MeshNodeIDFactory.cxx, SMDS_MeshNodeIDFactory.hxx,
- SMDS_MeshNodeIDFactory.ixx, SMDS_MeshNodeIDFactory.jxx,
- SMDS_MeshNodeIDFactory.lxx, SMDS_MeshNodesIterator.cdl,
- SMDS_MeshNodesIterator.cxx, SMDS_MeshNodesIterator.hxx,
- SMDS_MeshNodesIterator.ixx, SMDS_MeshNodesIterator.jxx,
- SMDS_MeshObject.cdl, SMDS_MeshObject.cxx, SMDS_MeshObject.hxx,
- SMDS_MeshObject.ixx, SMDS_MeshObject.jxx,
- SMDS_MeshOrientedElementMapHasher.cdl,
- SMDS_MeshOrientedElementMapHasher.cxx,
- SMDS_MeshOrientedElementMapHasher.hxx,
- SMDS_MeshOrientedElementMapHasher.ixx,
- SMDS_MeshOrientedElementMapHasher.jxx,
- SMDS_MeshOrientedElementMapHasher.lxx, SMDS_MeshPrism.cdl,
- SMDS_MeshPrism.cxx, SMDS_MeshPrism.hxx, SMDS_MeshPrism.ixx,
- SMDS_MeshPrism.jxx, SMDS_MeshPrism.lxx, SMDS_MeshPyramid.cdl,
- SMDS_MeshPyramid.cxx, SMDS_MeshPyramid.hxx, SMDS_MeshPyramid.ixx,
- SMDS_MeshPyramid.jxx, SMDS_MeshPyramid.lxx,
- SMDS_MeshQuadrangle.cdl, SMDS_MeshQuadrangle.cxx,
- SMDS_MeshQuadrangle.hxx, SMDS_MeshQuadrangle.ixx,
- SMDS_MeshQuadrangle.jxx, SMDS_MeshQuadrangle.lxx,
- SMDS_MeshTetrahedron.cdl, SMDS_MeshTetrahedron.cxx,
- SMDS_MeshTetrahedron.hxx, SMDS_MeshTetrahedron.ixx,
- SMDS_MeshTetrahedron.jxx, SMDS_MeshTetrahedron.lxx,
- SMDS_MeshTriangle.cdl, SMDS_MeshTriangle.cxx,
- SMDS_MeshTriangle.hxx, SMDS_MeshTriangle.ixx,
- SMDS_MeshTriangle.jxx, SMDS_MeshTriangle.lxx,
- SMDS_MeshVolume.cdl, SMDS_MeshVolume.cxx, SMDS_MeshVolume.hxx,
- SMDS_MeshVolume.ixx, SMDS_MeshVolume.jxx, SMDS_MeshVolume.lxx,
- SMDS_MeshVolumesIterator.cdl, SMDS_MeshVolumesIterator.cxx,
- SMDS_MeshVolumesIterator.hxx, SMDS_MeshVolumesIterator.ixx,
- SMDS_MeshVolumesIterator.jxx, SMDS_PntHasher.cdl,
- SMDS_PntHasher.cxx, SMDS_PntHasher.hxx, SMDS_PntHasher.ixx,
- SMDS_PntHasher.jxx, SMDS_PntHasher.lxx, SMDS_Position.cdl,
- SMDS_Position.cxx, SMDS_Position.hxx, SMDS_Position.ixx,
- SMDS_Position.jxx, SMDS_Position.lxx,
- SMDS_SequenceNodeOfSequenceOfMesh.hxx,
- SMDS_SequenceNodeOfSequenceOfMesh_0.cxx, SMDS_SequenceOfMesh.hxx,
- SMDS_SequenceOfMesh_0.cxx, SMDS_SpacePosition.cdl,
- SMDS_SpacePosition.cxx, SMDS_SpacePosition.hxx,
- SMDS_SpacePosition.ixx, SMDS_SpacePosition.jxx,
- SMDS_SpacePosition.lxx, SMDS_StdMapNode.lxx,
- SMDS_StdMapNodeOfExtendedMap.hxx,
- SMDS_StdMapNodeOfExtendedMap_0.cxx,
- SMDS_StdMapNodeOfExtendedOrientedMap.hxx,
- SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx,
- SMDS_TypeOfPosition.hxx, SMDS_VertexPosition.cdl,
- SMDS_VertexPosition.cxx, SMDS_VertexPosition.hxx,
- SMDS_VertexPosition.ixx, SMDS_VertexPosition.jxx: yfr : Merge
- with v1.2
-
-2003-07-10 09:32 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/: DriverDAT/Makefile.in, DriverUNV/Makefile.in,
- MEFISTO2/Makefile.in, OBJECT/Makefile.in, OBJECT/SMESH_Actor.cxx,
- OBJECT/SMESH_Actor.h, OBJECT/SMESH_Grid.cxx, OBJECT/SMESH_Grid.h:
- yfr : Merge with v1.2
-
-2003-07-10 09:14 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/Makefile.in: yfr : Merge with v1.2
-
-2003-07-10 09:00 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/: Driver/Document_Reader.cxx, Driver/Document_Reader.h,
- Driver/Document_Writer.cxx, Driver/Document_Writer.h,
- Driver/Driver_dl.cxx, Driver/Makefile.in, Driver/Mesh_Reader.cxx,
- Driver/Mesh_Reader.h, Driver/Mesh_Writer.cxx,
- Driver/Mesh_Writer.h, Driver/SMESHDriver.cxx,
- Driver/SMESHDriver.h, DriverDAT/DriverDAT_R_SMDS_Mesh.cxx,
- DriverDAT/DriverDAT_R_SMDS_Mesh.h,
- DriverDAT/DriverDAT_R_SMESHDS_Document.cxx,
- DriverDAT/DriverDAT_R_SMESHDS_Document.h,
- DriverDAT/DriverDAT_R_SMESHDS_Mesh.cxx,
- DriverDAT/DriverDAT_R_SMESHDS_Mesh.h,
- DriverDAT/DriverDAT_W_SMDS_Mesh.cxx,
- DriverDAT/DriverDAT_W_SMDS_Mesh.h,
- DriverDAT/DriverDAT_W_SMESHDS_Document.cxx,
- DriverDAT/DriverDAT_W_SMESHDS_Document.h,
- DriverDAT/DriverDAT_W_SMESHDS_Mesh.cxx,
- DriverDAT/DriverDAT_W_SMESHDS_Mesh.h, DriverDAT/Makefile.in,
- DriverMED/DriverMED_R_SMDS_Mesh.cxx,
- DriverMED/DriverMED_R_SMESHDS_Document.cxx,
- DriverMED/DriverMED_R_SMESHDS_Mesh.cxx,
- DriverMED/DriverMED_W_SMDS_Mesh.cxx,
- DriverMED/DriverMED_W_SMESHDS_Document.cxx,
- DriverMED/DriverMED_W_SMESHDS_Mesh.cxx, DriverMED/Makefile.in,
- MEFISTO2/Makefile.in, MEFISTO2/Rn.h, MEFISTO2/aptrte.cxx,
- MEFISTO2/aptrte.h: yfr : Merge with v1.2
-
-2003-07-10 08:12 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/SMESHGUI/SMESHGUI_icons.po: Initial revision
-
-2003-07-10 08:09 tag V1_2
-
-2003-07-10 08:09 Yves Fricaud <yves.fricaud@opencascade.com>
-
- * src/: DriverMED/DriverMED_R_SMESHDS_Document.h,
- DriverMED/DriverMED_W_SMESHDS_Document.h,
- SMESHGUI/SMESHGUI_msg_en.po: sources v1.2
-
-2003-06-29 13:17 Paul Rascle <paul.rascle@edf.fr>
-
- * src/SMESH_SWIG/: Makefile.in, SMESH_shared_modules.py: PR: needed
- by merge C. CAREMOLI branch CCAR_br1
-
-2003-06-12 10:37 Paul Rascle <paul.rascle@edf.fr>
-
- * Makefile.in: PR: avoids unnecessary compilation after
- regeneration of SALOMEconfig.h, with gcc3.2
-
-2003-06-12 10:34 Paul Rascle <paul.rascle@edf.fr>
-
- * src/SMESH_SWIG/SMESH_fixation.py: PR: bug on subshapes not sorted
-
-2003-05-28 16:42 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * adm_local/unix/make_commence.in: NRI : Add path fro GEOM and MED
- idls.
-
-2003-05-28 16:26 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * idl/Makefile.in, adm_local/unix/make_commence.in,
- adm_local/unix/make_omniorb.in, build_configure,
- configure.in.base: NRI : Update IDL Dependencies.
-
-2003-05-28 07:20 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * bin/VERSION, Makefile.in: NRI : Add MODULE version info.
-
-2003-05-28 07:16 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * configure.in.base, adm_local/unix/config_files/check_Med.m4: NRI
- : Add Check of MED.
-
-2003-05-26 14:21 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * adm_local/unix/config_files/check_Geom.m4, configure.in.base: NRI
- : Add GEOM check local.
-
-2003-05-26 14:00 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * build_configure: NRI : updated aclocal.
-
-2003-05-23 11:40 tag Start-v1_1a
-
-2003-05-23 11:40 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESHGUI/: SMESHGUI_AddAlgorithmDlg.cxx,
- SMESHGUI_AddEdgeDlg.cxx, SMESHGUI_AddFaceDlg.cxx,
- SMESHGUI_AddHypothesisDlg.cxx, SMESHGUI_AddSubMeshDlg.cxx,
- SMESHGUI_AddVolumeDlg.cxx, SMESHGUI_DiagonalInversionDlg.cxx,
- SMESHGUI_EdgesConnectivityDlg.cxx,
- SMESHGUI_EditHypothesesDlg.cxx, SMESHGUI_InitMeshDlg.cxx,
- SMESHGUI_LocalLengthDlg.cxx, SMESHGUI_MaxElementAreaDlg.cxx,
- SMESHGUI_MaxElementVolumeDlg.cxx, SMESHGUI_MoveNodesDlg.cxx,
- SMESHGUI_NbSegmentsDlg.cxx, SMESHGUI_NodesDlg.cxx,
- SMESHGUI_OrientationElementsDlg.cxx,
- SMESHGUI_RemoveElementsDlg.cxx, SMESHGUI_RemoveNodesDlg.cxx: NRI
- : loadPixmap( "SMESH", ...) instead of "SMESHGUI".
-
-2003-05-22 09:52 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * doc/: Makefile.in, html/Makefile.in, html/INPUT/doxyfile,
- html/INPUT/sources/Application-About.png,
- html/INPUT/sources/Application-About1.jpg,
- html/INPUT/sources/application.gif,
- html/INPUT/sources/application.jpg,
- html/INPUT/sources/bg_salomepro.gif,
- html/INPUT/sources/doxygen.css, html/INPUT/sources/logocorp.gif,
- html/INPUT/sources/myheader.html, html/INPUT/sources/occ.gif,
- html/INPUT/HTML/SMESH_BasicHypothesis.html,
- html/INPUT/HTML/SMESH_Gen.html,
- html/INPUT/HTML/SMESH_Hypothesis.html,
- html/INPUT/HTML/SMESH_Mesh.html: NRI : Add documentation.
-
-2003-05-22 09:51 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * configure.in.base: NRI : Add check HTML generators.
-
-2003-05-20 07:17 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/: SMESH_I/SMESH_Gen_i.cxx, SMESH_I/SMESH_test.py,
- SMESH_I/smeshpy.py, SMESH_SWIG/SMESH_fixation.py,
- SMESH_SWIG/SMESH_mechanic.py, SMESH_SWIG/SMESH_test0.py,
- SMESH_SWIG/SMESH_test1.py, SMESH_SWIG/SMESH_test3.py,
- SMESHGUI/SMESHGUI.cxx: NRI : Use GEOM instead of Geometry.
-
-2003-05-20 07:16 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * resources/SMESHCatalog.xml: NRI : Add component-username tag.
-
-2003-05-20 07:15 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * Makefile.in: NRI : Add SMESHCatalog.xml
-
-2003-05-19 14:50 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESHGUI/SMESHGUI_StudyAPI.cxx: NRI : Add QAD_Desktop.h.
-
-2003-05-19 14:49 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESHGUI/Makefile.in: NRI : Add GEOM includes and libs.
-
-2003-05-19 14:38 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESHFiltersSelection/Makefile.in: NRI : Add KERNEL includes.
-
-2003-05-19 14:34 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESH_I/Makefile.in: NRI : Change lGeometryClient by
- lGEOMClient.
-
-2003-05-19 14:32 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/SMESH_I/Makefile.in: NRI : Add GEOM includes and libs.
-
-2003-05-19 14:11 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/: SMESH/Makefile.in, SMESHDS/Makefile.in: NRI : Add KERNEL
- includes and libs.
-
-2003-05-19 14:09 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/: DriverDAT/Makefile.in, DriverMED/Makefile.in,
- DriverUNV/Makefile.in: NRI : Add KERNEL includes.
-
-2003-05-19 14:08 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * idl/Makefile.in: NRI : Add MED.idl
-
-2003-05-19 14:01 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/: SMESH_SWIG/Makefile.in, SMESH_SWIG/SMESH_fixation.py,
- SMESH_SWIG/SMESH_mechanic.py, SMESH_SWIG/SMESH_test0.py,
- SMESH_SWIG/SMESH_test1.py, SMESH_SWIG/SMESH_test2.py,
- SMESH_SWIG/SMESH_test3.py, SMESH_SWIG/batchmode_smesh.py,
- SMESH_SWIG/libSMESH_Swig.i, Makefile.in,
- SMESHFiltersSelection/Handle_SMESH_TypeFilter.hxx,
- SMESHFiltersSelection/Makefile.in,
- SMESHFiltersSelection/SMESH_Type.h,
- SMESHFiltersSelection/SMESH_TypeFilter.cxx,
- SMESHFiltersSelection/SMESH_TypeFilter.hxx,
- SMESHFiltersSelection/SMESH_TypeFilter.ixx,
- SMESHFiltersSelection/SMESH_TypeFilter.jxx, MEFISTO2/Makefile.in,
- MEFISTO2/Rn.h, MEFISTO2/aptrte.cxx, MEFISTO2/aptrte.h,
- MEFISTO2/areteideale.f, MEFISTO2/trte.f, OBJECT/Makefile.in,
- OBJECT/SMESH_Actor.cxx, OBJECT/SMESH_Actor.h,
- OBJECT/SMESH_Grid.cxx, OBJECT/SMESH_Grid.h,
- Driver/Document_Reader.cxx, Driver/Document_Reader.h,
- Driver/Document_Writer.cxx, Driver/Document_Writer.h,
- Driver/Driver_dl.cxx, Driver/Makefile.in, Driver/Mesh_Reader.cxx,
- Driver/Mesh_Reader.h, Driver/Mesh_Writer.cxx,
- Driver/Mesh_Writer.h, Driver/SMESHDriver.cxx,
- Driver/SMESHDriver.h: NRI : First integration.
-
-2003-05-19 13:48 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/: SMDS/Handle_SMDSControl_BoundaryEdges.hxx,
- SMDS/Handle_SMDSControl_BoundaryFaces.hxx,
- SMDS/Handle_SMDSControl_MeshBoundary.hxx,
- SMDS/Handle_SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx,
- SMDS/Handle_SMDS_DataMapNodeOfDataMapOfPntInteger.hxx,
- SMDS/Handle_SMDS_EdgePosition.hxx,
- SMDS/Handle_SMDS_FacePosition.hxx,
- SMDS/Handle_SMDS_HSequenceOfMesh.hxx,
- SMDS/Handle_SMDS_ListNodeOfListOfMesh.hxx,
- SMDS/Handle_SMDS_ListNodeOfListOfMeshElement.hxx,
- SMDS/Handle_SMDS_ListNodeOfListOfMeshGroup.hxx,
- SMDS/Handle_SMDS_Mesh.hxx, SMDS/Handle_SMDS_MeshEdge.hxx,
- SMDS/Handle_SMDS_MeshElement.hxx,
- SMDS/Handle_SMDS_MeshElementIDFactory.hxx,
- SMDS/Handle_SMDS_MeshFace.hxx, SMDS/Handle_SMDS_MeshGroup.hxx,
- SMDS/Handle_SMDS_MeshHexahedron.hxx,
- SMDS/Handle_SMDS_MeshIDFactory.hxx,
- SMDS/Handle_SMDS_MeshNode.hxx,
- SMDS/Handle_SMDS_MeshNodeIDFactory.hxx,
- SMDS/Handle_SMDS_MeshObject.hxx, SMDS/Handle_SMDS_MeshPrism.hxx,
- SMDS/Handle_SMDS_MeshPyramid.hxx,
- SMDS/Handle_SMDS_MeshQuadrangle.hxx,
- SMDS/Handle_SMDS_MeshTetrahedron.hxx,
- SMDS/Handle_SMDS_MeshTriangle.hxx,
- SMDS/Handle_SMDS_MeshVolume.hxx, SMDS/Handle_SMDS_Position.hxx,
- SMDS/Handle_SMDS_SequenceNodeOfSequenceOfMesh.hxx,
- SMDS/Handle_SMDS_SpacePosition.hxx,
- SMDS/Handle_SMDS_StdMapNodeOfExtendedMap.hxx,
- SMDS/Handle_SMDS_StdMapNodeOfExtendedOrientedMap.hxx,
- SMDS/Handle_SMDS_VertexPosition.hxx, SMDS/Makefile.in,
- SMDS/SMDS.cdl, SMDS/SMDSAbs.cdl, SMDS/SMDSAbs_ElementType.hxx,
- SMDS/SMDSControl.cdl, SMDS/SMDSControl.cxx, SMDS/SMDSControl.hxx,
- SMDS/SMDSControl.ixx, SMDS/SMDSControl.jxx,
- SMDS/SMDSControl_BoundaryEdges.cdl,
- SMDS/SMDSControl_BoundaryEdges.cxx,
- SMDS/SMDSControl_BoundaryEdges.hxx,
- SMDS/SMDSControl_BoundaryEdges.ixx,
- SMDS/SMDSControl_BoundaryEdges.jxx,
- SMDS/SMDSControl_BoundaryFaces.cdl,
- SMDS/SMDSControl_BoundaryFaces.cxx,
- SMDS/SMDSControl_BoundaryFaces.hxx,
- SMDS/SMDSControl_BoundaryFaces.ixx,
- SMDS/SMDSControl_BoundaryFaces.jxx,
- SMDS/SMDSControl_MeshBoundary.cdl,
- SMDS/SMDSControl_MeshBoundary.cxx,
- SMDS/SMDSControl_MeshBoundary.hxx,
- SMDS/SMDSControl_MeshBoundary.ixx,
- SMDS/SMDSControl_MeshBoundary.jxx, SMDS/SMDSEdit.cdl,
- SMDS/SMDSEdit_Transform.cdl, SMDS/SMDSEdit_Transform.cxx,
- SMDS/SMDSEdit_Transform.hxx, SMDS/SMDSEdit_Transform.ixx,
- SMDS/SMDSEdit_Transform.jxx, SMDS/SMDS_BasicMap.lxx,
- SMDS/SMDS_BasicMapIterator.lxx,
- SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement.hxx,
- SMDS/SMDS_DataMapIteratorOfDataMapOfIntegerMeshElement_0.cxx,
- SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger.hxx,
- SMDS/SMDS_DataMapIteratorOfDataMapOfPntInteger_0.cxx,
- SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement.hxx,
- SMDS/SMDS_DataMapNodeOfDataMapOfIntegerMeshElement_0.cxx,
- SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger.hxx,
- SMDS/SMDS_DataMapNodeOfDataMapOfPntInteger_0.cxx,
- SMDS/SMDS_DataMapOfIntegerMeshElement.hxx,
- SMDS/SMDS_DataMapOfIntegerMeshElement_0.cxx,
- SMDS/SMDS_DataMapOfPntInteger.hxx,
- SMDS/SMDS_DataMapOfPntInteger_0.cxx, SMDS/SMDS_EdgePosition.cdl,
- SMDS/SMDS_EdgePosition.cxx, SMDS/SMDS_EdgePosition.hxx,
- SMDS/SMDS_EdgePosition.ixx, SMDS/SMDS_EdgePosition.jxx,
- SMDS/SMDS_EdgePosition.lxx, SMDS/SMDS_ExtendedMap.hxx,
- SMDS/SMDS_ExtendedMap_0.cxx, SMDS/SMDS_ExtendedOrientedMap.hxx,
- SMDS/SMDS_ExtendedOrientedMap_0.cxx, SMDS/SMDS_FacePosition.cdl,
- SMDS/SMDS_FacePosition.cxx, SMDS/SMDS_FacePosition.hxx,
- SMDS/SMDS_FacePosition.ixx, SMDS/SMDS_FacePosition.jxx,
- SMDS/SMDS_FacePosition.lxx, SMDS/SMDS_HSequenceOfMesh.hxx,
- SMDS/SMDS_HSequenceOfMesh_0.cxx,
- SMDS/SMDS_ListIteratorOfListOfMesh.hxx,
- SMDS/SMDS_ListIteratorOfListOfMeshElement.hxx,
- SMDS/SMDS_ListIteratorOfListOfMeshElement_0.cxx,
- SMDS/SMDS_ListIteratorOfListOfMeshGroup.hxx,
- SMDS/SMDS_ListIteratorOfListOfMeshGroup_0.cxx,
- SMDS/SMDS_ListIteratorOfListOfMesh_0.cxx,
- SMDS/SMDS_ListNodeOfListOfMesh.hxx,
- SMDS/SMDS_ListNodeOfListOfMeshElement.hxx,
- SMDS/SMDS_ListNodeOfListOfMeshElement_0.cxx,
- SMDS/SMDS_ListNodeOfListOfMeshGroup.hxx,
- SMDS/SMDS_ListNodeOfListOfMeshGroup_0.cxx,
- SMDS/SMDS_ListNodeOfListOfMesh_0.cxx, SMDS/SMDS_ListOfMesh.hxx,
- SMDS/SMDS_ListOfMeshElement.hxx,
- SMDS/SMDS_ListOfMeshElement_0.cxx, SMDS/SMDS_ListOfMeshGroup.hxx,
- SMDS/SMDS_ListOfMeshGroup_0.cxx, SMDS/SMDS_ListOfMesh_0.cxx,
- SMDS/SMDS_Map.gxx, SMDS/SMDS_MapHasher.gxx,
- SMDS/SMDS_MapIterator.gxx,
- SMDS/SMDS_MapIteratorOfExtendedMap.hxx,
- SMDS/SMDS_MapIteratorOfExtendedMap_0.cxx,
- SMDS/SMDS_MapIteratorOfExtendedOrientedMap.hxx,
- SMDS/SMDS_MapIteratorOfExtendedOrientedMap_0.cxx,
- SMDS/SMDS_MapNode.lxx, SMDS/SMDS_MapOfMeshElement.cdl,
- SMDS/SMDS_MapOfMeshElement.cxx, SMDS/SMDS_MapOfMeshElement.hxx,
- SMDS/SMDS_MapOfMeshElement.ixx, SMDS/SMDS_MapOfMeshElement.jxx,
- SMDS/SMDS_MapOfMeshElement.lxx,
- SMDS/SMDS_MapOfMeshOrientedElement.cdl,
- SMDS/SMDS_MapOfMeshOrientedElement.cxx,
- SMDS/SMDS_MapOfMeshOrientedElement.hxx,
- SMDS/SMDS_MapOfMeshOrientedElement.ixx,
- SMDS/SMDS_MapOfMeshOrientedElement.jxx,
- SMDS/SMDS_MapOfMeshOrientedElement.lxx, SMDS/SMDS_Mesh.cdl,
- SMDS/SMDS_Mesh.cxx, SMDS/SMDS_Mesh.hxx, SMDS/SMDS_Mesh.ixx,
- SMDS/SMDS_Mesh.jxx, SMDS/SMDS_Mesh.lxx, SMDS/SMDS_MeshEdge.cdl,
- SMDS/SMDS_MeshEdge.cxx, SMDS/SMDS_MeshEdge.hxx,
- SMDS/SMDS_MeshEdge.ixx, SMDS/SMDS_MeshEdge.jxx,
- SMDS/SMDS_MeshEdge.lxx, SMDS/SMDS_MeshEdgesIterator.cdl,
- SMDS/SMDS_MeshEdgesIterator.cxx, SMDS/SMDS_MeshEdgesIterator.hxx,
- SMDS/SMDS_MeshEdgesIterator.ixx, SMDS/SMDS_MeshEdgesIterator.jxx,
- SMDS/SMDS_MeshElement.cdl, SMDS/SMDS_MeshElement.cxx,
- SMDS/SMDS_MeshElement.hxx, SMDS/SMDS_MeshElement.ixx,
- SMDS/SMDS_MeshElement.jxx, SMDS/SMDS_MeshElement.lxx,
- SMDS/SMDS_MeshElementIDFactory.cdl,
- SMDS/SMDS_MeshElementIDFactory.cxx,
- SMDS/SMDS_MeshElementIDFactory.hxx,
- SMDS/SMDS_MeshElementIDFactory.ixx,
- SMDS/SMDS_MeshElementIDFactory.jxx,
- SMDS/SMDS_MeshElementIDFactory.lxx,
- SMDS/SMDS_MeshElementMapHasher.cdl,
- SMDS/SMDS_MeshElementMapHasher.cxx,
- SMDS/SMDS_MeshElementMapHasher.hxx,
- SMDS/SMDS_MeshElementMapHasher.ixx,
- SMDS/SMDS_MeshElementMapHasher.jxx,
- SMDS/SMDS_MeshElementMapHasher.lxx,
- SMDS/SMDS_MeshElementsIterator.cdl,
- SMDS/SMDS_MeshElementsIterator.cxx,
- SMDS/SMDS_MeshElementsIterator.hxx,
- SMDS/SMDS_MeshElementsIterator.ixx,
- SMDS/SMDS_MeshElementsIterator.jxx,
- SMDS/SMDS_MeshElementsIterator.lxx, SMDS/SMDS_MeshFace.cdl,
- SMDS/SMDS_MeshFace.cxx, SMDS/SMDS_MeshFace.hxx,
- SMDS/SMDS_MeshFace.ixx, SMDS/SMDS_MeshFace.jxx,
- SMDS/SMDS_MeshFace.lxx, SMDS/SMDS_MeshFacesIterator.cdl,
- SMDS/SMDS_MeshFacesIterator.cxx, SMDS/SMDS_MeshFacesIterator.hxx,
- SMDS/SMDS_MeshFacesIterator.ixx, SMDS/SMDS_MeshFacesIterator.jxx,
- SMDS/SMDS_MeshGroup.cdl, SMDS/SMDS_MeshGroup.cxx,
- SMDS/SMDS_MeshGroup.hxx, SMDS/SMDS_MeshGroup.ixx,
- SMDS/SMDS_MeshGroup.jxx, SMDS/SMDS_MeshGroup.lxx,
- SMDS/SMDS_MeshHexahedron.cdl, SMDS/SMDS_MeshHexahedron.cxx,
- SMDS/SMDS_MeshHexahedron.hxx, SMDS/SMDS_MeshHexahedron.ixx,
- SMDS/SMDS_MeshHexahedron.jxx, SMDS/SMDS_MeshHexahedron.lxx,
- SMDS/SMDS_MeshIDFactory.cdl, SMDS/SMDS_MeshIDFactory.cxx,
- SMDS/SMDS_MeshIDFactory.ixx, SMDS/SMDS_MeshIDFactory.jxx,
- SMDS/SMDS_MeshIDFactory.lxx, SMDS/SMDS_MeshNode.cdl,
- SMDS/SMDS_MeshNode.cxx, SMDS/SMDS_MeshNode.hxx,
- SMDS/SMDS_MeshNode.ixx, SMDS/SMDS_MeshNode.jxx,
- SMDS/SMDS_MeshNode.lxx, SMDS/SMDS_MeshNodeIDFactory.cdl,
- SMDS/SMDS_MeshNodeIDFactory.cxx, SMDS/SMDS_MeshNodeIDFactory.hxx,
- SMDS/SMDS_MeshNodeIDFactory.ixx, SMDS/SMDS_MeshNodeIDFactory.jxx,
- SMDS/SMDS_MeshNodeIDFactory.lxx, SMDS/SMDS_MeshNodesIterator.cdl,
- SMDS/SMDS_MeshNodesIterator.cxx, SMDS/SMDS_MeshNodesIterator.hxx,
- SMDS/SMDS_MeshNodesIterator.ixx, SMDS/SMDS_MeshNodesIterator.jxx,
- SMDS/SMDS_MeshObject.cdl, SMDS/SMDS_MeshObject.cxx,
- SMDS/SMDS_MeshObject.hxx, SMDS/SMDS_MeshObject.ixx,
- SMDS/SMDS_MeshObject.jxx,
- SMDS/SMDS_MeshOrientedElementMapHasher.cdl,
- SMDS/SMDS_MeshOrientedElementMapHasher.cxx,
- SMDS/SMDS_MeshOrientedElementMapHasher.hxx,
- SMDS/SMDS_MeshOrientedElementMapHasher.ixx,
- SMDS/SMDS_MeshOrientedElementMapHasher.jxx,
- SMDS/SMDS_MeshOrientedElementMapHasher.lxx,
- SMDS/SMDS_MeshPrism.cdl, SMDS/SMDS_MeshPrism.cxx,
- SMDS/SMDS_MeshPrism.hxx, SMDS/SMDS_MeshPrism.ixx,
- SMDS/SMDS_MeshPrism.jxx, SMDS/SMDS_MeshPrism.lxx,
- SMDS/SMDS_MeshPyramid.cdl, SMDS/SMDS_MeshPyramid.cxx,
- SMDS/SMDS_MeshPyramid.hxx, SMDS/SMDS_MeshPyramid.ixx,
- SMDS/SMDS_MeshPyramid.jxx, SMDS/SMDS_MeshPyramid.lxx,
- SMDS/SMDS_MeshQuadrangle.cdl, SMDS/SMDS_MeshQuadrangle.cxx,
- SMDS/SMDS_MeshQuadrangle.hxx, SMDS/SMDS_MeshQuadrangle.ixx,
- SMDS/SMDS_MeshQuadrangle.jxx, SMDS/SMDS_MeshQuadrangle.lxx,
- SMDS/SMDS_MeshTetrahedron.cdl, SMDS/SMDS_MeshTetrahedron.cxx,
- SMDS/SMDS_MeshTetrahedron.hxx, SMDS/SMDS_MeshTetrahedron.ixx,
- SMDS/SMDS_MeshTetrahedron.jxx, SMDS/SMDS_MeshTetrahedron.lxx,
- SMDS/SMDS_MeshTriangle.cdl, SMDS/SMDS_MeshTriangle.cxx,
- SMDS/SMDS_MeshTriangle.hxx, SMDS/SMDS_MeshTriangle.ixx,
- SMDS/SMDS_MeshTriangle.jxx, SMDS/SMDS_MeshTriangle.lxx,
- SMDS/SMDS_MeshVolume.cdl, SMDS/SMDS_MeshVolume.cxx,
- SMDS/SMDS_MeshVolume.hxx, SMDS/SMDS_MeshVolume.ixx,
- SMDS/SMDS_MeshVolume.jxx, SMDS/SMDS_MeshVolume.lxx,
- SMDS/SMDS_MeshVolumesIterator.cdl,
- SMDS/SMDS_MeshVolumesIterator.cxx,
- SMDS/SMDS_MeshVolumesIterator.hxx,
- SMDS/SMDS_MeshVolumesIterator.ixx,
- SMDS/SMDS_MeshVolumesIterator.jxx, SMDS/SMDS_PntHasher.cdl,
- SMDS/SMDS_PntHasher.cxx, SMDS/SMDS_PntHasher.hxx,
- SMDS/SMDS_PntHasher.ixx, SMDS/SMDS_PntHasher.jxx,
- SMDS/SMDS_PntHasher.lxx, SMDS/SMDS_Position.cdl,
- SMDS/SMDS_Position.cxx, SMDS/SMDS_Position.hxx,
- SMDS/SMDS_Position.ixx, SMDS/SMDS_Position.jxx,
- SMDS/SMDS_Position.lxx,
- SMDS/SMDS_SequenceNodeOfSequenceOfMesh.hxx,
- SMDS/SMDS_SequenceNodeOfSequenceOfMesh_0.cxx,
- SMDS/SMDS_SequenceOfMesh.hxx, SMDS/SMDS_SequenceOfMesh_0.cxx,
- SMDS/SMDS_SpacePosition.cdl, SMDS/SMDS_SpacePosition.cxx,
- SMDS/SMDS_SpacePosition.hxx, SMDS/SMDS_SpacePosition.ixx,
- SMDS/SMDS_SpacePosition.jxx, SMDS/SMDS_SpacePosition.lxx,
- SMDS/SMDS_StdMapNode.gxx, SMDS/SMDS_StdMapNode.lxx,
- SMDS/SMDS_StdMapNodeOfExtendedMap.hxx,
- SMDS/SMDS_StdMapNodeOfExtendedMap_0.cxx,
- SMDS/SMDS_StdMapNodeOfExtendedOrientedMap.hxx,
- SMDS/SMDS_StdMapNodeOfExtendedOrientedMap_0.cxx,
- SMDS/SMDS_TypeOfPosition.hxx, SMDS/SMDS_VertexPosition.cdl,
- SMDS/SMDS_VertexPosition.cxx, SMDS/SMDS_VertexPosition.hxx,
- SMDS/SMDS_VertexPosition.ixx, SMDS/SMDS_VertexPosition.jxx,
- SMDS/SMDS_MeshIDFactory.hxx, SMESH_I/Makefile.in,
- SMESH_I/SMESH_1D_Algo_i.cxx, SMESH_I/SMESH_1D_Algo_i.hxx,
- SMESH_I/SMESH_2D_Algo_i.cxx, SMESH_I/SMESH_2D_Algo_i.hxx,
- SMESH_I/SMESH_3D_Algo_i.cxx, SMESH_I/SMESH_3D_Algo_i.hxx,
- SMESH_I/SMESH_Algo_i.cxx, SMESH_I/SMESH_Algo_i.hxx,
- SMESH_I/SMESH_Gen_i.cxx, SMESH_I/SMESH_Gen_i.hxx,
- SMESH_I/SMESH_Hexa_3D_i.cxx, SMESH_I/SMESH_Hexa_3D_i.hxx,
- SMESH_I/SMESH_HypothesisFactory_i.cxx,
- SMESH_I/SMESH_HypothesisFactory_i.hxx,
- SMESH_I/SMESH_Hypothesis_i.cxx, SMESH_I/SMESH_Hypothesis_i.hxx,
- SMESH_I/SMESH_LocalLength_i.cxx, SMESH_I/SMESH_LocalLength_i.hxx,
- SMESH_I/SMESH_MEDFamily_i.cxx, SMESH_I/SMESH_MEDFamily_i.hxx,
- SMESH_I/SMESH_MEDMesh_i.cxx, SMESH_I/SMESH_MEDMesh_i.hxx,
- SMESH_I/SMESH_MEDSupport_i.cxx, SMESH_I/SMESH_MEDSupport_i.hxx,
- SMESH_I/SMESH_MEFISTO_2D_i.cxx, SMESH_I/SMESH_MEFISTO_2D_i.hxx,
- SMESH_I/SMESH_MaxElementArea_i.cxx,
- SMESH_I/SMESH_MaxElementArea_i.hxx,
- SMESH_I/SMESH_MaxElementVolume_i.cxx,
- SMESH_I/SMESH_MaxElementVolume_i.hxx,
- SMESH_I/SMESH_MeshEditor_i.cxx, SMESH_I/SMESH_MeshEditor_i.hxx,
- SMESH_I/SMESH_Mesh_i.cxx, SMESH_I/SMESH_Mesh_i.hxx,
- SMESH_I/SMESH_NumberOfSegments_i.cxx,
- SMESH_I/SMESH_NumberOfSegments_i.hxx,
- SMESH_I/SMESH_Quadrangle_2D_i.cxx,
- SMESH_I/SMESH_Quadrangle_2D_i.hxx,
- SMESH_I/SMESH_Regular_1D_i.cxx, SMESH_I/SMESH_Regular_1D_i.hxx,
- SMESH_I/SMESH_subMesh_i.cxx, SMESH_I/SMESH_subMesh_i.hxx,
- SMESH_I/SMESH_test.py, SMESH_I/SMESH_topo.cxx,
- SMESH_I/SMESH_topo.hxx, SMESH_I/smeshpy.py, SMESH_I/sstream,
- SMESHGUI/Makefile.in, SMESHGUI/SMESHGUI.cxx, SMESHGUI/SMESHGUI.h,
- SMESHGUI/SMESHGUI_AddAlgorithmDlg.cxx,
- SMESHGUI/SMESHGUI_AddAlgorithmDlg.h,
- SMESHGUI/SMESHGUI_AddEdgeDlg.cxx, SMESHGUI/SMESHGUI_AddEdgeDlg.h,
- SMESHGUI/SMESHGUI_AddFaceDlg.cxx, SMESHGUI/SMESHGUI_AddFaceDlg.h,
- SMESHGUI/SMESHGUI_AddHypothesisDlg.cxx,
- SMESHGUI/SMESHGUI_AddHypothesisDlg.h,
- SMESHGUI/SMESHGUI_AddSubMeshDlg.cxx,
- SMESHGUI/SMESHGUI_AddSubMeshDlg.h,
- SMESHGUI/SMESHGUI_AddVolumeDlg.cxx,
- SMESHGUI/SMESHGUI_AddVolumeDlg.h,
- SMESHGUI/SMESHGUI_ComputeScalarValue.cxx,
- SMESHGUI/SMESHGUI_ComputeScalarValue.h,
- SMESHGUI/SMESHGUI_DiagonalInversionDlg.cxx,
- SMESHGUI/SMESHGUI_DiagonalInversionDlg.h,
- SMESHGUI/SMESHGUI_EdgesConnectivityDlg.cxx,
- SMESHGUI/SMESHGUI_EdgesConnectivityDlg.h,
- SMESHGUI/SMESHGUI_EditHypothesesDlg.cxx,
- SMESHGUI/SMESHGUI_EditHypothesesDlg.h,
- SMESHGUI/SMESHGUI_EditScalarBarDlg.cxx,
- SMESHGUI/SMESHGUI_EditScalarBarDlg.h,
- SMESHGUI/SMESHGUI_InitMeshDlg.cxx,
- SMESHGUI/SMESHGUI_InitMeshDlg.h,
- SMESHGUI/SMESHGUI_LocalLengthDlg.cxx,
- SMESHGUI/SMESHGUI_LocalLengthDlg.h,
- SMESHGUI/SMESHGUI_MaxElementAreaDlg.cxx,
- SMESHGUI/SMESHGUI_MaxElementAreaDlg.h,
- SMESHGUI/SMESHGUI_MaxElementVolumeDlg.cxx,
- SMESHGUI/SMESHGUI_MaxElementVolumeDlg.h,
- SMESHGUI/SMESHGUI_MeshInfosDlg.cxx,
- SMESHGUI/SMESHGUI_MeshInfosDlg.h,
- SMESHGUI/SMESHGUI_MoveNodesDlg.cxx,
- SMESHGUI/SMESHGUI_MoveNodesDlg.h,
- SMESHGUI/SMESHGUI_NbSegmentsDlg.cxx,
- SMESHGUI/SMESHGUI_NbSegmentsDlg.h,
- SMESHGUI/SMESHGUI_NodesDlg.cxx, SMESHGUI/SMESHGUI_NodesDlg.h,
- SMESHGUI/SMESHGUI_OrientationElementsDlg.cxx,
- SMESHGUI/SMESHGUI_OrientationElementsDlg.h,
- SMESHGUI/SMESHGUI_Preferences_ColorDlg.cxx,
- SMESHGUI/SMESHGUI_Preferences_ColorDlg.h,
- SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.cxx,
- SMESHGUI/SMESHGUI_Preferences_ScalarBarDlg.h,
- SMESHGUI/SMESHGUI_RemoveElementsDlg.cxx,
- SMESHGUI/SMESHGUI_RemoveElementsDlg.h,
- SMESHGUI/SMESHGUI_RemoveNodesDlg.cxx,
- SMESHGUI/SMESHGUI_RemoveNodesDlg.h,
- SMESHGUI/SMESHGUI_SpinBox.cxx, SMESHGUI/SMESHGUI_SpinBox.h,
- SMESHGUI/SMESHGUI_StudyAPI.cxx, SMESHGUI/SMESHGUI_StudyAPI.h,
- SMESHGUI/SMESHGUI_Swig.cxx, SMESHGUI/SMESHGUI_Swig.hxx,
- SMESHGUI/SMESHGUI_Swig.i, SMESHGUI/SMESHGUI_TransparencyDlg.cxx,
- SMESHGUI/SMESHGUI_TransparencyDlg.h,
- SMESHGUI/SMESHGUI_aParameterDlg.cxx,
- SMESHGUI/SMESHGUI_aParameterDlg.h, SMESHGUI/SMESH_icons.po,
- SMESHGUI/SMESH_msg_en.po: NRI : First integration.
-
-2003-05-19 13:18 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * src/: SMESH/Makefile.in, SMESH/SMESH_1D_Algo.cxx,
- SMESH/SMESH_1D_Algo.hxx, SMESH/SMESH_2D_Algo.cxx,
- SMESH/SMESH_2D_Algo.hxx, SMESH/SMESH_3D_Algo.cxx,
- SMESH/SMESH_3D_Algo.hxx, SMESH/SMESH_Algo.cxx,
- SMESH/SMESH_Algo.hxx, SMESH/SMESH_Gen.cxx, SMESH/SMESH_Gen.hxx,
- SMESH/SMESH_Hexa_3D.cxx, SMESH/SMESH_Hexa_3D.hxx,
- SMESH/SMESH_Hypothesis.cxx, SMESH/SMESH_Hypothesis.hxx,
- SMESH/SMESH_HypothesisCreator.hxx,
- SMESH/SMESH_HypothesisFactory.cxx,
- SMESH/SMESH_HypothesisFactory.hxx,
- SMESH/SMESH_LengthFromEdges.cxx, SMESH/SMESH_LengthFromEdges.hxx,
- SMESH/SMESH_LocalLength.cxx, SMESH/SMESH_LocalLength.hxx,
- SMESH/SMESH_MEFISTO_2D.cxx, SMESH/SMESH_MEFISTO_2D.hxx,
- SMESH/SMESH_MaxElementArea.cxx, SMESH/SMESH_MaxElementArea.hxx,
- SMESH/SMESH_MaxElementVolume.cxx,
- SMESH/SMESH_MaxElementVolume.hxx, SMESH/SMESH_Mesh.cxx,
- SMESH/SMESH_Mesh.hxx, SMESH/SMESH_NumberOfSegments.cxx,
- SMESH/SMESH_NumberOfSegments.hxx, SMESH/SMESH_Quadrangle_2D.cxx,
- SMESH/SMESH_Quadrangle_2D.hxx, SMESH/SMESH_Regular_1D.cxx,
- SMESH/SMESH_Regular_1D.hxx, SMESH/SMESH_subMesh.cxx,
- SMESH/SMESH_subMesh.hxx, SMESHDS/Handle_SMESHDS_Command.hxx,
- SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx,
- SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx,
- SMESHDS/Handle_SMESHDS_ListNodeOfListOfCommand.hxx,
- SMESHDS/Handle_SMESHDS_Mesh.hxx,
- SMESHDS/Handle_SMESHDS_Script.hxx, SMESHDS/Makefile.in,
- SMESHDS/SMESHDS_Command.cdl, SMESHDS/SMESHDS_Command.cxx,
- SMESHDS/SMESHDS_Command.ixx, SMESHDS/SMESHDS_Command.jxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerSubMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh.hxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerSubMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapOfIntegerMesh.hxx,
- SMESHDS/SMESHDS_DataMapOfIntegerMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapOfIntegerPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_DataMapOfIntegerSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapOfIntegerSubMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapOfShapeSubMesh.hxx,
- SMESHDS/SMESHDS_DataMapOfShapeSubMesh_0.cxx,
- SMESHDS/SMESHDS_Document.cdl, SMESHDS/SMESHDS_Document.hxx,
- SMESHDS/SMESHDS_Document.ixx, SMESHDS/SMESHDS_Hypothesis.hxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString_0.cxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfCommand.hxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfCommand_0.cxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_ListNodeOfListOfAsciiString.hxx,
- SMESHDS/SMESHDS_ListNodeOfListOfAsciiString_0.cxx,
- SMESHDS/SMESHDS_ListNodeOfListOfCommand.hxx,
- SMESHDS/SMESHDS_ListNodeOfListOfCommand_0.cxx,
- SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_ListOfCommand.hxx,
- SMESHDS/SMESHDS_ListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_ListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_Mesh.cdl, SMESHDS/SMESHDS_Mesh.hxx,
- SMESHDS/SMESHDS_Script.cdl, SMESHDS/SMESHDS_Script.cxx,
- SMESHDS/SMESHDS_Script.hxx, SMESHDS/SMESHDS_Script.ixx,
- SMESHDS/SMESHDS_Script.jxx, SMESHDS/SMESHDS_SubMesh.cdl,
- SMESHDS/SMESHDS_SubMesh.cxx, SMESHDS/SMESHDS_SubMesh.hxx,
- SMESHDS/SMESHDS_SubMesh.ixx, SMESHDS/SMESHDS_SubMesh.jxx,
- SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS/Handle_SMESHDS_DataMapNodeOfDataMapOfShapeSubMesh.hxx,
- SMESHDS/Handle_SMESHDS_Document.hxx,
- SMESHDS/Handle_SMESHDS_ListNodeOfListOfAsciiString.hxx,
- SMESHDS/Handle_SMESHDS_ListNodeOfListOfPtrHypothesis.hxx,
- SMESHDS/Handle_SMESHDS_SubMesh.hxx, SMESHDS/SMESHDS.cdl,
- SMESHDS/SMESHDS_Command.hxx, SMESHDS/SMESHDS_CommandType.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerMesh.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapIteratorOfDataMapOfShapeSubMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerMesh_0.cxx,
- SMESHDS/SMESHDS_DataMapNodeOfDataMapOfIntegerPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_DataMapOfShapeListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_Document.cxx, SMESHDS/SMESHDS_Document.jxx,
- SMESHDS/SMESHDS_Hypothesis.cxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfAsciiString.hxx,
- SMESHDS/SMESHDS_ListIteratorOfListOfPtrHypothesis.hxx,
- SMESHDS/SMESHDS_ListNodeOfListOfPtrHypothesis_0.cxx,
- SMESHDS/SMESHDS_ListOfAsciiString.hxx,
- SMESHDS/SMESHDS_ListOfAsciiString_0.cxx,
- SMESHDS/SMESHDS_ListOfCommand_0.cxx, SMESHDS/SMESHDS_Mesh.cxx,
- SMESHDS/SMESHDS_Mesh.ixx, SMESHDS/SMESHDS_Mesh.jxx,
- SMESHDS/SMESHDS_PtrHypothesis.hxx: NRI : First integration.
-
-2003-05-19 13:03 Nicolas Rejneri <nicolas.rejneri@opencascade.com>
-
- * Makefile.in, build_configure, configure.in.base,
- resources/ModuleMesh.png, resources/SMESHCatalog.xml,
- resources/SMESH_en.xml, resources/SMESH_fr.xml,
- resources/delete.png, resources/mesh.png,
- resources/mesh_add_sub.png, resources/mesh_algo_hexa.png,
- resources/mesh_algo_mefisto.png, resources/mesh_algo_quad.png,
- resources/mesh_algo_regular.png, resources/mesh_angle.png,
- resources/mesh_area.png, resources/mesh_aspect.png,
- resources/mesh_compute.png, resources/mesh_connectivity.png,
- resources/mesh_diagonal.png, resources/mesh_edit.png,
- resources/mesh_hexa.png, resources/mesh_hexa_n.png,
- resources/mesh_hypo_area.png, resources/mesh_hypo_length.png,
- resources/mesh_hypo_segment.png, resources/mesh_hypo_volume.png,
- resources/mesh_info.png, resources/mesh_init.png,
- resources/mesh_length.png, resources/mesh_line.png,
- resources/mesh_line_n.png, resources/mesh_move_node.png,
- resources/mesh_orientation.png, resources/mesh_pyramid.png,
- resources/mesh_pyramid_n.png, resources/mesh_quad.png,
- resources/mesh_quad_n.png, resources/mesh_rem_element.png,
- resources/mesh_rem_node.png, resources/mesh_set_algo.png,
- resources/mesh_set_hypo.png, resources/mesh_shading.png,
- resources/mesh_shrink.png, resources/mesh_skew.png,
- resources/mesh_taper.png, resources/mesh_tetra.png,
- resources/mesh_tetra_n.png, resources/mesh_tree_algo.png,
- resources/mesh_tree_algo_hexa.png,
- resources/mesh_tree_algo_mefisto.png,
- resources/mesh_tree_algo_quad.png,
- resources/mesh_tree_algo_regular.png,
- resources/mesh_tree_hypo.png, resources/mesh_tree_hypo_area.png,
- resources/mesh_tree_hypo_length.png,
- resources/mesh_tree_hypo_segment.png,
- resources/mesh_tree_hypo_volume.png,
- resources/mesh_tree_mesh.png, resources/mesh_tree_mesh_warn.png,
- resources/mesh_triangle.png, resources/mesh_triangle_n.png,
- resources/mesh_update.png, resources/mesh_vertex.png,
- resources/mesh_vertex_n.png, resources/mesh_wireframe.png,
- resources/mesh_wrap.png, resources/select1.png, idl/Makefile.in,
- idl/SMESH_BasicHypothesis.idl, idl/SMESH_Gen.idl,
- idl/SMESH_Hypothesis.idl, idl/SMESH_Mesh.idl,
- 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/DriverMED/DriverMED_R_SMDS_Mesh.cxx,
- src/DriverMED/DriverMED_R_SMESHDS_Document.cxx,
- src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx,
- src/DriverMED/DriverMED_W_SMDS_Mesh.cxx,
- src/DriverMED/DriverMED_W_SMESHDS_Document.cxx,
- src/DriverMED/DriverMED_W_SMESHDS_Mesh.cxx,
- src/DriverMED/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: NRI : First integration.
-
-2003-03-07 14:55 tag V1
-
-2003-03-07 14:55 cvsadmin
-
- * src/DriverMED/: DriverMED_R_SMESHDS_Document.h,
- DriverMED_W_SMESHDS_Document.h:
- Initialisation module SMESH_SRC de la base SMESH
-
-2003-03-07 14:55 cvsadmin
-
- * src/DriverMED/: DriverMED_R_SMDS_Mesh.cxx,
- DriverMED_R_SMDS_Mesh.h, DriverMED_R_SMESHDS_Document.cxx,
- DriverMED_R_SMESHDS_Mesh.cxx, DriverMED_R_SMESHDS_Mesh.h,
- DriverMED_W_SMDS_Mesh.cxx, DriverMED_W_SMDS_Mesh.h,
- DriverMED_W_SMESHDS_Document.cxx, DriverMED_W_SMESHDS_Mesh.cxx,
- DriverMED_W_SMESHDS_Mesh.h, Makefile.in: Initial revision
-
MEFISTO_2D_3 = Mesh_1.Triangle(algo=smeshBuilder.MEFISTO,geom=Face_3)
SubMesh_3 = MEFISTO_2D_3.GetSubMesh()
-# check exisiting sub-mesh priority order
+# check existing sub-mesh priority order
[ [ SubMesh_1, SubMesh_3, SubMesh_2 ] ] = Mesh_1.GetMeshOrder()
isDone = Mesh_1.Compute()
print "Nb elements at initial order of sub-meshes:", Mesh_1.NbElements()
--- /dev/null
+import salome
+salome.salome_init()
+
+### create geometry
+
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+Box_1 = geompy.MakeBoxDXDYDZ(200, 200, 200)
+geompy.addToStudy( Box_1, 'Box_1' )
+
+### create a mesh
+
+import SMESH
+from salome.smesh import smeshBuilder
+smesh = smeshBuilder.New(salome.myStudy)
+
+Mesh_1 = smesh.Mesh( Box_1 )
+Mesh_1.Segment().NumberOfSegments(15)
+Mesh_1.Triangle()
+Mesh_1.Compute()
+
+# define arguments for MakePolyLine
+
+segments = []
+# between nodes 20 and 1, default plane
+segments.append( SMESH.PolySegment( 20, 0, 1, 0, smesh.MakeDirStruct(0,0,0) ))
+# between nodes 1 and 100, default plane
+segments.append( SMESH.PolySegment( 1, 0, 200, 0, smesh.MakeDirStruct(0,0,0) ))
+# between nodes 200 and edge (578, 577), plane includes vector (1,1,1)
+segments.append( SMESH.PolySegment( 200, 0, 578, 577, smesh.MakeDirStruct(1,1,1) ))
+
+Mesh_1.MakePolyLine( segments, "1D group")
+
+
+if salome.sg.hasDesktop():
+ salome.sg.updateObjBrowser(True)
print "Number of faces with aspect ratio > 1.5:", len(ids)
# copy the faces with aspect ratio > 1.5 to another mesh;
-# this demostrates that a filter can be used where usually a group or sub-mesh is acceptable
+# this demonstrates that a filter can be used where usually a group or sub-mesh is acceptable
filter.SetMesh( mesh.GetMesh() ) # - actually non necessary as mesh is set at filter creation
mesh2 = smesh.CopyMesh( filter, "AR > 1.5" )
print "Number of copied faces with aspect ratio > 1.5:", mesh2.NbFaces()
]
filt = smesh.GetFilterFromCriteria( critaria )
filtGroup = mesh.GroupOnFilter( SMESH.FACE, "group on filter", filt )
-print "Group on filter contains %s elemens" % filtGroup.Size()
+print "Group on filter contains %s elements" % filtGroup.Size()
# group on filter is updated if the mesh is modified
hyp1D.SetStartLength( 2.5 )
hyp1D.SetEndLength( 2.5 )
mesh.Compute()
-print "After mesh change, group on filter contains %s elemens" % filtGroup.Size()
+print "After mesh change, group on filter contains %s elements" % filtGroup.Size()
# set a new filter defining the group
filt2 = smesh.GetFilter( SMESH.FACE, SMESH.FT_RangeOfIds, "1-50" )
filtGroup.SetFilter( filt2 )
-print "With a new filter, group on filter contains %s elemens" % filtGroup.Size()
+print "With a new filter, group on filter contains %s elements" % filtGroup.Size()
# group is updated at modification of the filter
filt2.SetCriteria( [ smesh.GetCriterion( SMESH.FACE, SMESH.FT_RangeOfIds, "1-70" )])
filtIDs3 = filtGroup.GetIDs()
-print "After filter modification, group on filter contains %s elemens" % filtGroup.Size()
+print "After filter modification, group on filter contains %s elements" % filtGroup.Size()
salome.sg.updateObjBrowser(True)
--- /dev/null
+# Deflection 2D
+
+
+import salome
+salome.salome_init()
+from salome.geom import geomBuilder
+geompy = geomBuilder.New(salome.myStudy)
+
+import SMESH
+from salome.smesh import smeshBuilder
+smesh = smeshBuilder.New(salome.myStudy)
+
+# fuse a box and a sphere
+Sphere_1 = geompy.MakeSphereR(100)
+Box_1 = geompy.MakeBoxDXDYDZ(200, 200, 200)
+Fuse = geompy.MakeFuse( Sphere_1, Box_1, theName="box + sphere" )
+
+# create a mesh
+mesh = smesh.Mesh( Fuse, "Deflection_2D")
+algo = mesh.Segment()
+algo.LocalLength(35)
+algo = mesh.Triangle()
+mesh.Compute()
+
+# get min and max deflection
+minMax = mesh.GetMinMax( SMESH.FT_Deflection2D )
+print "min and max deflection: ", minMax
+
+# get deflection of a certain face
+faceID = mesh.NbEdges() + mesh.NbFaces()
+defl = mesh.FunctorValue( SMESH.FT_Deflection2D, faceID )
+print "deflection of face %s = %s" % ( faceID, defl )
+
+margin = minMax[1] / 2
+
+# get all faces with deflection LESS than the margin
+aFilter = smesh.GetFilter(SMESH.FACE, SMESH.FT_Deflection2D, '<', margin, mesh=mesh)
+anIds = aFilter.GetIDs()
+print "%s faces have deflection less than %s" %( len(anIds), margin )
+
+# create a group of faces with deflection MORE than the margin
+aGroup = mesh.MakeGroup("Deflection > " + `margin`, SMESH.FACE, SMESH.FT_Deflection2D,'>',margin)
+print "%s faces have deflection more than %s: %s ..." %( aGroup.Size(), margin, aGroup.GetIDs()[:10] )
+
+salome.sg.updateObjBrowser(True)
quality_controls_ex17.py
quality_controls_ex18.py
quality_controls_ex19.py
+ quality_controls_defl.py
transforming_meshes_ex01.py
transforming_meshes_ex02.py
transforming_meshes_ex03.py
or edit mesh groups, remove elements from the mesh, control
mesh quality by different parameters, etc.
-Several criteria can be combined together by using logical operators \a
-AND and \a OR. In addition, a filter criterion can be reverted
-using logical operator \a NOT.
+Several \ref filtering_criteria "filtering criteria" can be combined
+together by using logical operators \a AND and \a OR. In addition, a
+filter criterion can be reverted using logical operator \a NOT.
-Some filtering criteria use the functionality of \ref quality_page "mesh quality controls"
-to filter mesh nodes / elements by specific characteristic (Area, Length, etc).
+Some filtering criteria use the functionality of \ref quality_page
+"mesh quality controls" to filter mesh nodes / elements by specific
+characteristic (Area, Length, etc).
The functinality of mesh filters is available in both GUI and TUI
modes:
-- In GUI, filters are available in some dialog boxes via
-"Set Filters" button, clicking on which opens the dialog box
+- In GUI, filters are available in some dialog boxes via "Set Filters"
+button, clicking on which opens the \ref filtering_elements "dialog box"
allowing to specify the list of filter criteria to be applied to the
-current selection. See \subpage selection_filter_library_page page to learn more
-about selection filters and their usage in GUI.
+current selection. See \subpage selection_filter_library_page page to
+learn more about selection filters and their usage in GUI.
- In Python scripts, filters can be used to choose only some mesh
entities (nodes or elements) for the operations, which require the
<li>\subpage bare_border_faces_page "Bare border faces"</li>
<li>\subpage over_constrained_faces_page "Over-constrained faces"</li>
<li>\subpage length_2d_page "Length 2D"</li>
+<li>\subpage deflection_2d_page "Deflection 2D"</li>
<li>\subpage borders_at_multi_connection_2d_page "Borders at multi-connection 2D"</li>
<li>\subpage area_page "Area"</li>
<li>\subpage taper_page "Taper"</li>
--- /dev/null
+/*!
+
+\page deflection_2d_page Deflection 2D
+
+\n This quality control criterion consists of calculation of distance
+between a mesh face gravity corner and the surface the face discretizes.
+
+<em>To apply the Deflection 2D quality criterion to your mesh:</em>
+<ol>
+<li>Display your mesh in the viewer. </li>
+
+<li>Choose <b>Controls > Face Controls > Deflection 2D</b> or click
+<em>"Deflection 2D"</em> button in the toolbar.
+
+Your mesh will be displayed in the viewer with faces colored according
+to the applied mesh quality control criterion:
+
+\image html deflection_2d.png
+</li>
+</ol>
+
+<br><b>See Also</b> a sample TUI Script of a
+\ref tui_deflection_2d "Deflection 2D quality control" operation.
+
+*/
\page selection_filter_library_page Selection filter library
+\tableofcontents
+
+\section selection_filter_library Filter library
+
\n Selection filter library allows creating and storing in files
the filters that can be later reused for operations on meshes. You can
access it from the Main Menu via <b>Tools / Selection filter library</b>.
\n In <b>Filter name</b> box you can specify the name for your
filter. By default it is prefixed with the corresponding entity type.
-\anchor filtering_elements
-<h2>Filter Dialog</h2>
+\section filtering_elements Filter Dialog
When we use filters during group creation or another operation (by
clicking <b>Set Filter</b> button in the corresponding dialog), the
is no selected mesh in the Object Browser and the filter can not be
created. You have to select the mesh and the button will be enabled.
+\section filtering_criteria Filtering Criteria
+
Some criteria are applicable to all <b>Entity types</b>:
<ul><li>
<b>Belong to Geom</b> selects entities whose all nodes lie on the
angular tolerance (defined in degrees). Selection continues among all neighbor faces of already
selected ones.<br>
</li><li>
+<b>Deflection 2D</b> selects 2D mesh elements having distance between their gravity
+centers and underlying surfaces, which is more, less or equal (within a given <b>Tolerance</b>) to the predefined <b>Threshold Value</b>. See also a
+\ref deflection_2d_page "Deflection 2D quality control".
+</li><li>
<b>Element Diameter 2D</b> selects triangles and quadrangles composed of the edges and
diagonals with a value of length, which is more, less or equal
(within a given <b>Tolerance</b>) to the predefined <b>Threshold Value</b>. See also a
/*!
-\page smesh_migration_page Modifing Mesh Python scripts from SALOME 6 and before
+\page smesh_migration_page Modifying Mesh Python scripts from SALOME 6 and before
\n In SALOME 7.2, the Python interface for %Mesh has been slightly modified to offer new functionality:
<b> Of course, <em>from smesh import *</em> is no more possible.</b>
-\n You have to explicitely write <em>smesh.some_method()</em>.
+\n You have to explicitly write <em>smesh.some_method()</em>.
<b>All algorithms have been transferred from the namespace <em>smesh</em> to the namespace <em>smeshBuilder</em>.</b>
\n For instance:
Compound1 = smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 0, 1, 1e-05)
\endcode
-<b>If you need to import a %SMESH Plugin explicitely, keep in mind that they are now located in separate namespaces.</b>
+<b>If you need to import a %SMESH Plugin explicitly, keep in mind that they are now located in separate namespaces.</b>
\n For instance:
\code
import StdMeshers
\section filter_double_elements Double edges, Double faces, Double volumes
filters mesh elements basing on the same set of nodes:
-- element type is either \a SMESH.EGDE, \a SMESH.FACE or \a SMESH.VOLUME
+- element type is either \a SMESH.EDGE, \a SMESH.FACE or \a SMESH.VOLUME
- functor type is either \a SMESH.FT_EqualEdges, \a
SMESH.FT_EqualFaces or \a SMESH.FT_EqualVolumes,
- threshold value is not required
\section tui_length_2d Length 2D
\tui_script{quality_controls_ex11.py}
+\section tui_deflection_2d Deflection 2D
+\tui_script{quality_controls_defl.py}
+
\section tui_borders_at_multiconnection_2d Borders at Multiconnection 2D
\tui_script{quality_controls_ex12.py}
};
/*!
- * Common inteface of 1D hypotheses that can be reversed
+ * Common interface of 1D hypotheses that can be reversed
*/
interface Reversible1D
{
FT_MultiConnection2D,
FT_Length,
FT_Length2D,
+ FT_Deflection2D,
FT_NodeConnectivityNumber,
FT_BelongToMeshGroup,
FT_BelongToGeom,
typedef sequence<Value> Values;
Values GetValues();
};
+ interface Deflection2D : NumericalFunctor{};
interface MultiConnection : NumericalFunctor{};
interface MultiConnection2D : NumericalFunctor
{
MaxElementLength3D CreateMaxElementLength3D();
Length CreateLength();
Length2D CreateLength2D();
+ Deflection2D CreateDeflection2D();
MultiConnection CreateMultiConnection();
MultiConnection2D CreateMultiConnection2D();
BallDiameter CreateBallDiameter();
const long Tag_LastGroup = 16;
/*!
- * Hypothesis definintion error
+ * Hypothesis definition error
*/
struct AlgoStateError
{
raises ( SALOME::SALOME_Exception );
/*!
- * Return errors of hypotheses definintion
+ * Return errors of hypotheses definition
* algo_error_array is empty if everything is OK
*/
algo_error_array GetAlgoState( in SMESH_Mesh theMesh,
raises (SALOME::SALOME_Exception);
/*!
- * Remove an hypothesis previouly added with AddHypothesis.
+ * Remove an hypothesis previously added with AddHypothesis.
*/
Hypothesis_Status RemoveHypothesis(in GEOM::GEOM_Object aSubObject,
in SMESH_Hypothesis anHyp)
double GetComputeProgress();
/*!
- * Get informations about mesh contents
+ * Get information about mesh contents
*/
long NbNodes()
raises (SALOME::SALOME_Exception);
};
+ // structure used in MakePolyLine() to define a cutting plane
+ struct PolySegment
+ {
+ // point 1: if node1ID2 > 0, then the point is in the middle of a face edge defined
+ // by two nodes, else it is at node1ID1
+ long node1ID1;
+ long node1ID2;
+
+ // point 2: if node2ID2 > 0, then the point is in the middle of a face edge defined
+ // by two nodes, else it is at node2ID1
+ long node2ID1;
+ long node2ID2;
+
+ DirStruct vector; // vector on the plane; to use a default plane set vector = (0,0,0)
+ };
+ typedef sequence<PolySegment> ListOfPolySegments;
+
+
/*!
* This interface makes modifications on the Mesh - removing elements and nodes etc.
*/
* \param IDsOfElements Ids of triangles to be fused.
* \param theCriterion Is used to choose a neighbour to fuse with.
* \param theMaxAngle Is a max angle between element normals at which fusion
- * is still performed; theMaxAngle is mesured in radians.
+ * is still performed; theMaxAngle is measured in radians.
* \return \c true in case of success, FALSE otherwise.
*/
boolean TriToQuad (in long_array IDsOfElements,
/*!
* \brief Split quadrangles into triangles.
- * \param theElems The faces to be splitted.
+ * \param theElems The faces to be split.
* \param the13Diag Is used to choose a diagonal for splitting.
* \return TRUE in case of success, FALSE otherwise.
*/
/*!
* Find better splitting of the given quadrangle.
- * \param IDOfQuad ID of the quadrangle to be splitted.
+ * \param IDOfQuad ID of the quadrangle to be split.
* \param Criterion A criterion to choose a diagonal for splitting.
* \return 1 if 1-3 diagonal is better, 2 if 2-4
* diagonal is better, 0 if error occurs.
* Return point state in a closed 2D mesh in terms of TopAbs_State enumeration.
* TopAbs_UNKNOWN state means that either mesh is wrong or the analysis fails.
*/
- short GetPointState(in double x, in double y, in double z)
+ short GetPointState(in double x, in double y, in double z)
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Check if a 2D mesh is manifold
+ */
+ boolean IsManifold()
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Check if orientation of 2D elements is coherent
+ */
+ boolean IsCoherentOrientation2D()
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Returns all or only closed FreeBorder's.
+ */
+ ListOfFreeBorders FindFreeBorders(in boolean closedOnly)
+ raises (SALOME::SALOME_Exception);
+
+ /*!
+ * Fill with 2D elements a hole defined by a FreeBorder.
+ */
+ void FillHole(in FreeBorder hole)
raises (SALOME::SALOME_Exception);
/*!
in GEOM::GEOM_Object theShape,
in string groupName,
in double_array theNodesCoords,
- out array_of_long_array GroupsOfNodes)
+ out array_of_long_array GroupsOfNodes)
+ raises (SALOME::SALOME_Exception);
+
+
+ /*!
+ * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
+ * the initial mesh. Positions of new nodes are found by cutting the mesh by the
+ * plane passing through pairs of points specified by each PolySegment structure.
+ * If there are several paths connecting a pair of points, the shortest path is
+ * selected by the module. Position of the cutting plane is defined by the two
+ * points and an optional vector lying on the plane specified by a PolySegment.
+ * By default the vector is defined by Mesh module as following. A middle point
+ * of the two given points is computed. The middle point is projected to the mesh.
+ * The vector goes from the middle point to the projection point. In case of planar
+ * mesh, the vector is normal to the mesh.
+ * \param [inout] segments - PolySegment's defining positions of cutting planes.
+ * Return the used vector which goes from the middle point to its projection.
+ * \param [in] groupName - optional name of a group where created mesh segments will
+ * be added.
+ */
+ void MakePolyLine(inout ListOfPolySegments segments,
+ in string groupName)
raises (SALOME::SALOME_Exception);
};
};
mesh_quality.png
mesh_show.png
mesh_hide.png
+ mesh_deflection.png
)
INSTALL(FILES ${SMESH_RESOURCES_FILES} DESTINATION ${SALOME_SMESH_INSTALL_RES_DATA})
#include "SMESH_ControlsDef.hxx"
#include "SMDS_BallElement.hxx"
+#include "SMDS_FacePosition.hxx"
#include "SMDS_Iterator.hxx"
#include "SMDS_Mesh.hxx"
#include "SMDS_MeshElement.hxx"
#include <BRepAdaptor_Surface.hxx>
#include <BRepBndLib.hxx>
#include <BRepBuilderAPI_Copy.hxx>
+#include <BRepClass3d_SolidClassifier.hxx>
#include <BRepClass_FaceClassifier.hxx>
#include <BRep_Tool.hxx>
+#include <GeomLib_IsPlanarSurface.hxx>
#include <Geom_CylindricalSurface.hxx>
#include <Geom_Plane.hxx>
#include <Geom_Surface.hxx>
#include <NCollection_Map.hxx>
#include <Precision.hxx>
+#include <ShapeAnalysis_Surface.hxx>
#include <TColStd_MapIteratorOfMapOfInteger.hxx>
#include <TColStd_MapOfInteger.hxx>
#include <TColStd_SequenceOfAsciiString.hxx>
v2.Magnitude() < gp::Resolution() ? 0 : v1.Angle( v2 );
}
+ inline double getCos2( const gp_XYZ& P1, const gp_XYZ& P2, const gp_XYZ& P3 )
+ {
+ gp_Vec v1( P1 - P2 ), v2( P3 - P2 );
+ double dot = v1 * v2, len1 = v1.SquareMagnitude(), len2 = v2.SquareMagnitude();
+
+ return ( dot < 0 || len1 < gp::Resolution() || len2 < gp::Resolution() ? -1 :
+ dot * dot / len1 / len2 );
+ }
+
inline double getArea( const gp_XYZ& P1, const gp_XYZ& P2, const gp_XYZ& P3 )
{
gp_Vec aVec1( P2 - P1 );
}
if ( anIter ) {
- double xyz[3];
+ SMESH_NodeXYZ p;
while( anIter->more() ) {
- if ( const SMDS_MeshNode* aNode = static_cast<const SMDS_MeshNode*>( anIter->next() ))
- {
- aNode->GetXYZ( xyz );
- theRes.push_back( gp_XYZ( xyz[0], xyz[1], xyz[2] ));
- }
+ if ( p.Set( anIter->next() ))
+ theRes.push_back( p );
}
}
double MinimumAngle::GetValue( const TSequenceOfXYZ& P )
{
- double aMin;
-
- if (P.size() <3)
+ if ( P.size() < 3 )
return 0.;
- aMin = getAngle(P( P.size() ), P( 1 ), P( 2 ));
- aMin = Min(aMin,getAngle(P( P.size()-1 ), P( P.size() ), P( 1 )));
+ double aMaxCos2;
+
+ aMaxCos2 = getCos2( P( P.size() ), P( 1 ), P( 2 ));
+ aMaxCos2 = Max( aMaxCos2, getCos2( P( P.size()-1 ), P( P.size() ), P( 1 )));
for ( size_t i = 2; i < P.size(); i++ )
{
- double A0 = getAngle( P( i-1 ), P( i ), P( i+1 ) );
- aMin = Min(aMin,A0);
+ double A0 = getCos2( P( i-1 ), P( i ), P( i+1 ) );
+ aMaxCos2 = Max( aMaxCos2, A0 );
}
+ if ( aMaxCos2 < 0 )
+ return 0; // all nodes coincide
- return aMin * 180.0 / M_PI;
+ double cos = sqrt( aMaxCos2 );
+ if ( cos >= 1 ) return 0;
+ return acos( cos ) * 180.0 / M_PI;
}
double MinimumAngle::GetBadRate( double Value, int nbNodes ) const
if ( nbNodes == 3 ) {
// Compute lengths of the sides
- std::vector< double > aLen (nbNodes);
- for ( int i = 0; i < nbNodes - 1; i++ )
- aLen[ i ] = getDistance( P( i + 1 ), P( i + 2 ) );
- aLen[ nbNodes - 1 ] = getDistance( P( 1 ), P( nbNodes ) );
+ double aLen1 = getDistance( P( 1 ), P( 2 ));
+ double aLen2 = getDistance( P( 2 ), P( 3 ));
+ double aLen3 = getDistance( P( 3 ), P( 1 ));
// Q = alfa * h * p / S, where
//
// alfa = sqrt( 3 ) / 6
// h - length of the longest edge
// p - half perimeter
// S - triangle surface
- const double alfa = sqrt( 3. ) / 6.;
- double maxLen = Max( aLen[ 0 ], Max( aLen[ 1 ], aLen[ 2 ] ) );
- double half_perimeter = ( aLen[0] + aLen[1] + aLen[2] ) / 2.;
- double anArea = getArea( P( 1 ), P( 2 ), P( 3 ) );
+ const double alfa = sqrt( 3. ) / 6.;
+ double maxLen = Max( aLen1, Max( aLen2, aLen3 ));
+ double half_perimeter = ( aLen1 + aLen2 + aLen3 ) / 2.;
+ double anArea = getArea( P( 1 ), P( 2 ), P( 3 ));
if ( anArea <= theEps )
return theInf;
return alfa * maxLen * half_perimeter / anArea;
}
else if ( nbNodes == 6 ) { // quadratic triangles
// Compute lengths of the sides
- std::vector< double > aLen (3);
- aLen[0] = getDistance( P(1), P(3) );
- aLen[1] = getDistance( P(3), P(5) );
- aLen[2] = getDistance( P(5), P(1) );
- // Q = alfa * h * p / S, where
- //
- // alfa = sqrt( 3 ) / 6
- // h - length of the longest edge
- // p - half perimeter
- // S - triangle surface
- const double alfa = sqrt( 3. ) / 6.;
- double maxLen = Max( aLen[ 0 ], Max( aLen[ 1 ], aLen[ 2 ] ) );
- double half_perimeter = ( aLen[0] + aLen[1] + aLen[2] ) / 2.;
- double anArea = getArea( P(1), P(3), P(5) );
+ double aLen1 = getDistance( P( 1 ), P( 3 ));
+ double aLen2 = getDistance( P( 3 ), P( 5 ));
+ double aLen3 = getDistance( P( 5 ), P( 1 ));
+ // algo same as for the linear triangle
+ const double alfa = sqrt( 3. ) / 6.;
+ double maxLen = Max( aLen1, Max( aLen2, aLen3 ));
+ double half_perimeter = ( aLen1 + aLen2 + aLen3 ) / 2.;
+ double anArea = getArea( P( 1 ), P( 3 ), P( 5 ));
if ( anArea <= theEps )
return theInf;
return alfa * maxLen * half_perimeter / anArea;
}
else if( nbNodes == 4 ) { // quadrangle
// Compute lengths of the sides
- std::vector< double > aLen (4);
+ double aLen[4];
aLen[0] = getDistance( P(1), P(2) );
aLen[1] = getDistance( P(2), P(3) );
aLen[2] = getDistance( P(3), P(4) );
aLen[3] = getDistance( P(4), P(1) );
// Compute lengths of the diagonals
- std::vector< double > aDia (2);
+ double aDia[2];
aDia[0] = getDistance( P(1), P(3) );
aDia[1] = getDistance( P(2), P(4) );
// Compute areas of all triangles which can be built
// taking three nodes of the quadrangle
- std::vector< double > anArea (4);
+ double anArea[4];
anArea[0] = getArea( P(1), P(2), P(3) );
anArea[1] = getArea( P(1), P(2), P(4) );
anArea[2] = getArea( P(1), P(3), P(4) );
// Si - areas of the triangles
const double alpha = sqrt( 1 / 32. );
double L = Max( aLen[ 0 ],
- Max( aLen[ 1 ],
- Max( aLen[ 2 ],
- Max( aLen[ 3 ],
- Max( aDia[ 0 ], aDia[ 1 ] ) ) ) ) );
+ Max( aLen[ 1 ],
+ Max( aLen[ 2 ],
+ Max( aLen[ 3 ],
+ Max( aDia[ 0 ], aDia[ 1 ] ) ) ) ) );
double C1 = sqrt( ( aLen[0] * aLen[0] +
aLen[1] * aLen[1] +
aLen[2] * aLen[2] +
aLen[3] * aLen[3] ) / 4. );
double C2 = Min( anArea[ 0 ],
- Min( anArea[ 1 ],
- Min( anArea[ 2 ], anArea[ 3 ] ) ) );
+ Min( anArea[ 1 ],
+ Min( anArea[ 2 ], anArea[ 3 ] ) ) );
if ( C2 <= theEps )
return theInf;
return alpha * L * C1 / C2;
}
else if( nbNodes == 8 || nbNodes == 9 ) { // nbNodes==8 - quadratic quadrangle
// Compute lengths of the sides
- std::vector< double > aLen (4);
+ double aLen[4];
aLen[0] = getDistance( P(1), P(3) );
aLen[1] = getDistance( P(3), P(5) );
aLen[2] = getDistance( P(5), P(7) );
aLen[3] = getDistance( P(7), P(1) );
// Compute lengths of the diagonals
- std::vector< double > aDia (2);
+ double aDia[2];
aDia[0] = getDistance( P(1), P(5) );
aDia[1] = getDistance( P(3), P(7) );
// Compute areas of all triangles which can be built
// taking three nodes of the quadrangle
- std::vector< double > anArea (4);
+ double anArea[4];
anArea[0] = getArea( P(1), P(3), P(5) );
anArea[1] = getArea( P(1), P(3), P(7) );
anArea[2] = getArea( P(1), P(5), P(7) );
} // switch(nbNodes)
if ( nbNodes > 4 ) {
- // avaluate aspect ratio of quadranle faces
+ // evaluate aspect ratio of quadrangle faces
AspectRatio aspect2D;
SMDS_VolumeTool::VolumeType type = SMDS_VolumeTool::GetType( nbNodes );
int nbFaces = SMDS_VolumeTool::NbFaces( type );
if ( SMDS_VolumeTool::NbFaceNodes( type, i ) != 4 )
continue;
const int* pInd = SMDS_VolumeTool::GetFaceNodesIndices( type, i, true );
- for ( int p = 0; p < 4; ++p ) // loop on nodes of a quadranle face
+ for ( int p = 0; p < 4; ++p ) // loop on nodes of a quadrangle face
points( p + 1 ) = P( pInd[ p ] + 1 );
aQuality = std::max( aQuality, aspect2D.GetValue( points ));
}
*/
//================================================================================
-double Length2D::GetValue( long theElementId )
+double Length2D::GetValue( const TSequenceOfXYZ& P )
{
- TSequenceOfXYZ P;
-
- if ( GetPoints( theElementId, P ))
- {
- double aVal = 0;
- int len = P.size();
- SMDSAbs_EntityType aType = P.getElementEntity();
+ double aVal = 0;
+ int len = P.size();
+ SMDSAbs_EntityType aType = P.getElementEntity();
- switch (aType) {
- case SMDSEntity_Edge:
- if (len == 2)
- aVal = getDistance( P( 1 ), P( 2 ) );
- break;
- case SMDSEntity_Quad_Edge:
- if (len == 3) // quadratic edge
- aVal = getDistance(P( 1 ),P( 3 )) + getDistance(P( 3 ),P( 2 ));
- break;
- case SMDSEntity_Triangle:
- if (len == 3){ // triangles
- double L1 = getDistance(P( 1 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 1 ));
- aVal = Min(L1,Min(L2,L3));
- }
- break;
- case SMDSEntity_Quadrangle:
- if (len == 4){ // quadrangles
- double L1 = getDistance(P( 1 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 4 ));
- double L4 = getDistance(P( 4 ),P( 1 ));
- aVal = Min(Min(L1,L2),Min(L3,L4));
- }
- break;
- case SMDSEntity_Quad_Triangle:
- case SMDSEntity_BiQuad_Triangle:
- if (len >= 6){ // quadratic triangles
- double L1 = getDistance(P( 1 ),P( 2 )) + getDistance(P( 2 ),P( 3 ));
- double L2 = getDistance(P( 3 ),P( 4 )) + getDistance(P( 4 ),P( 5 ));
- double L3 = getDistance(P( 5 ),P( 6 )) + getDistance(P( 6 ),P( 1 ));
- aVal = Min(L1,Min(L2,L3));
- }
- break;
- case SMDSEntity_Quad_Quadrangle:
- case SMDSEntity_BiQuad_Quadrangle:
- if (len >= 8){ // quadratic quadrangles
- double L1 = getDistance(P( 1 ),P( 2 )) + getDistance(P( 2 ),P( 3 ));
- double L2 = getDistance(P( 3 ),P( 4 )) + getDistance(P( 4 ),P( 5 ));
- double L3 = getDistance(P( 5 ),P( 6 )) + getDistance(P( 6 ),P( 7 ));
- double L4 = getDistance(P( 7 ),P( 8 )) + getDistance(P( 8 ),P( 1 ));
- aVal = Min(Min(L1,L2),Min(L3,L4));
- }
- break;
- case SMDSEntity_Tetra:
- if (len == 4){ // tetrahedra
- double L1 = getDistance(P( 1 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 1 ));
- double L4 = getDistance(P( 1 ),P( 4 ));
- double L5 = getDistance(P( 2 ),P( 4 ));
- double L6 = getDistance(P( 3 ),P( 4 ));
- aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
- }
- break;
- case SMDSEntity_Pyramid:
- if (len == 5){ // pyramid
- double L1 = getDistance(P( 1 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 4 ));
- double L4 = getDistance(P( 4 ),P( 1 ));
- double L5 = getDistance(P( 1 ),P( 5 ));
- double L6 = getDistance(P( 2 ),P( 5 ));
- double L7 = getDistance(P( 3 ),P( 5 ));
- double L8 = getDistance(P( 4 ),P( 5 ));
-
- aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
- aVal = Min(aVal,Min(L7,L8));
- }
- break;
- case SMDSEntity_Penta:
- if (len == 6) { // pentahedron
- double L1 = getDistance(P( 1 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 1 ));
- double L4 = getDistance(P( 4 ),P( 5 ));
- double L5 = getDistance(P( 5 ),P( 6 ));
- double L6 = getDistance(P( 6 ),P( 4 ));
- double L7 = getDistance(P( 1 ),P( 4 ));
- double L8 = getDistance(P( 2 ),P( 5 ));
- double L9 = getDistance(P( 3 ),P( 6 ));
-
- aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
- aVal = Min(aVal,Min(Min(L7,L8),L9));
- }
- break;
- case SMDSEntity_Hexa:
- if (len == 8){ // hexahedron
- double L1 = getDistance(P( 1 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 4 ));
- double L4 = getDistance(P( 4 ),P( 1 ));
- double L5 = getDistance(P( 5 ),P( 6 ));
- double L6 = getDistance(P( 6 ),P( 7 ));
- double L7 = getDistance(P( 7 ),P( 8 ));
- double L8 = getDistance(P( 8 ),P( 5 ));
- double L9 = getDistance(P( 1 ),P( 5 ));
- double L10= getDistance(P( 2 ),P( 6 ));
- double L11= getDistance(P( 3 ),P( 7 ));
- double L12= getDistance(P( 4 ),P( 8 ));
-
- aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
- aVal = Min(aVal,Min(Min(L7,L8),Min(L9,L10)));
- aVal = Min(aVal,Min(L11,L12));
- }
- break;
- case SMDSEntity_Quad_Tetra:
- if (len == 10){ // quadratic tetrahedron
- double L1 = getDistance(P( 1 ),P( 5 )) + getDistance(P( 5 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 6 )) + getDistance(P( 6 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 7 )) + getDistance(P( 7 ),P( 1 ));
- double L4 = getDistance(P( 1 ),P( 8 )) + getDistance(P( 8 ),P( 4 ));
- double L5 = getDistance(P( 2 ),P( 9 )) + getDistance(P( 9 ),P( 4 ));
- double L6 = getDistance(P( 3 ),P( 10 )) + getDistance(P( 10 ),P( 4 ));
- aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
- }
- break;
- case SMDSEntity_Quad_Pyramid:
- if (len == 13){ // quadratic pyramid
- double L1 = getDistance(P( 1 ),P( 6 )) + getDistance(P( 6 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 7 )) + getDistance(P( 7 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 8 )) + getDistance(P( 8 ),P( 4 ));
- double L4 = getDistance(P( 4 ),P( 9 )) + getDistance(P( 9 ),P( 1 ));
- double L5 = getDistance(P( 1 ),P( 10 )) + getDistance(P( 10 ),P( 5 ));
- double L6 = getDistance(P( 2 ),P( 11 )) + getDistance(P( 11 ),P( 5 ));
- double L7 = getDistance(P( 3 ),P( 12 )) + getDistance(P( 12 ),P( 5 ));
- double L8 = getDistance(P( 4 ),P( 13 )) + getDistance(P( 13 ),P( 5 ));
- aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
- aVal = Min(aVal,Min(L7,L8));
- }
- break;
- case SMDSEntity_Quad_Penta:
- case SMDSEntity_BiQuad_Penta:
- if (len >= 15){ // quadratic pentahedron
- double L1 = getDistance(P( 1 ),P( 7 )) + getDistance(P( 7 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 8 )) + getDistance(P( 8 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 9 )) + getDistance(P( 9 ),P( 1 ));
- double L4 = getDistance(P( 4 ),P( 10 )) + getDistance(P( 10 ),P( 5 ));
- double L5 = getDistance(P( 5 ),P( 11 )) + getDistance(P( 11 ),P( 6 ));
- double L6 = getDistance(P( 6 ),P( 12 )) + getDistance(P( 12 ),P( 4 ));
- double L7 = getDistance(P( 1 ),P( 13 )) + getDistance(P( 13 ),P( 4 ));
- double L8 = getDistance(P( 2 ),P( 14 )) + getDistance(P( 14 ),P( 5 ));
- double L9 = getDistance(P( 3 ),P( 15 )) + getDistance(P( 15 ),P( 6 ));
- aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
- aVal = Min(aVal,Min(Min(L7,L8),L9));
- }
- break;
- case SMDSEntity_Quad_Hexa:
- case SMDSEntity_TriQuad_Hexa:
- if (len >= 20) { // quadratic hexahedron
- double L1 = getDistance(P( 1 ),P( 9 )) + getDistance(P( 9 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 10 )) + getDistance(P( 10 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 11 )) + getDistance(P( 11 ),P( 4 ));
- double L4 = getDistance(P( 4 ),P( 12 )) + getDistance(P( 12 ),P( 1 ));
- double L5 = getDistance(P( 5 ),P( 13 )) + getDistance(P( 13 ),P( 6 ));
- double L6 = getDistance(P( 6 ),P( 14 )) + getDistance(P( 14 ),P( 7 ));
- double L7 = getDistance(P( 7 ),P( 15 )) + getDistance(P( 15 ),P( 8 ));
- double L8 = getDistance(P( 8 ),P( 16 )) + getDistance(P( 16 ),P( 5 ));
- double L9 = getDistance(P( 1 ),P( 17 )) + getDistance(P( 17 ),P( 5 ));
- double L10= getDistance(P( 2 ),P( 18 )) + getDistance(P( 18 ),P( 6 ));
- double L11= getDistance(P( 3 ),P( 19 )) + getDistance(P( 19 ),P( 7 ));
- double L12= getDistance(P( 4 ),P( 20 )) + getDistance(P( 20 ),P( 8 ));
- aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
- aVal = Min(aVal,Min(Min(L7,L8),Min(L9,L10)));
- aVal = Min(aVal,Min(L11,L12));
- }
- break;
- case SMDSEntity_Polygon:
- if ( len > 1 ) {
- aVal = getDistance( P(1), P( P.size() ));
- for ( size_t i = 1; i < P.size(); ++i )
- aVal = Min( aVal, getDistance( P( i ), P( i+1 )));
- }
- break;
- case SMDSEntity_Quad_Polygon:
- if ( len > 2 ) {
- aVal = getDistance( P(1), P( P.size() )) + getDistance( P(P.size()), P( P.size()-1 ));
- for ( size_t i = 1; i < P.size()-1; i += 2 )
- aVal = Min( aVal, getDistance( P( i ), P( i+1 )) + getDistance( P( i+1 ), P( i+2 )));
- }
- break;
- case SMDSEntity_Hexagonal_Prism:
- if (len == 12) { // hexagonal prism
- double L1 = getDistance(P( 1 ),P( 2 ));
- double L2 = getDistance(P( 2 ),P( 3 ));
- double L3 = getDistance(P( 3 ),P( 4 ));
- double L4 = getDistance(P( 4 ),P( 5 ));
- double L5 = getDistance(P( 5 ),P( 6 ));
- double L6 = getDistance(P( 6 ),P( 1 ));
-
- double L7 = getDistance(P( 7 ), P( 8 ));
- double L8 = getDistance(P( 8 ), P( 9 ));
- double L9 = getDistance(P( 9 ), P( 10 ));
- double L10= getDistance(P( 10 ),P( 11 ));
- double L11= getDistance(P( 11 ),P( 12 ));
- double L12= getDistance(P( 12 ),P( 7 ));
-
- double L13 = getDistance(P( 1 ),P( 7 ));
- double L14 = getDistance(P( 2 ),P( 8 ));
- double L15 = getDistance(P( 3 ),P( 9 ));
- double L16 = getDistance(P( 4 ),P( 10 ));
- double L17 = getDistance(P( 5 ),P( 11 ));
- double L18 = getDistance(P( 6 ),P( 12 ));
- aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
- aVal = Min(aVal, Min(Min(Min(L7,L8),Min(L9,L10)),Min(L11,L12)));
- aVal = Min(aVal, Min(Min(Min(L13,L14),Min(L15,L16)),Min(L17,L18)));
- }
- break;
- case SMDSEntity_Polyhedra:
- {
+ switch (aType) {
+ case SMDSEntity_Edge:
+ if (len == 2)
+ aVal = getDistance( P( 1 ), P( 2 ) );
+ break;
+ case SMDSEntity_Quad_Edge:
+ if (len == 3) // quadratic edge
+ aVal = getDistance(P( 1 ),P( 3 )) + getDistance(P( 3 ),P( 2 ));
+ break;
+ case SMDSEntity_Triangle:
+ if (len == 3){ // triangles
+ double L1 = getDistance(P( 1 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 1 ));
+ aVal = Min(L1,Min(L2,L3));
}
break;
- default:
- return 0;
+ case SMDSEntity_Quadrangle:
+ if (len == 4){ // quadrangles
+ double L1 = getDistance(P( 1 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 4 ));
+ double L4 = getDistance(P( 4 ),P( 1 ));
+ aVal = Min(Min(L1,L2),Min(L3,L4));
+ }
+ break;
+ case SMDSEntity_Quad_Triangle:
+ case SMDSEntity_BiQuad_Triangle:
+ if (len >= 6){ // quadratic triangles
+ double L1 = getDistance(P( 1 ),P( 2 )) + getDistance(P( 2 ),P( 3 ));
+ double L2 = getDistance(P( 3 ),P( 4 )) + getDistance(P( 4 ),P( 5 ));
+ double L3 = getDistance(P( 5 ),P( 6 )) + getDistance(P( 6 ),P( 1 ));
+ aVal = Min(L1,Min(L2,L3));
+ }
+ break;
+ case SMDSEntity_Quad_Quadrangle:
+ case SMDSEntity_BiQuad_Quadrangle:
+ if (len >= 8){ // quadratic quadrangles
+ double L1 = getDistance(P( 1 ),P( 2 )) + getDistance(P( 2 ),P( 3 ));
+ double L2 = getDistance(P( 3 ),P( 4 )) + getDistance(P( 4 ),P( 5 ));
+ double L3 = getDistance(P( 5 ),P( 6 )) + getDistance(P( 6 ),P( 7 ));
+ double L4 = getDistance(P( 7 ),P( 8 )) + getDistance(P( 8 ),P( 1 ));
+ aVal = Min(Min(L1,L2),Min(L3,L4));
+ }
+ break;
+ case SMDSEntity_Tetra:
+ if (len == 4){ // tetrahedra
+ double L1 = getDistance(P( 1 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 1 ));
+ double L4 = getDistance(P( 1 ),P( 4 ));
+ double L5 = getDistance(P( 2 ),P( 4 ));
+ double L6 = getDistance(P( 3 ),P( 4 ));
+ aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
}
+ break;
+ case SMDSEntity_Pyramid:
+ if (len == 5){ // pyramid
+ double L1 = getDistance(P( 1 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 4 ));
+ double L4 = getDistance(P( 4 ),P( 1 ));
+ double L5 = getDistance(P( 1 ),P( 5 ));
+ double L6 = getDistance(P( 2 ),P( 5 ));
+ double L7 = getDistance(P( 3 ),P( 5 ));
+ double L8 = getDistance(P( 4 ),P( 5 ));
- if (aVal < 0 ) {
- return 0.;
+ aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
+ aVal = Min(aVal,Min(L7,L8));
}
+ break;
+ case SMDSEntity_Penta:
+ if (len == 6) { // pentahedron
+ double L1 = getDistance(P( 1 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 1 ));
+ double L4 = getDistance(P( 4 ),P( 5 ));
+ double L5 = getDistance(P( 5 ),P( 6 ));
+ double L6 = getDistance(P( 6 ),P( 4 ));
+ double L7 = getDistance(P( 1 ),P( 4 ));
+ double L8 = getDistance(P( 2 ),P( 5 ));
+ double L9 = getDistance(P( 3 ),P( 6 ));
- if ( myPrecision >= 0 )
- {
- double prec = pow( 10., (double)( myPrecision ) );
- aVal = floor( aVal * prec + 0.5 ) / prec;
+ aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
+ aVal = Min(aVal,Min(Min(L7,L8),L9));
}
+ break;
+ case SMDSEntity_Hexa:
+ if (len == 8){ // hexahedron
+ double L1 = getDistance(P( 1 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 4 ));
+ double L4 = getDistance(P( 4 ),P( 1 ));
+ double L5 = getDistance(P( 5 ),P( 6 ));
+ double L6 = getDistance(P( 6 ),P( 7 ));
+ double L7 = getDistance(P( 7 ),P( 8 ));
+ double L8 = getDistance(P( 8 ),P( 5 ));
+ double L9 = getDistance(P( 1 ),P( 5 ));
+ double L10= getDistance(P( 2 ),P( 6 ));
+ double L11= getDistance(P( 3 ),P( 7 ));
+ double L12= getDistance(P( 4 ),P( 8 ));
- return aVal;
+ aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
+ aVal = Min(aVal,Min(Min(L7,L8),Min(L9,L10)));
+ aVal = Min(aVal,Min(L11,L12));
+ }
+ break;
+ case SMDSEntity_Quad_Tetra:
+ if (len == 10){ // quadratic tetrahedron
+ double L1 = getDistance(P( 1 ),P( 5 )) + getDistance(P( 5 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 6 )) + getDistance(P( 6 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 7 )) + getDistance(P( 7 ),P( 1 ));
+ double L4 = getDistance(P( 1 ),P( 8 )) + getDistance(P( 8 ),P( 4 ));
+ double L5 = getDistance(P( 2 ),P( 9 )) + getDistance(P( 9 ),P( 4 ));
+ double L6 = getDistance(P( 3 ),P( 10 )) + getDistance(P( 10 ),P( 4 ));
+ aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
+ }
+ break;
+ case SMDSEntity_Quad_Pyramid:
+ if (len == 13){ // quadratic pyramid
+ double L1 = getDistance(P( 1 ),P( 6 )) + getDistance(P( 6 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 7 )) + getDistance(P( 7 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 8 )) + getDistance(P( 8 ),P( 4 ));
+ double L4 = getDistance(P( 4 ),P( 9 )) + getDistance(P( 9 ),P( 1 ));
+ double L5 = getDistance(P( 1 ),P( 10 )) + getDistance(P( 10 ),P( 5 ));
+ double L6 = getDistance(P( 2 ),P( 11 )) + getDistance(P( 11 ),P( 5 ));
+ double L7 = getDistance(P( 3 ),P( 12 )) + getDistance(P( 12 ),P( 5 ));
+ double L8 = getDistance(P( 4 ),P( 13 )) + getDistance(P( 13 ),P( 5 ));
+ aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
+ aVal = Min(aVal,Min(L7,L8));
+ }
+ break;
+ case SMDSEntity_Quad_Penta:
+ case SMDSEntity_BiQuad_Penta:
+ if (len >= 15){ // quadratic pentahedron
+ double L1 = getDistance(P( 1 ),P( 7 )) + getDistance(P( 7 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 8 )) + getDistance(P( 8 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 9 )) + getDistance(P( 9 ),P( 1 ));
+ double L4 = getDistance(P( 4 ),P( 10 )) + getDistance(P( 10 ),P( 5 ));
+ double L5 = getDistance(P( 5 ),P( 11 )) + getDistance(P( 11 ),P( 6 ));
+ double L6 = getDistance(P( 6 ),P( 12 )) + getDistance(P( 12 ),P( 4 ));
+ double L7 = getDistance(P( 1 ),P( 13 )) + getDistance(P( 13 ),P( 4 ));
+ double L8 = getDistance(P( 2 ),P( 14 )) + getDistance(P( 14 ),P( 5 ));
+ double L9 = getDistance(P( 3 ),P( 15 )) + getDistance(P( 15 ),P( 6 ));
+ aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
+ aVal = Min(aVal,Min(Min(L7,L8),L9));
+ }
+ break;
+ case SMDSEntity_Quad_Hexa:
+ case SMDSEntity_TriQuad_Hexa:
+ if (len >= 20) { // quadratic hexahedron
+ double L1 = getDistance(P( 1 ),P( 9 )) + getDistance(P( 9 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 10 )) + getDistance(P( 10 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 11 )) + getDistance(P( 11 ),P( 4 ));
+ double L4 = getDistance(P( 4 ),P( 12 )) + getDistance(P( 12 ),P( 1 ));
+ double L5 = getDistance(P( 5 ),P( 13 )) + getDistance(P( 13 ),P( 6 ));
+ double L6 = getDistance(P( 6 ),P( 14 )) + getDistance(P( 14 ),P( 7 ));
+ double L7 = getDistance(P( 7 ),P( 15 )) + getDistance(P( 15 ),P( 8 ));
+ double L8 = getDistance(P( 8 ),P( 16 )) + getDistance(P( 16 ),P( 5 ));
+ double L9 = getDistance(P( 1 ),P( 17 )) + getDistance(P( 17 ),P( 5 ));
+ double L10= getDistance(P( 2 ),P( 18 )) + getDistance(P( 18 ),P( 6 ));
+ double L11= getDistance(P( 3 ),P( 19 )) + getDistance(P( 19 ),P( 7 ));
+ double L12= getDistance(P( 4 ),P( 20 )) + getDistance(P( 20 ),P( 8 ));
+ aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
+ aVal = Min(aVal,Min(Min(L7,L8),Min(L9,L10)));
+ aVal = Min(aVal,Min(L11,L12));
+ }
+ break;
+ case SMDSEntity_Polygon:
+ if ( len > 1 ) {
+ aVal = getDistance( P(1), P( P.size() ));
+ for ( size_t i = 1; i < P.size(); ++i )
+ aVal = Min( aVal, getDistance( P( i ), P( i+1 )));
+ }
+ break;
+ case SMDSEntity_Quad_Polygon:
+ if ( len > 2 ) {
+ aVal = getDistance( P(1), P( P.size() )) + getDistance( P(P.size()), P( P.size()-1 ));
+ for ( size_t i = 1; i < P.size()-1; i += 2 )
+ aVal = Min( aVal, getDistance( P( i ), P( i+1 )) + getDistance( P( i+1 ), P( i+2 )));
+ }
+ break;
+ case SMDSEntity_Hexagonal_Prism:
+ if (len == 12) { // hexagonal prism
+ double L1 = getDistance(P( 1 ),P( 2 ));
+ double L2 = getDistance(P( 2 ),P( 3 ));
+ double L3 = getDistance(P( 3 ),P( 4 ));
+ double L4 = getDistance(P( 4 ),P( 5 ));
+ double L5 = getDistance(P( 5 ),P( 6 ));
+ double L6 = getDistance(P( 6 ),P( 1 ));
+
+ double L7 = getDistance(P( 7 ), P( 8 ));
+ double L8 = getDistance(P( 8 ), P( 9 ));
+ double L9 = getDistance(P( 9 ), P( 10 ));
+ double L10= getDistance(P( 10 ),P( 11 ));
+ double L11= getDistance(P( 11 ),P( 12 ));
+ double L12= getDistance(P( 12 ),P( 7 ));
+
+ double L13 = getDistance(P( 1 ),P( 7 ));
+ double L14 = getDistance(P( 2 ),P( 8 ));
+ double L15 = getDistance(P( 3 ),P( 9 ));
+ double L16 = getDistance(P( 4 ),P( 10 ));
+ double L17 = getDistance(P( 5 ),P( 11 ));
+ double L18 = getDistance(P( 6 ),P( 12 ));
+ aVal = Min(Min(Min(L1,L2),Min(L3,L4)),Min(L5,L6));
+ aVal = Min(aVal, Min(Min(Min(L7,L8),Min(L9,L10)),Min(L11,L12)));
+ aVal = Min(aVal, Min(Min(Min(L13,L14),Min(L15,L16)),Min(L17,L18)));
+ }
+ break;
+ case SMDSEntity_Polyhedra:
+ {
+ }
+ break;
+ default:
+ return 0;
+ }
+ if (aVal < 0 ) {
+ return 0.;
}
- return 0.;
+
+ if ( myPrecision >= 0 )
+ {
+ double prec = pow( 10., (double)( myPrecision ) );
+ aVal = floor( aVal * prec + 0.5 ) / prec;
+ }
+
+ return aVal;
}
double Length2D::GetBadRate( double Value, int /*nbNodes*/ ) const
}
}
+//================================================================================
+/*
+ Class : Deflection2D
+ Description : Functor for calculating number of faces conneted to the edge
+*/
+//================================================================================
+
+double Deflection2D::GetValue( const TSequenceOfXYZ& P )
+{
+ if ( myMesh && P.getElement() )
+ {
+ // get underlying surface
+ if ( myShapeIndex != P.getElement()->getshapeId() )
+ {
+ mySurface.Nullify();
+ myShapeIndex = P.getElement()->getshapeId();
+ const TopoDS_Shape& S =
+ static_cast< const SMESHDS_Mesh* >( myMesh )->IndexToShape( myShapeIndex );
+ if ( !S.IsNull() && S.ShapeType() == TopAbs_FACE )
+ {
+ mySurface = new ShapeAnalysis_Surface( BRep_Tool::Surface( TopoDS::Face( S )));
+
+ GeomLib_IsPlanarSurface isPlaneCheck( mySurface->Surface() );
+ if ( isPlaneCheck.IsPlanar() )
+ myPlane.reset( new gp_Pln( isPlaneCheck.Plan() ));
+ else
+ myPlane.reset();
+ }
+ }
+ // project gravity center to the surface
+ if ( !mySurface.IsNull() )
+ {
+ gp_XYZ gc(0,0,0);
+ gp_XY uv(0,0);
+ int nbUV = 0;
+ for ( size_t i = 0; i < P.size(); ++i )
+ {
+ gc += P(i+1);
+
+ if ( const SMDS_FacePosition* fPos = dynamic_cast<const SMDS_FacePosition*>
+ ( P.getElement()->GetNode( i )->GetPosition() ))
+ {
+ uv.ChangeCoord(1) += fPos->GetUParameter();
+ uv.ChangeCoord(2) += fPos->GetVParameter();
+ ++nbUV;
+ }
+ }
+ gc /= P.size();
+ if ( nbUV ) uv /= nbUV;
+
+ double maxLen = MaxElementLength2D().GetValue( P );
+ double tol = 1e-3 * maxLen;
+ double dist;
+ if ( myPlane )
+ {
+ dist = myPlane->Distance( gc );
+ if ( dist < tol )
+ dist = 0;
+ }
+ else
+ {
+ if ( uv.X() != 0 && uv.Y() != 0 ) // faster way
+ mySurface->NextValueOfUV( uv, gc, tol, 0.5 * maxLen );
+ else
+ mySurface->ValueOfUV( gc, tol );
+ dist = mySurface->Gap();
+ }
+ return Round( dist );
+ }
+ }
+ return 0;
+}
+
+void Deflection2D::SetMesh( const SMDS_Mesh* theMesh )
+{
+ NumericalFunctor::SetMesh( dynamic_cast<const SMESHDS_Mesh* >( theMesh ));
+ myShapeIndex = -100;
+ myPlane.reset();
+}
+
+SMDSAbs_ElementType Deflection2D::GetType() const
+{
+ return SMDSAbs_Face;
+}
+
+double Deflection2D::GetBadRate( double Value, int /*nbNodes*/ ) const
+{
+ // meaningless as it is not quality control functor
+ return Value;
+}
+
//================================================================================
/*
Class : MultiConnection
#include "SMESH_TypeDefs.hxx"
-#include <BRepClass3d_SolidClassifier.hxx>
#include <Bnd_B3d.hxx>
#include <GeomAPI_ProjectPointOnCurve.hxx>
#include <GeomAPI_ProjectPointOnSurf.hxx>
class SMESHDS_SubMesh;
class SMESHDS_GroupBase;
+class BRepClass3d_SolidClassifier;
+class ShapeAnalysis_Surface;
+class gp_Pln;
class gp_Pnt;
namespace SMESH{
*/
class SMESHCONTROLS_EXPORT Length2D: public virtual NumericalFunctor{
public:
- virtual double GetValue( long theElementId );
+ virtual double GetValue( const TSequenceOfXYZ& thePoints );
virtual double GetBadRate( double Value, int nbNodes ) const;
virtual SMDSAbs_ElementType GetType() const;
struct Value{
};
typedef boost::shared_ptr<Length2D> Length2DPtr;
+ /*
+ Class : Deflection2D
+ Description : Functor for calculating distance between a face and geometry
+ */
+ class SMESHCONTROLS_EXPORT Deflection2D: public virtual NumericalFunctor{
+ public:
+ virtual void SetMesh( const SMDS_Mesh* theMesh );
+ virtual double GetValue( const TSequenceOfXYZ& thePoints );
+ virtual double GetBadRate( double Value, int nbNodes ) const;
+ virtual SMDSAbs_ElementType GetType() const;
+ private:
+ Handle(ShapeAnalysis_Surface) mySurface;
+ int myShapeIndex;
+ boost::shared_ptr<gp_Pln> myPlane;
+ };
+
/*
Class : MultiConnection
Description : Functor for calculating number of faces connected to the edge
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH Driver : implementaion of driver for reading and writing
+// SMESH Driver : implementation of driver for reading and writing
// File : Mesh_Reader.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH Driver : implementaion of driver for reading and writing
+// SMESH Driver : implementation of driver for reading and writing
// File : Mesh_Reader.h
// Module : SMESH
//
return(0);
}
- /* Open the file in the required mod and initialyse the mesh structure */
+ /* Open the file in the required mod and initialise the mesh structure */
if(msh->mod == GmfRead)
{
namespace DriverMED
{
- // Implemetation is in DriverMED_W_Field.cxx
+ // Implementation is in DriverMED_W_Field.cxx
/*
* Returns MED element geom type (MED::EGeometrieElement) by SMDS type
return myType;
}
-const std::set< SMDSAbs_ElementType >&
+const ElemTypeSet&
DriverMED_Family
::GetTypes() const
{
#include "SMESHDS_SubMesh.hxx"
#include "MED_Common.hxx"
+#include <boost/container/flat_set.hpp>
#include <boost/shared_ptr.hpp>
#include <set>
#include <limits>
#define NIG_BALL_FAMILY INT_MAX-5
#define NIG_GROUP_PREFIX "NOT_IN_GRP"
-typedef std::list<DriverMED_FamilyPtr > DriverMED_FamilyPtrList;
-typedef std::map<int,SMESHDS_SubMesh* > SMESHDS_SubMeshPtrMap;
-typedef std::list<SMESHDS_GroupBase* > SMESHDS_GroupBasePtrList;
-typedef std::set<const SMDS_MeshElement*,TIDCompare > ElementsSet;
+typedef std::list<DriverMED_FamilyPtr > DriverMED_FamilyPtrList;
+typedef std::map<int,SMESHDS_SubMesh* > SMESHDS_SubMeshPtrMap;
+typedef std::list<SMESHDS_GroupBase* > SMESHDS_GroupBasePtrList;
+typedef std::set<const SMDS_MeshElement*,TIDCompare > ElementsSet;
+typedef boost::container::flat_set< SMDSAbs_ElementType > ElemTypeSet;
class MESHDRIVERMED_EXPORT DriverMED_Family
{
void SetType(const SMDSAbs_ElementType theType);
SMDSAbs_ElementType GetType();
- const std::set< SMDSAbs_ElementType >& GetTypes() const;
+ const ElemTypeSet& GetTypes() const;
bool MemberOf(std::string theGroupName) const;
//! Split <theSubMesh> on some parts (families) on the basis of the elements type.
static
- DriverMED_FamilyPtrList
- SplitByType(SMESHDS_SubMesh* theSubMesh,
- const int theId);
+ DriverMED_FamilyPtrList SplitByType(SMESHDS_SubMesh* theSubMesh,
+ const int theId);
/*! Remove from <Elements> elements, common with <by>,
private:
- int myId;
- SMDSAbs_ElementType myType;
- ElementsSet myElements;
- MED::TStringSet myGroupNames;
- int myGroupAttributVal;
- std::set<SMDSAbs_ElementType> myTypes; // Issue 0020576
+ int myId;
+ SMDSAbs_ElementType myType;
+ ElementsSet myElements;
+ MED::TStringSet myGroupNames;
+ int myGroupAttributVal;
+ ElemTypeSet myTypes; // Issue 0020576
};
#endif
set<string>::const_iterator aGrNamesIter = aGroupNames.begin();
for (; aGrNamesIter != aGroupNames.end(); aGrNamesIter++)
{
- const set< SMDSAbs_ElementType >& types = aFamily->GetTypes();
- set< SMDSAbs_ElementType >::const_iterator type = types.begin();
+ const ElemTypeSet& types = aFamily->GetTypes();
+ ElemTypeSet::const_iterator type = types.begin();
for ( ; type != types.end(); ++type )
{
TNameAndType aNameAndType = make_pair( *aGrNamesIter, *type );
void DriverMED_R_SMESHDS_Mesh::GetGroup(SMESHDS_Group* theGroup)
{
- string aGroupName (theGroup->GetStoreName());
+ TFamilyVec * famVecPtr;
+
+ if ( myGroups2FamiliesMap.IsEmpty() ) // PAL23514
+ {
+ TFamilyVec famVector( 1 );
+ map<int, DriverMED_FamilyPtr>::iterator famIter = myFamilies.begin();
+ for ( ; famIter != myFamilies.end(); famIter++ )
+ {
+ DriverMED_FamilyPtr family = famIter->second;
+ const MED::TStringSet& groups = family->GetGroupNames();
+ famVector[ 0 ] = family;
+ MED::TStringSet::const_iterator grpIter = groups.begin();
+ for ( ; grpIter != groups.end(); ++grpIter )
+ {
+ TCollection_AsciiString groupName = grpIter->c_str();
+ if (( famVecPtr = myGroups2FamiliesMap.ChangeSeek( groupName )))
+ famVecPtr->push_back( family );
+ else
+ myGroups2FamiliesMap.Bind( groupName, famVector );
+ }
+ }
+ }
+
+ const char* aGroupName = theGroup->GetStoreName();
if(MYDEBUG) MESSAGE("Get Group " << aGroupName);
- map<int, DriverMED_FamilyPtr>::iterator aFamsIter = myFamilies.begin();
- for (; aFamsIter != myFamilies.end(); aFamsIter++)
+ if (( famVecPtr = myGroups2FamiliesMap.ChangeSeek( aGroupName )))
{
- DriverMED_FamilyPtr aFamily = (*aFamsIter).second;
- if (aFamily->GetTypes().count( theGroup->GetType() ) && aFamily->MemberOf(aGroupName))
+ for ( size_t i = 0; i < famVecPtr->size(); ++i )
{
- const ElementsSet& anElements = aFamily->GetElements();
- ElementsSet::const_iterator anElemsIter = anElements.begin();
- for (; anElemsIter != anElements.end(); anElemsIter++)
+ DriverMED_FamilyPtr aFamily = (*famVecPtr)[i];
+ if ( aFamily->GetTypes().count( theGroup->GetType() ))
{
- const SMDS_MeshElement * element = *anElemsIter;
- if ( element->GetType() == theGroup->GetType() ) // Issue 0020576
- theGroup->SMDSGroup().Add(element);
+ const ElementsSet& anElements = aFamily->GetElements();
+ ElementsSet::const_iterator anElemsIter = anElements.begin();
+ for (; anElemsIter != anElements.end(); anElemsIter++)
+ {
+ const SMDS_MeshElement * element = *anElemsIter;
+ if ( element->GetType() == theGroup->GetType() ) // Issue 0020576
+ theGroup->SMDSGroup().Add(element);
+ }
+ int aGroupAttrVal = aFamily->GetGroupAttributVal();
+ if( aGroupAttrVal != 0 )
+ theGroup->SetColorGroup(aGroupAttrVal);
}
- int aGroupAttrVal = aFamily->GetGroupAttributVal();
- if( aGroupAttrVal != 0)
- theGroup->SetColorGroup(aGroupAttrVal);
-// if ( element ) -- Issue 0020576
-// theGroup->SetType( theGroup->SMDSGroup().GetType() );
}
}
}
#include <list>
#include <map>
+#include <NCollection_DataMap.hxx>
+#include <TCollection_AsciiString.hxx>
+
class SMESHDS_Mesh;
class SMESHDS_Group;
class SMESHDS_SubMesh;
-typedef std::pair< std::string, SMDSAbs_ElementType > TNameAndType;
+typedef std::vector< DriverMED_FamilyPtr > TFamilyVec;
+typedef std::pair< std::string, SMDSAbs_ElementType > TNameAndType;
+typedef NCollection_DataMap< TCollection_AsciiString, TFamilyVec > TName2Falilies;
class MESHDRIVERMED_EXPORT DriverMED_R_SMESHDS_Mesh: public Driver_SMESHDS_Mesh
{
void SetMeshName(std::string theMeshName);
private:
- std::string myMeshName;
+ std::string myMeshName;
std::map<int, DriverMED_FamilyPtr> myFamilies;
-
+ TName2Falilies myGroups2FamiliesMap;
};
#endif
return DRS_OK;
}
-namespace DriverMED // Implemetation of fuctions declared in DriverMED.hxx
+namespace DriverMED // Implementation of functions declared in DriverMED.hxx
{
//================================================================================
/*!
continue;
}
+ // build map of family numbers for this type
+ if ( !isElemFamMapBuilt[ aElemTypeData->_smdsType ])
+ {
+ fillElemFamilyMap( anElemFamMap, aFamilies, aElemTypeData->_smdsType );
+ isElemFamMapBuilt[ aElemTypeData->_smdsType ] = true;
+ }
+
// iterator on elements of a current type
SMDS_ElemIteratorPtr elemIterator;
int iElem = 0;
else if (aElemTypeData->_geomType == ePOLYEDRE )
{
elemIterator = myMesh->elementGeomIterator( SMDSGeom_POLYHEDRA );
-
+
if ( nbPolyhedronNodes == 0 ) {
// Count nb of nodes
while ( elemIterator->more() ) {
// allocate data arrays
PBallInfo aBallInfo = myMed->CrBallInfo( aMeshInfo, aElemTypeData->_nbElems );
- // build map of family numbers for this type
- if ( !isElemFamMapBuilt[ aElemTypeData->_smdsType ])
- {
- fillElemFamilyMap( anElemFamMap, aFamilies, aElemTypeData->_smdsType );
- isElemFamMapBuilt[ aElemTypeData->_smdsType ] = true;
- }
-
elemIterator = myMesh->elementsIterator( SMDSAbs_Ball );
while ( elemIterator->more() )
{
theConnMode,
theIsElemNum,
theIsElemNames);
- // build map of family numbers for this type
- if ( !isElemFamMapBuilt[ aElemTypeData->_smdsType ])
- {
- fillElemFamilyMap( anElemFamMap, aFamilies, aElemTypeData->_smdsType );
- isElemFamMapBuilt[ aElemTypeData->_smdsType ] = true;
- }
TInt aNbNodes = MED::GetNbNodes(aElemTypeData->_geomType);
elemIterator = myMesh->elementsIterator( aElemTypeData->_smdsType );
#endif
namespace MED{
- // enum EVersion sould be synchronized with enum MED_VERSION in SMESH_Mesh.idl (.hh)
+ // enum EVersion should be synchronized with enum MED_VERSION in SMESH_Mesh.idl (.hh)
// i.e. same positive values!
enum EVersion {eVUnknown = -1, eV2_1, eV2_2, eLATEST,
eMINOR_0, eMINOR_1, eMINOR_2, eMINOR_3, eMINOR_4, eMINOR_5, eMINOR_6, eMINOR_7, eMINOR_8, eMINOR_9};
typedef TIntVector TElemNum;
typedef SharedPtr<TElemNum> PElemNum;
- //! Define a parent class for all MED entities that describes mesh entites such as nodes and cells.
+ //! Define a parent class for all MED entities that describes mesh entities such as nodes and cells.
struct MEDWRAPPER_EXPORT TElemInfo: virtual TBase
{
PMeshInfo myMeshInfo; //!< A reference to correspondig MED Mesh
TInt myNbElem; //<! Number of corresponding mesh entities
TInt GetNbElem() const { return myNbElem;} //! Get number of mesh elements
- //! Defines sequence MED Family indexes for corresponding mesh entites
+ //! Defines sequence MED Family indexes for corresponding mesh entities
PElemNum myFamNum;
//! Get number of a MED FAMILY by order number of the mesh element
TInt GetFamNum(TInt theId) const;
//! Defines if the mesh elements are named
EBooleen myIsElemNames;
- //! Let know if the mesh elements havew names
+ //! Let know if the mesh elements have names
EBooleen IsElemNames() const { return myIsElemNames;}
//! Contains sequence of the names for the mesh elements
void SetGrilleStructure(TInt theAxis,TInt theNb);
/*!
- *Defines sequence MED Family indexes for corresponding mesh entites
+ *Defines sequence MED Family indexes for corresponding mesh entities
*/
TElemNum myFamNum;
//! Get number of a MED FAMILY by order number of the mesh element
void SetFamNum(TInt theId, TInt theVal);
/*!
- *Defines sequence MED Family indexes for sub entites
+ *Defines sequence MED Family indexes for sub entities
*/
TElemNum myFamSubNum;
//! Get number of a MED FAMILY by order number of sub element
//----------------------------------------------------------------------------
- //! Read the values for MEDWrapper MED TIEMSTAMP from defined MED file
+ //! Read the values for MEDWrapper MED TIMESTAMP from defined MED file
virtual
void
GetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
const TKey2Gauss& theKey2Gauss,
TErr* theErr = NULL) = 0;
- //! Write the values for MEDWrapper MED TIEMSTAMP to defined MED file
+ //! Write the values for MEDWrapper MED TIMESTAMP to defined MED file
virtual
void
SetTimeStampValue(const PTimeStampValueBase& theTimeStampValue,
TErr* theErr = NULL) = 0;
- //! Creates the values for MEDWrapper MED TIEMSTAMP representation
+ //! Creates the values for MEDWrapper MED TIMESTAMP representation
virtual
PTimeStampValueBase
CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const TGeom2Profile& theGeom2Profile = TGeom2Profile(),
EModeSwitch theMode = eFULL_INTERLACE) = 0;
- //! Creates the values for MEDWrapper MED TIEMSTAMP representation
+ //! Creates the values for MEDWrapper MED TIMESTAMP representation
virtual
PTimeStampValueBase
CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const TGeom2Profile& theGeom2Profile = TGeom2Profile(),
EModeSwitch theMode = eFULL_INTERLACE);
- //! A copy-constructor for the values for MEDWrapper MED TIEMSTAMP representation
+ //! A copy-constructor for the values for MEDWrapper MED TIMESTAMP representation
virtual
PTimeStampValueBase
CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const PTimeStampValueBase& theInfo,
ETypeChamp theTypeChamp) = 0;
- //! A copy-constructor for the values for MEDWrapper MED TIEMSTAMP representation
+ //! A copy-constructor for the values for MEDWrapper MED TIMESTAMP representation
virtual
PTimeStampValueBase
CrTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const PTimeStampValueBase& theInfo);
- //! Read the values for MEDWrapper MED TIEMSTAMP from defined MED file
+ //! Read the values for MEDWrapper MED TIMESTAMP from defined MED file
PTimeStampValueBase
GetPTimeStampValue(const PTimeStampInfo& theTimeStampInfo,
const TMKey2Profile& theMKey2Profile,
//----------------------------------------------------------------------------
// Backward compatibility declarations
- //! Read the values for MEDWrapper MED TIEMSTAMP from defined MED file
+ //! Read the values for MEDWrapper MED TIMESTAMP from defined MED file
virtual
void
GetTimeStampVal(const PTimeStampVal& theVal,
const TKey2Gauss& theKey2Gauss,
TErr* theErr = NULL);
- //! Write the values for MEDWrapper MED TIEMSTAMP to defined MED file
+ //! Write the values for MEDWrapper MED TIMESTAMP to defined MED file
virtual
void
SetTimeStamp(const PTimeStampVal& theVal,
TErr* theErr = NULL);
- //! Creates the values for MEDWrapper MED TIEMSTAMP representation
+ //! Creates the values for MEDWrapper MED TIMESTAMP representation
virtual
PTimeStampVal
CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
const TGeom2Profile& theGeom2Profile = TGeom2Profile(),
EModeSwitch theMode = eFULL_INTERLACE);
- //! A copy-constructor for the values for MEDWrapper MED TIEMSTAMP representation
+ //! A copy-constructor for the values for MEDWrapper MED TIMESTAMP representation
virtual
PTimeStampVal
CrTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
const PTimeStampVal& theInfo);
- //! Read the values for MEDWrapper MED TIEMSTAMP from defined MED file
+ //! Read the values for MEDWrapper MED TIMESTAMP from defined MED file
PTimeStampVal
GetPTimeStampVal(const PTimeStampInfo& theTimeStampInfo,
const TMKey2Profile& theMKey2Profile,
break;
}
case eLength2D:
- {
myFunctor.reset(new SMESH::Controls::Length2D());
myControlActor = my2DActor;
break;
- }
case eFreeBorders:
myFunctor.reset(new SMESH::Controls::FreeBorders());
myControlActor = my1DActor;
myControlActor = my3DActor;
break;
}
+ case eDeflection2D:
+ {
+ SMESH::Controls::Deflection2D* aControl = new SMESH::Controls::Deflection2D();
+ aControl->SetPrecision( myControlsPrecision );
+ myFunctor.reset( aControl );
+ myControlActor = my2DActor;
+ break;
+ }
case eBareBorderVolume:
{
myFunctor.reset(new SMESH::Controls::BareBorderVolume());
return myPickableActor->GetNodeCoord(theObjID);
}
+int SMESH_ActorDef::GetNodeVtkId(int theObjID)
+{
+ return myPickableActor->GetNodeVtkId(theObjID);
+}
int SMESH_ActorDef::GetElemObjId(int theVtkID)
{
virtual void SetFacesOrientation3DVectors(bool theState) = 0;
virtual bool GetFacesOrientation3DVectors() = 0;
- enum eControl{eNone, eLength, eLength2D, eFreeBorders, eFreeEdges, eFreeNodes,
+ enum eControl{eNone, eLength, eLength2D, eDeflection2D, eFreeBorders, eFreeEdges, eFreeNodes,
eFreeFaces, eMultiConnection, eArea, eTaper, eAspectRatio,
eMinimumAngle, eWarping, eSkew, eAspectRatio3D, eMultiConnection2D, eVolume3D,
eMaxElementLength2D, eMaxElementLength3D, eBareBorderFace, eBareBorderVolume,
virtual int GetNodeObjId(int theVtkID);
virtual double* GetNodeCoord(int theObjID);
+ virtual int GetNodeVtkId(int theObjID);
virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID);
return aCoord;
}
+int
+SMESH_DeviceActor
+::GetNodeVtkId(int theObjID)
+{
+ return myVisualObj->GetNodeVTKId(theObjID);
+}
int
SMESH_DeviceActor
virtual int GetNodeObjId(int theVtkID);
virtual double* GetNodeCoord(int theObjID);
+ virtual int GetNodeVtkId(int theObjID);
virtual int GetElemObjId(int theVtkID);
virtual vtkCell* GetElemCell(int theObjID);
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
- // get the input and ouptut
+ // get the input and output
vtkDataSet *input =
vtkDataSet::SafeDownCast(inInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkUnstructuredGrid *output =
vtkInformation *inInfo = inputVector[0]->GetInformationObject(0);
vtkInformation *outInfo = outputVector->GetInformationObject(0);
- // get the input and ouptut
+ // get the input and output
vtkDataSet *input = vtkDataSet::SafeDownCast(
inInfo->Get(vtkDataObject::DATA_OBJECT()));
vtkPolyData *output = vtkPolyData::SafeDownCast(
}
//polygons & cell colors
- unsigned char *rgba, *rgb;
+ unsigned char *rgb;
+ const unsigned char *rgba;
vtkIdType ptIds[4], dcCount=0;
for ( i = 0; i < numColors; i++ )
{
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDSAbs_ElementType.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// Module : SMESH
// File : SMDS_BallElement.cxx
// Author : Edward AGAPOV (eap)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_BallElement.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_EdgePosition.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_EdgePosition.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshElement.hxx
// Module : SMESH
// Created: 12.01.05 18:02:52
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifndef _SMDS_FaceOfNodes_HeaderFile
#define _SMDS_FaceOfNodes_HeaderFile
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_FacePosition.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_FacePosition.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifndef _SMDS_Iterator_HeaderFile
#define _SMDS_Iterator_HeaderFile
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#include "SMESH_SMDS.hxx"
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_IteratorOnIterators.hxx
// Author : Edward AGAPOV (eap)
//
///////////////////////////////////////////////////////////////////////////////
/// SMDS_Iterator iterating over all elements provided by other iterators
///
-/// Other iterators must implement SMDS_Iterator iterface and
+/// Other iterators must implement SMDS_Iterator interface and
/// must be provided within a stl-like container
/// BE CAREFUL: iterator pointed value is static_cast'ed to VALUE
///////////////////////////////////////////////////////////////////////////////
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_Mesh.hxx
// Module : SMESH
//
int idnode4, int idnode5, int idnode6) const;
const SMDS_MeshFace *FindFace(int idnode1, int idnode2, int idnode3, int idnode4,
int idnode5, int idnode6, int idnode7, int idnode8) const;
- const SMDS_MeshElement *FindElement(int IDelem) const;
+ virtual const SMDS_MeshElement * FindElement(int IDelem) const;
static const SMDS_Mesh0DElement* Find0DElement(const SMDS_MeshNode * n);
static const SMDS_BallElement* FindBall(const SMDS_MeshNode * n);
static const SMDS_MeshEdge* FindEdge(const SMDS_MeshNode * n1,
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_Mesh0DElement.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_Mesh0DElement.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshEdge.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshElement.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshElementIDFactory.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshElementIDFactory.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#include "SMDS_MeshFace.hxx"
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshFace.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshGroup.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshGroup.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshIDFactory.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshIDFactory.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshNode.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshObject.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshObject.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshVolume.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshVolume.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifndef _SMDS_PolygonalFaceOfNodes_HeaderFile
#define _SMDS_PolygonalFaceOfNodes_HeaderFile
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_PolyhedralVolumeOfNodes.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_Position.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_Position.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File: SMDS_QuadraticEdge.cxx
// Created: 16.01.06 16:25:42
// Author: Sergey KUUL
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_QuadraticEdge.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File: SMDS_QuadraticFaceOfNodes.cxx
// Created: 16.01.06 17:12:58
// Author: Sergey KUUL
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_QuadraticVolumeOfNodes.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File: SMDS_QuadraticVolumeOfNodes.cxx
// Created: 17.01.06 09:46:11
// Author: Sergey KUUL
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_QuadraticVolumeOfNodes.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_SetIterator.hxx
// Created : Feb 27 2006
// Author : Edward AGAPOV (eap)
static VALUE value(VALUE_SET_ITERATOR it) { return (VALUE) it->second; }
};
+ template<typename VALUE,typename VALUE_SET_ITERATOR>
+ struct PointerAccessor {
+ static VALUE value(VALUE_SET_ITERATOR it) { return (VALUE) &(*it); }
+ };
+
///////////////////////////////////////////////////////////////////////////////
/// Filters of value pointed by iterator
///////////////////////////////////////////////////////////////////////////////
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_SpacePosition.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_SpacePosition.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_StdIterator.hxx
// Created : Fri Feb 5 11:03:46 2010
// Author : Edward AGAPOV (eap)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_TypeOfPosition.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VertexPosition.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VertexPosition.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VolumeOfFaces.cxx
// Author : Jean-Michel BOULCOURT
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VolumeOfFaces.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
//
#ifdef _MSC_VER
#pragma warning(disable:4786)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_MeshVolume.hxx
// Module : SMESH
//
//================================================================================
/*!
- * \brief fast check that only one volume is build on the face nodes
+ * \brief Fast quickly check that only one volume is built on the face nodes
* This check is valid for conformal meshes only
*/
//================================================================================
//================================================================================
/*!
- * \brief Thorough check that only one volume is build on the face nodes
+ * \brief Thorough check that only one volume is built on the face nodes
*/
//================================================================================
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VolumeTool.hxx
// Module : SMESH
// Created : Tue Jul 13 11:27:17 2004
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMDS : implementaion of Salome mesh data structure
+// SMESH SMDS : implementation of Salome mesh data structure
// File : SMDS_VtkEdge.hxx
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Algo.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
bool SMESH_Algo::Features::IsCompatible( const SMESH_Algo::Features& algo2 ) const
{
if ( _dim > algo2._dim ) return algo2.IsCompatible( *this );
- // algo2 is of highter dimension
+ // algo2 is of higher dimension
if ( _outElemTypes.empty() || algo2._inElemTypes.empty() )
return false;
bool compatible = true;
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Algo.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
* Methods of the class are grouped into several parts:
* - main lifecycle methods, like Compute()
* - methods describing features of the algorithm, like NeedShape()
- * - methods related to dependencies between sub-meshes imposed by the algorith
+ * - methods related to dependencies between sub-meshes imposed by the algorithm
* - static utilities, like EdgeLength()
*/
// ==================================================================================
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Gen.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
{
Unexpect aCatch(SalomeException);
- // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
+ // Get studyContext, create it if it doesn't exist, with a SMESHDS_Document
StudyContextStruct *aStudyContext = GetStudyContext(theStudyId);
// create a new SMESH_mesh object
StudyContextStruct *SMESH_Gen::GetStudyContext(int studyId)
{
- // Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
+ // Get studyContext, create it if it doesn't exist, with a SMESHDS_Document
if (_mapStudyContext.find(studyId) == _mapStudyContext.end())
{
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Gen.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Group.cxx
// Author : Michael Sazonov (OCC)
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Group.hxx
// Author : Michael Sazonov (OCC)
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_HypoFilter.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_HypoFilter.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Hypothesis.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Hypothesis.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
}
}
- // check concurent hypotheses on ancestors
+ // check concurrent hypotheses on ancestors
if (ret < SMESH_Hypothesis::HYP_CONCURENT && !isGlobalHyp )
{
SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false);
if (ret2 > ret) // more severe
ret = ret2;
- // check concurent hypotheses on ancestors
+ // check concurrent hypotheses on ancestors
if (ret < SMESH_Hypothesis::HYP_CONCURENT && !IsMainShape( aSubShape ) )
{
SMESH_subMeshIteratorPtr smIt = subMesh->getDependsOnIterator(false,false);
save << clause << ".3) Faces in detail: " << endl;
map <int,int>::iterator itF;
for (itF = myFaceMap.begin(); itF != myFaceMap.end(); itF++)
- save << "--> nb nodes: " << itF->first << " - nb elemens:\t" << itF->second << endl;
+ save << "--> nb nodes: " << itF->first << " - nb elements:\t" << itF->second << endl;
}
}
save << ++clause << ") Total number of " << orderStr << " volumes:\t" << NbVolumes(order) << endl;
save << clause << ".5) Volumes in detail: " << endl;
map <int,int>::iterator itV;
for (itV = myVolumesMap.begin(); itV != myVolumesMap.end(); itV++)
- save << "--> nb nodes: " << itV->first << " - nb elemens:\t" << itV->second << endl;
+ save << "--> nb nodes: " << itV->first << " - nb elements:\t" << itV->second << endl;
}
}
save << endl;
#include <Standard_Failure.hxx>
#include <Standard_ErrorHandler.hxx>
+#include <OSD_Parallel.hxx>
+
+#include "SMESH_TryCatch.hxx" // include after OCCT headers!
#define cast2Node(elem) static_cast<const SMDS_MeshNode*>( elem )
}
if ( otherFace && otherFace != theFace)
{
- // link must be reverse in otherFace if orientation ot otherFace
+ // link must be reverse in otherFace if orientation to otherFace
// is same as that of theFace
if ( abs(nodeInd2-nodeInd1) == 1 ? nodeInd2 > nodeInd1 : nodeInd1 > nodeInd2 )
{
//=======================================================================
/*!
* \brief Split each of given quadrangles into 4 triangles.
- * \param theElems - The faces to be splitted. If empty all faces are split.
+ * \param theElems - The faces to be split. If empty all faces are split.
*/
//=======================================================================
makeEdgePathPoints(aPrms, aTrackEdge,(aN1->GetID()==startNid), LPP);
LLPPs.push_back(LPP);
UsedNums.Add(k);
- // update startN for search following egde
+ // update startN for search following edge
if( aN1->GetID() == startNid ) startNid = aN2->GetID();
else startNid = aN1->GetID();
break;
makeEdgePathPoints(aPrms, aTrackEdge, aN1isOK, LPP);
LLPPs.push_back(LPP);
UsedNums.Add(k);
- // update startN for search following egde
+ // update startN for search following edge
if ( aN1isOK ) aVprev = aV2;
else aVprev = aV1;
break;
default:;
}
}
+
+namespace // utils for MakePolyLine
+{
+ //================================================================================
+ /*!
+ * \brief Sequence of found points and a current point data
+ */
+ struct Path
+ {
+ std::vector< gp_XYZ > myPoints;
+ double myLength;
+
+ int mySrcPntInd; //!< start point index
+ const SMDS_MeshElement* myFace;
+ SMESH_NodeXYZ myNode1;
+ SMESH_NodeXYZ myNode2;
+ int myNodeInd1;
+ int myNodeInd2;
+ double myDot1;
+ double myDot2;
+ TIDSortedElemSet myElemSet, myAvoidSet;
+
+ Path(): myLength(0.0), myFace(0) {}
+
+ bool SetCutAtCorner( const SMESH_NodeXYZ& cornerNode,
+ const SMDS_MeshElement* face,
+ const gp_XYZ& plnNorm,
+ const gp_XYZ& plnOrig );
+
+ void AddPoint( const gp_XYZ& p );
+
+ bool Extend( const gp_XYZ& plnNorm, const gp_XYZ& plnOrig );
+
+ bool ReachSamePoint( const Path& other );
+
+ static void Remove( std::vector< Path > & paths, size_t& i );
+ };
+
+ //================================================================================
+ /*!
+ * \brief Return true if this Path meats another
+ */
+ //================================================================================
+
+ bool Path::ReachSamePoint( const Path& other )
+ {
+ return ( mySrcPntInd != other.mySrcPntInd &&
+ myFace == other.myFace );
+ }
+
+ //================================================================================
+ /*!
+ * \brief Remove a path from a vector
+ */
+ //================================================================================
+
+ void Path::Remove( std::vector< Path > & paths, size_t& i )
+ {
+ if ( paths.size() > 1 )
+ {
+ size_t j = paths.size() - 1; // last item to be removed
+ if ( i < j )
+ {
+ paths[ i ].myPoints.swap( paths[ j ].myPoints );
+ paths[ i ].myLength = paths[ j ].myLength;
+ paths[ i ].mySrcPntInd = paths[ j ].mySrcPntInd;
+ paths[ i ].myFace = paths[ j ].myFace;
+ paths[ i ].myNode1 = paths[ j ].myNode1;
+ paths[ i ].myNode2 = paths[ j ].myNode2;
+ paths[ i ].myNodeInd1 = paths[ j ].myNodeInd1;
+ paths[ i ].myNodeInd2 = paths[ j ].myNodeInd2;
+ paths[ i ].myDot1 = paths[ j ].myDot1;
+ paths[ i ].myDot2 = paths[ j ].myDot2;
+ }
+ }
+ paths.pop_back();
+ if ( i > 0 )
+ --i;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Store a point that is at a node of a face if the face is intersected by plane.
+ * Return false if the node is a sole intersection point of the face and the plane
+ */
+ //================================================================================
+
+ bool Path::SetCutAtCorner( const SMESH_NodeXYZ& cornerNode,
+ const SMDS_MeshElement* face,
+ const gp_XYZ& plnNorm,
+ const gp_XYZ& plnOrig )
+ {
+ if ( face == myFace )
+ return false;
+ myNodeInd1 = face->GetNodeIndex( cornerNode._node );
+ myNodeInd2 = ( myNodeInd1 + 1 ) % face->NbCornerNodes();
+ int ind3 = ( myNodeInd1 + 2 ) % face->NbCornerNodes();
+ myNode1.Set( face->GetNode( ind3 ));
+ myNode2.Set( face->GetNode( myNodeInd2 ));
+
+ myDot1 = plnNorm * ( myNode1 - plnOrig );
+ myDot2 = plnNorm * ( myNode2 - plnOrig );
+
+ bool ok = ( myDot1 * myDot2 < 0 );
+ if ( !ok && myDot1 * myDot2 == 0 )
+ {
+ ok = ( myDot1 != myDot2 );
+ if ( ok && myFace )
+ ok = ( myFace->GetNodeIndex(( myDot1 == 0 ? myNode1 : myNode2 )._node ) < 0 );
+ }
+ if ( ok )
+ {
+ myFace = face;
+ myDot1 = 0;
+ AddPoint( cornerNode );
+ }
+ return ok;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Store a point and update myLength
+ */
+ //================================================================================
+
+ void Path::AddPoint( const gp_XYZ& p )
+ {
+ if ( !myPoints.empty() )
+ myLength += ( p - myPoints.back() ).Modulus();
+ else
+ myLength = 0;
+ myPoints.push_back( p );
+ }
+
+ //================================================================================
+ /*!
+ * \brief Try to find the next point
+ * \param [in] plnNorm - cutting plane normal
+ * \param [in] plnOrig - cutting plane origin
+ */
+ //================================================================================
+
+ bool Path::Extend( const gp_XYZ& plnNorm, const gp_XYZ& plnOrig )
+ {
+ int nodeInd3 = ( myNodeInd1 + 1 ) % myFace->NbCornerNodes();
+ if ( myNodeInd2 == nodeInd3 )
+ nodeInd3 = ( myNodeInd1 + 2 ) % myFace->NbCornerNodes();
+
+ SMESH_NodeXYZ node3 = myFace->GetNode( nodeInd3 );
+ double dot3 = plnNorm * ( node3 - plnOrig );
+
+ if ( dot3 * myDot1 < 0. )
+ {
+ myNode2 = node3;
+ myNodeInd2 = nodeInd3;
+ myDot2 = dot3;
+ }
+ else if ( dot3 * myDot2 < 0. )
+ {
+ myNode1 = node3;
+ myNodeInd1 = nodeInd3;
+ myDot1 = dot3;
+ }
+ else if ( dot3 == 0. )
+ {
+ SMDS_ElemIteratorPtr fIt = node3._node->GetInverseElementIterator(SMDSAbs_Face);
+ while ( fIt->more() )
+ if ( SetCutAtCorner( node3, fIt->next(), plnNorm, plnOrig ))
+ return true;
+ return false;
+ }
+ else if ( myDot2 == 0. )
+ {
+ SMESH_NodeXYZ node2 = myNode2; // copy as myNode2 changes in SetCutAtCorner()
+ SMDS_ElemIteratorPtr fIt = node2._node->GetInverseElementIterator(SMDSAbs_Face);
+ while ( fIt->more() )
+ if ( SetCutAtCorner( node2, fIt->next(), plnNorm, plnOrig ))
+ return true;
+ return false;
+ }
+
+ double r = Abs( myDot1 / ( myDot2 - myDot1 ));
+ AddPoint( myNode1 * ( 1 - r ) + myNode2 * r );
+
+ myAvoidSet.clear();
+ myAvoidSet.insert( myFace );
+ myFace = SMESH_MeshAlgos::FindFaceInSet( myNode1._node, myNode2._node,
+ myElemSet, myAvoidSet,
+ &myNodeInd1, &myNodeInd2 );
+ return myFace;
+ }
+
+ //================================================================================
+ /*!
+ * \brief Compute a path between two points of PolySegment
+ */
+ struct PolyPathCompute
+ {
+ SMESH_MeshEditor::TListOfPolySegments& mySegments; //!< inout PolySegment's
+ std::vector< Path >& myPaths; //!< path of each of segments to compute
+ SMESH_Mesh* myMesh;
+ mutable std::vector< std::string > myErrors;
+
+ PolyPathCompute( SMESH_MeshEditor::TListOfPolySegments& theSegments,
+ std::vector< Path >& thePaths,
+ SMESH_Mesh* theMesh):
+ mySegments( theSegments ),
+ myPaths( thePaths ),
+ myMesh( theMesh ),
+ myErrors( theSegments.size() )
+ {
+ }
+#undef SMESH_CAUGHT
+#define SMESH_CAUGHT myErrors[i] =
+ void operator() ( const int i ) const
+ {
+ SMESH_TRY;
+ const_cast< PolyPathCompute* >( this )->Compute( i );
+ SMESH_CATCH( SMESH::returnError );
+ }
+#undef SMESH_CAUGHT
+ //================================================================================
+ /*!
+ * \brief Compute a path of a given segment
+ */
+ //================================================================================
+
+ void Compute( const int iSeg )
+ {
+ SMESH_MeshEditor::PolySegment& polySeg = mySegments[ iSeg ];
+
+ // get a cutting plane
+
+ gp_XYZ p1 = SMESH_NodeXYZ( polySeg.myNode1[0] );
+ gp_XYZ p2 = SMESH_NodeXYZ( polySeg.myNode1[1] );
+ if ( polySeg.myNode2[0] ) p1 = 0.5 * ( p1 + SMESH_NodeXYZ( polySeg.myNode2[0] ));
+ if ( polySeg.myNode2[1] ) p2 = 0.5 * ( p2 + SMESH_NodeXYZ( polySeg.myNode2[1] ));
+
+ gp_XYZ plnNorm = ( p1 - p2 ) ^ polySeg.myVector.XYZ();
+ gp_XYZ plnOrig = p2;
+
+ // find paths connecting the 2 end points of polySeg
+
+ std::vector< Path > paths; paths.reserve(10);
+
+ // initialize paths
+
+ for ( int iP = 0; iP < 2; ++iP ) // loop on the polySeg end points
+ {
+ Path path;
+ path.mySrcPntInd = iP;
+ size_t nbPaths = paths.size();
+
+ if ( polySeg.myNode2[ iP ] && polySeg.myNode2[ iP ] != polySeg.myNode1[ iP ] )
+ {
+ while (( path.myFace = SMESH_MeshAlgos::FindFaceInSet( polySeg.myNode1[ iP ],
+ polySeg.myNode2[ iP ],
+ path.myElemSet,
+ path.myAvoidSet,
+ &path.myNodeInd1,
+ &path.myNodeInd2 )))
+ {
+ path.myNode1.Set( polySeg.myNode1[ iP ]);
+ path.myNode2.Set( polySeg.myNode2[ iP ]);
+ path.myDot1 = plnNorm * ( path.myNode1 - plnOrig );
+ path.myDot2 = plnNorm * ( path.myNode2 - plnOrig );
+ path.myPoints.clear();
+ path.AddPoint( 0.5 * ( path.myNode1 + path.myNode2 ));
+ path.myAvoidSet.insert( path.myFace );
+ paths.push_back( path );
+ }
+ if ( nbPaths == paths.size() )
+ throw SALOME_Exception ( SMESH_Comment("No face edge found by point ") << iP+1
+ << " in a PolySegment " << iSeg );
+ }
+ else // an end point is at node
+ {
+ std::set<const SMDS_MeshNode* > nodes;
+ SMDS_ElemIteratorPtr fIt = polySeg.myNode1[ iP ]->GetInverseElementIterator(SMDSAbs_Face);
+ while ( fIt->more() )
+ {
+ path.myPoints.clear();
+ if ( path.SetCutAtCorner( polySeg.myNode1[ iP ], fIt->next(), plnNorm, plnOrig ))
+ {
+ if (( path.myDot1 * path.myDot2 != 0 ) ||
+ ( nodes.insert( path.myDot1 == 0 ? path.myNode1._node : path.myNode2._node ).second ))
+ paths.push_back( path );
+ }
+ }
+ }
+
+ // look for a one-segment path
+ for ( size_t i = 0; i < nbPaths; ++i )
+ for ( size_t j = nbPaths; j < paths.size(); ++j )
+ if ( paths[i].myFace == paths[j].myFace )
+ {
+ myPaths[ iSeg ].myPoints.push_back( paths[i].myPoints[0] );
+ myPaths[ iSeg ].myPoints.push_back( paths[j].myPoints[0] );
+ paths.clear();
+ }
+ }
+
+ // extend paths
+
+ myPaths[ iSeg ].myLength = 1e100;
+
+ while ( paths.size() >= 2 )
+ {
+ for ( size_t i = 0; i < paths.size(); ++i )
+ {
+ Path& path = paths[ i ];
+ if ( !path.Extend( plnNorm, plnOrig ) || // path reached a mesh boundary
+ path.myLength > myPaths[ iSeg ].myLength ) // path is longer than others
+ {
+ Path::Remove( paths, i );
+ continue;
+ }
+
+ // join paths that reach same point
+ for ( size_t j = 0; j < paths.size(); ++j )
+ {
+ if ( i != j && paths[i].ReachSamePoint( paths[j] ))
+ {
+ double distLast = ( paths[i].myPoints.back() - paths[j].myPoints.back() ).Modulus();
+ double fullLength = ( paths[i].myLength + paths[j].myLength + distLast );
+ if ( fullLength < myPaths[ iSeg ].myLength )
+ {
+ myPaths[ iSeg ].myLength = fullLength;
+ std::vector< gp_XYZ > & allPoints = myPaths[ iSeg ].myPoints;
+ allPoints.swap( paths[i].myPoints );
+ allPoints.insert( allPoints.end(),
+ paths[j].myPoints.rbegin(),
+ paths[j].myPoints.rend() );
+ }
+ Path::Remove( paths, i );
+ Path::Remove( paths, j );
+ }
+ }
+ }
+ if ( !paths.empty() && (int) paths[0].myPoints.size() > myMesh->NbFaces() )
+ throw SALOME_Exception(LOCALIZED( "Infinite loop in MakePolyLine()"));
+ }
+
+ if ( myPaths[ iSeg ].myPoints.empty() )
+ throw SALOME_Exception( SMESH_Comment("Can't find a full path for PolySegment #") << iSeg );
+
+ } // PolyPathCompute::Compute()
+
+ }; // struct PolyPathCompute
+
+} // namespace
+
+//=======================================================================
+//function : MakePolyLine
+//purpose : Create a polyline consisting of 1D mesh elements each lying on a 2D element of
+// the initial mesh
+//=======================================================================
+
+void SMESH_MeshEditor::MakePolyLine( TListOfPolySegments& theSegments,
+ SMESHDS_Group* theGroup,
+ SMESH_ElementSearcher* theSearcher)
+{
+ std::vector< Path > segPaths( theSegments.size() ); // path of each of segments
+
+ SMESH_ElementSearcher* searcher = theSearcher;
+ SMESHUtils::Deleter<SMESH_ElementSearcher> delSearcher;
+ if ( !searcher )
+ {
+ searcher = SMESH_MeshAlgos::GetElementSearcher( *GetMeshDS() );
+ delSearcher._obj = searcher;
+ }
+
+ // get cutting planes
+
+ std::vector< bool > isVectorOK( theSegments.size(), true );
+ const double planarCoef = 0.333; // plane height in planar case
+
+ for ( size_t iSeg = 0; iSeg < theSegments.size(); ++iSeg )
+ {
+ PolySegment& polySeg = theSegments[ iSeg ];
+
+ gp_XYZ p1 = SMESH_NodeXYZ( polySeg.myNode1[0] );
+ gp_XYZ p2 = SMESH_NodeXYZ( polySeg.myNode1[1] );
+ if ( polySeg.myNode2[0] ) p1 = 0.5 * ( p1 + SMESH_NodeXYZ( polySeg.myNode2[0] ));
+ if ( polySeg.myNode2[1] ) p2 = 0.5 * ( p2 + SMESH_NodeXYZ( polySeg.myNode2[1] ));
+
+ gp_XYZ plnNorm = ( p1 - p2 ) ^ polySeg.myVector.XYZ();
+
+ isVectorOK[ iSeg ] = ( plnNorm.Modulus() > std::numeric_limits<double>::min() );
+ if ( !isVectorOK[ iSeg ])
+ {
+ gp_XYZ pMid = 0.5 * ( p1 + p2 );
+ const SMDS_MeshElement* face;
+ polySeg.myMidProjPoint = searcher->Project( pMid, SMDSAbs_Face, &face );
+ polySeg.myVector = polySeg.myMidProjPoint.XYZ() - pMid;
+
+ gp_XYZ faceNorm;
+ SMESH_MeshAlgos::FaceNormal( face, faceNorm );
+
+ if ( polySeg.myVector.Magnitude() < Precision::Confusion() ||
+ polySeg.myVector * faceNorm < Precision::Confusion() )
+ {
+ polySeg.myVector = faceNorm;
+ polySeg.myMidProjPoint = pMid + faceNorm * ( p1 - p2 ).Modulus() * planarCoef;
+ }
+ }
+ else
+ {
+ polySeg.myVector = plnNorm ^ ( p1 - p2 );
+ }
+ }
+
+ // assure that inverse elements are constructed, avoid their concurrent building in threads
+ GetMeshDS()->nodesIterator()->next()->NbInverseElements();
+
+ // find paths
+
+ PolyPathCompute algo( theSegments, segPaths, myMesh );
+ OSD_Parallel::For( 0, theSegments.size(), algo, theSegments.size() == 1 );
+
+ for ( size_t iSeg = 0; iSeg < theSegments.size(); ++iSeg )
+ if ( !algo.myErrors[ iSeg ].empty() )
+ throw SALOME_Exception( algo.myErrors[ iSeg ].c_str() );
+
+ // create an 1D mesh
+
+ const SMDS_MeshNode *n, *nPrev = 0;
+ SMESHDS_Mesh* mesh = GetMeshDS();
+
+ for ( size_t iSeg = 0; iSeg < theSegments.size(); ++iSeg )
+ {
+ const Path& path = segPaths[iSeg];
+ if ( path.myPoints.size() < 2 )
+ continue;
+
+ double tol = path.myLength / path.myPoints.size() / 1000.;
+ if ( !nPrev || ( SMESH_NodeXYZ( nPrev ) - path.myPoints[0] ).SquareModulus() > tol*tol )
+ {
+ nPrev = mesh->AddNode( path.myPoints[0].X(), path.myPoints[0].Y(), path.myPoints[0].Z() );
+ myLastCreatedNodes.Append( nPrev );
+ }
+ for ( size_t iP = 1; iP < path.myPoints.size(); ++iP )
+ {
+ n = mesh->AddNode( path.myPoints[iP].X(), path.myPoints[iP].Y(), path.myPoints[iP].Z() );
+ myLastCreatedNodes.Append( n );
+
+ const SMDS_MeshElement* elem = mesh->AddEdge( nPrev, n );
+ myLastCreatedElems.Append( elem );
+ if ( theGroup )
+ theGroup->Add( elem );
+
+ nPrev = n;
+ }
+
+ // return a vector
+
+ gp_XYZ pMid = 0.5 * ( path.myPoints[0] + path.myPoints.back() );
+ if ( isVectorOK[ iSeg ])
+ {
+ // find the most distance point of a path
+ double maxDist = 0;
+ for ( size_t iP = 1; iP < path.myPoints.size(); ++iP )
+ {
+ double dist = Abs( theSegments[iSeg].myVector * ( path.myPoints[iP] - path.myPoints[0] ));
+ if ( dist > maxDist )
+ {
+ maxDist = dist;
+ theSegments[iSeg].myMidProjPoint = path.myPoints[iP];
+ }
+ }
+ if ( maxDist < Precision::Confusion() ) // planar case
+ theSegments[iSeg].myMidProjPoint =
+ pMid + theSegments[iSeg].myVector.XYZ().Normalized() * path.myLength * planarCoef;
+ }
+ theSegments[iSeg].myVector = gp_Vec( pMid, theSegments[iSeg].myMidProjPoint );
+ }
+
+ return;
+}
class SMDS_MeshElement;
class SMDS_MeshFace;
class SMDS_MeshNode;
+class SMESHDS_Group;
class SMESHDS_Mesh;
class SMESHDS_SubMesh;
+class SMESH_ElementSearcher;
class SMESH_Group;
class SMESH_Mesh;
class SMESH_MesherHelper;
* \param theElems - The triangles to be fused.
* \param theCriterion - Is used to choose a neighbour to fuse with.
* \param theMaxAngle - Is a max angle between element normals at which fusion
- * is still performed; theMaxAngle is mesured in radians.
+ * is still performed; theMaxAngle is measured in radians.
* \return bool - Success or not.
*/
bool TriToQuad (TIDSortedElemSet & theElems,
const double theMaxAngle);
/*!
* \brief Split quadrangles into triangles.
- * \param theElems - The faces to be splitted.
+ * \param theElems - The faces to be split.
* \param theCriterion - Is used to choose a diagonal for splitting.
* \return bool - Success or not.
*/
SMESH::Controls::NumericalFunctorPtr theCriterion);
/*!
* \brief Split quadrangles into triangles.
- * \param theElems - The faces to be splitted.
+ * \param theElems - The faces to be split.
* \param the13Diag - Is used to choose a diagonal for splitting.
* \return bool - Success or not.
*/
const bool the13Diag);
/*!
* \brief Split each of given quadrangles into 4 triangles.
- * \param theElems - The faces to be splitted. If empty all faces are split.
+ * \param theElems - The faces to be split. If empty all faces are split.
*/
void QuadTo4Tri (TIDSortedElemSet & theElems);
// of the side 2. If nb of links in the free border and
// between theSide2FirstNode and theSide2LastNode are different,
// additional nodes are inserted on a link provided that no
- // volume elements share the splitted link.
+ // volume elements share the split link.
// The side 2 is a free border if theSide2IsFreeBorder == true.
// Sewing is performed between the given first, second and last
// nodes on the sides.
bool toAddExistingBondary = false,
bool aroundElements = false);
+
+ // structure used in MakePolyLine() to define a cutting plane
+ struct PolySegment
+ {
+ // 2 points: if myNode2 != 0, then the point is the middle of a face edge defined
+ // by two nodes, else it is at myNode1
+ const SMDS_MeshNode* myNode1[2];
+ const SMDS_MeshNode* myNode2[2];
+
+ gp_Vec myVector; // vector on the plane; to use a default plane set vector = (0,0,0)
+
+ // point to return coordinates of a middle of the two points, projected to mesh
+ gp_Pnt myMidProjPoint;
+ };
+ typedef std::vector<PolySegment> TListOfPolySegments;
+
+ /*!
+ * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
+ * the initial mesh. Positions of new nodes are found by cutting the mesh by the
+ * plane passing through pairs of points specified by each PolySegment structure.
+ * If there are several paths connecting a pair of points, the shortest path is
+ * selected by the module. Position of the cutting plane is defined by the two
+ * points and an optional vector lying on the plane specified by a PolySegment.
+ * By default the vector is defined by Mesh module as following. A middle point
+ * of the two given points is computed. The middle point is projected to the mesh.
+ * The vector goes from the middle point to the projection point. In case of planar
+ * mesh, the vector is normal to the mesh.
+ * \param [inout] segments - PolySegment's defining positions of cutting planes.
+ * Return the used vector and position of the middle point.
+ * \param [in] group - an optional group where created mesh segments will
+ * be added.
+ */
+ void MakePolyLine( TListOfPolySegments& segments,
+ SMESHDS_Group* group=0,
+ SMESH_ElementSearcher* searcher=0);
+
private:
/*!
* \brief Find out elements orientation on a geometrical face
* \param theFace - The face correctly oriented in the shape being meshed
* \retval bool - true if the face normal and the normal of first element
- * in the correspoding submesh point in different directions
+ * in the corresponding submesh point in different directions
*/
//================================================================================
return fabs(param-myPar1[i]) < fabs(param-myPar2[i]) ? myPar2[i] : myPar1[i];
}
+//=======================================================================
+//function : NbRealSeam
+//purpose : Return a number of real seam edges in the shape set through
+// IsQuadraticSubMesh() or SetSubShape(). A real seam edge encounters twice in a wire
+//=======================================================================
+
+size_t SMESH_MesherHelper::NbRealSeam() const
+{
+ size_t nb = 0;
+
+ std::set< int >::const_iterator id = mySeamShapeIds.begin();
+ for ( ; id != mySeamShapeIds.end(); ++id )
+ if ( *id < 0 ) ++nb;
+ else break;
+
+ return nb;
+}
+
//=======================================================================
//function : IsOnSeam
//purpose : Check if UV is on seam. Return 0 if not, 1 for U seam, 2 for V seam
vector< TChain> & resultChains,
SMDS_TypeOfPosition pos )
{
- // put links in the set and evalute number of result chains by number of boundary links
+ // put links in the set and evaluate number of result chains by number of boundary links
TLinkSet linkSet;
size_t nbBndLinks = 0;
for ( TChain::iterator lnk = allLinks.begin(); lnk != allLinks.end(); ++lnk ) {
MSG("Internal chain - ignore");
continue;
}
- // mesure chain length and compute link position along the chain
+ // measure chain length and compute link position along the chain
double chainLen = 0;
vector< double > linkPos;
TChain savedChain; // backup
typedef SMDS_Iterator<const TopoDS_Shape*> PShapeIterator;
typedef boost::shared_ptr< PShapeIterator > PShapeIteratorPtr;
-
+
typedef std::vector<const SMDS_MeshNode* > TNodeColumn;
typedef std::map< double, TNodeColumn > TParam2ColumnMap;
/*!
* \brief Check if the shape set through IsQuadraticSubMesh() or SetSubShape()
* has a degenerated edges
- * \retval bool - true if it has
+ * \retval bool - true if there are degenerated edges
*/
bool HasDegeneratedEdges() const { return !myDegenShapeIds.empty(); }
+ /*!
+ * \brief Return a number of degenerated edges in the shape set through
+ * IsQuadraticSubMesh() or SetSubShape()
+ * \retval size_t - nb edges
+ */
+ size_t NbDegeneratedEdges() const { return myDegenShapeIds.size(); }
/*!
* \brief Check if shape is a seam edge or it's vertex
* \retval bool - true if it has
*/
bool HasRealSeam() const { return HasSeam() && ( *mySeamShapeIds.begin() < 0 ); }
+ /*!
+ * \brief Return a number of real seam edges in the shape set through
+ * IsQuadraticSubMesh() or SetSubShape(). A real seam edge encounters twice in a wire
+ * \retval size_t - nb of real seams
+ */
+ size_t NbRealSeam() const;
/*!
* \brief Return index of periodic parametric direction of a closed face
* \retval int - 1 for U, 2 for V direction
// If there are several wires, define the order of edges of inner wires:
// compute UV of inner edge-points using 2 methods: the one for in-face points
// and the one for on-edge points and then choose the best edge order
- // by the best correspondance of the 2 results
+ // by the best correspondence of the 2 results
if ( nbWires > 1 )
{
// compute UV of inner edge-points using the method for in-face points
//================================================================================
/*!
- * \brief Destructor deletes proxy submeshes and tmp elemens
+ * \brief Destructor deletes proxy submeshes and tmp elements
*/
//================================================================================
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_subMesh.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
"SMESH_TETRAHEDRA","SMESH_QUADRATIC_TETRAHEDRONS","SMESH_PYRAMIDS",
"SMESH_QUADRATIC_PYRAMIDS","SMESH_HEXAHEDRA","SMESH_QUADRATIC_HEXAHEDRONS",
"SMESH_TRIQUADRATIC_HEXAHEDRONS","SMESH_PENTAHEDRA","SMESH_QUADRATIC_PENTAHEDRONS",
- "SMESH_BIQUADRATIC_PENTAHEDRONS",
+ "SMESH_BIQUADRATIC_PENTAHEDRONS",
"SMESH_OCTAHEDRA","SMESH_POLYEDRONS","SMESH_QUADRATIC_POLYEDRONS","SMESH_BALLS"
};
// is typeMsg complete? (compilation failure mains that enum SMDSAbs_EntityType changed)
type = QObject::tr( "LENGTH_EDGES" );
else if ( dynamic_cast< SMESH::Controls::Length2D* >( f.get() ) )
type = QObject::tr( "LENGTH2D_EDGES" );
+ else if ( dynamic_cast< SMESH::Controls::Deflection2D* >( f.get() ) )
+ type = QObject::tr( "DEFLECTION2D_FACES" );
else if ( dynamic_cast< SMESH::Controls::MultiConnection* >( f.get() ) )
type = QObject::tr( "MULTI_BORDERS" );
else if ( dynamic_cast< SMESH::Controls::MultiConnection2D* >( f.get() ) )
ActionControl.Bind( SMESHOp::OpBareBorderFace, SMESH_Actor::eBareBorderFace );
ActionControl.Bind( SMESHOp::OpOverConstrainedFace, SMESH_Actor::eOverConstrainedFace );
ActionControl.Bind( SMESHOp::OpLength2D, SMESH_Actor::eLength2D );
+ ActionControl.Bind( SMESHOp::OpDeflection2D, SMESH_Actor::eDeflection2D );
ActionControl.Bind( SMESHOp::OpConnection2D, SMESH_Actor::eMultiConnection2D );
ActionControl.Bind( SMESHOp::OpArea, SMESH_Actor::eArea );
ActionControl.Bind( SMESHOp::OpTaper, SMESH_Actor::eTaper );
case SMESHOp::OpBareBorderFace:
case SMESHOp::OpOverConstrainedFace:
case SMESHOp::OpLength2D:
+ case SMESHOp::OpDeflection2D:
case SMESHOp::OpConnection2D:
case SMESHOp::OpArea:
case SMESHOp::OpTaper:
createSMESHAction( SMESHOp::OpBareBorderFace, "BARE_BORDER_FACE", "ICON_BARE_BORDER_FACE", 0, true );
createSMESHAction( SMESHOp::OpOverConstrainedFace, "OVER_CONSTRAINED_FACE", "ICON_OVER_CONSTRAINED_FACE", 0, true );
createSMESHAction( SMESHOp::OpLength2D, "LENGTH_2D", "ICON_LENGTH_2D", 0, true );
+ createSMESHAction( SMESHOp::OpDeflection2D, "DEFLECTION_2D", "ICON_DEFLECTION_2D", 0, true );
createSMESHAction( SMESHOp::OpConnection2D, "CONNECTION_2D", "ICON_CONNECTION_2D", 0, true );
createSMESHAction( SMESHOp::OpArea, "AREA", "ICON_AREA", 0, true );
createSMESHAction( SMESHOp::OpTaper, "TAPER", "ICON_TAPER", 0, true );
<< SMESHOp::OpNodeConnectivityNb // node controls
<< SMESHOp::OpFreeEdge << SMESHOp::OpFreeBorder
<< SMESHOp::OpLength << SMESHOp::OpConnection << SMESHOp::OpEqualEdge // edge controls
+ << SMESHOp::OpDeflection2D
<< SMESHOp::OpFreeFace << SMESHOp::OpLength2D << SMESHOp::OpConnection2D
<< SMESHOp::OpArea << SMESHOp::OpTaper << SMESHOp::OpAspectRatio
<< SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
createMenu( SMESHOp::OpSkew, faceId, -1 );
createMenu( SMESHOp::OpMaxElementLength2D, faceId, -1 );
createMenu( SMESHOp::OpEqualFace, faceId, -1 );
+ createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
createMenu( SMESHOp::OpVolume, volumeId, -1 );
createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
createTool( SMESHOp::OpSkew, ctrl2dTb );
createTool( SMESHOp::OpMaxElementLength2D, ctrl2dTb );
createTool( SMESHOp::OpEqualFace, ctrl2dTb );
+ createTool( SMESHOp::OpDeflection2D, ctrl2dTb );
createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
createTool( SMESHOp::OpVolume, ctrl3dTb );
popupMgr()->insert ( action( SMESHOp::OpOverConstrainedFace ), aSubId, -1 );
popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
popupMgr()->setRule( action( SMESHOp::OpOverConstrainedFace ), "controlMode = 'eOverConstrainedFace'", QtxPopupMgr::ToggleRule );
+
popupMgr()->insert ( action( SMESHOp::OpEqualFace ), aSubId, -1 );
popupMgr()->setRule( action( SMESHOp::OpEqualFace ), aMeshInVtkHasFaces, QtxPopupMgr::VisibleRule );
popupMgr()->setRule( action( SMESHOp::OpEqualFace ), "controlMode = 'eCoincidentElems2D'", QtxPopupMgr::ToggleRule );
+ popupMgr()->insert ( action( SMESHOp::OpDeflection2D ), aSubId, -1 );
+ popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), aMeshInVtkHasFaces + " && hasGeomReference", QtxPopupMgr::VisibleRule );
+ popupMgr()->setRule( action( SMESHOp::OpDeflection2D ), "controlMode = 'eDeflection2D'", QtxPopupMgr::ToggleRule );
+
aSubId = popupMgr()->insert( tr( "MEN_VOLUME_CTRL" ), anId, -1 ); // VOLUME CONTROLS
popupMgr()->insert ( action( SMESHOp::OpAspectRatio3D ), aSubId, -1 );
//================================================================================
/*!
- * \brief Desctructor
+ * \brief Destructor
*/
//================================================================================
//================================================================================
/*!
- * \brief Desctructor
+ * \brief Destructor
*/
//================================================================================
/*
Class : SMESHGUI_QuadrangleFilter
- Description : Verify whether selected cell is quadranle
+ Description : Verify whether selected cell is quadrangle
*/
//=======================================================================
//=======================================================================
// name : SMESHGUI_QuadrangleFilter::IsValid
-// Purpose : Verify whether selected cell is quadranle
+// Purpose : Verify whether selected cell is quadrangle
//=======================================================================
bool SMESHGUI_QuadrangleFilter::IsValid( const int theCellId ) const
{
//=======================================================================
// name : SMESHGUI_QuadrangleFilter::IsValid
-// Purpose : Verify whether selected cell is quadranle
+// Purpose : Verify whether selected cell is quadrangle
//=======================================================================
bool SMESHGUI_QuadrangleFilter::IsObjValid( const int theObjId ) const
{
/*
Class : SMESHGUI_QuadrangleFilter
- Description : Verify whether selected cell is quadranle
+ Description : Verify whether selected cell is quadrangle
*/
DEFINE_STANDARD_HANDLE(SMESHGUI_QuadrangleFilter, SMESHGUI_Filter)
//=======================================================================
// name : SMESHGUI_FilterTable::Table::isEditable
-// Purpose : Verify wheter cell is editable
+// Purpose : Verify whether cell is editable
//=======================================================================
bool SMESHGUI_FilterTable::Table::isEditable (int row, int col) const
{
aCriterion == SMESH::FT_MaxElementLength3D ||
aCriterion == SMESH::FT_Length ||
aCriterion == SMESH::FT_Length2D ||
+ aCriterion == SMESH::FT_Deflection2D ||
aCriterion == SMESH::FT_BallDiameter );
bool toEnable = (( isDbl && ((ComboItem*)aTable->item(aRow, 1))->value() == SMESH::FT_EqualTo) ||
retval = "len_tol_precision"; break;
case SMESH::FT_Length:
case SMESH::FT_Length2D:
+ case SMESH::FT_Deflection2D:
case SMESH::FT_MaxElementLength2D:
case SMESH::FT_MaxElementLength3D:
case SMESH::FT_BallDiameter:
}
// find out a type of item required by a new criterion and other table features
- int aCriterionType = GetCriterionType(row);
+ int aCriterionType = GetCriterionType(row);
bool anIsDoubleCriterion = false;
bool anIsIntCriterion = false;
bool anIsComboCriterion = false;
// other features:
QList<int> comboIDs; // values to show in a combo item
- int nbCompareSigns = 0; // possible values are 0,1,3
+ int nbCompareSigns = 0; // possible values are 0,1,3
bool isThresholdEditable = false; // actual for "simple" item types
switch ( aCriterionType )
{
case SMESH::FT_Area:
case SMESH::FT_Volume3D:
case SMESH::FT_MaxElementLength2D:
- case SMESH::FT_MaxElementLength3D:
- anIsDoubleCriterion = true; break;
+ case SMESH::FT_MaxElementLength3D: anIsDoubleCriterion = true; break;
case SMESH::FT_FreeBorders:
case SMESH::FT_FreeEdges:
case SMESH::FT_MultiConnection2D: anIsIntCriterion = true; nbCompareSigns = 3; break;
case SMESH::FT_Length:
- case SMESH::FT_Length2D: anIsDoubleCriterion = true; break;
+ case SMESH::FT_Length2D:
+ case SMESH::FT_Deflection2D: anIsDoubleCriterion = true; break;
case SMESH::FT_BelongToMeshGroup: break;
aCriteria[ SMESH::FT_BelongToGenSurface ] = tr("BELONG_TO_GENSURFACE");
aCriteria[ SMESH::FT_LyingOnGeom ] = tr("LYING_ON_GEOM");
aCriteria[ SMESH::FT_Length2D ] = tr("LENGTH2D");
+ aCriteria[ SMESH::FT_Deflection2D ] = tr("DEFLECTION2D");
aCriteria[ SMESH::FT_MultiConnection2D ] = tr("MULTI2D_BORDERS");
aCriteria[ SMESH::FT_FreeFaces ] = tr("FREE_FACES");
aCriteria[ SMESH::FT_BareBorderFace ] = tr("BARE_BORDER_FACE");
QLabel* a2DTriQuad = createField();
a2DTriQuad->setObjectName("nbQuadraticTriangle");
QLabel* a2DTriBiQuad = createField();
- a2DTriBiQuad->setObjectName("nbBiQuadraticTriangle");
+ a2DTriBiQuad->setObjectName("nbBiQuadraticTriangle");
QLabel* a2DQuaLab = new QLabel( tr( "QUADRANGLES_LAB" ), this );
QLabel* a2DQuaTotal = createField();
a2DQuaTotal->setObjectName("nbQuadrangle");
\param parent parent widget
*/
SMESHGUI_ElemInfo::SMESHGUI_ElemInfo( QWidget* parent )
-: QWidget( parent ), myActor( 0 ), myIsElement( -1 )
+ : QWidget( parent ), myActor( 0 ), myIsElement( -1 )
{
myFrame = new QWidget( this );
myExtra = new ExtraWidget( this );
\brief Set mesh data source (actor)
\param actor mesh object actor
*/
-void SMESHGUI_ElemInfo::setSource( SMESH_Actor* actor )
+void SMESHGUI_ElemInfo::setSource( SMESH_Actor* actor, SMESH::SMESH_IDSource_var obj )
{
if ( myActor != actor ) {
myActor = actor;
myIsElement = -1;
+ SMESH::SMESH_Mesh_var mesh = obj->GetMesh();
+ myMeshHasShape = ( !mesh->_is_nil() && mesh->HasShapeToMesh() );
clear();
}
}
\param parent parent widget
*/
SMESHGUI_SimpleElemInfo::SMESHGUI_SimpleElemInfo( QWidget* parent )
-: SMESHGUI_ElemInfo( parent )
+ : SMESHGUI_ElemInfo( parent )
{
myInfo = new QTextBrowser( frame() );
QVBoxLayout* l = new QVBoxLayout( frame() );
void SMESHGUI_SimpleElemInfo::information( const QList<long>& ids )
{
clearInternal();
-
+
if ( actor() ) {
int grp_details = SMESHGUI::resourceMgr()->booleanValue( "SMESH", "elem_info_grp_details", false );
int precision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "length_precision", 6 );
int cprecision = -1;
- if ( SMESHGUI::resourceMgr()->booleanValue( "SMESH", "use_precision", false ))
+ if ( SMESHGUI::resourceMgr()->booleanValue( "SMESH", "use_precision", false ))
cprecision = SMESHGUI::resourceMgr()->integerValue( "SMESH", "controls_precision", -1 );
foreach ( long id, ids ) {
if ( !isElements() ) {
myInfo->append( QString( "<b>%1</b>" ).arg( SMESHGUI_ElemInfo::tr( "FREE_NODE" )).arg( id ));
}
// node position
- SMESH::SMESH_Mesh_ptr aMeshPtr = actor()->GetObject()->GetMeshServer();
+ SMESH::SMESH_Mesh_ptr aMeshPtr = actor()->GetObject()->GetMeshServer();
if ( !CORBA::is_nil( aMeshPtr )) {
SMESH::NodePosition_var pos = aMeshPtr->GetNodePosition( id );
int shapeID = pos->shapeID;
case GEOM::FACE:
shapeType = SMESHGUI_ElemInfo::tr( "GEOM_FACE" );
if ( pos->params.length() == 2 ) {
- u = pos->params[0];
- v = pos->params[1];
+ u = pos->params[0];
+ v = pos->params[1];
}
break;
case GEOM::VERTEX:
SMESH::SMESH_Group_var aStdGroup = SMESH::SMESH_Group::_narrow( aGrp );
SMESH::SMESH_GroupOnGeom_var aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( aGrp );
SMESH::SMESH_GroupOnFilter_var aFltGroup = SMESH::SMESH_GroupOnFilter::_narrow( aGrp );
-
+
// type : group on geometry, standalone group, group on filter
if ( !CORBA::is_nil( aStdGroup )) {
myInfo->append( QString( " - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "TYPE" )).
myInfo->append( QString( " - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "TYPE" )).
arg( SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" )) );
}
-
+
// size
myInfo->append( QString( " - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "SIZE" )).
arg( QString::number( aGrp->Size() )) );
-
+
// color
SALOMEDS::Color color = aGrp->GetColor();
myInfo->append( QString( " - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "COLOR" )).
else {
//
// show element info
- //
+ //
const SMDS_MeshElement* e = actor()->GetObject()->GetMesh()->FindElement( id );
SMESH::Controls::NumericalFunctorPtr afunctor;
if ( !e ) return;
-
+
// Element ID && Type
QString stype;
switch( e->GetType() ) {
stype = SMESHGUI_ElemInfo::tr( "FACE" ); break;
case SMDSAbs_Volume:
stype = SMESHGUI_ElemInfo::tr( "VOLUME" ); break;
- default:
+ default:
break;
}
if ( stype.isEmpty() ) return;
case SMDSEntity_Polyhedra:
case SMDSEntity_Quad_Polyhedra:
gtype = SMESHGUI_ElemInfo::tr( "POLYHEDRON" ); break;
- default:
+ default:
break;
}
if ( !gtype.isEmpty() )
afunctor.reset( new SMESH::Controls::Length() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
afunctor->SetPrecision( cprecision );
- myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "LENGTH_EDGES" )).arg( afunctor->GetValue( id )) );
+ myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "LENGTH_EDGES" )).arg( afunctor->GetValue( id )) );
}
if( e->GetType() == SMDSAbs_Face ) {
//Area
afunctor.reset( new SMESH::Controls::Area() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
- afunctor->SetPrecision( cprecision );
+ afunctor->SetPrecision( cprecision );
myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "AREA_ELEMENTS" )).arg( afunctor->GetValue( id )) );
//Taper
afunctor.reset( new SMESH::Controls::Taper() );
- afunctor->SetMesh( actor()->GetObject()->GetMesh() );
+ afunctor->SetMesh( actor()->GetObject()->GetMesh() );
afunctor->SetPrecision( cprecision );
myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "TAPER_ELEMENTS" )).arg( afunctor->GetValue( id )) );
//AspectRatio2D
afunctor.reset( new SMESH::Controls::AspectRatio() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "ASPECTRATIO_ELEMENTS" )).arg( afunctor->GetValue( id )) );
- //Minimum angle
+ //Minimum angle
afunctor.reset( new SMESH::Controls::MinimumAngle() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
afunctor->SetPrecision( cprecision );
myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "MINIMUMANGLE_ELEMENTS" )).arg( afunctor->GetValue( id )) );
- //Wraping angle
+ //Warping angle
afunctor.reset( new SMESH::Controls::Warping() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
afunctor->SetPrecision( cprecision );
myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "WARP_ELEMENTS" )).arg( afunctor->GetValue( id )) );
- //Skew
+ //Skew
afunctor.reset( new SMESH::Controls::Skew() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
afunctor->SetPrecision( cprecision );
myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "SKEW_ELEMENTS" )).arg( afunctor->GetValue( id )) );
- //ElemDiam2D
+ //ElemDiam2D
afunctor.reset( new SMESH::Controls::MaxElementLength2D() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
+ afunctor->SetPrecision( cprecision );
myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "MAX_ELEMENT_LENGTH_2D" )).arg( afunctor->GetValue( id )) );
+ //min edge length
+ afunctor.reset( new SMESH::Controls::Length2D() );
+ afunctor->SetMesh( actor()->GetObject()->GetMesh() );
+ myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "MIN_ELEM_EDGE" )).arg( afunctor->GetValue( id )) );
}
if( e->GetType() == SMDSAbs_Volume ) {
//AspectRatio3D
afunctor.reset( new SMESH::Controls::AspectRatio3D() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "ASPECTRATIO_3D_ELEMENTS" )).arg( afunctor->GetValue( id )) );
- //Volume
+ //Volume
afunctor.reset( new SMESH::Controls::Volume() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "VOLUME_3D_ELEMENTS" )).arg( afunctor->GetValue( id )) );
- //ElementDiameter3D
+ //ElementDiameter3D
afunctor.reset( new SMESH::Controls::Volume() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
myInfo->append( QString( "- <b>%1:</b> %2" ).arg( tr( "MAX_ELEMENT_LENGTH_3D" )).arg( afunctor->GetValue( id )) );
// Gravity center
XYZ gc = gravityCenter( e );
myInfo->append( QString( "<b>%1:</b> (%2, %3, %4)" ).arg( SMESHGUI_ElemInfo::tr( "GRAVITY_CENTER" )).arg( gc.x() ).arg( gc.y() ).arg( gc.z() ));
-
+
// Normal vector
if( e->GetType() == SMDSAbs_Face ) {
XYZ gc = normal( e );
// Element position
if ( e->GetType() >= SMDSAbs_Edge && e->GetType() <= SMDSAbs_Volume ) {
- SMESH::SMESH_Mesh_ptr aMesh = actor()->GetObject()->GetMeshServer();
+ SMESH::SMESH_Mesh_ptr aMesh = actor()->GetObject()->GetMeshServer();
if ( !CORBA::is_nil( aMesh )) {
SMESH::ElementPosition pos = aMesh->GetElementPosition( id );
int shapeID = pos.shapeID;
SMESH::SMESH_Group_var aStdGroup = SMESH::SMESH_Group::_narrow( aGrp );
SMESH::SMESH_GroupOnGeom_var aGeomGroup = SMESH::SMESH_GroupOnGeom::_narrow( aGrp );
SMESH::SMESH_GroupOnFilter_var aFltGroup = SMESH::SMESH_GroupOnFilter::_narrow( aGrp );
-
+
// type : group on geometry, standalone group, group on filter
if ( !CORBA::is_nil( aStdGroup )) {
myInfo->append( QString( " - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "TYPE" )).
myInfo->append( QString( " - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "TYPE" )).
arg( SMESHGUI_AddInfo::tr( "GROUP_ON_FILTER" )) );
}
-
+
myInfo->append( QString( " - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "SIZE" )).
arg( QString::number( aGrp->Size() )) );
-
+
// color
SALOMEDS::Color color = aGrp->GetColor();
myInfo->append( QString( " - <b>%1:</b> %2" ).arg( SMESHGUI_AddInfo::tr( "COLOR" )).
\param parent parent widget
*/
SMESHGUI_TreeElemInfo::SMESHGUI_TreeElemInfo( QWidget* parent )
-: SMESHGUI_ElemInfo( parent )
+ : SMESHGUI_ElemInfo( parent )
{
myInfo = new QTreeWidget( frame() );
myInfo->setColumnCount( 2 );
QTreeWidgetItem* taperlItem = createItem( cntrItem, Bold );
taperlItem->setText( 0, tr( "TAPER_ELEMENTS" ));
taperlItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
- //Wraping angle
+ //Warping angle
afunctor.reset( new SMESH::Controls::Warping() );
afunctor->SetMesh( actor()->GetObject()->GetMesh() );
afunctor->SetPrecision( cprecision );
skewItem->setText( 0, tr( "SKEW_ELEMENTS" ));
skewItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
}
+ //Deflection
+ if ( hasShapeToMesh() )
+ {
+ afunctor.reset( new SMESH::Controls::Deflection2D() );
+ afunctor->SetMesh( actor()->GetObject()->GetMesh() );
+ QTreeWidgetItem* deflItem = createItem( cntrItem, Bold );
+ deflItem->setText( 0, tr( "DEFLECTION_2D" ));
+ deflItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
+ }
//ElemDiam2D
if ( !e->IsPoly() )
{
diam3Item->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
}
+ //min edge length
+ afunctor.reset( new SMESH::Controls::Length2D() );
+ afunctor->SetMesh( actor()->GetObject()->GetMesh() );
+ QTreeWidgetItem* minEdgeItem = createItem( cntrItem, Bold );
+ minEdgeItem->setText( 0, tr( "MIN_ELEM_EDGE" ));
+ minEdgeItem->setText( 1, QString( "%1" ).arg( afunctor->GetValue( id )) );
+
// gravity center
XYZ gc = gravityCenter( e );
QTreeWidgetItem* gcItem = createItem( elemItem, Bold );
\param parent parent widget
*/
SMESHGUI_AddInfo::SMESHGUI_AddInfo( QWidget* parent )
-: QTreeWidget( parent )
+ : QTreeWidget( parent )
{
setColumnCount( 2 );
header()->setStretchLastSection( true );
SMESH::GetNameOfSelectedElements( selector, IO, ID ) :
SMESH::GetNameOfSelectedNodes( selector, IO, ID );
}
- myElemInfo->setSource( myActor ) ;
+ myElemInfo->setSource( myActor, obj ) ;
if ( nb > 0 ) {
myID->setText( ID.trimmed() );
QSet<long> ids;
computeOverConstrainedVolumesInfo();
// aspect Ratio 3D histogram
computeAspectRatio3D();
- }
- else {
- myButtons[7]->setEnabled( true );
- myButtons[8]->setEnabled( true );
- myButtons[9]->setEnabled( true );
- }
+ }
+ else {
+ myButtons[7]->setEnabled( true );
+ myButtons[8]->setEnabled( true );
+ myButtons[9]->setEnabled( true );
+ }
#ifdef DISABLE_PLOT2DVIEWER
myMainLayout->setRowStretch(17,0);
for( int i=35; i<=37; i++)
\param parent parent widget
*/
SMESHGUI_CtrlInfoDlg::SMESHGUI_CtrlInfoDlg( QWidget* parent )
-: QDialog( parent )
+ : QDialog( parent )
{
setAttribute( Qt::WA_DeleteOnClose, true );
setWindowTitle( tr( "CTRL_INFO" ));
SMESHGUI_ElemInfo( QWidget* = 0 );
~SMESHGUI_ElemInfo();
- void setSource( SMESH_Actor* );
+ void setSource( SMESH_Actor*, SMESH::SMESH_IDSource_var );
void showInfo( long, bool );
void showInfo( QSet<long>, bool );
void clear();
QWidget* frame() const;
SMESH_Actor* actor() const;
bool isElements() const;
+ bool hasShapeToMesh() const { return myMeshHasShape; }
virtual void information( const QList<long>& ) = 0;
virtual void clearInternal();
QWidget* myFrame;
ExtraWidget* myExtra;
int myIndex;
+ bool myMeshHasShape;
};
class SMESHGUI_EXPORT SMESHGUI_SimpleElemInfo : public SMESHGUI_ElemInfo
OpRemoveElemGroupPopup = 2082, // POPUP MENU - REMOVE ELEMENTS FROM GROUP
OpMeshInformation = 2100, // MENU MESH - MESH INFORMATION
OpWhatIs = 2101, // MENU MESH - MESH ELEMENT INFORMATION
- OpStdInfo = 2102, // MENU MESH - MESH STANDART INFORMATION
+ OpStdInfo = 2102, // MENU MESH - MESH STANDARD INFORMATION
OpFindElementByPoint = 2103, // MENU MESH - FIND ELEMENT BY POINT
OpUpdate = 2200, // POPUP MENU - UPDATE
// Controls -----------------------//--------------------------------
OpSkew = 3210, // MENU CONTROLS - SKEW
OpMaxElementLength2D = 3211, // MENU CONTROLS - ELEMENT DIAMETER 2D
OpEqualFace = 3212, // MENU CONTROLS - DOUBLE FACES
+ OpDeflection2D = 3213, // MENU CONTROLS - DEFLECTION 2D
OpAspectRatio3D = 3300, // MENU CONTROLS - ASPECT RATIO 3D
OpVolume = 3301, // MENU CONTROLS - VOLUME
OpMaxElementLength3D = 3302, // MENU CONTROLS - ELEMENT DIAMETER 3D
switch( actor->GetControlMode() ) {
case SMESH_Actor::eLength: mode = "eLength"; break;
case SMESH_Actor::eLength2D: mode = "eLength2D"; break;
+ case SMESH_Actor::eDeflection2D: mode = "eDeflection2D"; break;
case SMESH_Actor::eFreeEdges: mode = "eFreeEdges"; break;
case SMESH_Actor::eFreeNodes: mode = "eFreeNodes"; break;
case SMESH_Actor::eFreeBorders: mode = "eFreeBorders"; break;
return "eNone";
}
+//=======================================================================
+//function : isNumFunctor
+//purpose : return true if a given actor is shown using a numeric functor
+//=======================================================================
+
bool SMESHGUI_Selection::isNumFunctor( int ind ) const
{
bool result = false;
switch( actor->GetControlMode() ) {
case SMESH_Actor::eLength:
case SMESH_Actor::eLength2D:
+ case SMESH_Actor::eDeflection2D:
case SMESH_Actor::eMultiConnection:
case SMESH_Actor::eMultiConnection2D:
case SMESH_Actor::eArea:
//=======================================================================
//function : facesOrientationMode
-//purpose :
+//purpose :
//=======================================================================
QString SMESHGUI_Selection::facesOrientationMode( int ind ) const
// File : SMESHGUI_SingleEditDlg.cxx
// Author : Sergey LITONIN, Open CASCADE S.A.S.
+
+#include <SVTK_Selector.h>
+
// SMESH includes
//
#include "SMESHGUI_SingleEditDlg.h"
#include <SUIT_Desktop.h>
#include <SUIT_Session.h>
-#include <SVTK_Selector.h>
#include <SVTK_ViewWindow.h>
#include <SALOME_ListIO.hxx>
aList.Append(anIO);
mySelectionMgr->setSelectedObjects(aList,false);
- TColStd_IndexedMapOfInteger selectedIndices;
- TColStd_MapOfInteger newIndices;
- mySelector->GetIndex(anIO,selectedIndices);
+ SVTK_IndexedMapOfIds selectedIndices;
+ SVTK_ListOfInteger newIndices;
+ mySelector->GetCompositeIndex(anIO,selectedIndices);
int id1, id2;
if ( !getNodeIds(myEdge->text(), id1, id2) )
if ( findTriangles(aNode1,aNode2,tria1,tria2) )
{
- newIndices.Add(tria1->GetID());
-
- const SMDS_MeshNode* a3Nodes[3];
- SMDS_ElemIteratorPtr it;
- int edgeInd = 2, i;
- for (i = 0, it = tria1->nodesIterator(); it->more(); i++) {
- a3Nodes[ i ] = static_cast<const SMDS_MeshNode*>(it->next());
- if (i > 0 && ( (a3Nodes[ i ] == aNode1 && a3Nodes[ i - 1] == aNode2) ||
- (a3Nodes[ i ] == aNode2 && a3Nodes[ i - 1] == aNode1) ) ) {
- edgeInd = i - 1;
- break;
- }
- }
- newIndices.Add(-edgeInd-1);
+ newIndices.push_back( aNode1->GetID() );
+ newIndices.push_back( aNode2->GetID() );
myOkBtn->setEnabled(true);
myApplyBtn->setEnabled(true);
}
- mySelector->AddOrRemoveIndex(anIO,newIndices, false);
+ mySelector->AddOrRemoveCompositeIndex(anIO, newIndices, false);
SMESH::GetViewWindow(mySMESHGUI)->highlight( anIO, true, true );
}
}
if(SMDS_Mesh* aMesh = aVisualObj->GetMesh())
{
const SMDS_MeshElement* tria[2];
- if( SMESH::GetEdgeNodes( mySelector, aVisualObj, anId1, anId2 ) >= 1 &&
+
+ bool valid = false;
+ SVTK_IndexedMapOfIds anIds;
+ mySelector->GetCompositeIndex(anIO,anIds);
+ if( anIds.Extent() == 1 && anIds(1).size() == 2 ) {
+ anId1 = anIds(1)[0];
+ anId2 = anIds(1)[1];
+ valid = true;
+ }
+
+ if( valid &&
findTriangles( aMesh->FindNode( anId1 ), aMesh->FindNode( anId2 ), tria[0],tria[1] ) )
{
QString aText = QString("%1-%2").arg(anId1).arg(anId2);
// update actor
if (aResult) {
mySelector->ClearIndex();
+ mySelector->ClearCompositeIndex();
mySelectionMgr->setSelectedObjects(aList, false);
onSelectionDone();
SMESH::UpdateView();
}
if ( objModified ) {
- // PAL16631. Mesurements showed that to show aVisualObj in SHADING(default) mode,
+ // PAL16631. Measurements showed that to show aVisualObj in SHADING(default) mode,
// ~5 times more memory is used than it occupies.
// Warn the user if there is less free memory than 30 sizes of a grid
// TODO: estimate memory usage in other modes and take current mode into account
/*! Return active view window, if it instantiates SVTK_ViewWindow class,
- * overwise find or create corresponding view window, make it active and return it.
+ * otherwise find or create corresponding view window, make it active and return it.
* \note Active VVTK_ViewWindow can be returned, because it inherits SVTK_ViewWindow.
*/
SVTK_ViewWindow* GetViewWindow (const SalomeApp_Module* theModule,
<source>ICON_LENGTH_2D</source>
<translation>mesh_length_2d.png</translation>
</message>
+ <message>
+ <source>ICON_DEFLECTION_2D</source>
+ <translation>mesh_deflection.png</translation>
+ </message>
<message>
<source>ICON_MAP</source>
<translation>mesh_pattern.png</translation>
<source>MIN_DIAG_ELEMENTS</source>
<translation>Minimum diagonal</translation>
</message>
+ <message>
+ <source>MIN_ELEM_EDGE</source>
+ <translation>Minimum Edge Length</translation>
+ </message>
<message>
<source>ASPECTRATIO_3D_ELEMENTS</source>
<translation>Aspect Ratio 3D</translation>
<source>LENGTH2D_EDGES</source>
<translation>Length 2D</translation>
</message>
+ <message>
+ <source>DEFLECTION2D_FACES</source>
+ <translation>Deflection 2D</translation>
+ </message>
<message>
<source>LENGTH_EDGES</source>
<translation>Length</translation>
<source>MAX_ELEMENT_LENGTH_3D</source>
<translation>Element Diameter 3D</translation>
</message>
+ <message>
+ <source>DEFLECTION_2D</source>
+ <translation>Deflection 2D</translation>
+ </message>
<message>
<source>MEN_ADD</source>
<translation>Add</translation>
<source>MEN_LENGTH_2D</source>
<translation>Length 2D</translation>
</message>
+ <message>
+ <source>MEN_DEFLECTION_2D</source>
+ <translation>Deflection 2D</translation>
+ </message>
<message>
<source>MEN_MAP</source>
<translation>Pattern Mapping</translation>
</message>
<message>
<source>SMESH_MESHINFO_ALL_TYPES</source>
- <translation>Heterogenous</translation>
+ <translation>Heterogeneous</translation>
</message>
<message>
<source>SMESH_MESHINFO_EDGES</source>
<source>STB_LENGTH_2D</source>
<translation>Length 2D</translation>
</message>
+ <message>
+ <source>STB_DEFLECTION_2D</source>
+ <translation>Deflection 2D</translation>
+ </message>
<message>
<source>STB_MAP</source>
<translation>Pattern mapping</translation>
<source>TOP_LENGTH_2D</source>
<translation>Length 2D</translation>
</message>
+ <message>
+ <source>TOP_DEFLECTION_2D</source>
+ <translation>Deflection 2D</translation>
+ </message>
<message>
<source>TOP_MAP</source>
<translation>Pattern mapping</translation>
<source>LENGTH2D</source>
<translation>Length 2D</translation>
</message>
+ <message>
+ <source>DEFLECTION2D</source>
+ <translation>Deflection 2D</translation>
+ </message>
<message>
<source>LESS_THAN</source>
<translation>Less than</translation>
${CAS_TKMesh}
${Boost_LIBRARIES}
SMDS
-)
+ )
# --- headers ---
SMESH_MAT2d.hxx
SMESH_ControlPnt.hxx
SMESH_Delaunay.hxx
-)
+ )
# --- sources ---
SMESH_ControlPnt.cxx
SMESH_DeMerge.cxx
SMESH_Delaunay.cxx
+ SMESH_FillHole.cxx
)
# --- rules ---
const bool isOnFace = IsFaceID( theShapeID );
double * coef = GetShapeCoef( theShapeID );
- // Find the first guess paremeters
+ // Find the first guess parameters
gp_XYZ start(0, 0, 0);
}
//================================================================================
/*!
- * \brief Call it after geometry initialisation
+ * \brief Call it after geometry initialization
*/
//================================================================================
protected:
/*!
- * \brief Call it after geometry initialisation
+ * \brief Call it after geometry initialization
*/
void init();
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : SMESH_Comment.hxx
// Created : Wed Mar 14 18:28:45 2007
// Author : Edward AGAPOV (eap)
bool getInts(std::vector<int>& ids);
// ------------------------
- // Writting a binary file
+ // Writing a binary file
// ------------------------
bool openForWriting(); // binary writing only
--- /dev/null
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+// File : SMESH_FillHole.cxx
+// Created : Tue Sep 26 15:11:17 2017
+// Author : Edward AGAPOV (eap)
+//
+
+#include "SMESH_MeshAlgos.hxx"
+
+#include "SMESH_Comment.hxx"
+
+#include "SMESH_TypeDefs.hxx"
+#include "SMDS_Mesh.hxx"
+
+#include <Utils_SALOME_Exception.hxx>
+
+#include <boost/intrusive/circular_list_algorithms.hpp>
+#include <boost/container/flat_map.hpp>
+
+#include <Bnd_B3d.hxx>
+
+namespace
+{
+ bool isSmallAngle( double cos2 )
+ {
+ // cosine of min angle at which adjacent faces are considered overlapping
+ const double theMinCos2 = 0.996 * 0.996; // ~5 degrees
+ return ( cos2 > theMinCos2 );
+ }
+
+ struct BEdge;
+ typedef std::multimap< double, BEdge* > TAngleMap;
+ typedef std::map< const SMDS_MeshElement*, int > TFaceIndMap;
+
+ //--------------------------------------------------------------------------------
+ /*!
+ * \brief Edge of a free border
+ */
+ struct BEdge
+ {
+ const SMDS_MeshNode* myNode1;
+ const SMDS_MeshNode* myNode2;
+ const SMDS_MeshElement* myFace; // face adjacent to the border
+
+ gp_XYZ myFaceNorm;
+ gp_XYZ myDir; // myNode1 -> myNode2
+ double myDirCoef; // 1. or -1, to make myDir oriented as myNodes in myFace
+ double myLength; // between nodes
+ double myAngleWithPrev; // between myDir and -myPrev->myDir
+ double myMinMaxRatio; // of a possible triangle sides
+ TAngleMap::iterator myAngleMapPos;
+ double myOverlapAngle; // angle delta due to overlapping
+ const SMDS_MeshNode* myNode1Shift; // nodes created to avoid overlapping of faces
+ const SMDS_MeshNode* myNode2Shift;
+
+ BEdge* myPrev; // neighbors in the border
+ BEdge* myNext;
+
+ BEdge(): myNode1Shift(0), myNode2Shift(0) {}
+ void Init( const SMDS_MeshNode* n1, const SMDS_MeshNode* n2,
+ const SMDS_MeshElement* f=0,
+ const SMDS_MeshNode* nf1=0, const SMDS_MeshNode* nf2=0 );
+ void ComputeAngle( bool reverseAngle = false );
+ void ShiftOverlapped( const SMDS_MeshNode* oppNode,
+ const TFaceIndMap& capFaceWithBordInd,
+ SMDS_Mesh& mesh,
+ std::vector<const SMDS_MeshElement*>& newFaces);
+ void MakeShiftfFaces( SMDS_Mesh& mesh,
+ std::vector<const SMDS_MeshElement*>& newFaces,
+ const bool isReverse );
+ gp_XYZ GetInFaceDir() const { return myFaceNorm ^ myDir * myDirCoef; }
+ double ShapeFactor() const { return 0.5 * ( 1. - myMinMaxRatio ); }
+ void InsertSelf(TAngleMap& edgesByAngle, bool isReverseFaces, bool reBind, bool useOverlap )
+ {
+ if ( reBind ) edgesByAngle.erase( myAngleMapPos );
+ double key = (( isReverseFaces ? 2 * M_PI - myAngleWithPrev : myAngleWithPrev )
+ + myOverlapAngle * useOverlap
+ + ShapeFactor() );
+ myAngleMapPos = edgesByAngle.insert( std::make_pair( key, this ));
+ }
+
+ // traits used by boost::intrusive::circular_list_algorithms
+ typedef BEdge node;
+ typedef BEdge * node_ptr;
+ typedef const BEdge * const_node_ptr;
+ static node_ptr get_next(const_node_ptr n) { return n->myNext; }
+ static void set_next(node_ptr n, node_ptr next) { n->myNext = next; }
+ static node_ptr get_previous(const_node_ptr n) { return n->myPrev; }
+ static void set_previous(node_ptr n, node_ptr prev){ n->myPrev = prev; }
+ };
+
+ //================================================================================
+ /*!
+ * \brief Initialize a border edge data
+ */
+ //================================================================================
+
+ void BEdge::Init( const SMDS_MeshNode* n1,
+ const SMDS_MeshNode* n2,
+ const SMDS_MeshElement* newFace, // new cap face
+ const SMDS_MeshNode* nf1,
+ const SMDS_MeshNode* nf2 )
+ {
+ myNode1 = n1;
+ myNode2 = n2;
+ myDir = SMESH_NodeXYZ( n2 ) - SMESH_NodeXYZ( n1 );
+ myLength = myDir.Modulus();
+ if ( myLength > std::numeric_limits<double>::min() )
+ myDir /= myLength;
+
+ myFace = newFace;
+ if ( !myFace )
+ {
+ TIDSortedElemSet elemSet, avoidSet;
+ int ind1, ind2;
+ myFace = SMESH_MeshAlgos::FindFaceInSet( n1, n2, elemSet, avoidSet, &ind1, &ind2 );
+ if ( !myFace )
+ throw SALOME_Exception( SMESH_Comment("No face sharing nodes #")
+ << myNode1->GetID() << " and #" << myNode2->GetID());
+ avoidSet.insert( myFace );
+ if ( SMESH_MeshAlgos::FindFaceInSet( n1, n2, elemSet, avoidSet ))
+ throw SALOME_Exception( SMESH_Comment("No free border between nodes #")
+ << myNode1->GetID() << " and #" << myNode2->GetID());
+
+ myDirCoef = SMESH_MeshAlgos::IsRightOrder( myFace, myNode1, myNode2 ) ? 1. : -1.;
+ }
+
+ if (! SMESH_MeshAlgos::FaceNormal( myFace, myFaceNorm, /*normalized=*/false ))
+ {
+ SMDS_ElemIteratorPtr fIt = myNode1->GetInverseElementIterator( SMDSAbs_Face );
+ while ( fIt->more() )
+ if ( SMESH_MeshAlgos::FaceNormal( fIt->next(), myFaceNorm, /*normalized=*/false ))
+ break;
+ }
+
+ if ( newFace )
+ {
+ myFace = 0;
+ myDirCoef = SMESH_MeshAlgos::IsRightOrder( newFace, nf1, nf2 ) ? 1. : -1.;
+ if ( myPrev->myNode2 == n1 )
+ myNode1Shift = myPrev->myNode2Shift;
+ if ( myNext->myNode1 == n2 )
+ myNode2Shift = myNext->myNode1Shift;
+ }
+ else if ( myDirCoef * myPrev->myDirCoef < 0 ) // different orientation of faces
+ {
+ myFaceNorm *= -1;
+ myDirCoef *= -1;
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \brief Compute myAngleWithPrev
+ */
+ //================================================================================
+
+ void BEdge::ComputeAngle( bool theReverseAngle )
+ {
+ double dot = myDir.Dot( myPrev->myDir.Reversed() );
+ if ( dot >= 1 ) myAngleWithPrev = 0;
+ else if ( dot <= -1 ) myAngleWithPrev = M_PI;
+ else myAngleWithPrev = acos( dot );
+
+ bool isObtuse;
+ gp_XYZ inFaceDirNew = myDir - myPrev->myDir;
+ gp_XYZ inFaceDir1 = myPrev->GetInFaceDir();
+ gp_XYZ inFaceDir2 = this->GetInFaceDir();
+ double dot1 = inFaceDirNew * inFaceDir1;
+ double dot2 = inFaceDirNew * inFaceDir2;
+ bool isOverlap1 = ( dot1 > 0 );
+ bool isOverlap2 = ( dot2 > 0 );
+ if ( !myPrev->myFace )
+ isObtuse = isOverlap1;
+ else if ( !myFace )
+ isObtuse = isOverlap2;
+ else
+ {
+ double dt1 = myDir.Dot( myPrev->myFaceNorm );
+ double dt2 = myPrev->myDir.Dot( myFaceNorm );
+ isObtuse = ( dt1 > 0 || dt2 < 0 ); // suppose face normals point outside the border
+ if ( theReverseAngle )
+ isObtuse = !isObtuse;
+ }
+ if ( isObtuse )
+ {
+ myAngleWithPrev = 2 * M_PI - myAngleWithPrev;
+ }
+
+ // if ( ! isObtuse )
+ // isObtuse =
+ // isSmallAngle( 1 - myDir.CrossSquareMagnitude( myPrev->myDir )); // edges co-directed
+
+ myOverlapAngle = 0;
+ //if ( !isObtuse )
+ {
+ // check if myFace and a triangle built on this and prev edges overlap
+ if ( isOverlap1 )
+ {
+ double cos2 = dot1 * dot1 / inFaceDirNew.SquareModulus() / inFaceDir1.SquareModulus();
+ myOverlapAngle += 1. * M_PI * cos2;
+ }
+ if ( isOverlap2 )
+ {
+ double cos2 = dot2 * dot2 / inFaceDirNew.SquareModulus() / inFaceDir2.SquareModulus();
+ myOverlapAngle += 1. * M_PI * cos2;
+ }
+ }
+
+ {
+ double len3 = SMESH_NodeXYZ( myPrev->myNode1 ).Distance( myNode2 );
+ double minLen = Min( myLength, Min( myPrev->myLength, len3 ));
+ double maxLen = Max( myLength, Max( myPrev->myLength, len3 ));
+ myMinMaxRatio = minLen / maxLen;
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \brief Check if myFace is overlapped by a triangle formed by myNode's and a
+ * given node. If so, create shifted nodes to avoid overlapping
+ */
+ //================================================================================
+
+ void BEdge::ShiftOverlapped( const SMDS_MeshNode* theOppNode,
+ const TFaceIndMap& theCapFaceWithBordInd,
+ SMDS_Mesh& theMesh,
+ std::vector<const SMDS_MeshElement*>& theNewFaces )
+ {
+ if ( myNode1Shift && myNode2Shift )
+ return;
+
+ gp_XYZ inNewFaceDir = SMESH_NodeXYZ( theOppNode ) - SMESH_NodeXYZ( myNode1 );
+ double dot = inNewFaceDir.Dot( myFaceNorm );
+ double cos2 = dot * dot / myFaceNorm.SquareModulus() / inNewFaceDir.SquareModulus();
+ bool isOverlap = ( isSmallAngle( 1 - cos2 ) && GetInFaceDir() * inNewFaceDir > 0 );
+
+ if ( isOverlap )
+ {
+ gp_XYZ shift = myFaceNorm / myLength / 4;
+ if ( myFace )
+ shift.Reverse();
+ if ( !myNode1Shift )
+ {
+ gp_XYZ p = SMESH_NodeXYZ( myNode1 ) + shift;
+ myNode1Shift = theMesh.AddNode( p.X(), p.Y(), p.Z() );
+ myPrev->myNode2Shift = myNode1Shift;
+ }
+ if ( !myNode2Shift )
+ {
+ gp_XYZ p = SMESH_NodeXYZ( myNode2 ) + shift;
+ myNode2Shift = theMesh.AddNode( p.X(), p.Y(), p.Z() );
+ myNext->myNode1Shift = myNode2Shift;
+ }
+
+ // MakeShiftfFaces() for already created cap faces
+ for ( int is2nd = 0; is2nd < 2; ++is2nd )
+ {
+ const SMDS_MeshNode* ns = is2nd ? myNode2Shift : myNode1Shift;
+ const SMDS_MeshNode* n = is2nd ? myNode2 : myNode1;
+ if ( !ns ) continue;
+
+ SMDS_ElemIteratorPtr fIt = n->GetInverseElementIterator( SMDSAbs_Face );
+ while ( fIt->more() )
+ {
+ const SMDS_MeshElement* f = fIt->next();
+ if ( !f->isMarked() ) continue;
+
+ TFaceIndMap::const_iterator f2i = theCapFaceWithBordInd.find( f );
+ if ( f2i == theCapFaceWithBordInd.end() )
+ continue;
+ const SMDS_MeshNode* nf1 = f->GetNode( f2i->second );
+ const SMDS_MeshNode* nf2 = f->GetNode(( f2i->second+1 ) % f->NbNodes() );
+ if ( nf1 == n || nf2 == n )
+ {
+ BEdge tmpE;
+ tmpE.myPrev = tmpE.myNext = this;
+ tmpE.Init( nf1, nf2, f, nf1, nf2 );
+ if ( !tmpE.myNode1Shift && !tmpE.myNode2Shift )
+ tmpE.Init( nf2, nf1, f, nf2, nf1 );
+ tmpE.myFace = f;
+ tmpE.MakeShiftfFaces( theMesh, theNewFaces, tmpE.myDirCoef < 0 );
+ }
+ std::vector< const SMDS_MeshNode* > nodes( f->begin_nodes(), f->end_nodes() );
+ nodes[ f->GetNodeIndex( n ) ] = ns;
+ theMesh.ChangeElementNodes( f, &nodes[0], nodes.size() );
+ }
+ }
+ }
+ }
+
+ //================================================================================
+ /*!
+ * \brief Create a triangle
+ */
+ //================================================================================
+
+ const SMDS_MeshElement* MakeTria( SMDS_Mesh& mesh,
+ const SMDS_MeshNode* n1,
+ const SMDS_MeshNode* n2,
+ const SMDS_MeshNode* n3,
+ const bool isReverse )
+ {
+ if ( isReverse )
+ return mesh.AddFace( n1, n3, n2 );
+ return mesh.AddFace( n1, n2, n3 );
+ }
+
+ //================================================================================
+ /*!
+ * \brief Create a quadrangle
+ */
+ //================================================================================
+
+ // const SMDS_MeshElement* MakeQuad( SMDS_Mesh& mesh,
+ // const SMDS_MeshNode* n1,
+ // const SMDS_MeshNode* n2,
+ // const SMDS_MeshNode* n3,
+ // const SMDS_MeshNode* n4,
+ // const bool isReverse )
+ // {
+ // if ( isReverse )
+ // return mesh.AddFace( n4, n3, n2, n1 );
+ // return mesh.AddFace( n1, n2, n3, n4 );
+ // }
+
+ //================================================================================
+ /*!
+ * \brief Create faces on myNode* and myNode*Shift
+ */
+ //================================================================================
+
+ void BEdge::MakeShiftfFaces(SMDS_Mesh& mesh,
+ std::vector<const SMDS_MeshElement*>& newFaces,
+ const bool isReverse )
+ {
+ if ( !myFace )
+ return;
+ if ( myNode1Shift && myNode2Shift )
+ {
+ newFaces.push_back( MakeTria( mesh, myNode1, myNode2, myNode2Shift, isReverse ));
+ newFaces.push_back( MakeTria( mesh, myNode1, myNode2Shift, myNode1Shift, isReverse ));
+ }
+ else if ( myNode1Shift )
+ {
+ newFaces.push_back( MakeTria( mesh, myNode1, myNode2, myNode1Shift, isReverse ));
+ }
+ else if ( myNode2Shift )
+ {
+ newFaces.push_back( MakeTria( mesh, myNode1, myNode2, myNode2Shift, isReverse ));
+ }
+ }
+
+} // namespace
+
+//================================================================================
+/*!
+ * \brief Fill with 2D elements a hole defined by a TFreeBorder
+ */
+//================================================================================
+
+void SMESH_MeshAlgos::FillHole(const SMESH_MeshAlgos::TFreeBorder & theFreeBorder,
+ SMDS_Mesh& theMesh,
+ std::vector<const SMDS_MeshElement*>& theNewFaces)
+{
+ if ( theFreeBorder.size() < 4 || // at least 3 nodes
+ theFreeBorder[0] != theFreeBorder.back() ) // the hole must be closed
+ return;
+
+ // prepare data of the border
+
+ ObjectPool< BEdge > edgeAllocator;
+ boost::intrusive::circular_list_algorithms< BEdge > circularList;
+ BEdge* edge;
+ BEdge* edge0 = edgeAllocator.getNew();
+ BEdge* edgePrev = edge0;
+ circularList.init_header( edge0 );
+ edge0->Init( theFreeBorder[0], theFreeBorder[1], 0 );
+ Bnd_B3d box;
+ box.Add( SMESH_NodeXYZ( edge0->myNode1 ));
+ for ( size_t i = 2; i < theFreeBorder.size(); ++i )
+ {
+ edge = edgeAllocator.getNew();
+ circularList.link_after( edgePrev, edge );
+ edge->Init( theFreeBorder[i-1], theFreeBorder[i] );
+ edge->ComputeAngle();
+ edgePrev = edge;
+ box.Add( SMESH_NodeXYZ( edge->myNode1 ));
+ }
+ edge0->ComputeAngle();
+
+ // check if face normals point outside the border
+
+ gp_XYZ hSize = 0.5 * ( box.CornerMax() - box.CornerMin() );
+ const double hDelta = 1e-6 * hSize.Modulus();
+ hSize -= gp_XYZ( hDelta, hDelta, hDelta );
+ if ( hSize.X() < 0 ) hSize.SetX(hDelta);
+ if ( hSize.Y() < 0 ) hSize.SetY(hDelta);
+ if ( hSize.Z() < 0 ) hSize.SetZ(hDelta);
+ box.SetHSize( hSize ); // decrease the box by hDelta
+
+ size_t nbEdges = theFreeBorder.size() - 1;
+ edge = edge0;
+ int nbRev = 0, nbFrw = 0;
+ double angTol = M_PI - ( nbEdges - 2 ) * M_PI / nbEdges, sumDirCoeff = 0;
+ for ( size_t i = 0; i < nbEdges; ++i, edge = edge->myNext )
+ {
+ if ( box.IsOut( SMESH_NodeXYZ( edge->myNode1 )) &&
+ edge->myOverlapAngle < 0.1 * M_PI )
+ {
+ nbRev += edge->myAngleWithPrev > M_PI + angTol;
+ nbFrw += edge->myAngleWithPrev < M_PI - angTol;
+ }
+ sumDirCoeff += edge->myDirCoef;
+
+ // unmark all adjacent faces, new faces will be marked
+ SMDS_ElemIteratorPtr fIt = edge->myNode1->GetInverseElementIterator( SMDSAbs_Face );
+ while ( fIt->more() )
+ fIt->next()->setIsMarked( false );
+ }
+ bool isReverseAngle = ( nbRev > nbFrw ); // true == face normals point inside the border
+ //std::cout << "nbRev="<< nbRev << ", nbFrw="<< nbFrw<<std::endl;
+
+ // sort border edges by myAngleWithPrev
+
+ TAngleMap edgesByAngle;
+ bool useOverlap = true; // to add BEdge.myOverlapAngle when filling edgesByAngle
+ edge = edge0;
+ for ( size_t i = 0; i < nbEdges; ++i, edge = edge->myNext )
+ edge->InsertSelf( edgesByAngle, isReverseAngle, /*reBind=*/false, useOverlap );
+
+ // create triangles to fill the hole
+
+ //compare order of nodes in the edges with their order in faces
+ bool isReverse = sumDirCoeff > 0.5 * nbEdges;
+
+ // faces filling the hole (cap faces) and indices of border edges in them
+ TFaceIndMap capFaceWithBordInd;
+
+ theNewFaces.reserve( nbEdges - 2 );
+ std::vector< const SMDS_MeshNode* > nodes(3);
+ while ( edgesByAngle.size() > 2 )
+ {
+ TAngleMap::iterator a2e = edgesByAngle.begin();
+ edge = a2e->second;
+ if ( useOverlap &&
+ a2e->first - edge->ShapeFactor() > M_PI - angTol ) // all new triangles need shift
+ {
+ // re-sort the edges w/o overlap consideration
+ useOverlap = false;
+ nbEdges = edgesByAngle.size();
+ edgesByAngle.clear();
+ for ( size_t i = 0; i < nbEdges; ++i, edge = edge->myNext )
+ edge->InsertSelf( edgesByAngle, isReverseAngle, /*reBind=*/false, useOverlap );
+ a2e = edgesByAngle.begin();
+ }
+ edge = a2e->second;
+ edgePrev = edge->myPrev;
+
+ // create shift nodes and faces
+ edgePrev->ShiftOverlapped( edge->myNode2, capFaceWithBordInd, theMesh, theNewFaces );
+ edge->ShiftOverlapped( edgePrev->myNode1, capFaceWithBordInd, theMesh, theNewFaces );
+ edge ->MakeShiftfFaces( theMesh, theNewFaces, isReverse );
+ edgePrev->MakeShiftfFaces( theMesh, theNewFaces, isReverse );
+
+ // make a cap face
+ //nodes.resize( 3 );
+ nodes[0] = edgePrev->myNode1Shift ? edgePrev->myNode1Shift : edgePrev->myNode1;
+ nodes[1] = edgePrev->myNode2Shift ? edgePrev->myNode2Shift : edgePrev->myNode2;
+ nodes[2] = edge->myNode2Shift ? edge->myNode2Shift : edge->myNode2;
+ theNewFaces.push_back( MakeTria( theMesh, nodes[0], nodes[1], nodes[2], isReverse ));
+ // std::cout << nodes[1]->GetID() << " " << nodes[0]->GetID() << " " << nodes[2]->GetID()
+ // << " " << edge->myAngleWithPrev << std::endl;
+
+ // remember a border edge within the new cap face
+ theNewFaces.back()->setIsMarked( true );
+ if ( edgePrev->myFace )
+ capFaceWithBordInd.insert( std::make_pair( theNewFaces.back(), isReverse ? 2 : 0 ));
+ if ( edge->myFace )
+ capFaceWithBordInd.insert( std::make_pair( theNewFaces.back(), 1 ));
+
+ // remove edgePrev from the list and update <edge>
+ edgesByAngle.erase( edgePrev->myAngleMapPos );
+ circularList.unlink( edgePrev ); // remove edgePrev from the border
+
+ edge->Init( edgePrev->myNode1, edge->myNode2, theNewFaces.back(), nodes[0], nodes[2] );
+ edge->ComputeAngle( isReverseAngle );
+ edge->InsertSelf( edgesByAngle, /*isReverse=*/false, /*reBind=*/true, useOverlap );
+ edge->myNext->ComputeAngle( isReverseAngle );
+ edge->myNext->InsertSelf( edgesByAngle, /*isReverse=*/false, /*reBind=*/true, useOverlap );
+ // std::cout << "A " << edge->myNode1->GetID() << " " << edge->myAngleWithPrev
+ // << " " << edge->myNext->myNode1->GetID() << " " << edge->myNext->myAngleWithPrev
+ // << std::endl;
+ }
+ edge = edgesByAngle.begin()->second;
+ edge-> MakeShiftfFaces( theMesh, theNewFaces, isReverse );
+ edge->myNext->MakeShiftfFaces( theMesh, theNewFaces, isReverse );
+}
if ( myID < 0 )
{
myID = id;
- if ( myNext )
- myNext->SetID( id + 1 );
+
+ for ( BEdge* be = myNext; be && be->myID < 0; be = be->myNext )
+ {
+ be->myID = ++id;
+ }
}
}
//================================================================================
} // SMESH_MeshAlgos::FindCoincidentFreeBorders()
+//================================================================================
+/*
+ * Returns all TFreeBorder's. Optionally check if the mesh is manifold
+ * and if faces are correctly oriented.
+ */
+//================================================================================
+
+void SMESH_MeshAlgos::FindFreeBorders(SMDS_Mesh& theMesh,
+ TFreeBorderVec & theFoundFreeBordes,
+ const bool theClosedOnly,
+ bool* theIsManifold,
+ bool* theIsGoodOri)
+{
+ bool isManifold = true;
+
+ // find free links
+ typedef NCollection_DataMap<SMESH_TLink, const SMDS_MeshElement*, SMESH_TLink > TLink2FaceMap;
+ TLink2FaceMap linkMap;
+ int nbSharedLinks = 0;
+ SMDS_FaceIteratorPtr faceIt = theMesh.facesIterator();
+ while ( faceIt->more() )
+ {
+ const SMDS_MeshElement* face = faceIt->next();
+ if ( !face ) continue;
+
+ const SMDS_MeshNode* n0 = face->GetNode( face->NbNodes() - 1 );
+ SMDS_NodeIteratorPtr nodeIt = face->interlacedNodesIterator();
+ while ( nodeIt->more() )
+ {
+ const SMDS_MeshNode* n1 = nodeIt->next();
+ SMESH_TLink link( n0, n1 );
+ if ( const SMDS_MeshElement** faceInMap = linkMap.ChangeSeek( link ))
+ {
+ if ( *faceInMap )
+ {
+ if ( theIsGoodOri && *theIsGoodOri && !IsRightOrder( *faceInMap, n1, n0 ))
+ *theIsGoodOri = false;
+ }
+ else
+ {
+ isManifold = false;
+ }
+ nbSharedLinks += bool( *faceInMap );
+ *faceInMap = 0;
+ }
+ else
+ {
+ linkMap.Bind( link, face );
+ }
+ n0 = n1;
+ }
+ }
+ if ( theIsManifold )
+ *theIsManifold = isManifold;
+
+ if ( linkMap.Extent() == nbSharedLinks )
+ return;
+
+ // form free borders
+ std::set < BNode > bNodes;
+ std::vector< BEdge > bEdges( linkMap.Extent() - nbSharedLinks );
+
+ TLink2FaceMap::Iterator linkIt( linkMap );
+ for ( int iEdge = 0; linkIt.More(); linkIt.Next() )
+ {
+ if ( !linkIt.Value() ) continue;
+ const SMESH_TLink & link = linkIt.Key();
+ std::set< BNode >::iterator n1 = bNodes.insert( BNode( link.node1() )).first;
+ std::set< BNode >::iterator n2 = bNodes.insert( BNode( link.node2() )).first;
+ bEdges[ iEdge ].Set( &*n1, &*n2, linkIt.Value(), iEdge+1 );
+ n1->AddLinked( & bEdges[ iEdge ] );
+ n2->AddLinked( & bEdges[ iEdge ] );
+ ++iEdge;
+ }
+ linkMap.Clear();
+
+ // assign IDs to borders
+ std::vector< BEdge* > borders; // 1st of connected (via myPrev and myNext) edges
+ std::set< BNode >::iterator bn = bNodes.begin();
+ for ( ; bn != bNodes.end(); ++bn )
+ {
+ for ( size_t i = 0; i < bn->myLinkedEdges.size(); ++i )
+ {
+ if ( bn->myLinkedEdges[i]->myBorderID < 0 )
+ {
+ BEdge* be = bn->myLinkedEdges[i];
+ int borderID = borders.size();
+ borders.push_back( be );
+ for ( ; be && be->myBorderID < 0; be = be->myNext )
+ {
+ be->myBorderID = borderID;
+ be->Orient();
+ }
+ bool isClosed = ( be == bn->myLinkedEdges[i] );
+ if ( !isClosed && theClosedOnly )
+ {
+ borders.pop_back();
+ continue;
+ }
+ be = bn->myLinkedEdges[i]->myPrev;
+ for ( ; be && be->myBorderID < 0; be = be->myPrev )
+ {
+ be->myBorderID = borderID;
+ be->Orient();
+ }
+ if ( !isClosed )
+ while ( borders.back()->myPrev )
+ borders.back() = borders.back()->myPrev;
+ }
+ }
+ }
+ theFoundFreeBordes.resize( borders.size() );
+ for ( size_t i = 0; i < borders.size(); ++i )
+ {
+ TFreeBorder & bordNodes = theFoundFreeBordes[ i ];
+ BEdge* be = borders[i];
+
+ size_t cnt = 1;
+ for ( be = be->myNext; be && be != borders[i]; be = be->myNext )
+ ++cnt;
+ bordNodes.resize( cnt + 1 );
+
+ BEdge* beLast;
+ for ( be = borders[i], cnt = 0;
+ be && cnt < bordNodes.size()-1;
+ be = be->myNext, ++cnt )
+ {
+ bordNodes[ cnt ] = be->myBNode1->Node();
+ beLast = be;
+ }
+ bordNodes.back() = beLast->myBNode2->Node();
+ }
+}
#include "SMDS_VolumeTool.hxx"
#include "SMESH_OctreeNode.hxx"
+#include <Utils_SALOME_Exception.hxx>
+
#include <GC_MakeSegment.hxx>
#include <GeomAPI_ExtremaCurveCurve.hxx>
#include <Geom_Line.hxx>
SMDSAbs_ElementType elemType,
SMDS_ElemIteratorPtr theElemIt = SMDS_ElemIteratorPtr(),
double tolerance = NodeRadius );
- void prepare(); // !!!call it before calling the following methods!!!
void getElementsNearPoint( const gp_Pnt& point, vector<const SMDS_MeshElement*>& foundElems );
void getElementsNearLine ( const gp_Ax1& line, vector<const SMDS_MeshElement*>& foundElems);
void getElementsInSphere ( const gp_XYZ& center,
const double radius,
vector<const SMDS_MeshElement*>& foundElems);
+ ElementBndBoxTree* getLeafAtPoint( const gp_XYZ& point );
protected:
ElementBndBoxTree() {}
}
}
- //================================================================================
- /*!
- * \brief Un-mark all elements
- */
- //================================================================================
-
- void ElementBndBoxTree::prepare()
- {
- // TElementBoxPool& elBoPool = getElementBoxPool();
- // for ( size_t i = 0; i < elBoPool.nbElements(); ++i )
- // const_cast< ElementBox* >( elBoPool[ i ])->_isMarked = false;
- }
-
//================================================================================
/*!
* \brief Return elements which can include the point
}
}
+ //================================================================================
+ /*!
+ * \brief Return a leaf including a point
+ */
+ //================================================================================
+
+ ElementBndBoxTree* ElementBndBoxTree::getLeafAtPoint( const gp_XYZ& point )
+ {
+ if ( getBox()->IsOut( point ))
+ return 0;
+
+ if ( isLeaf() )
+ {
+ return this;
+ }
+ else
+ {
+ for (int i = 0; i < 8; i++)
+ if ( ElementBndBoxTree* l = ((ElementBndBoxTree*) myChildren[i])->getLeafAtPoint( point ))
+ return l;
+ }
+ return 0;
+ }
+
//================================================================================
/*!
* \brief Construct the element box
virtual const SMDS_MeshElement* FindClosestTo( const gp_Pnt& point,
SMDSAbs_ElementType type );
- void GetElementsNearLine( const gp_Ax1& line,
- SMDSAbs_ElementType type,
- vector< const SMDS_MeshElement* >& foundElems);
- void GetElementsInSphere( const gp_XYZ& center,
- const double radius,
- SMDSAbs_ElementType type,
- vector< const SMDS_MeshElement* >& foundElems);
+ virtual void GetElementsNearLine( const gp_Ax1& line,
+ SMDSAbs_ElementType type,
+ vector< const SMDS_MeshElement* >& foundElems);
+ virtual void GetElementsInSphere( const gp_XYZ& center,
+ const double radius,
+ SMDSAbs_ElementType type,
+ vector< const SMDS_MeshElement* >& foundElems);
+ virtual gp_XYZ Project(const gp_Pnt& point,
+ SMDSAbs_ElementType type,
+ const SMDS_MeshElement** closestElem);
double getTolerance();
bool getIntersParamOnLine(const gp_Lin& line, const SMDS_MeshElement* face,
const double tolerance, double & param);
{
_ebbTree[_elementType] = new ElementBndBoxTree( *_mesh, type, _meshPartIt, tolerance );
}
- else
- {
- _ebbTree[ type ]->prepare();
- }
vector< const SMDS_MeshElement* > suspectElems;
_ebbTree[ type ]->getElementsNearPoint( point, suspectElems );
vector< const SMDS_MeshElement* >::iterator elem = suspectElems.begin();
const SMDS_MeshElement* closestElem = 0;
_elementType = type;
- if ( type == SMDSAbs_Face || type == SMDSAbs_Volume )
+ if ( type == SMDSAbs_Face ||
+ type == SMDSAbs_Volume ||
+ type == SMDSAbs_Edge )
{
ElementBndBoxTree*& ebbTree = _ebbTree[ type ];
if ( !ebbTree )
ebbTree = new ElementBndBoxTree( *_mesh, type, _meshPartIt );
- else
- ebbTree->prepare();
vector<const SMDS_MeshElement*> suspectElems;
ebbTree->getElementsNearPoint( point, suspectElems );
radius = ebbTree->maxSize() / pow( 2., getTreeHeight()) / 2;
while ( suspectElems.empty() )
{
- ebbTree->prepare();
ebbTree->getElementsInSphere( point.XYZ(), radius, suspectElems );
radius *= 1.1;
}
ElementBndBoxTree*& ebbTree = _ebbTree[ SMDSAbs_Face ];
if ( !ebbTree )
ebbTree = new ElementBndBoxTree( *_mesh, _elementType, _meshPartIt );
- else
- ebbTree->prepare();
// Algo: analyse transition of a line starting at the point through mesh boundary;
// try three lines parallel to axis of the coordinate system and perform rough
gp_Lin line ( lineAxis );
vector<const SMDS_MeshElement*> suspectFaces; // faces possibly intersecting the line
- if ( axis > 0 ) ebbTree->prepare();
ebbTree->getElementsNearLine( lineAxis, suspectFaces );
// Intersect faces with the line
ElementBndBoxTree*& ebbTree = _ebbTree[ type ];
if ( !ebbTree )
ebbTree = new ElementBndBoxTree( *_mesh, _elementType, _meshPartIt );
- else
- ebbTree->prepare();
ebbTree->getElementsNearLine( line, foundElems );
}
ElementBndBoxTree*& ebbTree = _ebbTree[ type ];
if ( !ebbTree )
ebbTree = new ElementBndBoxTree( *_mesh, _elementType, _meshPartIt );
- else
- ebbTree->prepare();
ebbTree->getElementsInSphere( center, radius, foundElems );
}
+//=======================================================================
+/*
+ * \brief Return a projection of a given point to a mesh.
+ * Optionally return the closest element
+ */
+//=======================================================================
+
+gp_XYZ SMESH_ElementSearcherImpl::Project(const gp_Pnt& point,
+ SMDSAbs_ElementType type,
+ const SMDS_MeshElement** closestElem)
+{
+ _elementType = type;
+ if ( _mesh->GetMeshInfo().NbElements( _elementType ) == 0 )
+ throw SALOME_Exception( LOCALIZED( "No elements of given type in the mesh" ));
+
+ ElementBndBoxTree*& ebbTree = _ebbTree[ _elementType ];
+ if ( !ebbTree )
+ ebbTree = new ElementBndBoxTree( *_mesh, _elementType );
+
+ gp_XYZ p = point.XYZ();
+ ElementBndBoxTree* ebbLeaf = ebbTree->getLeafAtPoint( p );
+ const Bnd_B3d* box = ebbLeaf->getBox();
+ double radius = ( box->CornerMax() - box->CornerMin() ).Modulus();
+
+ vector< const SMDS_MeshElement* > elems;
+ ebbTree->getElementsInSphere( p, radius, elems );
+ while ( elems.empty() )
+ {
+ radius *= 1.5;
+ ebbTree->getElementsInSphere( p, radius, elems );
+ }
+ gp_XYZ proj, bestProj;
+ const SMDS_MeshElement* elem = 0;
+ double minDist = 2 * radius;
+ for ( size_t i = 0; i < elems.size(); ++i )
+ {
+ double d = SMESH_MeshAlgos::GetDistance( elems[i], p, &proj );
+ if ( d < minDist )
+ {
+ bestProj = proj;
+ elem = elems[i];
+ minDist = d;
+ }
+ }
+ if ( closestElem ) *closestElem = elem;
+
+ return bestProj;
+}
+
//=======================================================================
/*!
* \brief Return true if the point is IN or ON of the element
//=======================================================================
double SMESH_MeshAlgos::GetDistance( const SMDS_MeshElement* elem,
- const gp_Pnt& point )
+ const gp_Pnt& point,
+ gp_XYZ* closestPnt )
{
switch ( elem->GetType() )
{
case SMDSAbs_Volume:
- return GetDistance( dynamic_cast<const SMDS_MeshVolume*>( elem ), point);
+ return GetDistance( dynamic_cast<const SMDS_MeshVolume*>( elem ), point, closestPnt );
case SMDSAbs_Face:
- return GetDistance( dynamic_cast<const SMDS_MeshFace*>( elem ), point);
+ return GetDistance( dynamic_cast<const SMDS_MeshFace*>( elem ), point, closestPnt );
case SMDSAbs_Edge:
- return GetDistance( dynamic_cast<const SMDS_MeshEdge*>( elem ), point);
+ return GetDistance( dynamic_cast<const SMDS_MeshEdge*>( elem ), point, closestPnt );
case SMDSAbs_Node:
+ if ( closestPnt ) *closestPnt = SMESH_TNodeXYZ( elem );
return point.Distance( SMESH_TNodeXYZ( elem ));
default:;
}
//=======================================================================
double SMESH_MeshAlgos::GetDistance( const SMDS_MeshFace* face,
- const gp_Pnt& point )
+ const gp_Pnt& point,
+ gp_XYZ* closestPnt )
{
- double badDistance = -1;
+ const double badDistance = -1;
if ( !face ) return badDistance;
// coordinates of nodes (medium nodes, if any, ignored)
trsf.Transforms( tmpPnt );
gp_XY point2D( tmpPnt.X(), tmpPnt.Z() );
- // loop on segments of the face to analyze point position ralative to the face
+ // loop on edges of the face to analyze point position ralative to the face
set< PointPos > pntPosSet;
for ( size_t i = 1; i < xy.size(); ++i )
{
// compute distance
PointPos pos = *pntPosSet.begin();
- // cout << "Face " << face->GetID() << " DIST: ";
switch ( pos._name )
{
- case POS_LEFT: {
- // point is most close to a segment
- gp_Vec p0p1( point, xyz[ pos._index ] );
- gp_Vec p1p2( xyz[ pos._index ], xyz[ pos._index+1 ]); // segment vector
- p1p2.Normalize();
- double projDist = p0p1 * p1p2; // distance projected to the segment
- gp_Vec projVec = p1p2 * projDist;
- gp_Vec distVec = p0p1 - projVec;
- // cout << distVec.Magnitude() << ", SEG " << face->GetNode(pos._index)->GetID()
- // << " - " << face->GetNodeWrap(pos._index+1)->GetID() << endl;
- return distVec.Magnitude();
+ case POS_LEFT:
+ {
+ // point is most close to an edge
+ gp_Vec edge( xyz[ pos._index ], xyz[ pos._index+1 ]);
+ gp_Vec n1p ( xyz[ pos._index ], point );
+ double u = ( edge * n1p ) / edge.SquareMagnitude(); // param [0,1] on the edge
+ // projection of the point on the edge
+ gp_XYZ proj = ( 1. - u ) * xyz[ pos._index ] + u * xyz[ pos._index+1 ];
+ if ( closestPnt ) *closestPnt = proj;
+ return point.Distance( proj );
}
- case POS_RIGHT: {
+ case POS_RIGHT:
+ {
// point is inside the face
- double distToFacePlane = tmpPnt.Y();
- // cout << distToFacePlane << ", INSIDE " << endl;
- return Abs( distToFacePlane );
+ double distToFacePlane = Abs( tmpPnt.Y() );
+ if ( closestPnt )
+ {
+ if ( distToFacePlane < std::numeric_limits<double>::min() ) {
+ *closestPnt = point.XYZ();
+ }
+ else {
+ tmpPnt.SetY( 0 );
+ trsf.Inverted().Transforms( tmpPnt );
+ *closestPnt = tmpPnt;
+ }
+ }
+ return distToFacePlane;
}
- case POS_VERTEX: {
+ case POS_VERTEX:
+ {
// point is most close to a node
gp_Vec distVec( point, xyz[ pos._index ]);
- // cout << distVec.Magnitude() << " VERTEX " << face->GetNode(pos._index)->GetID() << endl;
return distVec.Magnitude();
}
default:;
*/
//=======================================================================
-double SMESH_MeshAlgos::GetDistance( const SMDS_MeshEdge* seg, const gp_Pnt& point )
+double SMESH_MeshAlgos::GetDistance( const SMDS_MeshEdge* seg,
+ const gp_Pnt& point,
+ gp_XYZ* closestPnt )
{
double dist = Precision::Infinite();
if ( !seg ) return dist;
{
gp_Vec edge( xyz[i-1], xyz[i] );
gp_Vec n1p ( xyz[i-1], point );
- double u = ( edge * n1p ) / edge.SquareMagnitude(); // param [0,1] on the edge
+ double d, u = ( edge * n1p ) / edge.SquareMagnitude(); // param [0,1] on the edge
if ( u <= 0. ) {
- dist = Min( dist, n1p.SquareMagnitude() );
+ if (( d = n1p.SquareMagnitude() ) < dist ) {
+ dist = d;
+ if ( closestPnt ) *closestPnt = xyz[i-1];
+ }
}
else if ( u >= 1. ) {
- dist = Min( dist, point.SquareDistance( xyz[i] ));
+ if (( d = point.SquareDistance( xyz[i] )) < dist ) {
+ dist = d;
+ if ( closestPnt ) *closestPnt = xyz[i];
+ }
}
else {
- gp_XYZ proj = ( 1. - u ) * xyz[i-1] + u * xyz[i]; // projection of the point on the edge
- dist = Min( dist, point.SquareDistance( proj ));
+ gp_XYZ proj = xyz[i-1] + u * edge.XYZ(); // projection of the point on the edge
+ if (( d = point.SquareDistance( proj )) < dist ) {
+ dist = d;
+ if ( closestPnt ) *closestPnt = proj;
+ }
}
}
return Sqrt( dist );
*/
//=======================================================================
-double SMESH_MeshAlgos::GetDistance( const SMDS_MeshVolume* volume, const gp_Pnt& point )
+double SMESH_MeshAlgos::GetDistance( const SMDS_MeshVolume* volume,
+ const gp_Pnt& point,
+ gp_XYZ* closestPnt )
{
SMDS_VolumeTool vTool( volume );
vTool.SetExternalNormal();
double n[3], bc[3];
double minDist = 1e100, dist;
+ gp_XYZ closeP = point.XYZ();
+ bool isOut = false;
for ( int iF = 0; iF < vTool.NbFaces(); ++iF )
{
// skip a facet with normal not "looking at" the point
case 3:
{
SMDS_FaceOfNodes tmpFace( nodes[0], nodes[ 1*iQ ], nodes[ 2*iQ ] );
- dist = GetDistance( &tmpFace, point );
+ dist = GetDistance( &tmpFace, point, closestPnt );
break;
}
case 4:
{
SMDS_FaceOfNodes tmpFace( nodes[0], nodes[ 1*iQ ], nodes[ 2*iQ ], nodes[ 3*iQ ]);
- dist = GetDistance( &tmpFace, point );
+ dist = GetDistance( &tmpFace, point, closestPnt );
break;
}
default:
vector<const SMDS_MeshNode *> nvec( nodes, nodes + vTool.NbFaceNodes( iF ));
SMDS_PolygonalFaceOfNodes tmpFace( nvec );
- dist = GetDistance( &tmpFace, point );
+ dist = GetDistance( &tmpFace, point, closestPnt );
+ }
+ if ( dist < minDist )
+ {
+ minDist = dist;
+ isOut = true;
+ if ( closestPnt ) closeP = *closestPnt;
}
- minDist = Min( minDist, dist );
}
- return minDist;
+ if ( isOut )
+ {
+ if ( closestPnt ) *closestPnt = closeP;
+ return minDist;
+ }
+
+ return 0; // point is inside the volume
}
//================================================================================
common.push_back( e1->GetNode( i ));
return common;
}
+//================================================================================
+/*!
+ * \brief Return true if node1 encounters first in the face and node2, after
+ */
+//================================================================================
+
+bool SMESH_MeshAlgos::IsRightOrder( const SMDS_MeshElement* face,
+ const SMDS_MeshNode* node0,
+ const SMDS_MeshNode* node1 )
+{
+ int i0 = face->GetNodeIndex( node0 );
+ int i1 = face->GetNodeIndex( node1 );
+ if ( face->IsQuadratic() )
+ {
+ if ( face->IsMediumNode( node0 ))
+ {
+ i0 -= ( face->NbNodes()/2 - 1 );
+ i1 *= 2;
+ }
+ else
+ {
+ i1 -= ( face->NbNodes()/2 - 1 );
+ i0 *= 2;
+ }
+ }
+ int diff = i1 - i0;
+ return ( diff == 1 ) || ( diff == -face->NbNodes()+1 );
+}
//=======================================================================
/*!
* \brief Find out if the given point is out of closed 2D mesh.
*/
virtual TopAbs_State GetPointState(const gp_Pnt& point) = 0;
+
+ /*!
+ * \brief Return a projection of a given point to a 2D mesh.
+ * Optionally return the closest face
+ */
+ virtual gp_XYZ Project(const gp_Pnt& point,
+ SMDSAbs_ElementType type,
+ const SMDS_MeshElement** closestFace= 0) = 0;
+
virtual ~SMESH_ElementSearcher();
};
bool IsOut( const SMDS_MeshElement* element, const gp_Pnt& point, double tol );
SMESHUtils_EXPORT
- double GetDistance( const SMDS_MeshElement* elem, const gp_Pnt& point );
+ double GetDistance( const SMDS_MeshElement* elem, const gp_Pnt& point, gp_XYZ* closestPnt = 0 );
SMESHUtils_EXPORT
- double GetDistance( const SMDS_MeshEdge* edge, const gp_Pnt& point );
+ double GetDistance( const SMDS_MeshEdge* edge, const gp_Pnt& point, gp_XYZ* closestPnt = 0 );
SMESHUtils_EXPORT
- double GetDistance( const SMDS_MeshFace* face, const gp_Pnt& point );
+ double GetDistance( const SMDS_MeshFace* face, const gp_Pnt& point, gp_XYZ* closestPnt = 0 );
SMESHUtils_EXPORT
- double GetDistance( const SMDS_MeshVolume* volume, const gp_Pnt& point );
+ double GetDistance( const SMDS_MeshVolume* volume, const gp_Pnt& point, gp_XYZ* closestPnt = 0 );
SMESHUtils_EXPORT
void GetBarycentricCoords( const gp_XY& point,
SMESHUtils_EXPORT
std::vector< const SMDS_MeshNode*> GetCommonNodes(const SMDS_MeshElement* e1,
const SMDS_MeshElement* e2);
+ /*!
+ * \brief Return true if node1 encounters first in the face and node2, after.
+ * The nodes are supposed to be neighbor nodes in the face.
+ */
+ SMESHUtils_EXPORT
+ bool IsRightOrder( const SMDS_MeshElement* face,
+ const SMDS_MeshNode* node0,
+ const SMDS_MeshNode* node1 );
/*!
* \brief Mark elements given by SMDS_Iterator
}
/*!
- * \brief Return SMESH_NodeSearcher. The caller is responsible for deleteing it
+ * \brief Return SMESH_NodeSearcher. The caller is responsible for deleting it
*/
SMESHUtils_EXPORT
SMESH_NodeSearcher* GetNodeSearcher( SMDS_Mesh& mesh );
void FindCoincidentFreeBorders(SMDS_Mesh& mesh,
double tolerance,
CoincidentFreeBorders & foundFreeBordes);
-
+ /*!
+ * Returns all or only closed TFreeBorder's.
+ * Optionally check if the mesh is manifold and if faces are correctly oriented.
+ *
+ * (Implemented in ./SMESH_FreeBorders.cxx)
+ */
+ SMESHUtils_EXPORT
+ void FindFreeBorders(SMDS_Mesh& mesh,
+ TFreeBorderVec & foundFreeBordes,
+ const bool closedOnly,
+ bool* isManifold = 0,
+ bool* isGoodOri = 0);
+ /*!
+ * Fill a hole defined by a TFreeBorder with 2D elements.
+ *
+ * (Implemented in ./SMESH_FillHole.cxx)
+ */
+ SMESHUtils_EXPORT
+ void FillHole(const TFreeBorder & freeBorder,
+ SMDS_Mesh& mesh,
+ std::vector<const SMDS_MeshElement*>& newFaces);
+
/*!
* \brief Find nodes whose merge makes the element invalid
{
MESSAGE( txt << " " << __FILE__ << ": " << __LINE__ );
}
+
+const char* SMESH::returnError(const char* txt)
+{
+ return txt;
+}
+
// ------------------------------------------------------------------
#include "SMESH_ComputeError.hxx"
{
SMESHUtils_EXPORT void throwSalomeEx(const char* txt);
SMESHUtils_EXPORT void doNothing(const char* txt);
+ SMESHUtils_EXPORT const char* returnError(const char* txt);
}
#endif
//------------------------------------------
/*!
- * \brief SMDS_MeshNode -> gp_XYZ convertor
+ * \brief SMDS_MeshNode -> gp_XYZ converter
*/
//------------------------------------------
struct SMESH_TNodeXYZ : public gp_XYZ
{
const SMDS_MeshNode* _node;
- double _xyz[3];
SMESH_TNodeXYZ( const SMDS_MeshElement* e=0):gp_XYZ(0,0,0),_node(0)
{
Set(e);
if (e) {
assert( e->GetType() == SMDSAbs_Node );
_node = static_cast<const SMDS_MeshNode*>(e);
- _node->GetXYZ(_xyz); // - thread safe getting coords
- SetCoord( _xyz[0], _xyz[1], _xyz[2] );
+ _node->GetXYZ( ChangeData() ); // - thread safe getting coords
return true;
}
return false;
}
double Distance(const SMDS_MeshNode* n) const { return (SMESH_TNodeXYZ( n )-*this).Modulus(); }
double SquareDistance(const SMDS_MeshNode* n) const { return (SMESH_TNodeXYZ( n )-*this).SquareModulus(); }
- bool operator==(const SMESH_TNodeXYZ& other) const { return _node == other._node; }
+ bool operator==(const SMESH_TNodeXYZ& other) const { return _node == other._node; }
};
typedef SMESH_TNodeXYZ SMESH_NodeXYZ;
/*!
* \brief Container of commands into which the initial script is split.
- * It also contains data coresponding to SMESH_Gen contents
+ * It also contains data corresponding to SMESH_Gen contents
*/
static Handle(_pyGen) theGen;
// - FT_BelongToMeshGroup = 22
// v 8.1.0: FT_Undefined == 48, new items:
// - FT_NodeConnectivityNumber= 22
+ // v 8.5.0: FT_Undefined == 49, new items:
+ // - FT_Deflection2D = 22
//
// It's necessary to continue recording this history and to fill
// undef2newItems (see below) accordingly.
undef2newItems[ 46 ].push_back( 39 );
undef2newItems[ 47 ].push_back( 22 );
undef2newItems[ 48 ].push_back( 22 );
+ undef2newItems[ 49 ].push_back( 22 );
ASSERT( undef2newItems.rbegin()->first == SMESH::FT_Undefined );
}
MESSAGE_BEGIN ( std::endl << " ######## RESULT ######## " << std::endl<< std::endl );
#endif
- // clean commmands of removed objects depending on myIsPublished flag
+ // clean commands of removed objects depending on myIsPublished flag
theGen->ClearCommands();
// reorder commands after conversion
//================================================================================
/*!
* \brief Convert a command using a specific converter
- * \param theCommand - the command to convert
+ * \param theCommand - the command to convert
*/
//================================================================================
aCommand->GetString() += tmpCmd.GetString();
}
// IMP issue 0021014
- // set GetCriterion(elementType,CritType,Compare,Treshold,UnaryOp,BinaryOp,Tolerance)
- // 1 2 3 4 5 6 7
+ // set GetCriterion(elementType,CritType,Compare,Threshold,UnaryOp,BinaryOp,Tolerance)
+ // 1 2 3 4 5 6 7
// instead of "SMESH.Filter.Criterion(
// Type,Compare,Threshold,ThresholdStr,ThresholdID,UnaryOp,BinaryOp,Tolerance,TypeOfElement,Precision)
// 1 2 3 4 5 6 7 8 9 10
//================================================================================
/*!
* \brief Convert the command or remember it for later conversion
- * \param theCommand - The python command calling a method of SMESH_Gen
+ * \param theCommand - The python command calling a method of SMESH_Gen
*/
//================================================================================
//================================================================================
/*!
- * \brief Clean commmands of removed objects depending on myIsPublished flag
+ * \brief Clean commands of removed objects depending on myIsPublished flag
*/
//================================================================================
//================================================================================
/*!
* \brief Add access method to mesh that is an argument
- * \param theCmd - command to add access method
- * \retval bool - true if added
+ * \param theCmd - command to add access method
+ * \retval bool - true if added
*/
//================================================================================
//================================================================================
/*!
* \brief Add access method to algo that is an object or an argument
- * \param theCmd - command to add access method
- * \retval bool - true if added
+ * \param theCmd - command to add access method
+ * \retval bool - true if added
*/
//================================================================================
//================================================================================
/*!
* \brief Find hypothesis by ID (entry)
- * \param theHypID - The hypothesis ID
- * \retval Handle(_pyHypothesis) - The found hypothesis
+ * \param theHypID - The hypothesis ID
+ * \retval Handle(_pyHypothesis) - The found hypothesis
*/
//================================================================================
//================================================================================
/*!
* \brief Find algorithm able to create a hypothesis
- * \param theGeom - The shape ID the algorithm was created on
- * \param theMesh - The mesh ID that created the algorithm
- * \param theHypothesis - The hypothesis the algorithm should be able to create
- * \retval Handle(_pyHypothesis) - The found algo
+ * \param theGeom - The shape ID the algorithm was created on
+ * \param theMesh - The mesh ID that created the algorithm
+ * \param theHypothesis - The hypothesis the algorithm should be able to create
+ * \retval Handle(_pyHypothesis) - The found algo
*/
//================================================================================
//================================================================================
/*!
* \brief Find subMesh by ID (entry)
- * \param theSubMeshID - The subMesh ID
- * \retval Handle(_pySubMesh) - The found subMesh
+ * \param theSubMeshID - The subMesh ID
+ * \retval Handle(_pySubMesh) - The found subMesh
*/
//================================================================================
//================================================================================
/*!
* \brief Change order of commands in the script
- * \param theCmd1 - One command
- * \param theCmd2 - Another command
+ * \param theCmd1 - One command
+ * \param theCmd2 - Another command
*/
//================================================================================
int nb1 = theCmd1->GetOrderNb();
theCmd1->SetOrderNb( theCmd2->GetOrderNb() );
theCmd2->SetOrderNb( nb1 );
-// cout << "BECOME " << theCmd1->GetOrderNb() << "\t" << theCmd1->GetString() << endl
-// << "BECOME " << theCmd2->GetOrderNb() << "\t" << theCmd2->GetString() << endl << endl;
+ // cout << "BECOME " << theCmd1->GetOrderNb() << "\t" << theCmd1->GetString() << endl
+ // << "BECOME " << theCmd2->GetOrderNb() << "\t" << theCmd2->GetString() << endl << endl;
}
//================================================================================
/*!
* \brief Set one command after the other
- * \param theCmd - Command to move
- * \param theAfterCmd - Command ater which to insert the first one
+ * \param theCmd - Command to move
+ * \param theAfterCmd - Command ater which to insert the first one
*/
//================================================================================
//================================================================================
/*!
* \brief Set one command before the other
- * \param theCmd - Command to move
- * \param theBeforeCmd - Command before which to insert the first one
+ * \param theCmd - Command to move
+ * \param theBeforeCmd - Command before which to insert the first one
*/
//================================================================================
//================================================================================
/*!
* \brief Set one command before or after the other
- * \param theCmd - Command to move
- * \param theOtherCmd - Command ater or before which to insert the first one
+ * \param theCmd - Command to move
+ * \param theOtherCmd - Command ater or before which to insert the first one
*/
//================================================================================
// void _pyGen::addFilterUser( Handle(_pyCommand)& theCommand, const Handle(_pyObject)& user )
// {
- // No more needed after adding _pyObject::myArgCommands
+// No more needed after adding _pyObject::myArgCommands
// const char filterPrefix[] = "aFilter0x";
// if ( theCommand->GetString().Search( filterPrefix ) < 1 )
//================================================================================
/*!
* \brief Set command be last in list of commands
- * \param theCmd - Command to be last
+ * \param theCmd - Command to be last
*/
//================================================================================
//================================================================================
/*!
* \brief Set method to access to object wrapped with python class
- * \param theID - The wrapped object entry
- * \param theMethod - The accessor method
+ * \param theID - The wrapped object entry
+ * \param theMethod - The accessor method
*/
//================================================================================
//================================================================================
/*!
* \brief Generated new ID for object and assign with existing name
- * \param theID - ID of existing object
+ * \param theID - ID of existing object
*/
//================================================================================
}
else if ( theObj->IsKind( STANDARD_TYPE( _pyMeshEditor ))) {
add = myMeshEditors.insert( make_pair( theObj->GetID(),
- Handle(_pyMeshEditor)::DownCast( theObj ))).second;
+ Handle(_pyMeshEditor)::DownCast( theObj ))).second;
}
else {
add = myObjects.insert( make_pair( theObj->GetID(), theObj )).second;
//================================================================================
/*!
* \brief Convert an IDL API command of SMESH::SMESH_Mesh to a method call of python Mesh
- * \param theCommand - Engine method called for this mesh
+ * \param theCommand - Engine method called for this mesh
*/
//================================================================================
"ExtrusionAlongPathX","ExtrusionAlongPathObject1D","ExtrusionAlongPathObject2D",
"ExtrusionSweepObjects","RotationSweepObjects","ExtrusionAlongPathObjects",
"Mirror","MirrorObject","Translate","TranslateObject","Rotate","RotateObject",
- "FindCoincidentNodes","MergeNodes","FindEqualElements",
+ "FindCoincidentNodes","MergeNodes","FindEqualElements","FillHole",
"MergeElements","MergeEqualElements","SewFreeBorders","SewConformFreeBorders",
"FindCoincidentFreeBorders", "SewCoincidentFreeBorders",
"SewBorderToSide","SewSideElements","ChangeElemNodes","GetLastCreatedNodes",
//================================================================================
/*!
* \brief _pyHypothesis constructor
- * \param theCreationCmd -
+ * \param theCreationCmd -
*/
//================================================================================
//================================================================================
/*!
* \brief Creates algorithm or hypothesis
- * \param theCreationCmd - The engine command creating a hypothesis
- * \retval Handle(_pyHypothesis) - Result _pyHypothesis
+ * \param theCreationCmd - The engine command creating a hypothesis
+ * \retval Handle(_pyHypothesis) - Result _pyHypothesis
*/
//================================================================================
//================================================================================
/*!
* \brief Convert the command adding a hypothesis to mesh into a smesh command
- * \param theCmd - The command like mesh.AddHypothesis( geom, hypo )
- * \param theAlgo - The algo that can create this hypo
- * \retval bool - false if the command can't be converted
+ * \param theCmd - The command like mesh.AddHypothesis( geom, hypo )
+ * \param theAlgo - The algo that can create this hypo
+ * \retval bool - false if the command can't be converted
*/
//================================================================================
//================================================================================
/*!
* \brief Remember hypothesis parameter values
- * \param theCommand - The called hypothesis method
+ * \param theCommand - The called hypothesis method
*/
//================================================================================
//================================================================================
/*!
* \brief Remember hypothesis parameter values
- * \param theCommand - The called hypothesis method
+ * \param theCommand - The called hypothesis method
*/
//================================================================================
{
CreationMethod& crMethod = type2meth->second;
while ( (int) crMethod.myArgs.size() < i+1 )
- crMethod.myArgs.push_back( "[]" );
- crMethod.myArgs[ i ] = theCommand->GetArg( 1 ); // arg value
+ crMethod.myArgs.push_back( "[]" );
+ crMethod.myArgs[ i ] = theCommand->GetArg( 1 ); // arg value
}
myArgCommands.push_back( theCommand );
}
//================================================================================
/*!
* \brief Convert methods of 1D hypotheses to my own methods
- * \param theCommand - The called hypothesis method
+ * \param theCommand - The called hypothesis method
*/
//================================================================================
//================================================================================
/*!
* \brief
- * \param theAdditionCmd - command to be converted
- * \param theMesh - mesh instance
- * \retval bool - status
+ * \param theAdditionCmd - command to be converted
+ * \param theMesh - mesh instance
+ * \retval bool - status
*/
//================================================================================
//================================================================================
/*!
* \brief additionally to Addition2Creation, clears SetDistrType() command
- * \param theCmd - AddHypothesis() command
- * \param theMesh - mesh to which a hypothesis is added
- * \retval bool - conversion result
+ * \param theCmd - AddHypothesis() command
+ * \param theMesh - mesh to which a hypothesis is added
+ * \retval bool - conversion result
*/
//================================================================================
/*!
* \brief Convert the command adding "SegmentLengthAroundVertex" to mesh
* into regular1D.LengthNearVertex( length, vertex )
- * \param theCmd - The command like mesh.AddHypothesis( vertex, SegmentLengthAroundVertex )
- * \param theMesh - The mesh needing this hypo
- * \retval bool - false if the command can't be converted
+ * \param theCmd - The command like mesh.AddHypothesis( vertex, SegmentLengthAroundVertex )
+ * \param theMesh - The mesh needing this hypo
+ * \retval bool - false if the command can't be converted
*/
//================================================================================
//================================================================================
/*!
* \brief _pyAlgorithm constructor
- * \param theCreationCmd - The command like "algo = smeshgen.CreateHypothesis(type,lib)"
+ * \param theCreationCmd - The command like "algo = smeshgen.CreateHypothesis(type,lib)"
*/
//================================================================================
//================================================================================
/*!
* \brief Convert the command adding an algorithm to mesh
- * \param theCmd - The command like mesh.AddHypothesis( geom, algo )
- * \param theMesh - The mesh needing this algo
- * \retval bool - false if the command can't be converted
+ * \param theCmd - The command like mesh.AddHypothesis( geom, algo )
+ * \param theMesh - The mesh needing this algo
+ * \retval bool - false if the command can't be converted
*/
//================================================================================
//================================================================================
/*!
* \brief Return starting position of a part of python command
- * \param thePartIndex - The index of command part
- * \retval int - Part position
+ * \param thePartIndex - The index of command part
+ * \retval int - Part position
*/
//================================================================================
//================================================================================
/*!
* \brief Store starting position of a part of python command
- * \param thePartIndex - The index of command part
- * \param thePosition - Part position
+ * \param thePartIndex - The index of command part
+ * \param thePosition - Part position
*/
//================================================================================
//================================================================================
/*!
* \brief Returns whitespace symbols at the line beginning
- * \retval TCollection_AsciiString - result
+ * \retval TCollection_AsciiString - result
*/
//================================================================================
//================================================================================
/*!
* \brief Return substring of python command looking like ResultValue = Obj.Meth()
- * \retval const TCollection_AsciiString & - ResultValue substring
+ * \retval const TCollection_AsciiString & - ResultValue substring
*/
//================================================================================
//================================================================================
/*!
* \brief Return substring of python command looking like ResVal = Obj.Method()
- * \retval const TCollection_AsciiString & - Method substring
+ * \retval const TCollection_AsciiString & - Method substring
*/
//================================================================================
//================================================================================
/*!
* \brief Return substring of python command looking like ResVal = Obj.Meth(Arg1,...)
- * \retval const TCollection_AsciiString & - Arg<index> substring
+ * \retval const TCollection_AsciiString & - Arg<index> substring
*/
//================================================================================
//================================================================================
/*!
* \brief Check if char is a word part
- * \param c - The character to check
- * \retval bool - The check result
+ * \param c - The character to check
+ * \retval bool - The check result
*/
//================================================================================
//================================================================================
/*!
* \brief Looks for a word in the string and returns word's beginning
- * \param theString - The input string
- * \param theStartPos - The position to start the search, returning word's beginning
- * \param theForward - The search direction
- * \retval TCollection_AsciiString - The found word
+ * \param theString - The input string
+ * \param theStartPos - The position to start the search, returning word's beginning
+ * \param theForward - The search direction
+ * \retval TCollection_AsciiString - The found word
*/
//================================================================================
//================================================================================
/*!
* \brief Look for position where not space char is
- * \param theString - The string
- * \param thePos - The position to search from and which returns result
- * \retval bool - false if there are only space after thePos in theString
+ * \param theString - The string
+ * \param thePos - The position to search from and which returns result
+ * \retval bool - false if there are only space after thePos in theString
*/
//================================================================================
//================================================================================
/*!
* \brief Modify a part of the command
- * \param thePartIndex - The index of the part
- * \param thePart - The new part string
- * \param theOldPart - The old part
+ * \param thePartIndex - The index of the part
+ * \param thePart - The new part string
+ * \param theOldPart - The old part
*/
//================================================================================
void _pyCommand::SetPart(int thePartIndex, const TCollection_AsciiString& thePart,
- TCollection_AsciiString& theOldPart)
+ TCollection_AsciiString& theOldPart)
{
int pos = GetBegPos( thePartIndex );
if ( pos <= Length() && theOldPart != thePart)
//================================================================================
/*!
- * \brief Set agrument
- * \param index - The argument index, it counts from 1
- * \param theArg - The argument string
+ * \brief Set argument
+ * \param index - The argument index, it counts from 1
+ * \param theArg - The argument string
*/
//================================================================================
//================================================================================
/*!
* \brief Insert accessor method after theObjectID
- * \param theObjectID - id of the accessed object
- * \param theAcsMethod - name of the method giving access to the object
- * \retval bool - false if theObjectID is not found in the command string
+ * \param theObjectID - id of the accessed object
+ * \param theAcsMethod - name of the method giving access to the object
+ * \retval bool - false if theObjectID is not found in the command string
*/
//================================================================================
//================================================================================
/*!
* \brief Return method name giving access to an interaface object wrapped by python class
- * \retval const char* - method name
+ * \retval const char* - method name
*/
//================================================================================
bool _pySubMesh::CanBeArgOfMethod(const _AString& theMethodName)
{
return false;
-// // names of all methods where a sub-mesh can be used as argument
-// static TStringSet methods;
-// if ( methods.empty() ) {
-// const char * names[] = {
-// // methods of SMESH_Gen
-// "CopyMesh",
-// // methods of SMESH_Group
-// "AddFrom",
-// // methods of SMESH_Measurements
-// "MinDistance",
-// // methods of SMESH_Mesh
-// "ExportPartToMED","ExportCGNS","ExportPartToDAT","ExportPartToUNV","ExportPartToSTL",
-// "RemoveSubMesh",
-// // methods of SMESH_MeshEditor
-// "ReorientObject","Reorient2D","TriToQuadObject","QuadToTriObject","SplitQuadObject",
-// "SplitVolumesIntoTetra","SmoothObject","SmoothParametricObject","ConvertFromQuadraticObject",
-// "RotationSweepObject","RotationSweepObjectMakeGroups","RotationSweepObject1D",
-// "RotationSweepObject1DMakeGroups","RotationSweepObject2D","RotationSweepObject2DMakeGroups",
-// "ExtrusionSweepObject","ExtrusionSweepObjectMakeGroups","ExtrusionSweepObject0D",
-// "ExtrusionSweepObject0DMakeGroups","ExtrusionSweepObject1D","ExtrusionSweepObject2D",
-// "ExtrusionSweepObject1DMakeGroups","ExtrusionSweepObject2DMakeGroups",
-// "ExtrusionAlongPathObjX","ExtrusionAlongPathObject","ExtrusionAlongPathObjectMakeGroups",
-// "ExtrusionAlongPathObject1D","ExtrusionAlongPathObject1DMakeGroups",
-// "ExtrusionAlongPathObject2D","ExtrusionAlongPathObject2DMakeGroups","MirrorObject",
-// "MirrorObjectMakeGroups","MirrorObjectMakeMesh","TranslateObject","Scale",
-// "TranslateObjectMakeGroups","TranslateObjectMakeMesh","ScaleMakeGroups","ScaleMakeMesh",
-// "RotateObject","RotateObjectMakeGroups","RotateObjectMakeMesh","FindCoincidentNodesOnPart",
-// "FindCoincidentNodesOnPartBut","FindEqualElements","FindAmongElementsByPoint",
-// "MakeBoundaryMesh","Create0DElementsOnAllNodes",
-// "" }; // <- mark of end
-// methods.Insert( names );
-// }
-// return methods.Contains( theMethodName );
+ // names of all methods where a sub-mesh can be used as argument
+ // static TStringSet methods;
+ // if ( methods.empty() ) {
+ // const char * names[] = {
+ // // methods of SMESH_Gen
+ // "CopyMesh",
+ // // methods of SMESH_Group
+ // "AddFrom",
+ // // methods of SMESH_Measurements
+ // "MinDistance",
+ // // methods of SMESH_Mesh
+ // "ExportPartToMED","ExportCGNS","ExportPartToDAT","ExportPartToUNV","ExportPartToSTL",
+ // "RemoveSubMesh",
+ // // methods of SMESH_MeshEditor
+ // "ReorientObject","Reorient2D","TriToQuadObject","QuadToTriObject","SplitQuadObject",
+ // "SplitVolumesIntoTetra","SmoothObject","SmoothParametricObject","ConvertFromQuadraticObject",
+ // "RotationSweepObject","RotationSweepObjectMakeGroups","RotationSweepObject1D",
+ // "RotationSweepObject1DMakeGroups","RotationSweepObject2D","RotationSweepObject2DMakeGroups",
+ // "ExtrusionSweepObject","ExtrusionSweepObjectMakeGroups","ExtrusionSweepObject0D",
+ // "ExtrusionSweepObject0DMakeGroups","ExtrusionSweepObject1D","ExtrusionSweepObject2D",
+ // "ExtrusionSweepObject1DMakeGroups","ExtrusionSweepObject2DMakeGroups",
+ // "ExtrusionAlongPathObjX","ExtrusionAlongPathObject","ExtrusionAlongPathObjectMakeGroups",
+ // "ExtrusionAlongPathObject1D","ExtrusionAlongPathObject1DMakeGroups",
+ // "ExtrusionAlongPathObject2D","ExtrusionAlongPathObject2DMakeGroups","MirrorObject",
+ // "MirrorObjectMakeGroups","MirrorObjectMakeMesh","TranslateObject","Scale",
+ // "TranslateObjectMakeGroups","TranslateObjectMakeMesh","ScaleMakeGroups","ScaleMakeMesh",
+ // "RotateObject","RotateObjectMakeGroups","RotateObjectMakeMesh","FindCoincidentNodesOnPart",
+ // "FindCoincidentNodesOnPartBut","FindEqualElements","FindAmongElementsByPoint",
+ // "MakeBoundaryMesh","Create0DElementsOnAllNodes",
+ // "" }; // <- mark of end
+ // methods.Insert( names );
+ // }
+ // return methods.Contains( theMethodName );
}
//================================================================================
//}
//else {
// ------------------------->>>>> GroupOnGeom( geom, name, typ )
- _pyID type = theCreationCmd->GetArg( 1 );
- _pyID name = theCreationCmd->GetArg( 2 );
- theCreationCmd->SetMethod( "GroupOnGeom" );
- theCreationCmd->RemoveArgs();
- theCreationCmd->SetArg( 1, geom );
- theCreationCmd->SetArg( 2, name );
- theCreationCmd->SetArg( 3, type );
+ _pyID type = theCreationCmd->GetArg( 1 );
+ _pyID name = theCreationCmd->GetArg( 2 );
+ theCreationCmd->SetMethod( "GroupOnGeom" );
+ theCreationCmd->RemoveArgs();
+ theCreationCmd->SetArg( 1, geom );
+ theCreationCmd->SetArg( 2, name );
+ theCreationCmd->SetArg( 3, type );
//}
}
else if ( method == "CreateGroupFromFilter" )
virtual void Flush() {}
virtual bool CanClear();
- DEFINE_STANDARD_RTTIEXT(_pyMesh,_pyObject)
+ DEFINE_STANDARD_RTTIEXT(_pyMeshEditor,_pyObject)
};
// -------------------------------------------------------------------------------------
case FT_MultiConnection2D: myStream<< "aMultiConnection2D"; break;
case FT_Length: myStream<< "aLength"; break;
case FT_Length2D: myStream<< "aLength2D"; break;
+ case FT_Deflection2D: myStream<< "aDeflection2D"; break;
case FT_NodeConnectivityNumber:myStream<< "aNodeConnectivityNumber";break;
case FT_BelongToMeshGroup: myStream<< "aBelongToMeshGroup"; break;
case FT_BelongToGeom: myStream<< "aBelongToGeom"; break;
{
// find the function name
int functBeg = posAlready;
- char* script = (char*) anUpdatedScript.ToCString() + posAlready - 1; // look at ":" after "def fuction()"
+ char* script = (char*) anUpdatedScript.ToCString() + posAlready - 1; // look at ":" after "def function()"
while ( *script != ' ' ) {
script--;
functBeg--;
/*
Class : Functor_i
- Description : An abstact class for all functors
+ Description : An abstract class for all functors
*/
Functor_i::Functor_i():
SALOME::GenericObj_i( SMESH_Gen_i::GetPOA() )
return aResult._retn();
}
+/*
+ Class : Deflection2D_i
+ Description : Functor for calculating distance between a face and geometry
+*/
+Deflection2D_i::Deflection2D_i()
+{
+ myNumericalFunctorPtr.reset( new Controls::Deflection2D() );
+ myFunctorPtr = myNumericalFunctorPtr;
+}
+
+FunctorType Deflection2D_i::GetFunctorType()
+{
+ return SMESH::FT_Deflection2D;
+}
+
/*
Class : MultiConnection_i
Description : Functor for calculating number of faces conneted to the edge
return anObj._retn();
}
+Deflection2D_ptr FilterManager_i::CreateDeflection2D()
+{
+ SMESH::Deflection2D_i* aServant = new SMESH::Deflection2D_i();
+ SMESH::Deflection2D_var anObj = aServant->_this();
+ TPythonDump()<<aServant<<" = "<<this<<".CreateLength2D()";
+ return anObj._retn();
+}
+
MultiConnection_ptr FilterManager_i::CreateMultiConnection()
{
SMESH::MultiConnection_i* aServant = new SMESH::MultiConnection_i();
case SMESH::FT_Length2D:
aFunctor = aFilterMgr->CreateLength2D();
break;
+ case SMESH::FT_Deflection2D:
+ aFunctor = aFilterMgr->CreateDeflection2D();
+ break;
case SMESH::FT_AspectRatio:
aFunctor = aFilterMgr->CreateAspectRatio();
break;
case FT_EqualFaces : return "Equal faces";
case FT_EqualVolumes : return "Equal volumes";
case FT_MultiConnection : return "Borders at multi-connections";
- case FT_MultiConnection2D :return "Borders at multi-connections 2D";
+ case FT_MultiConnection2D : return "Borders at multi-connections 2D";
case FT_Length : return "Length";
case FT_Length2D : return "Length 2D";
+ case FT_Deflection2D : return "Deflection 2D";
case FT_LessThan : return "Less than";
case FT_MoreThan : return "More than";
case FT_EqualTo : return "Equal to";
case FT_LogicalOR : return "Or";
case FT_GroupColor : return "Color of Group";
case FT_LinearOrQuadratic : return "Linear or Quadratic";
- case FT_ElemGeomType : return "Element geomtry type";
+ case FT_ElemGeomType : return "Element geometry type";
case FT_EntityType : return "Entity type";
case FT_Undefined : return "";
default : return "";
// else if ( theStr.equals( "Borders at multi-connections 2D" ) ) return FT_MultiConnection2D;
else if ( theStr.equals( "Length" ) ) return FT_Length;
// else if ( theStr.equals( "Length2D" ) ) return FT_Length2D;
+ else if ( theStr.equals( "Deflection" ) ) return FT_Deflection2D;
else if ( theStr.equals( "Range of IDs" ) ) return FT_RangeOfIds;
else if ( theStr.equals( "Bad Oriented Volume" ) ) return FT_BadOrientedVolume;
else if ( theStr.equals( "Volumes with bare border" ) ) return FT_BareBorderVolume;
else if ( theStr.equals( "Or" ) ) return FT_LogicalOR;
else if ( theStr.equals( "Color of Group" ) ) return FT_GroupColor;
else if ( theStr.equals( "Linear or Quadratic" ) ) return FT_LinearOrQuadratic;
- else if ( theStr.equals( "Element geomtry type" ) ) return FT_ElemGeomType;
+ else if ( theStr.equals( "Element geometry type" ) ) return FT_ElemGeomType;
else if ( theStr.equals( "Entity type" ) ) return FT_EntityType;
else if ( theStr.equals( "" ) ) return FT_Undefined;
else return FT_Undefined;
"FT_MultiConnection2D",
"FT_Length",
"FT_Length2D",
+ "FT_Deflection2D",
"FT_NodeConnectivityNumber",
"FT_BelongToMeshGroup",
"FT_BelongToGeom",
"FT_LinearOrQuadratic",
"FT_GroupColor",
"FT_ElemGeomType",
- "FT_EntityType",
+ "FT_EntityType",
"FT_CoplanarFaces",
"FT_BallDiameter",
"FT_ConnectedElements",
/*
Class : Functor_i
- Description : An abstact class for all functors
+ Description : An abstract class for all functors
*/
class SMESH_I_EXPORT Functor_i: public virtual POA_SMESH::Functor,
public virtual SALOME::GenericObj_i
Length2D_i();
SMESH::Length2D::Values* GetValues();
FunctorType GetFunctorType();
-
+
protected:
Controls::Length2DPtr myLength2DPtr;
};
-
+
+ /*
+ Class : Deflection2D_i
+ Description : Functor for calculating distance between a face and geometry
+ */
+ class SMESH_I_EXPORT Deflection2D_i: public virtual POA_SMESH::Deflection2D,
+ public virtual NumericalFunctor_i
+ {
+ public:
+ Deflection2D_i();
+ FunctorType GetFunctorType();
+ };
+
/*
Class : MultiConnection_i
Description : Functor for calculating number of faces conneted to the edge
MaxElementLength3D_ptr CreateMaxElementLength3D();
Length_ptr CreateLength();
Length2D_ptr CreateLength2D();
+ Deflection2D_ptr CreateDeflection2D();
NodeConnectivityNumber_ptr CreateNodeConnectivityNumber();
MultiConnection_ptr CreateMultiConnection();
MultiConnection2D_ptr CreateMultiConnection2D();
// Author : Paul RASCLE, EDF
// Module : SMESH
+#include <BRepPrimAPI_MakeBox.hxx>
+#include <BRepPrimAPI_MakeCylinder.hxx>
+#include <BRepPrimAPI_MakeSphere.hxx>
+#include <BRep_Tool.hxx>
+#include <OSD.hxx>
+#include <TColStd_MapOfAsciiString.hxx>
+#include <TCollection_AsciiString.hxx>
#include <TopExp.hxx>
#include <TopExp_Explorer.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_MapOfShape.hxx>
#include <TopoDS.hxx>
-#include <TopoDS_Iterator.hxx>
-#include <TopoDS_Compound.hxx>
#include <TopoDS_CompSolid.hxx>
-#include <TopoDS_Solid.hxx>
-#include <TopoDS_Shell.hxx>
-#include <TopoDS_Face.hxx>
-#include <TopoDS_Wire.hxx>
+#include <TopoDS_Compound.hxx>
#include <TopoDS_Edge.hxx>
-#include <TopoDS_Vertex.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
-#include <TopTools_MapOfShape.hxx>
-#include <TopTools_IndexedMapOfShape.hxx>
-#include <TopTools_ListOfShape.hxx>
-#include <TopTools_ListIteratorOfListOfShape.hxx>
+#include <TopoDS_Shell.hxx>
+#include <TopoDS_Solid.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <TopoDS_Wire.hxx>
#include <gp_Pnt.hxx>
-#include <BRep_Tool.hxx>
-#include <TCollection_AsciiString.hxx>
-#include <OSD.hxx>
-#include <BRepPrimAPI_MakeSphere.hxx>
-#include <BRepPrimAPI_MakeCylinder.hxx>
-#include <BRepPrimAPI_MakeBox.hxx>
#ifdef WIN32
throw (SALOME::SALOME_Exception)
{
std::string aPlatformLibName;
- /* It's Need to tranlate lib name for WIN32 or X platform */
+ /* It's Need to translate lib name for WIN32 or X platform */
if ( theLibName && theLibName[0] != '\0' )
{
int libNameLen = strlen(theLibName);
//================================================================================
/*!
- * \brief Returns errors of hypotheses definintion
+ * \brief Returns errors of hypotheses definition
* \param theMesh - the mesh
* \param theSubObject - the main or sub- shape
* \retval SMESH::algo_error_array* - sequence of errors
// "Face V positions" - V parameter of node on face
// Find out nb of nodes on edges and faces
- // Collect corresponing sub-meshes
+ // Collect corresponding sub-meshes
int nbEdgeNodes = 0, nbFaceNodes = 0;
list<SMESHDS_SubMesh*> aEdgeSM, aFaceSM;
// loop on SMESHDS_SubMesh'es
if ( aTopGroup->ExistInternalObject( name_group ) ) {
aGroup = new HDFgroup( name_group, aTopGroup );
aGroup->OpenOnDisk();
- // get number of groups
- int aNbSubObjects = aGroup->nInternalObjects();
- for ( int j = 0; j < aNbSubObjects; j++ ) {
- char name_dataset[ HDF_NAME_MAX_LEN+1 ];
- aGroup->InternalObjectIndentify( j, name_dataset );
- // check if it is an group
- if ( string( name_dataset ).substr( 0, 5 ) == string( "Group" ) ) {
+ // PAL23514: get all names from the HDFgroup to avoid iteration on its contents
+ // within aGroup->ExistInternalObject( name )
+ std::vector< std::string > subNames;
+ TColStd_MapOfAsciiString mapOfNames;
+ aGroup->GetAllObjects( subNames );
+ for ( size_t iN = 0; iN < subNames.size(); ++iN )
+ mapOfNames.Add( subNames[ iN ].c_str() );
+ // loop on groups
+ for ( size_t j = 0; j < subNames.size(); j++ ) {
+ const std::string& name_dataset = subNames[ j ];
+ // check if it is a group
+ if ( name_dataset.substr( 0, 5 ) == "Group" ) {
// --> get group id
- int subid = atoi( string( name_dataset ).substr( 5 ).c_str() );
+ int subid = atoi( name_dataset.substr( 5 ).c_str() );
if ( subid <= 0 )
continue;
- aDataset = new HDFdataset( name_dataset, aGroup );
+ aDataset = new HDFdataset( name_dataset.c_str(), aGroup );
aDataset->OpenOnDisk();
// Retrieve actual group name
TopoDS_Shape aShape;
char aRefName[ 30 ];
sprintf( aRefName, "Ref on shape %d", subid);
- if ( aGroup->ExistInternalObject( aRefName ) ) {
+ if ( mapOfNames.Contains( aRefName ))
+ {
// load mesh "Ref on shape" - it's an entry to SObject
aDataset = new HDFdataset( aRefName, aGroup );
aDataset->OpenOnDisk();
// Try to read a filter of SMESH_GroupOnFilter
SMESH::Filter_var filter;
SMESH_PredicatePtr predicate;
- std::string hdfGrpName = "Filter " + SMESH_Comment(subid);
- if ( aGroup->ExistInternalObject( hdfGrpName.c_str() ))
+ std::string hdfGrpName = ( SMESH_Comment( "Filter ") << subid );
+ if ( mapOfNames.Contains( hdfGrpName.c_str() ))
{
aDataset = new HDFdataset( hdfGrpName.c_str(), aGroup );
aDataset->OpenOnDisk();
if ( !aGroupBaseDS )
continue;
- aGroupBaseDS->SetStoreName( name_dataset );
+ aGroupBaseDS->SetStoreName( name_dataset.c_str() );
// ouv : NPAL12872
// Read color of the group
char aGroupColorName[ 30 ];
sprintf( aGroupColorName, "ColorGroup %d", subid);
- if ( aGroup->ExistInternalObject( aGroupColorName ) )
+ if ( mapOfNames.Contains( aGroupColorName ))
{
aDataset = new HDFdataset( aGroupColorName, aGroup );
aDataset->OpenOnDisk();
#include <TCollection_AsciiString.hxx>
#include <Resource_DataMapOfAsciiStringAsciiString.hxx>
#include <TColStd_HSequenceOfAsciiString.hxx>
+#include <NCollection_DataMap.hxx>
#include <map>
#include <sstream>
// ==========================================================
class SMESH_I_EXPORT StudyContext
{
+ typedef NCollection_DataMap< int, std::string > TInt2StringMap;
+ typedef NCollection_DataMap< int, int > TInt2IntMap;
public:
// constructor
StudyContext() {}
- // destructor
- ~StudyContext()
- {
- mapIdToIOR.clear();
- mapIdToId.clear();
- }
+
// register object in the internal map and return its id
int addObject( std::string theIOR )
{
int nextId = getNextId();
- mapIdToIOR[ nextId ] = theIOR;
+ mapIdToIOR.Bind( nextId, theIOR );
return nextId;
}
// find the object id in the internal map by the IOR
int findId( std::string theIOR )
{
- std::map<int, std::string>::iterator imap;
+ TInt2StringMap::iterator imap;
for ( imap = mapIdToIOR.begin(); imap != mapIdToIOR.end(); ++imap ) {
- if ( imap->second == theIOR )
- return imap->first;
+ if ( *imap == theIOR )
+ return imap.Iterator().Key();
}
return 0;
}
// get object's IOR by id
std::string getIORbyId( const int theId )
{
- if ( mapIdToIOR.find( theId ) != mapIdToIOR.end() )
- return mapIdToIOR[ theId ];
- return std::string( "" );
+ if ( mapIdToIOR.IsBound( theId ) )
+ return mapIdToIOR( theId );
+ return std::string();
}
// get object's IOR by old id
std::string getIORbyOldId( const int theOldId )
{
- if ( mapIdToId.find( theOldId ) != mapIdToId.end() )
- return getIORbyId( mapIdToId[ theOldId ] );
- return std::string( "" );
+ if ( mapIdToId.IsBound( theOldId ) )
+ return getIORbyId( mapIdToId( theOldId ));
+ return std::string();
}
// maps old object id to the new one (used when restoring data)
void mapOldToNew( const int oldId, const int newId ) {
- mapIdToId[ oldId ] = newId;
+ mapIdToId.Bind( oldId, newId );
}
// get old id by a new one
int getOldId( const int newId ) {
- std::map<int, int>::iterator imap;
+ TInt2IntMap::iterator imap;
for ( imap = mapIdToId.begin(); imap != mapIdToId.end(); ++imap ) {
- if ( imap->second == newId )
- return imap->first;
+ if ( *imap == newId )
+ return imap.Iterator().Key();
}
return 0;
}
int getNextId()
{
int id = 1;
- while( mapIdToIOR.find( id ) != mapIdToIOR.end() )
+ while( mapIdToIOR.IsBound( id ) )
id++;
return id;
}
- std::map<int, std::string> mapIdToIOR; // persistent-to-transient map
- std::map<int, int> mapIdToId; // to translate object from persistent to transient form
+ TInt2StringMap mapIdToIOR; // persistent-to-transient map
+ TInt2IntMap mapIdToId; // to translate object from persistent to transient form
};
// ===========================================================
// Get the SALOMEDS::SObject corresponding to a CORBA object
static SALOMEDS::SObject_ptr ObjectToSObject(SALOMEDS::Study_ptr theStudy,
CORBA::Object_ptr theObject);
- // Get GEOM Object correspoding to TopoDS_Shape
+ // Get GEOM Object corresponding to TopoDS_Shape
GEOM::GEOM_Object_ptr ShapeToGeomObject (const TopoDS_Shape& theShape );
- // Get TopoDS_Shape correspoding to GEOM_Object
+ // Get TopoDS_Shape corresponding to GEOM_Object
TopoDS_Shape GeomObjectToShape(GEOM::GEOM_Object_ptr theGeomObject);
// Default constructor
SMESH::long_array& theShapesId )
throw ( SALOME::SALOME_Exception );
- // Returns errors of hypotheses definintion
+ // Returns errors of hypotheses definition
SMESH::algo_error_array* GetAlgoState( SMESH::SMESH_Mesh_ptr theMesh,
GEOM::GEOM_Object_ptr theSubObject )
throw ( SALOME::SALOME_Exception );
// Return an object that previously had an oldID
template<class TInterface>
- typename TInterface::_var_type GetObjectByOldId( const int oldID )
+ typename TInterface::_var_type GetObjectByOldId( const int oldID )
{
if ( StudyContext* myStudyContext = GetCurrentStudyContext() ) {
std::string ior = myStudyContext->getIORbyOldId( oldID );
* \brief Stores names of variables that WILL be passes as parameters when calling
* some method of a given object.
* \param [in] theObject - the object whose a method WILL be called with \a theParameters.
- * \param [in] theParameters - a string contating parameters separated by ':'.
+ * \param [in] theParameters - a string containing parameters separated by ':'.
*/
//================================================================================
//=============================================================================
/*!
* Find better splitting of the given quadrangle.
- * \param IDOfQuad ID of the quadrangle to be splitted.
+ * \param IDOfQuad ID of the quadrangle to be split.
* \param Criterion A criterion to choose a diagonal for splitting.
* \return 1 if 1-3 diagonal is better, 2 if 2-4
* diagonal is better, 0 if error occurs.
// and then "GetGroups" using SMESH_Mesh::GetGroups()
TPythonDump pydump; // to prevent dump at mesh creation
- mesh = makeMesh( theMeshName );
+ mesh = makeMesh( theMeshName );
mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
if ( mesh_i )
return 0;
}
+//=======================================================================
+//function : IsManifold
+//purpose : Check if a 2D mesh is manifold
+//=======================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::IsManifold()
+ throw (SALOME::SALOME_Exception)
+{
+ bool isManifold = true;
+
+ SMESH_TRY;
+ SMESH_MeshAlgos::TFreeBorderVec foundFreeBordes;
+ SMESH_MeshAlgos::FindFreeBorders( *getMeshDS(),
+ foundFreeBordes,
+ /*closedOnly=*/true,
+ &isManifold );
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return isManifold;
+}
+
+//=======================================================================
+//function : IsCoherentOrientation2D
+//purpose : Check if orientation of 2D elements is coherent
+//=======================================================================
+
+CORBA::Boolean SMESH_MeshEditor_i::IsCoherentOrientation2D()
+ throw (SALOME::SALOME_Exception)
+{
+ bool isGoodOri = true;
+
+ SMESH_TRY;
+ SMESH_MeshAlgos::TFreeBorderVec foundFreeBordes;
+ SMESH_MeshAlgos::FindFreeBorders( *getMeshDS(),
+ foundFreeBordes,
+ /*closedOnly=*/true,
+ /*isManifold=*/0,
+ &isGoodOri);
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return isGoodOri;
+}
+
+//=======================================================================
+//function : FindFreeBorders
+//purpose : Returns all or only closed FreeBorder's.
+//=======================================================================
+
+SMESH::ListOfFreeBorders* SMESH_MeshEditor_i::FindFreeBorders(CORBA::Boolean closedOnly)
+ throw (SALOME::SALOME_Exception)
+{
+ SMESH::ListOfFreeBorders_var resBorders = new SMESH::ListOfFreeBorders;
+ SMESH_TRY;
+
+ SMESH_MeshAlgos::TFreeBorderVec foundFreeBordes;
+ SMESH_MeshAlgos::FindFreeBorders( *getMeshDS(), foundFreeBordes, closedOnly );
+
+ resBorders->length( foundFreeBordes.size() );
+ for ( size_t i = 0; i < foundFreeBordes.size(); ++i )
+ {
+ const SMESH_MeshAlgos::TFreeBorder& bordNodes = foundFreeBordes[i];
+ SMESH::FreeBorder& bordOut = resBorders[i];
+ bordOut.nodeIDs.length( bordNodes.size() );
+ for ( size_t iN = 0; iN < bordNodes.size(); ++iN )
+ bordOut.nodeIDs[ iN ] = bordNodes[ iN ]->GetID();
+ }
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+
+ return resBorders._retn();
+}
+
+//=======================================================================
+//function : FillHole
+//purpose : Fill with 2D elements a hole defined by a FreeBorder.
+//=======================================================================
+
+void SMESH_MeshEditor_i::FillHole(const SMESH::FreeBorder& theHole)
+ throw (SALOME::SALOME_Exception)
+{
+ initData();
+
+ if ( theHole.nodeIDs.length() < 4 )
+ THROW_SALOME_CORBA_EXCEPTION("A hole should be bound by at least 3 nodes", SALOME::BAD_PARAM);
+ if ( theHole.nodeIDs[0] != theHole.nodeIDs[ theHole.nodeIDs.length()-1 ] )
+ THROW_SALOME_CORBA_EXCEPTION("Not closed hole boundary. "
+ "First and last nodes must be same", SALOME::BAD_PARAM);
+
+ SMESH_MeshAlgos::TFreeBorder bordNodes;
+ bordNodes.resize( theHole.nodeIDs.length() );
+ for ( size_t iN = 0; iN < theHole.nodeIDs.length(); ++iN )
+ {
+ bordNodes[ iN ] = getMeshDS()->FindNode( theHole.nodeIDs[ iN ]);
+ if ( !bordNodes[ iN ] )
+ THROW_SALOME_CORBA_EXCEPTION(SMESH_Comment("Node #") << theHole.nodeIDs[ iN ]
+ << " does not exist", SALOME::BAD_PARAM);
+ }
+
+ SMESH_TRY;
+
+ MeshEditor_I::TPreviewMesh* previewMesh = 0;
+ SMDS_Mesh* meshDS = getMeshDS();
+ if ( myIsPreviewMode )
+ {
+ // copy faces sharing nodes of theHole
+ TIDSortedElemSet holeFaces;
+ previewMesh = getPreviewMesh( SMDSAbs_Face );
+ for ( size_t i = 0; i < bordNodes.size(); ++i )
+ {
+ SMDS_ElemIteratorPtr fIt = bordNodes[i]->GetInverseElementIterator( SMDSAbs_Face );
+ while ( fIt->more() )
+ {
+ const SMDS_MeshElement* face = fIt->next();
+ if ( holeFaces.insert( face ).second )
+ previewMesh->Copy( face );
+ }
+ bordNodes[i] = previewMesh->GetMeshDS()->FindNode( bordNodes[i]->GetID() );
+ ASSERT( bordNodes[i] );
+ }
+ meshDS = previewMesh->GetMeshDS();
+ }
+
+ std::vector<const SMDS_MeshElement*> newFaces;
+ SMESH_MeshAlgos::FillHole( bordNodes, *meshDS, newFaces );
+
+ if ( myIsPreviewMode )
+ {
+ previewMesh->Clear();
+ for ( size_t i = 0; i < newFaces.size(); ++i )
+ previewMesh->Copy( newFaces[i] );
+ }
+ else
+ {
+ getEditor().ClearLastCreated();
+ SMESH_SequenceOfElemPtr& aSeq =
+ const_cast<SMESH_SequenceOfElemPtr&>( getEditor().GetLastCreatedElems() );
+ for ( size_t i = 0; i < newFaces.size(); ++i )
+ aSeq.Append( newFaces[i] );
+
+ TPythonDump() << this << ".FillHole( SMESH.FreeBorder(" << theHole.nodeIDs << " ))";
+ }
+
+ SMESH_CATCH( SMESH::throwCorbaException );
+}
+
//=======================================================================
//function : convError
//purpose :
SMESH_CATCH( SMESH::throwCorbaException );
return 0;
}
+
+//================================================================================
+/*!
+ * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
+ * the initial mesh. Positions of new nodes are found by cutting the mesh by the
+ * plane passing through pairs of points specified by each PolySegment structure.
+ * If there are several paths connecting a pair of points, the shortest path is
+ * selected by the module. Position of the cutting plane is defined by the two
+ * points and an optional vector lying on the plane specified by a PolySegment.
+ * By default the vector is defined by Mesh module as following. A middle point
+ * of the two given points is computed. The middle point is projected to the mesh.
+ * The vector goes from the middle point to the projection point. In case of planar
+ * mesh, the vector is normal to the mesh.
+ * \param [inout] segments - PolySegment's defining positions of cutting planes.
+ * Return the used vector and position of the middle point.
+ * \param [in] groupName - optional name of a group where created mesh segments will
+ * be added.
+ */
+//================================================================================
+
+void SMESH_MeshEditor_i::MakePolyLine(SMESH::ListOfPolySegments& theSegments,
+ const char* theGroupName)
+ throw (SALOME::SALOME_Exception)
+{
+ if ( theSegments.length() == 0 )
+ THROW_SALOME_CORBA_EXCEPTION("No segments given", SALOME::BAD_PARAM );
+ if ( myMesh->NbFaces() == 0 )
+ THROW_SALOME_CORBA_EXCEPTION("No faces in the mesh", SALOME::BAD_PARAM );
+
+ SMESH_TRY;
+ initData(/*deleteSearchers=*/false);
+
+ SMESHDS_Group* groupDS = 0;
+ SMESHDS_Mesh* meshDS = getMeshDS();
+ if ( myIsPreviewMode ) // copy faces to the tmp mesh
+ {
+ TPreviewMesh * tmpMesh = getPreviewMesh( SMDSAbs_Edge );
+ SMDS_ElemIteratorPtr faceIt = getMeshDS()->elementsIterator( SMDSAbs_Face );
+ while ( faceIt->more() )
+ tmpMesh->Copy( faceIt->next() );
+ meshDS = tmpMesh->GetMeshDS();
+ }
+ else if ( theGroupName[0] ) // find/create a group of segments
+ {
+ SMESH_Mesh::GroupIteratorPtr grpIt = myMesh->GetGroups();
+ while ( !groupDS && grpIt->more() )
+ {
+ SMESH_Group* group = grpIt->next();
+ if ( group->GetGroupDS()->GetType() == SMDSAbs_Edge &&
+ strcmp( group->GetName(), theGroupName ) == 0 )
+ {
+ groupDS = dynamic_cast< SMESHDS_Group* >( group->GetGroupDS() );
+ }
+ }
+ if ( !groupDS )
+ {
+ SMESH::SMESH_Group_var groupVar = myMesh_i->CreateGroup( SMESH::EDGE, theGroupName );
+
+ if ( SMESH_Group_i* groupImpl = SMESH::DownCast<SMESH_Group_i*>( groupVar ))
+ groupDS = dynamic_cast< SMESHDS_Group* >( groupImpl->GetGroupDS() );
+ }
+ }
+
+ // convert input polySegments
+ ::SMESH_MeshEditor::TListOfPolySegments segments( theSegments.length() );
+ for ( CORBA::ULong i = 0; i < theSegments.length(); ++i )
+ {
+ SMESH::PolySegment& segIn = theSegments[ i ];
+ ::SMESH_MeshEditor::PolySegment& segOut = segments[ i ];
+ segOut.myNode1[0] = meshDS->FindNode( segIn.node1ID1 );
+ segOut.myNode2[0] = meshDS->FindNode( segIn.node1ID2 );
+ segOut.myNode1[1] = meshDS->FindNode( segIn.node2ID1 );
+ segOut.myNode2[1] = meshDS->FindNode( segIn.node2ID2 );
+ segOut.myVector.SetCoord( segIn.vector.PS.x,
+ segIn.vector.PS.y,
+ segIn.vector.PS.z );
+ if ( !segOut.myNode1[0] )
+ THROW_SALOME_CORBA_EXCEPTION( SMESH_Comment( "Invalid node ID: ") << segIn.node1ID1,
+ SALOME::BAD_PARAM );
+ if ( !segOut.myNode1[1] )
+ THROW_SALOME_CORBA_EXCEPTION( SMESH_Comment( "Invalid node ID: ") << segIn.node2ID1,
+ SALOME::BAD_PARAM );
+ }
+
+ // get a static ElementSearcher
+ SMESH::SMESH_IDSource_var idSource = SMESH::SMESH_IDSource::_narrow( myMesh_i->_this() );
+ theSearchersDeleter.Set( myMesh, getPartIOR( idSource, SMESH::FACE ));
+ if ( !theElementSearcher )
+ theElementSearcher = SMESH_MeshAlgos::GetElementSearcher( *getMeshDS() );
+
+ // compute
+ getEditor().MakePolyLine( segments, groupDS, theElementSearcher );
+
+ // return vectors
+ if ( myIsPreviewMode )
+ {
+ for ( CORBA::ULong i = 0; i < theSegments.length(); ++i )
+ {
+ SMESH::PolySegment& segOut = theSegments[ i ];
+ ::SMESH_MeshEditor::PolySegment& segIn = segments[ i ];
+ segOut.vector.PS.x = segIn.myVector.X();
+ segOut.vector.PS.y = segIn.myVector.Y();
+ segOut.vector.PS.z = segIn.myVector.Z();
+ }
+ }
+ else
+ {
+ TPythonDump() << "_segments = []";
+ for ( CORBA::ULong i = 0; i < theSegments.length(); ++i )
+ {
+ SMESH::PolySegment& segIn = theSegments[ i ];
+ TPythonDump() << "_segments.append( SMESH.PolySegment( "
+ << segIn.node1ID1 << ", "
+ << segIn.node1ID2 << ", "
+ << segIn.node2ID1 << ", "
+ << segIn.node2ID2 << ", "
+ << "smeshBuilder.MakeDirStruct( "
+ << segIn.vector.PS.x << ", "
+ << segIn.vector.PS.y << ", "
+ << segIn.vector.PS.z << ")))";
+ }
+ TPythonDump() << this << ".MakePolyLine( _segments, '" << theGroupName << "')";
+ }
+ meshDS->Modified();
+ SMESH_CATCH( SMESH::throwCorbaException );
+ return;
+}
SMESH::ElementType type)
throw (SALOME::SALOME_Exception);
/*!
- * Searching among the given elements, return elements of given type
+ * Searching among the given elements, return elements of given type
* where the given point is IN or ON.
* 'ALL' type means elements of any type excluding nodes
*/
CORBA::Short GetPointState(CORBA::Double x, CORBA::Double y, CORBA::Double z)
throw (SALOME::SALOME_Exception);
+ /*!
+ * Check if a 2D mesh is manifold
+ */
+ CORBA::Boolean IsManifold()
+ throw (SALOME::SALOME_Exception);
+
+ /*!
+ * Check if orientation of 2D elements is coherent
+ */
+ CORBA::Boolean IsCoherentOrientation2D()
+ throw (SALOME::SALOME_Exception);
+
+ /*!
+ * Returns all or only closed FreeBorder's.
+ */
+ SMESH::ListOfFreeBorders* FindFreeBorders(CORBA::Boolean closedOnly)
+ throw (SALOME::SALOME_Exception);
+
+ /*!
+ * Fill with 2D elements a hole defined by a FreeBorder.
+ */
+ void FillHole(const SMESH::FreeBorder& hole)
+ throw (SALOME::SALOME_Exception);
+
SMESH::CoincidentFreeBorders* FindCoincidentFreeBorders(CORBA::Double tolerance);
CORBA::Short SewCoincidentFreeBorders(const SMESH::CoincidentFreeBorders& freeBorders,
CORBA::Boolean createPolygons,
throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
- SewFreeBorders(CORBA::Long FirstNodeID1,
- CORBA::Long SecondNodeID1,
- CORBA::Long LastNodeID1,
- CORBA::Long FirstNodeID2,
- CORBA::Long SecondNodeID2,
- CORBA::Long LastNodeID2,
- CORBA::Boolean CreatePolygons,
- CORBA::Boolean CreatePolyedrs) throw (SALOME::SALOME_Exception);
+ SewFreeBorders(CORBA::Long FirstNodeID1,
+ CORBA::Long SecondNodeID1,
+ CORBA::Long LastNodeID1,
+ CORBA::Long FirstNodeID2,
+ CORBA::Long SecondNodeID2,
+ CORBA::Long LastNodeID2,
+ CORBA::Boolean CreatePolygons,
+ CORBA::Boolean CreatePolyedrs) throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
- SewConformFreeBorders(CORBA::Long FirstNodeID1,
- CORBA::Long SecondNodeID1,
- CORBA::Long LastNodeID1,
- CORBA::Long FirstNodeID2,
- CORBA::Long SecondNodeID2) throw (SALOME::SALOME_Exception);
+ SewConformFreeBorders(CORBA::Long FirstNodeID1,
+ CORBA::Long SecondNodeID1,
+ CORBA::Long LastNodeID1,
+ CORBA::Long FirstNodeID2,
+ CORBA::Long SecondNodeID2) throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
- SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
- CORBA::Long SecondNodeIDOnFreeBorder,
- CORBA::Long LastNodeIDOnFreeBorder,
- CORBA::Long FirstNodeIDOnSide,
- CORBA::Long LastNodeIDOnSide,
- CORBA::Boolean CreatePolygons,
- CORBA::Boolean CreatePolyedrs) throw (SALOME::SALOME_Exception);
+ SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
+ CORBA::Long SecondNodeIDOnFreeBorder,
+ CORBA::Long LastNodeIDOnFreeBorder,
+ CORBA::Long FirstNodeIDOnSide,
+ CORBA::Long LastNodeIDOnSide,
+ CORBA::Boolean CreatePolygons,
+ CORBA::Boolean CreatePolyedrs) throw (SALOME::SALOME_Exception);
SMESH::SMESH_MeshEditor::Sew_Error
- SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
- const SMESH::long_array& IDsOfSide2Elements,
- CORBA::Long NodeID1OfSide1ToMerge,
- CORBA::Long NodeID1OfSide2ToMerge,
- CORBA::Long NodeID2OfSide1ToMerge,
- CORBA::Long NodeID2OfSide2ToMerge) throw (SALOME::SALOME_Exception);
+ SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
+ const SMESH::long_array& IDsOfSide2Elements,
+ CORBA::Long NodeID1OfSide1ToMerge,
+ CORBA::Long NodeID1OfSide2ToMerge,
+ CORBA::Long NodeID2OfSide1ToMerge,
+ CORBA::Long NodeID2OfSide2ToMerge) throw (SALOME::SALOME_Exception);
/*!
* Set new nodes for given element.
const char* groupName,
const SMESH::double_array& theNodesCoords,
SMESH::array_of_long_array_out GroupsOfNodes)
- throw (SALOME::SALOME_Exception);
+ throw (SALOME::SALOME_Exception);
/*!
* \brief Generated skin mesh (containing 2D cells) from 3D mesh
SMESH::SMESH_Group_out group)
throw (SALOME::SALOME_Exception);
-private: //!< private methods
+ /*!
+ * \brief Create a polyline consisting of 1D mesh elements each lying on a 2D element of
+ * the initial mesh. Positions of new nodes are found by cutting the mesh by the
+ * plane passing through pairs of points specified by each PolySegment structure.
+ * If there are several paths connecting a pair of points, the shortest path is
+ * selected by the module. Position of the cutting plane is defined by the two
+ * points and an optional vector lying on the plane specified by a PolySegment.
+ * By default the vector is defined by Mesh module as following. A middle point
+ * of the two given points is computed. The middle point is projected to the mesh.
+ * The vector goes from the middle point to the projection point. In case of planar
+ * mesh, the vector is normal to the mesh.
+ * \param [inout] segments - PolySegment's defining positions of cutting planes.
+ * Return the used vector and position of the middle point.
+ * \param [in] groupName - optional name of a group where created mesh segments will
+ * be added.
+ */
+ void MakePolyLine(SMESH::ListOfPolySegments& segments,
+ const char* groupName)
+ throw (SALOME::SALOME_Exception);
+
+
+ private: //!< private methods
::SMESH_MeshEditor& getEditor();
#define __SMESH_MeshPartDS_HXX__
#include "SMESHDS_Mesh.hxx"
+#include "SMESH_TypeDefs.hxx"
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Mesh)
virtual SMDS_ElemIteratorPtr elementGeomIterator(SMDSAbs_GeometryType type) const;
virtual SMDS_ElemIteratorPtr elementEntityIterator(SMDSAbs_EntityType type) const;
+ virtual const SMDS_MeshElement *FindElement(int IDelem) const;
+
private:
TIDSortedElemSet _elements[ SMDSAbs_NbElementTypes ];
SMESHDS_Mesh* _meshDS;
{
void Add(const SMDS_MeshElement* e) { SMDS_MeshInfo::addWithPoly( e ); }
};
+ /*!
+ * \brief Element holing its ID only
+ */
+ struct TElemID : public SMDS_MeshElement
+ {
+ TElemID(int ID) : SMDS_MeshElement( ID ) {}
+ virtual SMDSAbs_ElementType GetType() const { return SMDSAbs_All; }
+ virtual SMDSAbs_EntityType GetEntityType() const { return SMDSEntity_Last; }
+ virtual SMDSAbs_GeometryType GetGeomType() const { return SMDSGeom_NONE; }
+ virtual vtkIdType GetVtkType() const { return -1; }
+ };
};
#endif
//-----------------------------------------------------------------------------
/*!
- * \brief Internal structure used to find concurent submeshes
+ * \brief Internal structure used to find concurrent submeshes
*
- * It represents a pair < submesh, concurent dimension >, where
- * 'concurrent dimension' is dimension of shape where the submesh can concurent
+ * It represents a pair < submesh, concurrent dimension >, where
+ * 'concurrent dimension' is dimension of shape where the submesh can concurrent
* with another submesh. In other words, it is dimension of a hypothesis assigned
* to submesh.
*/
removeDimHyps(dimHypListArr);
- // now, minimise the number of concurrent groups
+ // now, minimize the number of concurrent groups
// Here we assume that lists of submeshes can have same submesh
// in case of multi-dimension algorithms, as result
// list with common submesh has to be united into one list
continue;
if ( theIsDump )
aPythonDump << "[ ";
- // convert shape indeces into interfaces
+ // convert shape indices into interfaces
SMESH::submesh_array_var aResSubSet = new SMESH::submesh_array();
aResSubSet->length(aSubOrder.size());
TListOfInt::const_iterator subIt = aSubOrder.begin();
SMESH::SMESH_Mesh_var mesh = meshPart->GetMesh();
SMESH_Mesh_i* mesh_i = SMESH::DownCast<SMESH_Mesh_i*>( mesh );
+ mesh_i->Load();
_meshDS = mesh_i->GetImpl().GetMeshDS();
SetPersistentId( _meshDS->GetPersistentId() );
myInfo = tmpInfo;
}
// -------------------------------------------------------------------------------------
+const SMDS_MeshElement * SMESH_MeshPartDS::FindElement(int IDelem) const
+{
+ if ( _meshDS ) return _meshDS->FindElement( IDelem );
+
+ TElemID elem( IDelem );
+ for ( int iType = SMDSAbs_Edge; iType < SMDSAbs_NbElementTypes; ++iType )
+ if ( !_elements[ iType ].empty() )
+ {
+ TIDSortedElemSet::const_iterator it = _elements[ iType ].find( &elem );
+ if ( it != _elements[ iType ].end() )
+ return *it;
+ }
+ return 0;
+}
+// -------------------------------------------------------------------------------------
SMDS_ElemIteratorPtr SMESH_MeshPartDS::elementGeomIterator(SMDSAbs_GeometryType geomType) const
{
if ( _meshDS ) return _meshDS->elementGeomIterator( geomType );
*/
//================================================================================
-void SMESH_PreMeshInfo::hdf2meshInfo( const std::string& name,
- HDFgroup* hdfGroup)
+void SMESH_PreMeshInfo::hdf2meshInfo( const std::string& name,
+ HDFgroup* hdfGroup,
+ const TColStd_MapOfAsciiString& allHdfNames)
{
- if ( hdfGroup->ExistInternalObject( name.c_str()) )
+ //if ( hdfGroup->ExistInternalObject( name.c_str()) ) PAL23514
+ if ( allHdfNames.Contains( name.c_str() ))
{
HDFdataset* dataset = new HDFdataset( name.c_str(), hdfGroup );
dataset->OpenOnDisk();
HDFgroup* infoHdfGroup = new HDFgroup( hdfGroupName, aFile );
infoHdfGroup->OpenOnDisk();
- _mesh->changePreMeshInfo()->hdf2meshInfo( "Mesh", infoHdfGroup );
+ // PAL23514: get all names from the HDFgroup to avoid iteration on its contents
+ // within aGroup->ExistInternalObject( name )
+ TColStd_MapOfAsciiString mapOfNames;
+ {
+ std::vector< std::string > subNames;
+ infoHdfGroup->GetAllObjects( subNames );
+ for ( size_t iN = 0; iN < subNames.size(); ++iN )
+ mapOfNames.Add( subNames[ iN ].c_str() );
+ }
+
+ _mesh->changePreMeshInfo()->hdf2meshInfo( "Mesh", infoHdfGroup, mapOfNames );
// read SMESH_PreMeshInfo of groups
map<int, SMESH::SMESH_GroupBase_ptr>::const_iterator i2group = _mesh->_mapGroups.begin();
if ( SMESHDS_GroupBase* group = group_i->GetGroupDS() )
{
const std::string name = group->GetStoreName();
- group_i->changePreMeshInfo()->hdf2meshInfo( name, infoHdfGroup );
+ group_i->changePreMeshInfo()->hdf2meshInfo( name, infoHdfGroup, mapOfNames );
}
}
}
if ( SMESH_subMesh_i* sm = SMESH::DownCast<SMESH_subMesh_i*>( id2sm->second ))
{
sm->changePreMeshInfo() = newInstance();
- sm->changePreMeshInfo()->hdf2meshInfo( SMESH_Comment( sm->GetId()), infoHdfGroup );
+ sm->changePreMeshInfo()->hdf2meshInfo( SMESH_Comment( sm->GetId()),
+ infoHdfGroup,
+ mapOfNames );
}
}
}
#include CORBA_SERVER_HEADER(SALOMEDS)
#include <TopAbs_ShapeEnum.hxx>
+#include <TColStd_MapOfAsciiString.hxx>
class DriverMED_R_SMESHDS_Mesh;
class HDFfile;
// reading from the new study, for which SaveToFile() was called
bool readPreInfoFromHDF();
- void hdf2meshInfo( const std::string& dataSetName, HDFgroup* infoHdfGroup );
+ void hdf2meshInfo( const std::string& dataSetName,
+ HDFgroup* infoHdfGroup,
+ const TColStd_MapOfAsciiString& allHdfNames);
// reading from the old study, for which SaveToFile() was not called
bool readMeshInfo();
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-# SMESH SMESH_SWIG : binding of C++ implementaion with Python
+# SMESH SMESH_SWIG : binding of C++ implementation with Python
# File : SMESH_blocks.py
# Author : Julia DOROVSKIKH
# Module : SMESH
## doc string of the method
# @internal
docHelper = "Creates prism 3D algorithm for volumes"
+ ## flag pointing whether this algorithm should be used by default in dynamic method
+ # of smeshBuilder.Mesh class
+ # @internal
+ isDefault = True
## Private constructor.
# @param mesh parent mesh object algorithm is assigned to
## Return 3D hypothesis holding the 1D one
def Get3DHypothesis(self):
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorith doesn't support any hyposesis"
+ print "Prism_3D algorithm doesn't support any hypothesis"
return None
return self.distribHyp
# hypothesis. Returns the created hypothesis
def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorith doesn't support any hyposesis"
+ print "Prism_3D algorithm doesn't support any hypothesis"
return None
if not self.nbLayers is None:
self.mesh.GetMesh().RemoveHypothesis( self.geom, self.nbLayers )
# the same parameters, else (default) - creates a new one
def NumberOfLayers(self, n, UseExisting=0):
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorith doesn't support any hyposesis"
+ print "Prism_3D algorithm doesn't support any hypothesis"
return None
self.mesh.RemoveHypothesis( self.distribHyp, self.geom )
from salome.smesh.smeshBuilder import IsEqual
# @param p the precision of rounding
def LocalLength(self, l, p=1e-07):
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorith doesn't support any hyposesis"
+ print "Prism_3D algorithm doesn't support any hypothesis"
return None
hyp = self.OwnHypothesis("LocalLength", [l,p])
hyp.SetLength(l)
# @param s the scale factor (optional)
def NumberOfSegments(self, n, s=[]):
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorith doesn't support any hyposesis"
+ print "Prism_3D algorithm doesn't support any hypothesis"
return None
if not s:
hyp = self.OwnHypothesis("NumberOfSegments", [n])
# @param end the length of the last segment
def Arithmetic1D(self, start, end ):
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorith doesn't support any hyposesis"
+ print "Prism_3D algorithm doesn't support any hypothesis"
return None
hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
hyp.SetLength(start, 1)
# @param ratio the common ratio of the geometric progression
def GeometricProgression(self, start, ratio ):
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorith doesn't support any hyposesis"
+ print "Prism_3D algorithm doesn't support any hypothesis"
return None
hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
hyp.SetStartLength( start )
# @param end for the length of the last segment
def StartEndLength(self, start, end):
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorith doesn't support any hyposesis"
+ print "Prism_3D algorithm doesn't support any hypothesis"
return None
hyp = self.OwnHypothesis("StartEndLength", [start, end])
hyp.SetLength(start, 1)
# @param fineness defines the quality of the mesh within the range [0-1]
def AutomaticLength(self, fineness=0):
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorith doesn't support any hyposesis"
+ print "Prism_3D algorithm doesn't support any hypothesis"
return None
hyp = self.OwnHypothesis("AutomaticLength")
hyp.SetFineness( fineness )
functor = aFilterMgr.CreateLength()
elif theCriterion == FT_Length2D:
functor = aFilterMgr.CreateLength2D()
+ elif theCriterion == FT_Deflection2D:
+ functor = aFilterMgr.CreateDeflection2D()
elif theCriterion == FT_NodeConnectivityNumber:
functor = aFilterMgr.CreateNodeConnectivityNumber()
elif theCriterion == FT_BallDiameter:
return self.editor.MakeIDSource(ids, elemType)
- # Get informations about mesh contents:
+ # Get information about mesh contents:
# ------------------------------------
- ## Get the mesh stattistic
+ ## Get the mesh statistic
# @return dictionary type element - count of elements
# @ingroup l1_meshinfo
def GetMeshInfo(self, obj = None):
def GetPointState(self, x, y, z):
return self.editor.GetPointState(x, y, z)
+ ## Check if a 2D mesh is manifold
+ # @ingroup l1_controls
+ def IsManifold(self):
+ return self.editor.IsManifold()
+
+ ## Check if orientation of 2D elements is coherent
+ # @ingroup l1_controls
+ def IsCoherentOrientation2D(self):
+ return self.editor.IsCoherentOrientation2D()
+
## Find the node closest to a point and moves it to a point location
# @param x the X coordinate of a point
# @param y the Y coordinate of a point
# Type SMESH.FunctorType._items in the Python Console to see all items.
# Note that not all items correspond to numerical functors.
# @param MaxAngle is the maximum angle between element normals at which the fusion
- # is still performed; theMaxAngle is mesured in radians.
+ # is still performed; theMaxAngle is measured in radians.
# Also it could be a name of variable which defines angle in degrees.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_unitetri
# Type SMESH.FunctorType._items in the Python Console to see all items.
# Note that not all items correspond to numerical functors.
# @param MaxAngle a max angle between element normals at which the fusion
- # is still performed; theMaxAngle is mesured in radians.
+ # is still performed; theMaxAngle is measured in radians.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_unitetri
def TriToQuadObject (self, theObject, theCriterion, MaxAngle):
return self.editor.TriToQuadObject(theObject, Functor, MaxAngle)
## Split quadrangles into triangles.
- # @param IDsOfElements the faces to be splitted.
+ # @param IDsOfElements the faces to be split.
# @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
# choose a diagonal for splitting. If @a theCriterion is None, which is a default
# value, then quadrangles will be split by the smallest diagonal.
## Split each of given quadrangles into 4 triangles. A node is added at the center of
# a quadrangle.
- # @param theElements the faces to be splitted. This can be either mesh, sub-mesh,
+ # @param theElements the faces to be split. This can be either mesh, sub-mesh,
# group or a list of face IDs. By default all quadrangles are split
# @ingroup l2_modif_cutquadr
def QuadTo4Tri (self, theElements=[]):
return self.editor.QuadTo4Tri( theElements )
## Split quadrangles into triangles.
- # @param IDsOfElements the faces to be splitted
+ # @param IDsOfElements the faces to be split
# @param Diag13 is used to choose a diagonal for splitting.
# @return TRUE in case of success, FALSE otherwise.
# @ingroup l2_modif_cutquadr
return self.editor.SplitQuadObject(theObject, Diag13)
## Find a better splitting of the given quadrangle.
- # @param IDOfQuad the ID of the quadrangle to be splitted.
+ # @param IDOfQuad the ID of the quadrangle to be split.
# @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to
# choose a diagonal for splitting.
# Type SMESH.FunctorType._items in the Python Console to see all items.
def MergeEqualElements(self):
self.editor.MergeEqualElements()
+ ## Returns all or only closed free borders
+ # @return list of SMESH.FreeBorder's
+ # @ingroup l2_modif_trsf
+ def FindFreeBorders(self, ClosedOnly=True):
+ return self.editor.FindFreeBorders( ClosedOnly )
+
+ ## Fill with 2D elements a hole defined by a SMESH.FreeBorder.
+ # @param FreeBorder either a SMESH.FreeBorder or a list on node IDs. These nodes
+ # must describe all sequential nodes of the hole border. The first and the last
+ # nodes must be the same. Use FindFreeBorders() to get nodes of holes.
+ # @ingroup l2_modif_trsf
+ def FillHole(self, holeNodes):
+ if holeNodes and isinstance( holeNodes, list ) and isinstance( holeNodes[0], int ):
+ holeNodes = SMESH.FreeBorder(nodeIDs=holeNodes)
+ if not isinstance( holeNodes, SMESH.FreeBorder ):
+ raise TypeError, "holeNodes must be either SMESH.FreeBorder or list of integer and not %s" % holeNodes
+ self.editor.FillHole( holeNodes )
+
## Return groups of FreeBorder's coincident within the given tolerance.
# @param tolerance the tolerance. If the tolerance <= 0.0 then one tenth of an average
# size of elements adjacent to free borders being compared is used.
def CreateHoleSkin(self, radius, theShape, groupName, theNodesCoords):
return self.editor.CreateHoleSkin( radius, theShape, groupName, theNodesCoords )
- def _getFunctor(self, funcType ):
+ ## Create a polyline consisting of 1D mesh elements each lying on a 2D element of
+ # the initial mesh. Positions of new nodes are found by cutting the mesh by the
+ # plane passing through pairs of points specified by each PolySegment structure.
+ # If there are several paths connecting a pair of points, the shortest path is
+ # selected by the module. Position of the cutting plane is defined by the two
+ # points and an optional vector lying on the plane specified by a PolySegment.
+ # By default the vector is defined by Mesh module as following. A middle point
+ # of the two given points is computed. The middle point is projected to the mesh.
+ # The vector goes from the middle point to the projection point. In case of planar
+ # mesh, the vector is normal to the mesh.
+ # @param segments - PolySegment's defining positions of cutting planes.
+ # Return the used vector which goes from the middle point to its projection.
+ # @param groupName - optional name of a group where created mesh segments will
+ # be added.
+ # @ingroup l2_modif_duplicat
+ def MakePolyLine(self, segments, groupName='', isPreview=False ):
+ editor = self.editor
+ if isPreview:
+ editor = self.mesh.GetMeshEditPreviewer()
+ segmentsRes = editor.MakePolyLine( segments, groupName )
+ for i, seg in enumerate( segmentsRes ):
+ segments[i].vector = seg.vector
+ if isPreview:
+ return editor.GetPreviewData()
+ return None
+
+ ## Return a cached numerical functor by its type.
+ # @param theCriterion functor type - an item of SMESH.FunctorType enumeration.
+ # Type SMESH.FunctorType._items in the Python Console to see all items.
+ # Note that not all items correspond to numerical functors.
+ # @return SMESH_NumericalFunctor. The functor is already initialized
+ # with a mesh
+ # @ingroup l1_measurements
+ def GetFunctor(self, funcType ):
fn = self.functors[ funcType._v ]
if not fn:
fn = self.smeshpyD.GetFunctor(funcType)
# @return the functor value or zero in case of invalid arguments
# @ingroup l1_measurements
def FunctorValue(self, funcType, elemId, isElem=True):
- fn = self._getFunctor( funcType )
+ fn = self.GetFunctor( funcType )
if fn.GetElementType() == self.GetElementType(elemId, isElem):
val = fn.GetValue(elemId)
else:
unRegister.set( meshPart )
if isinstance( meshPart, Mesh ):
meshPart = meshPart.mesh
- fun = self._getFunctor( funType )
+ fun = self.GetFunctor( funType )
if fun:
if meshPart:
if hasattr( meshPart, "SetMesh" ):
if not algoType:
algoType = self.defaultAlgoType
if not algoType and self.algoTypeToClass:
- algoType = self.algoTypeToClass.keys()[0]
+ algoType = sorted( self.algoTypeToClass.keys() )[0]
if self.algoTypeToClass.has_key( algoType ):
#print "Create algo",algoType
return self.algoTypeToClass[ algoType ]( self.mesh, shape )
# @ingroup l2_algorithms
class Mesh_Algorithm:
- ## Private constuctor
+ ## Private constructor
def __init__(self):
self.mesh = None
self.geom = None
//
#include "libSMESH_Swig.h"
+#include <SVTK_Selector.h>
#include <SMESHGUI.h>
#include <SMESHGUI_Utils.h>
ProcessVoidEvent(new TEvent(Mesh_Entry, allViewers));
}
+void SMESH_Swig::UpdateActor( const char* Mesh_Entry ) {
+ class TEvent: public SALOME_Event
+ {
+ private:
+ const char* _entry;
+ public:
+ TEvent( const char* Mesh_Entry ) {
+ _entry = Mesh_Entry;
+ }
+ virtual void Execute() {
+ Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject
+ ( _entry, "SMESH", "" );
+ SMESH::Update( anIO, true );
+ }
+ };
+
+ ProcessVoidEvent( new TEvent(Mesh_Entry) );
+}
+
void SMESH_Swig::SetName(const char* theEntry,
const char* theName)
{
ProcessVoidEvent( new TSelectListEvent( id, ids, append ) );
}
+/*!
+ \brief Helper class for selection edges of cell event
+*/
+class TSelectListOfPairEvent: public SALOME_Event
+{
+ const char* myId;
+ std::vector<std::pair<int, int> > myIdsList;
+ bool myIsAppend;
+
+public:
+ TSelectListOfPairEvent(const char* id, std::vector<std::pair<int, int> > ids, bool append) :
+ myId(id),
+ myIdsList(ids),
+ myIsAppend(append)
+ {}
+ virtual void Execute()
+ {
+
+ LightApp_SelectionMgr* selMgr = 0;
+ SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
+ if( anApp )
+ selMgr = dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );
+
+ if( !selMgr )
+ return;
+
+ selMgr->clearFilters();
+
+ SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
+ if(!aViewWindow)
+ return;
+
+ SMESH_Actor* anActor = SMESH::FindActorByEntry( myId );
+
+ if (!anActor || !anActor->hasIO())
+ return;
+
+ Handle(SALOME_InteractiveObject) anIO = anActor->getIO();
+ SALOME_ListIO aList;
+ aList.Append(anIO);
+ selMgr->setSelectedObjects(aList, false);
+
+ if ( aViewWindow->SelectionMode() != EdgeOfCellSelection ) {
+ return;
+ }
+
+ SVTK_IndexedMapOfIds aMap;
+ std::vector<std::pair<int, int> >::const_iterator anIter;
+ for (anIter = myIdsList.begin(); anIter != myIdsList.end(); ++anIter) {
+ std::vector<int> aCompositeId;
+ aCompositeId.push_back((*anIter).first);
+ aCompositeId.push_back((*anIter).second);
+ aMap.Add(aCompositeId);
+ }
+
+ // Set new selection
+ SVTK_Selector* aSelector = aViewWindow->GetSelector();
+ aSelector->AddOrRemoveCompositeIndex(anIO, aMap, myIsAppend);
+ aViewWindow->highlight( anIO, true, true );
+ aViewWindow->GetInteractor()->onEmitSelectionChanged();
+ }
+};
+
+/*!
+ \brief Select the elements on the mesh, sub-mesh or group.
+ \param id object entry
+ \param ids list of the element ids
+ \param mode selection mode
+*/
+void SMESH_Swig::select( const char* id, std::vector<std::pair<int,int> > ids, bool append ) {
+ ProcessVoidEvent( new TSelectListOfPairEvent( id, ids, append ) );
+}
class TGetSelectionModeEvent : public SALOME_Event
{
std::vector<int> SMESH_Swig::getSelected( const char* Mesh_Entry ) {
return ProcessEvent( new TGetSelectedEvent(Mesh_Entry) );
}
+
+class TGetSelectedPairEvent : public SALOME_Event
+{
+public:
+ typedef std::vector<std::pair<int, int> > TResult;
+ TResult myResult;
+ const char* myId;
+
+ TGetSelectedPairEvent( const char* id) :
+ myResult( std::vector<std::pair<int,int> >() ),
+ myId(id)
+ {}
+
+ virtual void Execute()
+ {
+ SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
+ if( !aViewWindow )
+ return;
+
+ if(aViewWindow->SelectionMode() != EdgeOfCellSelection )
+ return;
+
+ SVTK_Selector* aSelector = aViewWindow->GetSelector();
+ if( !aSelector )
+ return;
+
+ SMESH_Actor* anActor = SMESH::FindActorByEntry( myId );
+
+ if ( !anActor || !anActor->hasIO() )
+ return;
+
+ SVTK_IndexedMapOfIds aMapIndex;
+ aSelector->GetCompositeIndex(anActor->getIO(),aMapIndex);
+
+ for( int i = 1; i <= aMapIndex.Extent(); i++ )
+ myResult.push_back( std::make_pair<int,int>( (int)aMapIndex( i )[0], (int)aMapIndex( i )[1]) );
+ }
+};
+
+std::vector<std::pair<int,int> > SMESH_Swig::getSelectedEdgeOfCell( const char* Mesh_Entry ) {
+ return ProcessEvent( new TGetSelectedPairEvent(Mesh_Entry) );
+}
+
//std includes
#include <vector>
+#include <utility>
#include <SVTK_Selection.h>
void EraseActor( const char*, const bool allViewers = false );
+ void UpdateActor( const char* Mesh_Entry );
+
/*!
* \brief Set mesh icon according to compute status
* \param Mesh_Entry - entry of a mesh
void setSelectionMode( SelectionMode selectionMode );
std::vector<int> getSelected( const char* Mesh_Entry );
+ std::vector<std::pair<int, int> > getSelectedEdgeOfCell( const char* Mesh_Entry );
// --------------------- for the test purposes -----------------------
SelectionMode getSelectionMode();
void select( const char *id, std::vector<int> ids, bool append = false );
void select( const char *id, int id1, bool append = false );
+ void select( const char *id, std::vector<std::pair<int,int> >, bool apend = false );
private:
SALOMEDS::Study_var myStudy;
%include "typemaps.i"
%include "std_vector.i"
+%include "std_pair.i"
namespace std {
+
%template(VectorInt) vector<int>;
+ %template() std::pair<int,int>;
+ %template(PairVector) std::vector<std::pair<int,int> >;
};
void CreateAndDisplayActor( const char* Mesh_Entry );
void EraseActor( const char* Mesh_Entry, const bool allViewers = false );
+ void UpdateActor( const char* Mesh_Entry );
+
+ void setSelectionMode( SelectionMode selectionMode);
+ std::vector<int> getSelected( const char* Mesh_Entry );
+ std::vector<std::pair<int,int> > getSelectedEdgeOfCell( const char* Mesh_Entry );
actorAspect GetActorAspect(const char* Mesh_Entry, int viewId = 0 );
void SetActorAspect( const actorAspect& actorPres, const char* Mesh_Entry, int viewId = 0 );
SelectionMode getSelectionMode();
void select( const char *id, std::vector<int> ids, bool append = false );
void select( const char *id, int id1, bool append = false );
+ void select( const char *id, std::vector<std::pair<int,int> >, bool apend = false );
};
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Arithmetic1D.cxx
// Author : Damien COQUERET, OCC
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Arithmetic1D.hxx
// Author : Damien COQUERET, OCC
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_AutomaticLength.cxx
// Author : Edward AGAPOV, OCC
// Module : SMESH
theTShapeToLengthMap.insert( make_pair( getTShape( edge ), L ));
}
- // Compute S0 - minimal segement length, is computed by the shortest EDGE
+ // Compute S0 - minimal segment length, is computed by the shortest EDGE
/* image attached to PAL10237
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_AutomaticLength.hxx
// Author : Edward AGAPOV, OCC
// Module : SMESH
ip._faceIDs = e2fIt->second;
ip._shapeID = edgeID;
- // discretize the EGDE
+ // discretize the EDGE
GCPnts_UniformDeflection discret( curve, deflection, true );
if ( !discret.IsDone() || discret.NbPoints() < 2 )
continue;
}
//================================================================================
/*!
- * \brief Classify a point by grid paremeters
+ * \brief Classify a point by grid parameters
*/
bool Hexahedron::isOutParam(const double uvw[3]) const
{
facesItersectors[i].Intersect();
#endif
- // put interesection points onto the GridLine's; this is done after intersection
+ // put intersection points onto the GridLine's; this is done after intersection
// to avoid contention of facesItersectors for writing into the same GridLine
// in case of parallel work of facesItersectors
for ( size_t i = 0; i < facesItersectors.size(); ++i )
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_CompositeHexa_3D.cxx
// Module : SMESH
// Created : Tue Nov 25 11:04:59 2008
//================================================================================
/*!
- * \brief Convertor of a pair of integers to a sole index
+ * \brief Converter of a pair of integers to a sole index
*/
struct _Indexer
{
if ( !fTop )
return error(COMPERR_BAD_SHAPE);
- // orient bottom egde of faces along axes of the unit box
+ // orient bottom edge of faces along axes of the unit box
fBottom->ReverseEdges();
fBack ->ReverseEdges();
fLeft ->ReverseEdges();
* \brief Computes hexahedral mesh on a box with composite sides
* \param aMesh - mesh to compute
* \param aShape - shape to mesh
- * \retval bool - succes sign
+ * \retval bool - success sign
*/
//================================================================================
myGrid.resize( myIndexer.size() );
- // strore nodes bound to the bottom edge
+ // store nodes bound to the bottom edge
mySides.GetSide( Q_BOTTOM )->StoreNodes( mesh, myGrid, myReverse );
// store the rest nodes row by row
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_CompositeBlock_3D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_CompositeSegment_1D.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_CompositeSegment_1D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers_Deflection1D : implementaion of SMESH idl descriptions
+// SMESH StdMeshers_Deflection1D : implementation of SMESH idl descriptions
// File : StdMeshers_Deflection1D.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of SMESH idl descriptions
+// SMESH StdMeshers : implementation of SMESH idl descriptions
// File : StdMeshers_Deflection1D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of point distribution algorithm
+// SMESH StdMeshers : implementation of point distribution algorithm
// File : StdMeshers_Distribution.cxx
// Author : Alexandre SOLOVYOV
// Module : SMESH
OCC_CATCH_SIGNALS;
f = pow( 10., f );
} catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
f = 0.0;
ok = false;
}
myExpr = ExprIntrp_GenExp::Create();
myExpr->Process( ( Standard_CString )str );
} catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
ok = false;
}
OCC_CATCH_SIGNALS;
f = myExpr->Expression()->Evaluate( myVars, myValues );
} catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
f = 0.0;
ok = false;
}
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of point distribution algorithm
+// SMESH StdMeshers : implementation of point distribution algorithm
// File : StdMeshers_Distribution.hxx
// Author : Alexandre SOLOVYOV
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_FixedPoints1D.cxx
// Author : Damien COQUERET, OCC
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_FixedPoints1D.hxx
// Author : Damien COQUERET, OCC
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Geometric1D.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Geometric1D.hxx
// Module : SMESH
//
//================================================================================
/*!
- * \brief Convertor of a pair of integers to a sole index
+ * \brief Converter of a pair of integers to a sole index
*/
struct _Indexer
{
};
//================================================================================
/*!
- * \brief Oriented convertor of a pair of integers to a sole index
+ * \brief Oriented converter of a pair of integers to a sole index
*/
class _OrientedIndexer : public _Indexer
{
const SMDS_MeshElement* cornerQuad,
const SMDS_MeshNode* nCorner)
{
- // Find out size of block side mesured in nodes and by the way find two rows
+ // Find out size of block side measured in nodes and by the way find two rows
// of nodes in two directions.
int x, y, nbX, nbY;
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Hexa_3D.cxx
// Moved here from SMESH_Hexa_3D.cxx
// Author : Paul RASCLE, EDF
//================================================================================
/*!
- * \brief Convertor of a pair of integers to a sole index
+ * \brief Converter of a pair of integers to a sole index
*/
struct _Indexer
{
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Hexa_3D.hxx
// Moved here from SMESH_Hexa_3D.hxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers_ImportSource1D : implementaion of SMESH idl descriptions
+// SMESH StdMeshers_ImportSource1D : implementation of SMESH idl descriptions
// File : StdMeshers_ImportSource1D.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of SMESH idl descriptions
+// SMESH StdMeshers : implementation of SMESH idl descriptions
// File : StdMeshers_ImportSource1D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Import_1D.cxx
// Module : SMESH
//
"StdMeshers_Import_1D::_Listener") {}
public:
- // return poiter to a static listener
+ // return pointer to a static listener
static _Listener* get() { static _Listener theListener; return &theListener; }
static _ImportData* getImportData(const SMESH_Mesh* srcMesh, SMESH_Mesh* tgtMesh);
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// Module : SMESH
//
#ifndef _SMESH_Import_1D_HXX_
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Import_1D2D.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// Module : SMESH
//
#ifndef _SMESH_Import_2D_HXX_
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_LengthFromEdges.cxx
// Moved here from SMESH_LengthFromEdges.cxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_LengthFromEdges.hxx
// Moved here from SMESH_LengthFromEdges.hxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_LocalLength.cxx
// Moved here from SMESH_LocalLength.cxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_LocalLength.hxx
// Moved here from SMESH_LocalLength.hxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_MEFISTO_2D.cxx
// Moved here from SMESH_MEFISTO_2D.cxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_MEFISTO_2D.hxx
// Moved here from SMESH_MEFISTO_2D.hxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_MaxElementArea.cxx
// Moved here from SMESH_MaxElementArea.cxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_MaxElementArea.hxx
// Moved here from SMESH_MaxElementArea.hxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_MaxElementVolume.cxx
// Moved here from SMESH_MaxElementVolume.cxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_MaxElementVolume.hxx
// Moved here from SMESH_MaxElementVolume.hxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_MaxLength.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_MaxLength.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of SMESH idl descriptions
+// SMESH StdMeshers : implementation of SMESH idl descriptions
// File : StdMeshers_NotConformAllowed.cxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of SMESH idl descriptions
+// SMESH StdMeshers : implementation of SMESH idl descriptions
// File : StdMeshers_NotConformAllowed.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_NumberOfSegments.cxx
// Moved here from SMESH_NumberOfSegments.cxx
// Author : Paul RASCLE, EDF
val = pow( 10.0, val );
}
catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
throw SALOME_Exception( LOCALIZED( "invalid value"));
return;
}
myExpr = ExprIntrp_GenExp::Create();
myExpr->Process( str.ToCString() );
} catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
parsed_ok = false;
}
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_NumberOfSegments.hxx
// Moved here from SMESH_NumberOfSegments.hxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers_Penta_3D implementaion of SMESH idl descriptions
+// SMESH StdMeshers_Penta_3D implementation of SMESH idl descriptions
// File : StdMeshers_Penta_3D.cxx
// Module : SMESH
//
aZ=(double)i/(double)(myISize-1);
aCoords.SetCoord(aX, aY, aZ);
//
- // suporting shape ID
+ // supporting shape ID
ShapeSupportID(bIsUpperLayer, aBNSSID, aSSID);
if (!myErrorStatus->IsOK()) {
MESSAGE("StdMeshers_Penta_3D::MakeNodes() pb");
SMESH_Block::GetFaceEdgesIDs( aFaceID, edgeVec );
//
int coord = SMESH_Block::GetCoordIndOnEdge( edgeVec[ BASE ] );
- bool isForward = myBlock.IsForwadEdge( edgeVec[ BASE ] );
+ bool isForward = myBlock.IsForwardEdge( edgeVec[ BASE ] );
double param = aBaseNodeParams.Coord( coord );
if ( !isForward)
}
// look for a not loaded node of the <face>
bool found = false;
- const SMDS_MeshNode* n3 = 0; // a node defferent from n1 and n2
+ const SMDS_MeshNode* n3 = 0; // a node different from n1 and n2
eIt = face->nodesIterator() ;
while ( !found && eIt->more() ) {
node = static_cast<const SMDS_MeshNode*>( eIt->next() );
}
//=======================================================================
-//function : IsForwadEdge
+//function : IsForwardEdge
//purpose :
//=======================================================================
-bool StdMeshers_SMESHBlock::IsForwadEdge(const int theEdgeID)
+bool StdMeshers_SMESHBlock::IsForwardEdge(const int theEdgeID)
{
int index = myTBlock.ShapeIndex( theEdgeID );
if ( !myTBlock.IsEdgeID( theEdgeID ))
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of SMESH idl descriptions
+// SMESH StdMeshers : implementation of SMESH idl descriptions
// File : StdMeshers_Penta_3D.hxx
// Module : SMESH
//
SMESH_Block & Block() { return myTBlock; }
- bool IsForwadEdge(const int theEdgeID);
+ bool IsForwardEdge(const int theEdgeID);
int ErrorStatus() const;
if ( side._topEdge.IsNull() )
{
- // find vertical EDGEs --- EGDEs shared with neighbor side FACEs
+ // find vertical EDGEs --- EDGEs shared with neighbor side FACEs
for ( int is2nd = 0; is2nd < 2 && isOK; ++is2nd ) // 2 adjacent neighbors
{
int di = is2nd ? 1 : -1;
if ( !botSM ) // find a proper bottom
{
bool savedSetErrorToSM = mySetErrorToSM;
- mySetErrorToSM = false; // ingore errors in initPrism()
+ mySetErrorToSM = false; // ignore errors in initPrism()
// search among meshed FACEs
list< SMESH_subMesh* >::iterator sm = meshedSubMesh.begin();
const size_t zSrc = 0, zTgt = zSize-1;
if ( zSize < 3 ) return true;
- vector< vector< gp_XYZ > > intPntsOfLayer( zSize ); // node coodinates to compute
+ vector< vector< gp_XYZ > > intPntsOfLayer( zSize ); // node coordinates to compute
// set coordinates of src and tgt nodes
for ( size_t z = 0; z < intPntsOfLayer.size(); ++z )
intPntsOfLayer[ z ].resize( myIntColumns.size() );
prepareTopBotDelaunay();
bool isErrorCorrectable = findDelaunayTriangles();
- // compute coordinates of internal nodes by projecting (transfroming) src and tgt
+ // compute coordinates of internal nodes by projecting (transforming) src and tgt
// nodes towards the central layer
vector< NSProjUtils::TrsfFinder3D > trsfOfLayer( zSize );
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Prism_3D.hxx
// Module : SMESH
//
}
/*!
- * \brief Convertor used in Delaunay constructor
+ * \brief Converter used in Delaunay constructor
*/
struct SideVector2UVPtStructVec
{
const TopoDS_Shape& v1 = vMap1(i);
if ( vMap2.Contains( v1 ))
{
- // find an egde sharing v1 and sharing at the same time another common vertex
+ // find an edge sharing v1 and sharing at the same time another common vertex
PShapeIteratorPtr edgeIt = SMESH_MesherHelper::GetAncestors( v1, *theMesh1, TopAbs_EDGE);
bool edgeFound = false;
while ( edgeIt->more() && !edgeFound )
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Projection_1D.cxx
// Module : SMESH
// Created : Fri Oct 20 11:37:07 2006
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Projection_1D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Projection_2D.cxx
// Module : SMESH
// Created : Fri Oct 20 11:37:07 2006
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Projection_2D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Projection_3D.cxx
// Module : SMESH
// Created : Fri Oct 20 11:37:07 2006
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Projection_3D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Propagation.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Propagation.hxx
// Module : SMESH
//
theSinuEdges [0].size() > 0 && theSinuEdges [1].size() > 0 );
// the sinuous EDGEs can be composite and C0 continuous,
- // therefor we use a complex criterion to find TWO short non-sinuous EDGEs
+ // therefore we use a complex criterion to find TWO short non-sinuous EDGEs
// and the rest EDGEs will be treated as sinuous.
// A short edge should have the following features:
// a) straight
* \param [in] theDivPoints - projections of VERTEXes to MA
* \param [in] theSinuEdges - the sinuous EDGEs
* \param [in] theSideEdgeIDs - indices of sinuous EDGEs per side
- * \param [in] theIsEdgeComputed - is sinuous EGDE is meshed
+ * \param [in] theIsEdgeComputed - is sinuous EDGE is meshed
* \param [in,out] thePointsOnE - the map to fill
* \param [out] theNodes2Merge - the map of nodes to merge
*/
//================================================================================
/*!
* \brief Divide the sinuous EDGEs by projecting the division point of Medial
- * Axis to the EGDEs
+ * Axis to the EDGEs
* \param [in] theHelper - the helper
* \param [in] theMinSegLen - minimal segment length
* \param [in] theMA - the Medial Axis
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers_QuadranglePreference : implementaion of SMESH idl descriptions
+// SMESH StdMeshers_QuadranglePreference : implementation of SMESH idl descriptions
// File : StdMeshers_QuadranglePreference.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of SMESH idl descriptions
+// SMESH StdMeshers : implementation of SMESH idl descriptions
// File : StdMeshers_QuadranglePreference.hxx
// Module : SMESH
//
// | | | |
// | |C | |
// | L | | R |
- // left | |__| | rigth
+ // left | |__| | right
// | / \ |
// | / C \ |
// |/ \|
// | |__| |
// | / \ |
// | / C \ |
- // left |/________\| rigth
+ // left |/________\| right
// | |
// | C |
// | |
// | | | |
// | | | |
// | L | | R |
- // left | | | | rigth
+ // left | | | | right
// | / \ |
// | / C \ |
// |/ \|
{
d = Abs( idealLen - accuLength[ iEV ]);
- // take into account presence of a coresponding halfDivider
+ // take into account presence of a corresponding halfDivider
const double cornerWgt = 0.5 / nbSides;
const double vertexWgt = 0.25 / nbSides;
TGeoIndex hd = halfDivider[ evVec[ iEV ]];
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers_QuadraticMesh : implementaion of SMESH idl descriptions
+// SMESH StdMeshers_QuadraticMesh : implementation of SMESH idl descriptions
// File : StdMeshers_QuadraticMesh.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of SMESH idl descriptions
+// SMESH StdMeshers : implementation of SMESH idl descriptions
// File : StdMeshers_QuadraticMesh.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_RadialPrism_3D.cxx
// Module : SMESH
// Created : Fri Oct 20 11:37:07 2006
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_RadialPrism_3D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_RadialQuadrangle_1D2D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Regular_1D.hxx
// Moved here from SMESH_Regular_1D.hxx
// Author : Paul RASCLE, EDF
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Reversible1D.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_Reversible1D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_SegmentAroundVertex_0D.cxx
// Module : SMESH
// Created : Fri Oct 20 11:37:07 2006
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_SegmentAroundVertex_0D.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_SegmentLengthAroundVertex.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_SegmentLengthAroundVertex.hxx
// Author : Paul RASCLE, EDF
// Module : SMESH
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers_StartEndLength : implementaion of SMESH idl descriptions
+// SMESH StdMeshers_StartEndLength : implementation of SMESH idl descriptions
// File : StdMeshers_StartEndLength.cxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of SMESH idl descriptions
+// SMESH StdMeshers : implementation of SMESH idl descriptions
// File : StdMeshers_StartEndLength.hxx
// Module : SMESH
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_UseExisting_1D2D.cxx
// Module : SMESH
// Created : Fri Oct 20 11:37:07 2006
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_UseExisting_1D2D.hxx
// Module : SMESH
//
// Convex FACEs whose radius of curvature is less than the thickness of layers
map< TGeomID, _ConvexFace > _convexFaces;
- // shapes (EDGEs and VERTEXes) srink from which is forbidden due to collisions with
+ // shapes (EDGEs and VERTEXes) shrink from which is forbidden due to collisions with
// the adjacent SOLID
set< TGeomID > _noShrinkShapes;
}
- // Fill _eosC1 to make that C1 FACEs and EGDEs between them to be smoothed as a whole
+ // Fill _eosC1 to make that C1 FACEs and EDGEs between them to be smoothed as a whole
TopTools_MapOfShape c1VV;
//================================================================================
/*!
- * \brief DEBUG. Create groups contating temorary data of _LayerEdge's
+ * \brief DEBUG. Create groups containing temporary data of _LayerEdge's
*/
//================================================================================
src2->GetID() < edge->_nodes[0]->GetID() )
continue; // avoid using same segment twice
- // a _LayerEdge containg tgt2
+ // a _LayerEdge containing tgt2
_LayerEdge* neiborEdge = edge->_2neibors->_edges[j];
_TmpMeshFaceOnEdge* f = new _TmpMeshFaceOnEdge( edge, neiborEdge, --_tmpFaceID );
vector< _EdgesOnShape* > subEOS;
vector< _LayerEdge* > lEdges;
- // loop on FACEs to srink mesh on
+ // loop on FACEs to shrink mesh on
map< TGeomID, list< _SolidData* > >::iterator f2sd = f2sdMap.begin();
for ( ; f2sd != f2sdMap.end(); ++f2sd )
{
if ( eos.SWOLType() == TopAbs_EDGE )
{
SMESH_subMesh* edgeSM = _mesh->GetSubMesh( eos._sWOL );
- _Shrinker1D& srinker = e2shrMap[ edgeSM->GetId() ];
- eShri1D.insert( & srinker );
- srinker.AddEdge( eos._edges[0], eos, helper );
+ _Shrinker1D& shrinker = e2shrMap[ edgeSM->GetId() ];
+ eShri1D.insert( & shrinker );
+ shrinker.AddEdge( eos._edges[0], eos, helper );
VISCOUS_3D::ToClearSubWithMain( edgeSM, data._solid );
- // restore params of nodes on EGDE if the EDGE has been already
- // srinked while srinking other FACE
- srinker.RestoreParams();
+ // restore params of nodes on EDGE if the EDGE has been already
+ // shrinked while shrinking other FACE
+ shrinker.RestoreParams();
}
for ( size_t i = 0; i < eos._edges.size(); ++i )
{
if ( data2 )
VISCOUS_3D::ToClearSubWithMain( sm, data2->_solid );
- } // loop on FACES to srink mesh on
+ } // loop on FACES to shrink mesh on
// Replace source nodes by target nodes in shrinked mesh edges
//================================================================================
/*!
- * \brief Try to fix triangles with high aspect ratio by swaping diagonals
+ * \brief Try to fix triangles with high aspect ratio by swapping diagonals
*/
//================================================================================
*/
struct _Segment
{
- const gp_XY* _uv[2]; // poiter to _LayerEdge::_uvIn
+ const gp_XY* _uv[2]; // pointer to _LayerEdge::_uvIn
int _indexInLine; // position in _PolyLine
_Segment() {}
//================================================================================
/*!
- * \brief Checks grid definintion mode
+ * \brief Checks grid definition mode
*/
//================================================================================
//================================================================================
/*!
- * \brief SLOT called when the grid definintion mode changes
+ * \brief SLOT called when the grid definition mode changes
*/
//================================================================================
OCC_CATCH_SIGNALS;
replot();
} catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
}
}
myExpr = ExprIntrp_GenExp::Create();
myExpr->Process( ( Standard_CString ) str.toLatin1().data() );
} catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
parsed_ok = false;
}
OCC_CATCH_SIGNALS;
res = myExpr->Expression()->Evaluate( myVars, myValues );
} catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
ok = false;
res = 0.0;
}
if(v < -7) v = -7.0;
v = pow( 10.0, v );
} catch(Standard_Failure) {
- Handle(Standard_Failure) aFail = Standard_Failure::Caught();
v = 0.0;
ok = false;
}
#include <SMESHGUI_SpinBox.h>
-// Qt incldues
+// Qt includes
#include <QItemDelegate>
#include <QTableWidget>
#include <QHeaderView>
#include <SVTK_ViewWindow.h>
#include <SALOME_ListIO.hxx>
-// SALOME KERNEL incldues
+// SALOME KERNEL includes
#include <SALOMEDSClient_SObject.hxx>
#include <SALOMEDSClient_Study.hxx>
void typeChanged(int);
private:
- QButtonGroup* myType; // Quadranle preference, Triangle preference, Reduced
+ QButtonGroup* myType; // Quadrangle preference, Triangle preference, Reduced
};
//================================================================================
//================================================================================
/*!
- * \brief Allow modifing myCustomWidgets in const methods
+ * \brief Allow modifying myCustomWidgets in const methods
* \retval ListOfWidgets* - non-const pointer to myCustomWidgets
*/
//================================================================================
//================================================================================
/*!
* \brief String to insert in "SMESH_%1_HYPOTHESIS" to get hypothesis type name
- * from message resouce file
+ * from message resource file
* \param t - hypothesis type
* \retval QString - result string
*/
</message>
<message>
<source>SMESH_DISTR_EXPR</source>
- <translation>Distribution with analitic density</translation>
+ <translation>Distribution with analytic density</translation>
</message>
<message>
<source>SMESH_DISTR_REGULAR</source>
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_ObjRefUlils.cxx
// Created : Wed Oct 18 15:38:22 2006
// Author : Edward AGAPOV (eap)
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH SMESH : implementaion of SMESH idl descriptions
+// SMESH SMESH : implementation of SMESH idl descriptions
// File : StdMeshers_ObjRefUlils.hxx
// Created : Wed Oct 18 15:15:27 2006
// Author : Edward AGAPOV (eap)
{
public:
/*!
- * \brief Return GEOM Object correspoding to TopoDS_Shape
+ * \brief Return GEOM Object corresponding to TopoDS_Shape
* \param theShape - input TopoDS_Shape
* \retval GEOM::GEOM_Object_ptr - result object
*/
}
/*!
- * \brief Return TopoDS_Shape correspoding to GEOM_Object
+ * \brief Return TopoDS_Shape corresponding to GEOM_Object
* \param theGeomObject - input object
* \retval TopoDS_Shape - result TopoDS_Shape
*/
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// SMESH StdMeshers : implementaion of SMESH idl descriptions
+// SMESH StdMeshers : implementation of SMESH idl descriptions
// File : StdMeshers_i.cxx
// Author : Julia DOROVSKIKH
// Module : SMESH
def RevolveMesh(MainMesh,**args):
"""
- This function premits to revolute and scale a 2D mesh while transforming the edge
+ This function permits to revolute and scale a 2D mesh while transforming the edge
groups into face groups. Moreover, the function automatically creates the face groups
corresponding to the symmetry lower and upper faces
Facultatif arguments are :
def ExtrudeMesh(MainMesh,**args):
"""
- This function premits to extrude and scale a 2D mesh while transforming the edge
+ This function permits to extrude and scale a 2D mesh while transforming the edge
groups into face groups. Moreover, the function automatically creates the face groups
corresponding to the symmetry lower and upper faces
Facultatif arguments are :
// Lecture des infos concernant le premier maillage
if (MEDmeshInfo(fid, 1, maa, &spacedim, &mdim, &type, desc, dtunit, &sortingtype, &nPasTemps, &axistype, axisname,
unitname) < 0)
- ERREUR("Error while reading mesh informations ");
+ ERREUR("Error while reading mesh information ");
//cout << chrono() << " --- inputMED: MEDmeshInfo: OK" << endl;
// cerr << "maa=" << maa << endl;
- **Mesh gradation**
-This parameter P controls the element size variation : MeshGems-SurfOpt will avoid having two adjacent egdes which sizes vary more than th given gradation. A size correction is applied to the size map : if two adjacent edges are respectively e1 and e2 long and e2 > Pxe1, then, the new size for the second edge will be set to P x e1.
+This parameter P controls the element size variation : MeshGems-SurfOpt will avoid having two adjacent edges which sizes vary more than the given gradation. A size correction is applied to the size map : if two adjacent edges are respectively e1 and e2 long and e2 > Pxe1, then, the new size for the second edge will be set to P x e1.
**This procedure is deactived if P=-1**
- **File**
-You can change the file used to store remeshing hypotheses, see :ref:`hypothesis-label` for further informations.
+You can change the file used to store remeshing hypotheses, see :ref:`hypothesis-label` for further information.
.. image:: images/Generic.png
:align: center
//jobParameters->maximum_duration = CORBA::string_dup("01:00");
jobParameters->queue = CORBA::string_dup("");
- // Setting resource and additionnal properties (if needed)
+ // Setting resource and additional properties (if needed)
// The resource parameters can be initiated from scratch, for
// example by specifying the values in hard coding:
// >>>
resourceDefinition = _resourcesManager->GetResourceDefinition(resourceName);
}
catch (const CORBA::SystemException& ex) {
- _lastErrorMessage = std::string("We can not access to the ressource ") + std::string(resourceName);
+ _lastErrorMessage = std::string("We can not access the resource ") + std::string(resourceName);
_lastErrorMessage+= std::string("(check the file CatalogResource.xml)");
LOG(_lastErrorMessage);
return JOBID_UNDEFINED;
// Then, the values can be used to initiate the resource parameters
// of the job:
jobParameters->resource_required.name = CORBA::string_dup(resourceDefinition->name.in());
- // CAUTION: the additionnal two following parameters MUST be
+ // CAUTION: the additional two following parameters MUST be
// specified explicitly, because they are not provided by the
// resource definition:
jobParameters->resource_required.mem_mb = resourceDefinition->mem_mb;
// SALOME application.
// In the code instructions, you just have to choose a resource
// configuration by its name and then define the ResourceParameters
- // that specify additionnal properties for a specific job submission
+ // that specify additional properties for a specific job submission
// (use the attribute resource_required of the JobParameters).
return resourceNames;
Engines::ResourcesManager_var _resourcesManager;
// This maps the config identifier to the config parameters. A
- // config is a resource with additionnal data specifying the
+ // config is a resource with additional data specifying the
// location of the binary program to be executed by the task
std::map<std::string, MESHJOB::ConfigParameter> _configMap;
