# variables are set properly; otherwise the script will fail.
#
################################################################################
+
+ import inspect
import sys
-def main(plugin_name, dummymeshhelp = True, output_file = "smeshBuilder.py"):
+def main(plugin_name, dummymeshhelp = True, output_file = "smeshBuilder.py", format = "doxygen"):
plugin_module_name = plugin_name + "Builder"
plugin_module = "salome.%s.%s" % (plugin_name, plugin_module_name)
try:
if methods:
output = []
if dummymeshhelp:
- if format == "doxygen":
- output.append( "## @package smeshBuilder" )
- output.append( "# Documentation of the methods dynamically added by the " + plugin_name + " meshing plug-in to the Mesh class." )
- output.append( "" )
++ if format == "doxygen":
+ output.append( "## @package smeshBuilder" )
+ output.append( "# Documentation of the methods dynamically added by the " + plugin_name + " meshing plug-in to the Mesh class." )
+ output.append( "" )
+ elif format == "sphinx":
+ output.append( '"""' )
+ output.append( 'Documentation of the methods dynamically added by the ' + plugin_name + ' meshing plug-in to the Mesh class.' )
+ output.append( '"""' )
+ output.append( '' )
pass
- output.append( "## This class allows defining and managing a mesh." )
- output.append( "#" )
+ if format == "doxygen":
+ output.append( "## This class allows defining and managing a mesh." )
+ output.append( "#" )
+ elif format == "sphinx":
+ output.append( "class Mesh:" )
+ output.append( ' """' )
+ output.append( ' This class allows defining and managing a mesh.' )
+ output.append( ' ' )
if dummymeshhelp:
# Add dummy Mesh help
# This is supposed to be done when generating documentation for meshing plug-ins
- output.append( "# @note The documentation below does not provide complete description of class @b %Mesh" )
- output.append( "# from @b smeshBuilder package. This documentation provides only information about" )
- output.append( "# the methods dynamically added to the %Mesh class by the " + plugin_name + " plugin" )
- output.append( "# For more details on the %Mesh class, please refer to the SALOME %Mesh module" )
- output.append( "# documentation." )
+ if format == "doxygen":
- output.append( "# @note The documentation below does not provide complete description of class @b %Mesh" )
++ output.append( "# @note The documentation below does not provide complete description of class @b %Mesh" )
+ output.append( "# from @b smeshBuilder package. This documentation provides only information about" )
+ output.append( "# the methods dynamically added to the %Mesh class by the " + plugin_name + " plugin" )
+ output.append( "# For more details on the %Mesh class, please refer to the SALOME %Mesh module" )
+ output.append( "# documentation." )
+ elif format == "sphinx":
+ output.append( ' The documentation below does not provide complete description of class @b %Mesh' )
+ output.append( ' from @b smeshBuilder package. This documentation provides only information about' )
+ output.append( ' the methods dynamically added to the %Mesh class by the " + plugin_name + " plugin' )
+ output.append( ' For more details on the %Mesh class, please refer to the SALOME %Mesh module' )
+ output.append( ' documentation.' )
+ output.append( ' """' )
+ output.append( ' ' )
pass
else:
# Extend documentation for Mesh class with information about dynamically added methods.
# This is supposed to be done only when building documentation for SMESH module
- output.append( "# @note Some methods are dynamically added to the @b %Mesh class in runtime by meshing " )
- output.append( "# plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " )
- output.append( "# try to look into the documentation for the meshing plug-ins." )
+ if format == "doxygen":
+ output.append( "# @note Some methods are dynamically added to the @b %Mesh class in runtime by meshing " )
- output.append( "# plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " )
- output.append( "# try to look into the documentation for the meshing plug-ins." )
- elif format == "sphinx":
++ output.append( "# plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " )
++ output.append( "# try to look into the documentation for the meshing plug-ins." )
++ elif format == "sphinx":
+ output.append( " Note:")
+ output.append( " Some methods are dynamically added to the @b %Mesh class in runtime by meshing " )
- output.append( " plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " )
- output.append( " try to look into the documentation for the meshing plug-ins." )
++ output.append( " plug-in modules. If you fail to find help on some methods in the documentation of SMESH module, " )
++ output.append( " try to look into the documentation for the meshing plug-ins." )
+ output.append( ' """' )
+ output.append( ' ' )
pass
- output.append( "class Mesh:" )
+ if format == "doxygen":
+ output.append( "class Mesh:" )
for method in methods:
docHelper = ""
for algo in methods[ method ]:
if docHelper: break
pass
if not docHelper: docHelper = "Creates new algorithm."
- output.append( " ## %s" % docHelper )
- output.append( " #" )
- output.append( " # This method is dynamically added to %Mesh class by the meshing plug-in(s). " )
- output.append( " #" )
- output.append( " # If the optional @a geom_shape parameter is not set, this algorithm is global (applied to whole mesh)." )
- output.append( " # Otherwise, this algorithm defines a submesh based on @a geom_shape subshape." )
- output.append( " # @param algo_type type of algorithm to be created; allowed values are specified by classes implemented by plug-in (see below)" )
- output.append( " # @param geom_shape if defined, the subshape to be meshed (GEOM_Object)" )
- output.append( " # @return An instance of Mesh_Algorithm sub-class according to the specified @a algo_type, see " )
- output.append( " # %s" % ", ".join( [ "%s.%s" % ( plugin_module_name, algo.__name__ ) for algo in methods[ method ] ] ) )
- output.append( " def %s(algo_type, geom_shape=0):" % method )
- output.append( " pass" )
+ if format == "doxygen":
+ output.append( " ## %s" % docHelper )
+ output.append( " #" )
+ output.append( " # This method is dynamically added to %Mesh class by the meshing plug-in(s). " )
+ output.append( " #" )
+ output.append( " # If the optional @a geom_shape parameter is not set, this algorithm is global (applied to whole mesh)." )
+ output.append( " # Otherwise, this algorithm defines a submesh based on @a geom_shape subshape." )
+ output.append( " # @param algo_type type of algorithm to be created; allowed values are specified by classes implemented by plug-in" )
+ output.append( " # @param geom_shape if defined, the subshape to be meshed (GEOM_Object)" )
+ output.append( " # @return An instance of Mesh_Algorithm sub-class according to the specified @a algo_type, see " )
+ output.append( " # %s" % ", ".join( [ "%s.%s" % ( plugin_module_name, algo.__name__ ) for algo in methods[ method ] ] ) )
+ output.append( " def %s(algo_type, geom_shape=0):" % method )
+ output.append( " pass" )
+ elif format == "sphinx":
+ output.append( ' def %s(algo_type, geom_shape=0):' % method )
+ output.append( ' """' )
+ output.append( ' %s' % docHelper )
+ output.append( ' ' )
+ output.append( ' This method is dynamically added to :class:`Mesh <smeshBuilder.Mesh>` class by the meshing plug-in(s). ' )
+ output.append( ' ' )
+ output.append( ' If the optional *geom_shape* parameter is not set, this algorithm is global (applied to whole mesh).' )
+ output.append( ' Otherwise, this algorithm defines a submesh based on *geom_shape* subshape.' )
+ output.append( ' ' )
+ output.append( ' Parameters:' )
+ output.append( ' algo_type: type of algorithm to be created; allowed values are specified by classes implemented by plug-in' )
+ output.append( ' geom_shape (GEOM_Object): if defined, the subshape to be meshed' )
+ output.append( ' ' )
+ output.append( ' Returns:')
+ output.append( ' An instance of Mesh_Algorithm sub-class according to the specified *algo_type*, see ' )
+ output.append( ' %s' % ", ".join( [ ":class:`~%s.%s`" % ( plugin_module_name, algo.__name__ ) for algo in methods[ method ] ] ) )
+ output.append( ' """' )
+ output.append( ' pass' )
pass
- f = open(output_file, "w")
- for line in output: f.write( line + "\n" )
- f.close()
+ with open(output_file, "w", encoding='utf8') as f:
+ f.write('\n'.join(output))
pass
pass
- except Exception, e:
- print e
+ except Exception as e:
+ print(e)
pass
pass
h = "If this option is True, dummy help for Mesh class is added. "
h += "This option should be False (default) when building documentation for SMESH module "
h += "and True when building documentation for meshing plug-ins."
- parser.add_option("-d", "--dummy-mesh-help", dest="dummymeshhelp",
+ parser.add_argument("-d", "--dummy-mesh-help", dest="dummymeshhelp",
action="store_true", default=False,
help=h)
- parser.add_argument("plugin", help='Name of plugin')
+ h = "Format of the documentation strings in the output file. Possible values are: "
+ h+= "'doxygen' - documentation strings are generated in the doxygen format, before a method defenition."
+ h+= "'sphinx' - documentation strings are generated in the sphinx format, after a method defenition."
- parser.add_option("-f", "--format", dest="format",
++ parser.add_argument("-f", "--format", dest="format",
+ action="store", default="doxygen", help=h)
+
- (options, args) = parser.parse_args()
++ parser.add_argument("plugin_name")
++
++
+ args = parser.parse_args()
- if len( args ) < 1: sys.exit("Plugin name is not specified")
- main( args[0], options.dummymeshhelp, options.output, options.format )
- main( args.plugin, args.dummymeshhelp, args.output )
++ if args.plugin_name is None : sys.exit("Plugin name is not specified")
++ main( args.plugin_name, args.dummymeshhelp, args.output, args.format )
pass
--- /dev/null
- *****************************************************
- Modifing Mesh Python scripts from SALOME 6 and before
- *****************************************************
+.. _smesh_migration_page:
+
- smesh = smeshBuilder.New(salome.myStudy)
++******************************************************
++Modifying Mesh Python scripts from SALOME 6 and before
++******************************************************
+
+In SALOME 7.2, the Python interface for Mesh has been slightly modified to offer new functionality:
+
+
+Scripts generated for SALOME 6 and older versions must be adapted to work in SALOME 7.2 with full functionality.
+The compatibility mode allows old scripts to work in almost all cases, but with a warning.
+
+* **Salome initialisation** must always be done as shown below.
+
+ (*salome_init()* can be invoked safely several times)::
+
+ import salome
+ salome.salome_init()
+
+* **smesh initialisation** is modified.
+
+ The old mode (from dump)::
+
+ import smesh, SMESH, SALOMEDS
+ smesh.SetCurrentStudy(salome.myStudy)
+
+ The new mode::
+
+ import SMESH, SALOMEDS
+ from salome.smesh import smeshBuilder
- You have to explicitely write *smesh.some_method()*.
++ smesh = smeshBuilder.New()
+
+
+* Of course, **from smesh import** * is **no more possible.**
+
- * If you need to **import a SMESH Plugin** explicitely, keep in mind that they are now located in separate namespaces.
++ You have to explicitly write *smesh.some_method()*.
+
+* All **algorithms** have been transferred from the namespace *smesh* to the namespace *smeshBuilder*.
+
+ For instance::
+
+ MEFISTO_2D_1 = Mesh_1.Triangle(algo=smesh.MEFISTO,geom=Face_1)
+
+ is replaced by::
+
+ MEFISTO_2D_1 = Mesh_1.Triangle(algo=smeshBuilder.MEFISTO,geom=Face_1)
+
+ StdMeshers algorithms concerned are *REGULAR, PYTHON, COMPOSITE, MEFISTO, Hexa, QUADRANGLE, RADIAL_QUAD*.
+
+ SMESH Plugins provide such algorithms as: *NETGEN, NETGEN_FULL, FULL_NETGEN, NETGEN_1D2D3D, NETGEN_1D2D, NETGEN_2D, NETGEN_3D*.
+
+ If you use DISTENE plugins, you also have *BLSURF, GHS3D, GHS3DPRL, Hexotic*.
+
+* Some **variables** were available in both namespaces *smesh* and *SMESH*. Now they are available only in namespace *SMESH*.
+
+ The dump function used only the namespace *SMESH*,
+ so, if your script was built with the help of the dump function, it should be already OK in this respect.
+
+ The most used variables concerned are:
+
+ * *NODE, EDGE, FACE, VOLUME, ALL.*
+ * *FT_xxx, geom_xxx, ADD_xxx...*
+
+ For instance::
+
+ srcFaceGroup = srcMesh.GroupOnGeom( midFace0, "src faces", smesh.FACE )
+ mesh.MakeGroup("Tetras",smesh.VOLUME,smesh.FT_ElemGeomType,"=",smesh.Geom_TETRA)
+ filter = smesh.GetFilter(smesh.FACE, smesh.FT_AspectRatio, smesh.FT_MoreThan, 6.5)
+
+ is replaced by::
+
+ srcFaceGroup = srcMesh.GroupOnGeom( midFace0, "src faces", SMESH.FACE )
+ mesh.MakeGroup("Tetras",SMESH.VOLUME,SMESH.FT_ElemGeomType,"=",SMESH.Geom_TETRA)
+ filter = smesh.GetFilter(SMESH.FACE, SMESH.FT_AspectRatio, SMESH.FT_MoreThan, 6.5)
+
+
+* The namespace **smesh.smesh** does not exist any more, use **smesh** instead.
+
+ For instance::
+
+ Compound1 = smesh.smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 0, 1, 1e-05)
+
+ is replaced by::
+
+ Compound1 = smesh.Concatenate([Mesh_inf.GetMesh(), Mesh_sup.GetMesh()], 0, 1, 1e-05)
+
++* If you need to **import a SMESH Plugin** explicitly, keep in mind that they are now located in separate namespaces.
+
+ For instance::
+
+ import StdMeshers
+ import NETGENPlugin
+ import BLSURFPlugin
+ import GHS3DPlugin
+ import HexoticPLUGIN
+
+ is replaced by::
+
+ from salome.StdMeshers import StdMeshersBuilder
+ from salome.NETGENPlugin import NETGENPluginBuilder
+ from salome.BLSURFPlugin import BLSURFPluginBuilder
+ from salome.GHS3DPlugin import GHS3DPluginBuilder
+ from salome.HexoticPLUGIN import HexoticPLUGINBuilder
+
+
--- /dev/null
- except Exception, e:
- print e
+import inspect
+import sys
+from types import FunctionType
+import copy
+
+ORIGIN_MODULE_SUFFIX = "_origin"
+DYNAMIC_MODULE_SUFFIX = "_dynamic"
+
+
+def main(module_name, output_file = "smeshBuilder.py"):
+ oringin_module_name = module_name + ORIGIN_MODULE_SUFFIX
+ dynamic_module_name = module_name + DYNAMIC_MODULE_SUFFIX
+ try:
+ exec( "import %s" % oringin_module_name )
+ exec( "origin_module = %s" % oringin_module_name )
+ origin_module_lines = inspect.getsourcelines( origin_module )[0]
+ origin_meshClass_lines = inspect.getsourcelines(origin_module.Mesh)[0]
+ origin_module_text = "".join( origin_module_lines )
+ origin_meshClass_text = "".join( origin_meshClass_lines )
+
+ exec( "import %s" % dynamic_module_name )
+ exec( "dynanmic_module = %s" % dynamic_module_name )
+ dynanmic_meshClass = dynanmic_module.Mesh
+
+ new_meshClass_lines = copy.copy(origin_meshClass_lines)
+ # remove end of class 'pass'
+ if new_meshClass_lines[-1].find("pass") > 0:
+ new_meshClass_lines.pop()
+
+ dynanmic_meshClass_methods = [x for x, y in dynanmic_meshClass.__dict__.items() if type(y) == FunctionType]
+ for method in dynanmic_meshClass_methods:
+ exec( "method_lines = inspect.getsourcelines(dynanmic_module.Mesh.%s)[0]" % method)
+ new_meshClass_lines+=method_lines
+ pass
+ new_meshClass_text = "".join( new_meshClass_lines )
+
+ f = open( output_file, "w" )
+
+ f.write( origin_module_text.replace( origin_meshClass_text, new_meshClass_text) )
+ f.close()
++ except Exception as e:
++ print(e)
+ pass
+ pass
+
+
+if __name__ == "__main__":
+ import optparse
+ parser = optparse.OptionParser(usage="%prog [options] modulename")
+ h = "Output file (smeshBuilder.py by default)"
+ parser.add_option("-o", "--output", dest="output",
+ action="store", default="smeshBuilder.py", metavar="file",
+ help=h)
+
+ (options, args) = parser.parse_args()
+
+ if len( args ) < 1: sys.exit("Module name is not specified")
+ main( args[0], options.output )
+ pass
INCLUDE_DIRECTORIES(
${HDF5_INCLUDE_DIRS}
${KERNEL_INCLUDE_DIRS}
- ${CAS_INCLUDE_DIRS}
+ ${OpenCASCADE_INCLUDE_DIR}
${VTK_INCLUDE_DIRS}
${Boost_INCLUDE_DIRS}
- ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
- ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Factory
+ ${PROJECT_SOURCE_DIR}/src/MEDWrapper
${PROJECT_SOURCE_DIR}/src/Driver
${PROJECT_SOURCE_DIR}/src/SMDS
${PROJECT_SOURCE_DIR}/src/SMESHUtils
${VTK_INCLUDE_DIRS}
${Boost_INCLUDE_DIRS}
${HDF5_INCLUDE_DIRS}
+ ${TBB_INCLUDE_DIRS}
${PROJECT_SOURCE_DIR}/src/Controls
- ${PROJECT_SOURCE_DIR}/src/MEDWrapper/Base
+ ${PROJECT_SOURCE_DIR}/src/MEDWrapper
${PROJECT_SOURCE_DIR}/src/Driver
${PROJECT_SOURCE_DIR}/src/DriverDAT
${PROJECT_SOURCE_DIR}/src/DriverMED
SMESHGUI_FieldSelectorWdg.h
SMESHGUI_DisplayEntitiesDlg.h
SMESHGUI_SplitBiQuad.h
-- SMESHGUI_PreVisualObj.h
SMESHGUI_IdPreview.h
)
break;
}
- if(checkLock(aStudy)) break;
+ case SMESHOp::OpOffset:
+ {
++ if(isStudyLocked()) break;
+ if ( vtkwnd ) {
+ EmitSignalDeactivateDialog();
+ ( new SMESHGUI_OffsetDlg( this ) )->show();
+ }
+ else {
+ SUIT_MessageBox::warning(SMESHGUI::desktop(),
+ tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
+ }
+ break;
+ }
+
case SMESHOp::OpSewing:
{
- if(checkLock(aStudy)) break;
+ if(isStudyLocked()) break;
if(vtkwnd) {
EmitSignalDeactivateDialog();
( new SMESHGUI_SewingDlg( this ) )->show();
aGroupMainShape = aGeomGroup;
aGroupMainShape->Register();
}
- _PTR(SObject) aGroupMainShapeSO = aStudy->FindObjectID( entry.in() );
+ CORBA::String_var entry = aGroupMainShape->GetStudyEntry();
- SMESH::getStudy()->FindObjectID(aGroupMainShape->GetStudyEntry());
+ _PTR(SObject) aGroupMainShapeSO =
++ SMESH::getStudy()->FindObjectID( entry.in() );
_PTR(SObject) anObj, aRef;
bool isRefOrSubShape = false;
--- /dev/null
- if (mySMESHGUI->isActiveStudyLocked())
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// 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 : SMESHGUI_OffsetDlg.cxx
+
+// SMESH includes
+
+#include "SMESHGUI_OffsetDlg.h"
+
+#include "SMESHGUI.h"
+#include "SMESHGUI_SpinBox.h"
+#include "SMESHGUI_Utils.h"
+#include "SMESHGUI_VTKUtils.h"
+#include "SMESHGUI_MeshUtils.h"
+#include "SMESHGUI_IdValidator.h"
+#include "SMESHGUI_FilterDlg.h"
+#include "SMESHGUI_MeshEditPreview.h"
+
+#include <SMESH_Actor.h>
+#include <SMESH_TypeFilter.hxx>
+#include <SMESH_LogicalFilter.hxx>
+#include <SMDS_Mesh.hxx>
+
+// SALOME GUI includes
+#include <LightApp_Application.h>
+#include <LightApp_SelectionMgr.h>
+#include <SALOME_ListIO.hxx>
+#include <SUIT_Desktop.h>
+#include <SUIT_MessageBox.h>
+#include <SUIT_OverrideCursor.h>
+#include <SUIT_ResourceMgr.h>
+#include <SUIT_Session.h>
+#include <SVTK_ViewModel.h>
+#include <SVTK_ViewWindow.h>
+#include <SalomeApp_Tools.h>
+
+// SALOME KERNEL includes
+#include <SALOMEDSClient.hxx>
+#include <SALOMEDSClient_SObject.hxx>
+
+// OCCT includes
+#include <TColStd_MapOfInteger.hxx>
+
+// Qt includes
+#include <QApplication>
+#include <QButtonGroup>
+#include <QGroupBox>
+#include <QLabel>
+#include <QLineEdit>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QCheckBox>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QGridLayout>
+#include <QSpinBox>
+#include <QKeyEvent>
+
+// IDL includes
+#include <SALOMEconfig.h>
+#include CORBA_SERVER_HEADER(SMESH_Group)
+#include CORBA_SERVER_HEADER(SMESH_MeshEditor)
+
+enum { MOVE_ELEMS_BUTTON = 0, COPY_ELEMS_BUTTON, MAKE_MESH_BUTTON }; //!< action type
+
+/*!
+ \class BusyLocker
+ \brief Simple 'busy state' flag locker.
+ \internal
+*/
+class BusyLocker
+{
+public:
+ //! Constructor. Sets passed boolean flag to \c true.
+ BusyLocker( bool& busy ) : myBusy( busy ) { myBusy = true; }
+ //! Destructor. Clear external boolean flag passed as parameter to the constructor to \c false.
+ ~BusyLocker() { myBusy = false; }
+private:
+ bool& myBusy; //! External 'busy state' boolean flag
+};
+
+#define SPACING 6
+#define MARGIN 11
+
+//=================================================================================
+// class : SMESHGUI_OffsetDlg()
+// purpose :
+//=================================================================================
+SMESHGUI_OffsetDlg::SMESHGUI_OffsetDlg( SMESHGUI* theModule ) :
+ SMESHGUI_MultiPreviewDlg( theModule ),
+ mySelectionMgr( SMESH::GetSelectionMgr( theModule ) ),
+ myFilterDlg(0)
+{
+ QPixmap image0 (SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap("SMESH", tr("ICON_DLG_MESH_OFFSET")));
+ QPixmap image1 (SMESH::GetResourceMgr( mySMESHGUI )->loadPixmap("SMESH", tr("ICON_SELECT")));
+
+ setModal(false);
+ setAttribute(Qt::WA_DeleteOnClose, true);
+ setWindowTitle(tr("SMESH_OFFSET_TITLE"));
+ setSizeGripEnabled(true);
+
+ QVBoxLayout* dlgLayout = new QVBoxLayout(this);
+ dlgLayout->setSpacing(SPACING);
+ dlgLayout->setMargin(MARGIN);
+
+ /***************************************************************/
+ ConstructorsBox = new QGroupBox(tr("SMESH_OFFSET"), this);
+ QHBoxLayout* ConstructorsBoxLayout = new QHBoxLayout(ConstructorsBox);
+ ConstructorsBoxLayout->setSpacing(SPACING);
+ ConstructorsBoxLayout->setMargin(MARGIN);
+
+ QRadioButton* RadioButton1= new QRadioButton(ConstructorsBox);
+ RadioButton1->setIcon(image0);
+
+ ConstructorsBoxLayout->addWidget(RadioButton1);
+
+ /***************************************************************/
+ GroupArguments = new QGroupBox(tr("SMESH_ARGUMENTS"), this);
+ QGridLayout* GroupArgumentsLayout = new QGridLayout(GroupArguments);
+ GroupArgumentsLayout->setSpacing(SPACING);
+ GroupArgumentsLayout->setMargin(MARGIN);
+
+ myIdValidator = new SMESHGUI_IdValidator(this);
+
+ // Controls for elements selection
+ TextLabelElements = new QLabel(tr("SMESH_ID_ELEMENTS"), GroupArguments);
+ // SelectElementsButton = new QPushButton(GroupArguments);
+ // SelectElementsButton->setIcon(image1);
+ LineEditElements = new QLineEdit(GroupArguments);
+ LineEditElements->setValidator(myIdValidator);
+ LineEditElements->setMaxLength(-1);
+ myFilterBtn = new QPushButton( tr( "SMESH_BUT_FILTER" ), GroupArguments );
+ connect(myFilterBtn, SIGNAL(clicked()), this, SLOT(setFilters()));
+
+ // Control for the whole mesh selection
+ CheckBoxMesh = new QCheckBox(tr("SMESH_SELECT_WHOLE_MESH"), GroupArguments);
+
+ // offset
+ QLabel* TextLabel1 = new QLabel(tr("OFFSET_VALUE"), GroupArguments);
+ SpinBox = new SMESHGUI_SpinBox(GroupArguments);
+
+
+ // switch of action type
+ ActionBox = new QGroupBox(GroupArguments);
+ ActionGroup = new QButtonGroup(GroupArguments);
+ QVBoxLayout* ActionBoxLayout = new QVBoxLayout(ActionBox);
+ ActionBoxLayout->addSpacing(SPACING);
+ ActionBoxLayout->setMargin(MARGIN);
+
+ QRadioButton* aMoveElements = new QRadioButton(tr("SMESH_MOVE_ELEMENTS"), ActionBox);
+ QRadioButton* aCopyElements = new QRadioButton(tr("SMESH_COPY_ELEMENTS"), ActionBox);
+ QRadioButton* aCreateMesh = new QRadioButton(tr("SMESH_CREATE_MESH"), ActionBox);
+
+ ActionBoxLayout->addWidget(aMoveElements);
+ ActionBoxLayout->addWidget(aCopyElements);
+ ActionBoxLayout->addWidget(aCreateMesh);
+ ActionGroup->addButton(aMoveElements, MOVE_ELEMS_BUTTON);
+ ActionGroup->addButton(aCopyElements, COPY_ELEMS_BUTTON);
+ ActionGroup->addButton(aCreateMesh, MAKE_MESH_BUTTON);
+
+ // CheckBox for groups generation
+ MakeGroupsCheck = new QCheckBox(tr("SMESH_MAKE_GROUPS"), GroupArguments);
+ MakeGroupsCheck->setChecked(false);
+
+ // Name of a mesh to create
+ LineEditNewMesh = new QLineEdit(GroupArguments);
+
+ //Preview check box
+ myPreviewCheckBox = new QCheckBox(tr("PREVIEW"), GroupArguments);
+
+ // layout
+ GroupArgumentsLayout->addWidget(TextLabelElements, 0, 0);
+ //GroupArgumentsLayout->addWidget(SelectElementsButton, 0, 1);
+ GroupArgumentsLayout->addWidget(LineEditElements, 0, 2, 1, 5);
+ GroupArgumentsLayout->addWidget(myFilterBtn, 0, 7);
+ GroupArgumentsLayout->addWidget(CheckBoxMesh, 1, 0, 1, 8);
+ GroupArgumentsLayout->addWidget(TextLabel1, 2, 0);
+ GroupArgumentsLayout->addWidget(SpinBox, 2, 3);
+ GroupArgumentsLayout->addWidget(ActionBox, 3, 0, 3, 4);
+ GroupArgumentsLayout->addWidget(MakeGroupsCheck, 4, 5, 1, 4);
+ GroupArgumentsLayout->addWidget(LineEditNewMesh, 5, 5, 1, 4);
+ GroupArgumentsLayout->addWidget(myPreviewCheckBox, 6, 0);
+
+ /***************************************************************/
+ GroupButtons = new QGroupBox(this);
+ QHBoxLayout* GroupButtonsLayout = new QHBoxLayout(GroupButtons);
+ GroupButtonsLayout->setSpacing(SPACING);
+ GroupButtonsLayout->setMargin(MARGIN);
+
+ buttonOk = new QPushButton(tr("SMESH_BUT_APPLY_AND_CLOSE"), GroupButtons);
+ buttonOk->setAutoDefault(true);
+ buttonOk->setDefault(true);
+ buttonApply = new QPushButton(tr("SMESH_BUT_APPLY"), GroupButtons);
+ buttonApply->setAutoDefault(true);
+ buttonCancel = new QPushButton(tr("SMESH_BUT_CLOSE"), GroupButtons);
+ buttonCancel->setAutoDefault(true);
+ buttonHelp = new QPushButton(tr("SMESH_BUT_HELP"), GroupButtons);
+ buttonHelp->setAutoDefault(true);
+
+ GroupButtonsLayout->addWidget(buttonOk);
+ GroupButtonsLayout->addSpacing(10);
+ GroupButtonsLayout->addWidget(buttonApply);
+ GroupButtonsLayout->addSpacing(10);
+ GroupButtonsLayout->addStretch();
+ GroupButtonsLayout->addWidget(buttonCancel);
+ GroupButtonsLayout->addWidget(buttonHelp);
+
+ /***************************************************************/
+ dlgLayout->addWidget(ConstructorsBox);
+ dlgLayout->addWidget(GroupArguments);
+ dlgLayout->addWidget(GroupButtons);
+
+ /* Initialisations */
+ SpinBox->RangeStepAndValidator(COORD_MIN, COORD_MAX, 1.0, "length_precision");
+
+ RadioButton1->setChecked(true);
+
+ mySelector = (SMESH::GetViewWindow( mySMESHGUI ))->GetSelector();
+
+ mySMESHGUI->SetActiveDialogBox((QDialog*)this);
+
+ // Costruction of the logical filter
+ SMESH_TypeFilter* aMeshOrSubMeshFilter = new SMESH_TypeFilter (SMESH::MESHorSUBMESH);
+ SMESH_TypeFilter* aSmeshGroupFilter = new SMESH_TypeFilter (SMESH::GROUP);
+
+ QList<SUIT_SelectionFilter*> aListOfFilters;
+ if (aMeshOrSubMeshFilter) aListOfFilters.append(aMeshOrSubMeshFilter);
+ if (aSmeshGroupFilter) aListOfFilters.append(aSmeshGroupFilter);
+
+ myMeshOrSubMeshOrGroupFilter =
+ new SMESH_LogicalFilter(aListOfFilters, SMESH_LogicalFilter::LO_OR);
+
+ myHelpFileName = "Offset_page.html";
+
+ Init();
+
+ /* signals and slots connections */
+ connect(buttonOk, SIGNAL(clicked()), this, SLOT(ClickOnOk()));
+ connect(buttonCancel, SIGNAL(clicked()), this, SLOT(reject()));
+ connect(buttonApply, SIGNAL(clicked()), this, SLOT(ClickOnApply()));
+ connect(buttonHelp, SIGNAL(clicked()), this, SLOT(ClickOnHelp()));
+
+ //connect(SelectElementsButton, SIGNAL (clicked()), this, SLOT(SetEditCurrentArgument()));
+
+ connect(mySMESHGUI, SIGNAL (SignalDeactivateActiveDialog()), this, SLOT(DeactivateActiveDialog()));
+ connect(mySelectionMgr, SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
+ /* to close dialog if study change */
+ connect(mySMESHGUI, SIGNAL(SignalCloseAllDialogs()), this, SLOT(reject()));
+ connect(mySMESHGUI, SIGNAL(SignalActivatedViewManager()), this, SLOT(onOpenView()));
+ connect(mySMESHGUI, SIGNAL(SignalCloseView()), this, SLOT(onCloseView()));
+
+ connect(LineEditElements, SIGNAL(textChanged(const QString&)), SLOT(onTextChange(const QString&)));
+ connect(CheckBoxMesh, SIGNAL(toggled(bool)), SLOT(onSelectMesh(bool)));
+ connect(ActionGroup, SIGNAL(buttonClicked(int)), SLOT(onActionClicked(int)));
+
+ connect(SpinBox, SIGNAL(valueChanged(double)), this, SLOT(toDisplaySimulation()));
+
+ //To Connect preview check box
+ connectPreviewControl();
+
+ SelectionIntoArgument();
+ onActionClicked(MOVE_ELEMS_BUTTON);
+}
+
+//=================================================================================
+// function : ~SMESHGUI_OffsetDlg()
+// purpose : Destroys the object and frees any allocated resources
+//=================================================================================
+SMESHGUI_OffsetDlg::~SMESHGUI_OffsetDlg()
+{
+ if ( myFilterDlg ) {
+ myFilterDlg->setParent( 0 );
+ delete myFilterDlg;
+ myFilterDlg = 0;
+ }
+}
+
+//=================================================================================
+// function : Init()
+// purpose :
+//=================================================================================
+void SMESHGUI_OffsetDlg::Init (bool ResetControls)
+{
+ myBusy = false;
+ myObjects.clear();
+ myObjectsNames.clear();
+ myMeshes.clear();
+
+ LineEditElements->clear();
+ myElementsId = "";
+ myNbOkElements = 0;
+
+ buttonOk->setEnabled(false);
+ buttonApply->setEnabled(false);
+
+ myActor = 0;
+
+ if (ResetControls)
+ {
+ SpinBox->SetValue(1.0);
+ myPreviewCheckBox->setChecked(false);
+ onDisplaySimulation(false);
+
+ ActionGroup->button( MOVE_ELEMS_BUTTON )->setChecked(true);
+ CheckBoxMesh->setChecked(true);
+ onSelectMesh(true);
+ }
+}
+
+//=================================================================================
+// function : ClickOnApply()
+// purpose :
+//=================================================================================
+bool SMESHGUI_OffsetDlg::ClickOnApply()
+{
++ if (mySMESHGUI->isStudyLocked())
+ return false;
+
+ if( !isValid() )
+ return false;
+
+ SUIT_OverrideCursor aWaitCursor;
+
+ if (myNbOkElements)
+ {
+ QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
+
+ SMESH::long_array_var anElementsId = new SMESH::long_array;
+ anElementsId->length(aListElementsId.count());
+ for (int i = 0; i < aListElementsId.count(); i++)
+ anElementsId[i] = aListElementsId[i].toInt();
+
+ double offsetValue = SpinBox->value();
+
+ QStringList aParameters;
+ aParameters << SpinBox->text();
+
+ int actionButton = ActionGroup->checkedId();
+ bool makeGroups = ( MakeGroupsCheck->isEnabled() && MakeGroupsCheck->isChecked() );
+ SMESH::ListOfGroups_var groups;
+ SMESH::SMESH_Mesh_var mesh;
+ QStringList anEntryList;
+ try
+ {
+ switch ( actionButton ) {
+
+ case MOVE_ELEMS_BUTTON:
+ if ( CheckBoxMesh->isChecked() )
+ for ( int i = 0; i < myObjects.count(); i++ ) {
+ SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
+ myMeshes[i]->SetParameters( aParameters.join( ":" ).toLatin1().constData() );
+ mesh = aMeshEditor->Offset( myObjects[i], offsetValue, true, "", groups.out() );
+ }
+ else {
+ SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
+ SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE);
+ myMeshes[0]->SetParameters( aParameters.join( ":" ).toLatin1().constData() );
+ mesh = aMeshEditor->Offset( src, offsetValue, true, "", groups.out() );
+ }
+ break;
+
+ case COPY_ELEMS_BUTTON:
+ if ( CheckBoxMesh->isChecked() )
+ for ( int i = 0; i < myObjects.count(); i++ ) {
+ SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ mesh = aMeshEditor->Offset( myObjects[i], offsetValue, makeGroups, "", groups.out() );
+ }
+ else {
+ SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
+ SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE );
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ mesh = aMeshEditor->Offset( src, offsetValue, makeGroups, "", groups.out() );
+ }
+ break;
+
+ case MAKE_MESH_BUTTON: {
+ SMESH::SMESH_Mesh_var mesh;
+ if ( CheckBoxMesh->isChecked() ) {
+ for ( int i = 0; i < myObjects.count(); i++ ) {
+ QString aName =
+ SMESH::UniqueMeshName( LineEditNewMesh->text().replace( "*", myObjectsNames[i] ));
+ SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditor();
+ myMeshes[i]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ mesh = aMeshEditor->Offset( myObjects[i], offsetValue, makeGroups,
+ aName.toLatin1().data(), groups.out() );
+ if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ))
+ anEntryList.append( aSObject->GetID().c_str() );
+ }
+ }
+ else {
+ SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditor();
+ myMeshes[0]->SetParameters(aParameters.join( ":" ).toLatin1().constData());
+ SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE );
+ mesh = aMeshEditor->Offset( src, offsetValue, makeGroups,
+ LineEditNewMesh->text().toLatin1().data(), groups.out() );
+ if( _PTR(SObject) aSObject = SMESH::ObjectToSObject( mesh ) )
+ anEntryList.append( aSObject->GetID().c_str() );
+ }
+ break;
+ }
+ }
+ }
+ catch ( const SALOME::SALOME_Exception& S_ex ) {
+ SalomeApp_Tools::QtCatchCorbaException( S_ex );
+ }
+ catch (...) {
+ }
+
+ for ( int i = 0; i < myObjects.count(); i++ ) {
+ SMESH_Actor* actor = SMESH::FindActorByObject( myObjects[i] );
+ if ( actor ) SMESH::Update( actor->getIO(), true );
+ }
+
+ if ( makeGroups || actionButton == MAKE_MESH_BUTTON )
+ {
+ mySMESHGUI->updateObjBrowser(true); // new groups may appear
+ if( LightApp_Application* anApp =
+ dynamic_cast<LightApp_Application*>( SUIT_Session::session()->activeApplication() ) )
+ anApp->browseObjects( anEntryList, isApplyAndClose() );
+ }
+ if ( !isApplyAndClose() )
+ {
+ Init(false);
+ SelectionIntoArgument();
+ }
+ SMESHGUI::Modified();
+ }
+
+ return true;
+}
+
+//=================================================================================
+// function : ClickOnOk()
+// purpose :
+//=================================================================================
+void SMESHGUI_OffsetDlg::ClickOnOk()
+{
+ setIsApplyAndClose( true );
+ if( ClickOnApply() )
+ reject();
+}
+
+//=================================================================================
+// function : reject()
+// purpose :
+//=================================================================================
+void SMESHGUI_OffsetDlg::reject()
+{
+ disconnect(mySelectionMgr, 0, this, 0);
+ mySelectionMgr->clearFilters();
+ if (SMESH::GetCurrentVtkView()) {
+ SMESH::RemoveFilters(); // PAL6938 -- clean all mesh entity filters
+ SMESH::SetPointRepresentation(false);
+ }
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode( ActorSelection );
+ mySMESHGUI->ResetState();
+ QDialog::reject();
+}
+
+//=================================================================================
+// function : onOpenView()
+// purpose :
+//=================================================================================
+void SMESHGUI_OffsetDlg::onOpenView()
+{
+ if ( mySelector ) {
+ SMESH::SetPointRepresentation(false);
+ }
+ else {
+ mySelector = SMESH::GetViewWindow( mySMESHGUI )->GetSelector();
+ ActivateThisDialog();
+ }
+}
+
+//=================================================================================
+// function : onCloseView()
+// purpose :
+//=================================================================================
+void SMESHGUI_OffsetDlg::onCloseView()
+{
+ DeactivateActiveDialog();
+ mySelector = 0;
+}
+
+//=================================================================================
+// function : ClickOnHelp()
+// purpose :
+//=================================================================================
+void SMESHGUI_OffsetDlg::ClickOnHelp()
+{
+ LightApp_Application* app = (LightApp_Application*)(SUIT_Session::session()->activeApplication());
+ if (app)
+ app->onHelpContextModule(mySMESHGUI ? app->moduleName(mySMESHGUI->moduleName()) : QString(""), myHelpFileName);
+ else {
+ QString platform;
+#ifdef WIN32
+ platform = "winapplication";
+#else
+ platform = "application";
+#endif
+ SUIT_MessageBox::warning(this, tr("WRN_WARNING"),
+ tr("EXTERNAL_BROWSER_CANNOT_SHOW_PAGE").
+ arg(app->resourceMgr()->stringValue("ExternalBrowser",
+ platform)).
+ arg(myHelpFileName));
+ }
+}
+
+//=======================================================================
+// function : onTextChange()
+// purpose :
+//=======================================================================
+
+void SMESHGUI_OffsetDlg::onTextChange (const QString& theNewText)
+{
+ if (myBusy) return;
+ BusyLocker lock( myBusy );
+
+ myNbOkElements = 0;
+
+ buttonOk->setEnabled(false);
+ buttonApply->setEnabled(false);
+
+ // highlight entered elements
+ SMDS_Mesh* aMesh = 0;
+ if (myActor)
+ aMesh = myActor->GetObject()->GetMesh();
+
+ if (aMesh) {
+ Handle(SALOME_InteractiveObject) anIO = myActor->getIO();
+
+ TColStd_MapOfInteger newIndices;
+
+ QStringList aListId = theNewText.split(" ", QString::SkipEmptyParts);
+ for (int i = 0; i < aListId.count(); i++)
+ {
+ if ( const SMDS_MeshElement * e = aMesh->FindElement(aListId[ i ].toInt()))
+ newIndices.Add( e->GetID() );
+ myNbOkElements++;
+ }
+
+ mySelector->AddOrRemoveIndex( anIO, newIndices, false );
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->highlight( anIO, true, true );
+
+ myElementsId = theNewText;
+ }
+
+ if (myNbOkElements) {
+ buttonOk->setEnabled(true);
+ buttonApply->setEnabled(true);
+ }
+}
+
+//=================================================================================
+// function : SelectionIntoArgument()
+// purpose : Called when selection as changed or other case
+//=================================================================================
+void SMESHGUI_OffsetDlg::SelectionIntoArgument()
+{
+ if (myBusy) return;
+ if (myFilterDlg && myFilterDlg->isVisible()) return; // filter dlg active
+
+ BusyLocker lock( myBusy );
+
+ // clear
+ myActor = 0;
+ QString aString = "";
+ onDisplaySimulation(false);
+
+ LineEditElements->setText(aString);
+ myNbOkElements = 0;
+ buttonOk->setEnabled(false);
+ buttonApply->setEnabled(false);
+
+ if (!GroupButtons->isEnabled()) // inactive
+ return;
+
+ // get selected mesh
+ SALOME_ListIO aList;
+ mySelectionMgr->selectedObjects(aList);
+
+ int nbSel = aList.Extent();
+ if (nbSel < 1)
+ return;
+
+ myElementsId = "";
+ myObjects.clear();
+ myObjectsNames.clear();
+ myMeshes.clear();
+
+ for ( SALOME_ListIteratorOfListIO it( aList ); it.More(); it.Next() )
+ {
+ Handle(SALOME_InteractiveObject) IO = it.Value();
+ SMESH::SMESH_Mesh_var aMesh = SMESH::GetMeshByIO( IO );
+ if ( aMesh->_is_nil() || aMesh->NbFaces() == 0 )
+ return;
+
+ myActor = SMESH::FindActorByObject( aMesh );
+ if ( !myActor )
+ myActor = SMESH::FindActorByEntry( IO->getEntry() );
+
+ SMESH::SMESH_IDSource_var idSrc = SMESH::IObjectToInterface<SMESH::SMESH_IDSource>( IO );
+ if ( _PTR(SObject) obj = SMESH::FindSObject( idSrc ))
+ {
+ std::string name = obj->GetName();
+ if ( !name.empty() )
+ {
+ myObjects << idSrc;
+ myObjectsNames << name.c_str();
+ myMeshes << aMesh;
+ }
+ }
+ }
+
+ // MakeGroups is available if there are groups and "Copy"
+ int aNbGroups = 0;
+ for ( int i = 0; i < myMeshes.count(); i++ )
+ aNbGroups += myMeshes[i]->NbGroups();
+
+ if ( aNbGroups == 0 ) {
+ MakeGroupsCheck->setChecked(false);
+ MakeGroupsCheck->setEnabled(false);
+ }
+ else if ( ActionGroup->checkedId() != MOVE_ELEMS_BUTTON ) {
+ MakeGroupsCheck->setEnabled(true);
+ }
+
+ if (CheckBoxMesh->isChecked()) {
+ if (myMeshes.isEmpty())
+ return;
+ SMESH::GetNameOfSelectedIObjects( mySelectionMgr, aString );
+ }
+ else {
+ int aNbUnits = SMESH::GetNameOfSelectedElements(mySelector, aList.First(), aString);
+ myElementsId = aString;
+ if (aNbUnits < 1)
+ return;
+ }
+
+ myNbOkElements = true;
+
+ LineEditElements->setText(aString);
+ LineEditElements->repaint();
+ LineEditElements->setEnabled(false); // to fully update lineedit IPAL 19809
+ LineEditElements->setEnabled(true);
+ setNewMeshName();
+
+ buttonOk->setEnabled(true);
+ buttonApply->setEnabled(true);
+
+ onDisplaySimulation(true);
+}
+
+//=================================================================================
+// function : DeactivateActiveDialog()
+// purpose :
+//=================================================================================
+
+void SMESHGUI_OffsetDlg::DeactivateActiveDialog()
+{
+ if (ConstructorsBox->isEnabled())
+ {
+ ConstructorsBox->setEnabled(false);
+ GroupArguments->setEnabled(false);
+ GroupButtons->setEnabled(false);
+ mySMESHGUI->ResetState();
+ mySMESHGUI->SetActiveDialogBox(0);
+ }
+}
+
+//=================================================================================
+// function : ActivateThisDialog()
+// purpose :
+//=================================================================================
+
+void SMESHGUI_OffsetDlg::ActivateThisDialog()
+{
+ /* Emit a signal to deactivate the active dialog */
+ mySMESHGUI->EmitSignalDeactivateDialog();
+ ConstructorsBox->setEnabled(true);
+ GroupArguments->setEnabled(true);
+ GroupButtons->setEnabled(true);
+
+ mySMESHGUI->SetActiveDialogBox((QDialog*)this);
+
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode( CellSelection );
+
+ SelectionIntoArgument();
+}
+
+//=================================================================================
+// function : enterEvent()
+// purpose :
+//=================================================================================
+
+void SMESHGUI_OffsetDlg::enterEvent (QEvent*)
+{
+ if (!ConstructorsBox->isEnabled()) {
+ SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI );
+ if ( aViewWindow && !mySelector) {
+ mySelector = aViewWindow->GetSelector();
+ }
+ ActivateThisDialog();
+ }
+}
+
+//=======================================================================
+//function : onSelectMesh
+//purpose :
+//=======================================================================
+
+void SMESHGUI_OffsetDlg::onSelectMesh (bool toSelectMesh)
+{
+ if (toSelectMesh)
+ TextLabelElements->setText(tr("SMESH_NAME"));
+ else
+ TextLabelElements->setText(tr("SMESH_ID_ELEMENTS"));
+ myFilterBtn->setEnabled(!toSelectMesh);
+
+ mySelectionMgr->clearFilters();
+ SMESH::SetPointRepresentation(false);
+
+ if (toSelectMesh)
+ {
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode( ActorSelection );
+ mySelectionMgr->installFilter( myMeshOrSubMeshOrGroupFilter );
+ LineEditElements->setReadOnly( true );
+ LineEditElements->setValidator( 0 );
+ }
+ else
+ {
+ if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
+ aViewWindow->SetSelectionMode( FaceSelection );
+ LineEditElements->setReadOnly( false );
+ LineEditElements->setValidator( myIdValidator );
+ onTextChange(LineEditElements->text());
+ hidePreview();
+ }
+
+ SelectionIntoArgument();
+}
+
+//=======================================================================
+//function : onActionClicked
+//purpose : slot called when an action type changed
+//=======================================================================
+
+void SMESHGUI_OffsetDlg::onActionClicked(int button)
+{
+ int aNbGroups = 0;
+ for ( int i = 0; i < myMeshes.count(); i++ )
+ aNbGroups += myMeshes[i]->NbGroups();
+
+ switch ( button ) {
+ case MOVE_ELEMS_BUTTON:
+ MakeGroupsCheck->setEnabled(false);
+ LineEditNewMesh->setEnabled(false);
+ break;
+ case COPY_ELEMS_BUTTON:
+ LineEditNewMesh->setEnabled(false);
+ MakeGroupsCheck->setText( tr("SMESH_MAKE_GROUPS"));
+ MakeGroupsCheck->setEnabled( myMeshes.isEmpty() || aNbGroups > 0 );
+ break;
+ case MAKE_MESH_BUTTON:
+ LineEditNewMesh->setEnabled(true);
+ MakeGroupsCheck->setText( tr("SMESH_COPY_GROUPS"));
+ MakeGroupsCheck->setEnabled( myMeshes.isEmpty() || aNbGroups > 0 );
+ break;
+ }
+ setNewMeshName();
+ //toDisplaySimulation();
+}
+
+//=======================================================================
+//function : setNewMeshName
+//purpose : update contents of LineEditNewMesh
+//=======================================================================
+
+void SMESHGUI_OffsetDlg::setNewMeshName()
+{
+ LineEditNewMesh->setText("");
+ if ( LineEditNewMesh->isEnabled() && !myMeshes.isEmpty() ) {
+ QString name;
+ if ( CheckBoxMesh->isChecked() ) {
+ name = myObjects.count() > 1 ? "*" : LineEditElements->text();
+ }
+ else {
+ _PTR(SObject) meshSO = SMESH::FindSObject( myMeshes[0] );
+ name = meshSO->GetName().c_str();
+ }
+ if ( !name.isEmpty() )
+ LineEditNewMesh->setText( SMESH::UniqueMeshName( name, "Offset"));
+ }
+}
+
+//=================================================================================
+// function : keyPressEvent()
+// purpose :
+//=================================================================================
+
+void SMESHGUI_OffsetDlg::keyPressEvent( QKeyEvent* e )
+{
+ QDialog::keyPressEvent( e );
+ if ( e->isAccepted() )
+ return;
+
+ if ( e->key() == Qt::Key_F1 ) {
+ e->accept();
+ ClickOnHelp();
+ }
+}
+
+//=================================================================================
+// function : setFilters()
+// purpose : SLOT. Called when "Filter" button pressed.
+//=================================================================================
+
+void SMESHGUI_OffsetDlg::setFilters()
+{
+ if ( myMeshes.isEmpty() ) {
+ SUIT_MessageBox::critical(this, tr("SMESH_ERROR"), tr("NO_MESH_SELECTED"));
+ return;
+ }
+ if ( !myFilterDlg ) {
+ myFilterDlg = new SMESHGUI_FilterDlg( mySMESHGUI, SMESH::ALL );
+ connect(myFilterDlg, SIGNAL(Accepted()), SLOT(onFilterAccepted()));
+ }
+
+ myFilterDlg->Init( SMESH::FACE );
+ myFilterDlg->SetSelection();
+ myFilterDlg->SetMesh( myMeshes[0] );
+ myFilterDlg->SetSourceWg( LineEditElements );
+
+ myFilterDlg->show();
+}
+
+//=======================================================================
+// name : onFilterAccepted()
+// Purpose : SLOT. Called when Filter dlg closed with OK button.
+// Activate [Apply] if no Actor is available
+//=======================================================================
+
+void SMESHGUI_OffsetDlg::onFilterAccepted()
+{
+ if ( myMeshes.length() > 0 && !buttonOk->isEnabled() )
+ {
+ myElementsId = LineEditElements->text();
+ QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
+ myNbOkElements = aListElementsId.count();
+ buttonOk->setEnabled ( myNbOkElements );
+ buttonApply->setEnabled( myNbOkElements );
+ }
+}
+
+//=================================================================================
+// function : isValid
+// purpose :
+//=================================================================================
+
+bool SMESHGUI_OffsetDlg::isValid()
+{
+ return true;
+}
+
+//=================================================================================
+// function : onDisplaySimulation
+// purpose : Show/Hide preview
+//=================================================================================
+void SMESHGUI_OffsetDlg::onDisplaySimulation( bool toDisplayPreview )
+{
+ SUIT_OverrideCursor aWaitCursor;
+
+ if (myPreviewCheckBox->isChecked() && toDisplayPreview)
+ {
+ if ( myNbOkElements && isValid() )
+ {
+ double offsetValue = SpinBox->value();
+
+ SMESH::ListOfGroups_var groups;
+ SMESH::SMESH_Mesh_var mesh;
+
+ try
+ {
+ QList<SMESH::MeshPreviewStruct_var> aMeshPreviewStruct;
+
+ if ( CheckBoxMesh->isChecked())
+ for ( int i = 0; i < myObjects.count(); i++ )
+ {
+ SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[i]->GetMeshEditPreviewer();
+ mesh = aMeshEditor->Offset( myObjects[i], offsetValue, false, "", groups.out() );
+ aMeshPreviewStruct << aMeshEditor->GetPreviewData();
+ }
+ else
+ {
+ SMESH::long_array_var anElementsId = new SMESH::long_array;
+ QStringList aListElementsId = myElementsId.split(" ", QString::SkipEmptyParts);
+ anElementsId->length(aListElementsId.count());
+ for (int i = 0; i < aListElementsId.count(); i++)
+ anElementsId[i] = aListElementsId[i].toInt();
+
+ SMESH::SMESH_MeshEditor_var aMeshEditor = myMeshes[0]->GetMeshEditPreviewer();
+ SMESH::IDSource_wrap src = aMeshEditor->MakeIDSource(anElementsId, SMESH::FACE);
+ mesh = aMeshEditor->Offset( src, offsetValue, false, "", groups.out() );
+ aMeshPreviewStruct << aMeshEditor->GetPreviewData();
+ }
+ setSimulationPreview(aMeshPreviewStruct);
+
+ } catch (...) {
+ hidePreview();
+ }
+ } else {
+ hidePreview();
+ }
+ } else {
+ hidePreview();
+ }
+}
${KERNEL_SalomeGenericObj}
${KERNEL_SalomeIDLKERNEL}
${KERNEL_SALOMELocalTrace}
- ${CAS_TKCDF}
- ${CAS_TKBO}
- ${CAS_TKShHealing}
+ ${KERNEL_SalomeKernelHelpers}
+ ${OpenCASCADE_ApplicationFramework_LIBRARIES}
+ ${OpenCASCADE_ModelingAlgorithms_LIBRARIES}
${GEOM_GEOMClient}
- ${GEOM_SalomeIDLGEOM}
+ ${GEOM_SalomeIDLGEOM}
SalomeIDLSMESH
SMESHimpl
SMDS
// create groups of just added elements
- SMESH::SMESH_Group_var aNewGroup;
- SMESH::ElementType aGroupType;
+ SMESH::SMESH_Group_var newGroup;
+ SMESH::ElementType groupType;
if ( theCommonGroups )
{
- SMESH::long_array_var curState = aNewMesh->GetNbElementsByType();
+ // type names
+ const char* typeNames[] = { "All","Nodes","Edges","Faces","Volumes","0DElems","Balls" };
+ { // check of typeNames: compilation failure mains that NB_ELEMENT_TYPES changed:
+ const int nbNames = sizeof(typeNames) / sizeof(const char*);
+ int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
+ }
+
+ SMESH::long_array_var curState = newMesh->GetNbElementsByType();
- for( aGroupType = SMESH::NODE;
- aGroupType < SMESH::NB_ELEMENT_TYPES;
- aGroupType = (SMESH::ElementType)( aGroupType + 1 ))
+ for( groupType = SMESH::NODE;
+ groupType < SMESH::NB_ELEMENT_TYPES;
+ groupType = (SMESH::ElementType)( groupType + 1 ))
{
- if ( curState[ aGroupType ] <= prevState[ aGroupType ])
- continue;
+ if ( curState[ groupType ] <= prevState[ groupType ])
+ continue; // no elements of groupType added from the i-th mesh
// make a group name
- const char* typeNames[] = { "All","Nodes","Edges","Faces","Volumes","0DElems","Balls" };
- { // check of typeNames: compilation failure mains that NB_ELEMENT_TYPES changed:
- const int nbNames = sizeof(typeNames) / sizeof(const char*);
- int _assert[( nbNames == SMESH::NB_ELEMENT_TYPES ) ? 2 : -1 ]; _assert[0]=_assert[1]=0;
- }
- string groupName = "Gr";
- SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( theMeshesArray[i] );
- if ( aMeshSObj ) {
- CORBA::String_var name = aMeshSObj->GetName();
+ std::string groupName = "Gr";
- SALOMEDS::SObject_wrap meshSO = ObjectToSObject( myCurrentStudy, theMeshesArray[i] );
++ SALOMEDS::SObject_wrap meshSO = ObjectToSObject( theMeshesArray[i] );
+ if ( meshSO ) {
+ CORBA::String_var name = meshSO->GetName();
groupName += name;
}
groupName += "_";
}
// IPAL21468 Change icon of compound because it need not be computed.
- SALOMEDS::SObject_wrap meshSO = ObjectToSObject( myCurrentStudy, newMesh );
- SALOMEDS::SObject_wrap aMeshSObj = ObjectToSObject( aNewMesh );
- SetPixMap( aMeshSObj, "ICON_SMESH_TREE_MESH" );
++ SALOMEDS::SObject_wrap meshSO = ObjectToSObject( newMesh );
+ SetPixMap( meshSO, "ICON_SMESH_TREE_MESH" );
- if (aNewMeshDS)
- aNewMeshDS->Modified();
+ newMeshDS->Modified();
- return aNewMesh._retn();
+ return newMesh._retn();
}
//================================================================================
// write applied hypotheses if exist
SALOMEDS::SObject_wrap myHypBranch;
found = gotBranch->FindSubObject( GetRefOnAppliedHypothesisTag(), myHypBranch.inout() );
- if ( found && !shapeRefFound && hasShape) { // remove applied hyps
+ if ( found && !shapeRefFound && hasShape ) { // remove applied hyps
- myCurrentStudy->NewBuilder()->RemoveObjectWithChildren( myHypBranch );
+ aStudy->NewBuilder()->RemoveObjectWithChildren( myHypBranch );
}
if ( found && (shapeRefFound || !hasShape) ) {
aGroup = new HDFgroup( "Applied Hypotheses", aTopGroup );
// Publishing a hypothesis or algorithm
SMESH::SMESH_Hypothesis_var aHyp = SMESH::SMESH_Hypothesis::_narrow( theIOR );
if ( aSO->_is_nil() && !aHyp->_is_nil() )
- aSO = PublishHypothesis( theStudy, aHyp, theName );
- aSO = PublishHypothesis( aHyp );
++ aSO = PublishHypothesis( aHyp, theName );
// Publishing a group
SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(theIOR);
hyp.SetUsePreestimatedLength( length == 0.0 )
return hyp
- ## Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments
- # @param n for the number of segments that cut an edge
- # @param s for the scale factor (optional)
- # @param reversedEdges is a list of edges to mesh using reversed orientation.
- # A list item can also be a tuple (edge, 1st_vertex_of_edge)
- # @param UseExisting if ==true - searches for an existing hypothesis created with
- # the same parameters, else (default) - create a new one
- # @return an instance of StdMeshers_NumberOfSegments hypothesis
- # @ingroup l3_hypos_1dhyps
def NumberOfSegments(self, n, s=[], reversedEdges=[], UseExisting=0):
- Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments
+ """
- A list item can also be a tuple (edge, 1st_vertex_of_edge)
++ Defines "NumberOfSegments" hypothesis to cut an edge in a fixed number of segments
+
+ Parameters:
+ n: for the number of segments that cut an edge
+ s: for the scale factor (optional)
+ reversedEdges: is a list of edges to mesh using reversed orientation.
- the same parameters, else (default) - create a new one
++ A list item can also be a tuple (edge, 1st_vertex_of_edge)
+ UseExisting: if ==true - searches for an existing hypothesis created with
- an instance of StdMeshers_NumberOfSegments hypothesis
++ the same parameters, else (default) - create a new one
+
+ Returns:
-
++ an instance of StdMeshers_NumberOfSegments hypothesis
+ """
+
++
if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
reversedEdges, UseExisting = [], reversedEdges
entry = self.MainShapeEntry()
hyp.SetObjectEntry( entry )
return hyp
- ## Private method
- #
- # Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments
def _compareNumberOfSegments(self, hyp, args):
- Private method
- Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments
+ """
++ Private method
++ Checks if the given "NumberOfSegments" hypothesis has the same parameters as the given arguments
+ """
if hyp.GetNumberOfSegments() == args[0]:
if len(args) == 3:
if hyp.GetReversedEdges() == args[1]:
return True
return False
- ## Defines "Adaptive" hypothesis to cut an edge into segments keeping segment size
- # within the given range and considering (1) deflection of segments from the edge
- # and (2) distance from segments to closest edges and faces to have segment length
- # not longer than two times shortest distances to edges and faces.
- # @param minSize defines the minimal allowed segment length
- # @param maxSize defines the maximal allowed segment length
- # @param deflection defines the maximal allowed distance from a segment to an edge
- # @param UseExisting if ==true - searches for an existing hypothesis created with
- # the same parameters, else (default) - creates a new one
- # @return an instance of StdMeshers_Adaptive1D hypothesis
- # @ingroup l3_hypos_1dhyps
def Adaptive(self, minSize, maxSize, deflection, UseExisting=False):
-
+ """
+ Defines "Adaptive" hypothesis to cut an edge into segments keeping segment size
+ within the given range and considering (1) deflection of segments from the edge
+ and (2) distance from segments to closest edges and faces to have segment length
+ not longer than two times shortest distances to edges and faces.
+
+ Parameters:
+ minSize: defines the minimal allowed segment length
+ maxSize: defines the maximal allowed segment length
+ deflection: defines the maximal allowed distance from a segment to an edge
+ UseExisting: if ==true - searches for an existing hypothesis created with
+ the same parameters, else (default) - creates a new one
+
+ Returns:
+ an instance of StdMeshers_Adaptive1D hypothesis
+ """
++
from salome.smesh.smeshBuilder import IsEqual
compFun = lambda hyp, args: ( IsEqual(hyp.GetMinSize(), args[0]) and \
IsEqual(hyp.GetMaxSize(), args[1]) and \
hyp.SetDeflection(deflection)
return hyp
- ## Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length
- # that changes in arithmetic progression
- # @param start defines the length of the first segment
- # @param end defines the length of the last segment
- # @param reversedEdges is a list of edges to mesh using reversed orientation.
- # A list item can also be a tuple (edge, 1st_vertex_of_edge)
- # @param UseExisting if ==true - searches for an existing hypothesis created with
- # the same parameters, else (default) - creates a new one
- # @return an instance of StdMeshers_Arithmetic1D hypothesis
- # @ingroup l3_hypos_1dhyps
def Arithmetic1D(self, start, end, reversedEdges=[], UseExisting=0):
- """
- Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length
- that changes in arithmetic progression
-
- Parameters:
- start: defines the length of the first segment
- end: defines the length of the last segment
- reversedEdges: is a list of edges to mesh using reversed orientation.
- A list item can also be a tuple (edge, 1st_vertex_of_edge)
- UseExisting: if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
-
- Returns:
- an instance of StdMeshers_Arithmetic1D hypothesis
- """
++ """
++ Defines "Arithmetic1D" hypothesis to cut an edge in several segments with a length
++ that changes in arithmetic progression
++
++ Parameters:
++ start: defines the length of the first segment
++ end: defines the length of the last segment
++ reversedEdges: is a list of edges to mesh using reversed orientation.
++ A list item can also be a tuple (edge, 1st_vertex_of_edge)
++ UseExisting: if ==true - searches for an existing hypothesis created with
++ the same parameters, else (default) - creates a new one
++
++ Returns:
++ an instance of StdMeshers_Arithmetic1D hypothesis
++ """
+
if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
reversedEdges, UseExisting = [], reversedEdges
reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
hyp.SetObjectEntry( entry )
return hyp
- ## Defines "GeometricProgression" hypothesis to cut an edge in several
- # segments with a length that changes in Geometric progression
- # @param start defines the length of the first segment
- # @param ratio defines the common ratio of the geometric progression
- # @param reversedEdges is a list of edges to mesh using reversed orientation.
- # A list item can also be a tuple (edge, 1st_vertex_of_edge)
- # @param UseExisting if ==true - searches for an existing hypothesis created with
- # the same parameters, else (default) - creates a new one
- # @return an instance of StdMeshers_Geometric1D hypothesis
- # @ingroup l3_hypos_1dhyps
def GeometricProgression(self, start, ratio, reversedEdges=[], UseExisting=0):
- """
- Defines "GeometricProgression" hypothesis to cut an edge in several
- segments with a length that changes in Geometric progression
-
- Parameters:
- start: defines the length of the first segment
- ratio: defines the common ratio of the geometric progression
- reversedEdges: is a list of edges to mesh using reversed orientation.
- A list item can also be a tuple (edge, 1st_vertex_of_edge)
- UseExisting: if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
-
- Returns:
- an instance of StdMeshers_Geometric1D hypothesis
- """
++ """
++ Defines "GeometricProgression" hypothesis to cut an edge in several
++ segments with a length that changes in Geometric progression
++
++ Parameters:
++ start: defines the length of the first segment
++ ratio: defines the common ratio of the geometric progression
++ reversedEdges: is a list of edges to mesh using reversed orientation.
++ A list item can also be a tuple (edge, 1st_vertex_of_edge)
++ UseExisting: if ==true - searches for an existing hypothesis created with
++ the same parameters, else (default) - creates a new one
++
++ Returns:
++ an instance of StdMeshers_Geometric1D hypothesis
++ """
+
reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
entry = self.MainShapeEntry()
from salome.smesh.smeshBuilder import IsEqual
hyp.SetObjectEntry( entry )
return hyp
- ## Defines "FixedPoints1D" hypothesis to cut an edge using parameter
- # on curve from 0 to 1 (additionally it is neecessary to check
- # orientation of edges and create list of reversed edges if it is
- # needed) and sets numbers of segments between given points (default
- # values are 1)
- # @param points defines the list of parameters on curve
- # @param nbSegs defines the list of numbers of segments
- # @param reversedEdges is a list of edges to mesh using reversed orientation.
- # A list item can also be a tuple (edge, 1st_vertex_of_edge)
- # @param UseExisting if ==true - searches for an existing hypothesis created with
- # the same parameters, else (default) - creates a new one
- # @return an instance of StdMeshers_FixedPoints1D hypothesis
- # @ingroup l3_hypos_1dhyps
def FixedPoints1D(self, points, nbSegs=[1], reversedEdges=[], UseExisting=0):
- Defines "FixedPoints1D" hypothesis to cut an edge using parameter
- on curve from 0 to 1 (additionally it is neecessary to check
- orientation of edges and create list of reversed edges if it is
- needed) and sets numbers of segments between given points (default
- values are 1)
-
- Parameters:
- points: defines the list of parameters on curve
- nbSegs: defines the list of numbers of segments
- reversedEdges: is a list of edges to mesh using reversed orientation.
- A list item can also be a tuple (edge, 1st_vertex_of_edge)
- UseExisting: if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
-
- Returns:
- an instance of StdMeshers_FixedPoints1D hypothesis
- """
+ """
++ Defines "FixedPoints1D" hypothesis to cut an edge using parameter
++ on curve from 0 to 1 (additionally it is neecessary to check
++ orientation of edges and create list of reversed edges if it is
++ needed) and sets numbers of segments between given points (default
++ values are 1)
++
++ Parameters:
++ points: defines the list of parameters on curve
++ nbSegs: defines the list of numbers of segments
++ reversedEdges: is a list of edges to mesh using reversed orientation.
++ A list item can also be a tuple (edge, 1st_vertex_of_edge)
++ UseExisting: if ==true - searches for an existing hypothesis created with
++ the same parameters, else (default) - creates a new one
++
++ Returns:
++ an instance of StdMeshers_FixedPoints1D hypothesis
++ """
+
if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
reversedEdges, UseExisting = [], reversedEdges
reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
hyp.SetObjectEntry(entry)
return hyp
- ## Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length
- # @param start defines the length of the first segment
- # @param end defines the length of the last segment
- # @param reversedEdges is a list of edges to mesh using reversed orientation.
- # A list item can also be a tuple (edge, 1st_vertex_of_edge)
- # @param UseExisting if ==true - searches for an existing hypothesis created with
- # the same parameters, else (default) - creates a new one
- # @return an instance of StdMeshers_StartEndLength hypothesis
- # @ingroup l3_hypos_1dhyps
def StartEndLength(self, start, end, reversedEdges=[], UseExisting=0):
-
+ """
+ Defines "StartEndLength" hypothesis to cut an edge in several segments with increasing geometric length
+
+ Parameters:
+ start: defines the length of the first segment
+ end: defines the length of the last segment
+ reversedEdges: is a list of edges to mesh using reversed orientation.
+ A list item can also be a tuple (edge, 1st_vertex_of_edge)
+ UseExisting: if ==true - searches for an existing hypothesis created with
+ the same parameters, else (default) - creates a new one
+
+ Returns:
+ an instance of StdMeshers_StartEndLength hypothesis
+ """
++
if not isinstance(reversedEdges,list): #old version script, before adding reversedEdges
reversedEdges, UseExisting = [], reversedEdges
reversedEdgeInd = self.ReversedEdgeIndices(reversedEdges)
hyp.SetObjectEntry( entry )
return hyp
- ## Defines "Deflection1D" hypothesis
- # @param d for the deflection
- # @param UseExisting if ==true - searches for an existing hypothesis created with
- # the same parameters, else (default) - create a new one
- # @ingroup l3_hypos_1dhyps
def Deflection1D(self, d, UseExisting=0):
- """
- Defines "Deflection1D" hypothesis
++ """
++ Defines "Deflection1D" hypothesis
+
- Parameters:
++ Parameters:
+ d: for the deflection
+ UseExisting: if ==true - searches for an existing hypothesis created with
+ the same parameters, else (default) - create a new one
- """
++ """
+
from salome.smesh.smeshBuilder import IsEqual
compFun = lambda hyp, args: IsEqual(hyp.GetDeflection(), args[0])
hyp = self.Hypothesis("Deflection1D", [d], UseExisting=UseExisting, CompareMethod=compFun)
hyp.SetDeflection(d)
return hyp
- ## Defines "Propagation" hypothesis that propagates 1D hypotheses
- # from an edge where this hypothesis is assigned to
- # on all other edges that are at the opposite side in case of quadrangular faces
- # This hypothesis should be assigned to an edge to propagate a hypothesis from.
- # @ingroup l3_hypos_additi
def Propagation(self):
- """
- Defines "Propagation" hypothesis that propagates 1D hypotheses
- from an edge where this hypothesis is assigned to
- on all other edges that are at the opposite side in case of quadrangular faces
- This hypothesis should be assigned to an edge to propagate a hypothesis from.
- """
++ """
++ Defines "Propagation" hypothesis that propagates 1D hypotheses
++ from an edge where this hypothesis is assigned to
++ on all other edges that are at the opposite side in case of quadrangular faces
++ This hypothesis should be assigned to an edge to propagate a hypothesis from.
++ """
+
return self.Hypothesis("Propagation", UseExisting=1, CompareMethod=self.CompareEqualHyp)
- ## Defines "Propagation of Node Distribution" hypothesis that propagates
- # distribution of nodes from an edge where this hypothesis is assigned to,
- # to opposite edges of quadrangular faces, so that number of segments on all these
- # edges will be the same, as well as relations between segment lengths.
- # @ingroup l3_hypos_additi
def PropagationOfDistribution(self):
- """
- Defines "Propagation of Node Distribution" hypothesis that propagates
- distribution of nodes from an edge where this hypothesis is assigned to,
- to opposite edges of quadrangular faces, so that number of segments on all these
- edges will be the same, as well as relations between segment lengths.
- """
++ """
++ Defines "Propagation of Node Distribution" hypothesis that propagates
++ distribution of nodes from an edge where this hypothesis is assigned to,
++ to opposite edges of quadrangular faces, so that number of segments on all these
++ edges will be the same, as well as relations between segment lengths.
++ """
+
return self.Hypothesis("PropagOfDistribution", UseExisting=1,
CompareMethod=self.CompareEqualHyp)
- ## Defines "AutomaticLength" hypothesis
- # @param fineness for the fineness [0-1]
- # @param UseExisting if ==true - searches for an existing hypothesis created with the
- # same parameters, else (default) - create a new one
- # @ingroup l3_hypos_1dhyps
def AutomaticLength(self, fineness=0, UseExisting=0):
- """
- Defines "AutomaticLength" hypothesis
-
- Parameters:
- fineness: for the fineness [0-1]
- UseExisting: if ==true - searches for an existing hypothesis created with the
- same parameters, else (default) - create a new one
- """
++ """
++ Defines "AutomaticLength" hypothesis
++
++ Parameters:
++ fineness: for the fineness [0-1]
++ UseExisting: if ==true - searches for an existing hypothesis created with the
++ same parameters, else (default) - create a new one
++ """
+
from salome.smesh.smeshBuilder import IsEqual
compFun = lambda hyp, args: IsEqual(hyp.GetFineness(), args[0])
hyp = self.Hypothesis("AutomaticLength",[fineness],UseExisting=UseExisting,
hyp.SetFineness( fineness )
return hyp
- ## Defines "SegmentLengthAroundVertex" hypothesis
- # @param length for the segment length
- # @param vertex for the length localization: the vertex index [0,1] | vertex object.
- # Any other integer value means that the hypothesis will be set on the
- # whole 1D shape, where Mesh_Segment algorithm is assigned.
- # @param UseExisting if ==true - searches for an existing hypothesis created with
- # the same parameters, else (default) - creates a new one
- # @ingroup l3_algos_segmarv
def LengthNearVertex(self, length, vertex=0, UseExisting=0):
- """
- Defines "SegmentLengthAroundVertex" hypothesis
-
- Parameters:
- length: for the segment length
- vertex: for the length localization: the vertex index [0,1] | vertex object.
- Any other integer value means that the hypothesis will be set on the
- whole 1D shape, where Mesh_Segment algorithm is assigned.
- UseExisting: if ==true - searches for an existing hypothesis created with
- the same parameters, else (default) - creates a new one
- """
++ """
++ Defines "SegmentLengthAroundVertex" hypothesis
++
++ Parameters:
++ length: for the segment length
++ vertex: for the length localization: the vertex index [0,1] | vertex object.
++ Any other integer value means that the hypothesis will be set on the
++ whole 1D shape, where Mesh_Segment algorithm is assigned.
++ UseExisting: if ==true - searches for an existing hypothesis created with
++ the same parameters, else (default) - creates a new one
++ """
+
import types
store_geom = self.geom
- if type(vertex) is types.IntType:
+ if isinstance(vertex, int):
if vertex == 0 or vertex == 1:
from salome.geom import geomBuilder
vertex = self.mesh.geompyD.ExtractShapes(self.geom, geomBuilder.geomBuilder.ShapeType["VERTEX"],True)[vertex]
hyp.SetLength( length )
return hyp
- ## Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
- # If the 2D mesher sees that all boundary edges are quadratic,
- # it generates quadratic faces, else it generates linear faces using
- # medium nodes as if they are vertices.
- # The 3D mesher generates quadratic volumes only if all boundary faces
- # are quadratic, else it fails.
- #
- # @ingroup l3_hypos_additi
def QuadraticMesh(self):
- """
- Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
- If the 2D mesher sees that all boundary edges are quadratic,
- it generates quadratic faces, else it generates linear faces using
- medium nodes as if they are vertices.
- The 3D mesher generates quadratic volumes only if all boundary faces
- are quadratic, else it fails.
- """
-
++ """
++ Defines "QuadraticMesh" hypothesis, forcing construction of quadratic edges.
++ If the 2D mesher sees that all boundary edges are quadratic,
++ it generates quadratic faces, else it generates linear faces using
++ medium nodes as if they are vertices.
++ The 3D mesher generates quadratic volumes only if all boundary faces
++ are quadratic, else it fails.
++ """
++
hyp = self.Hypothesis("QuadraticMesh", UseExisting=1, CompareMethod=self.CompareEqualHyp)
return hyp
pass # end of StdMeshersBuilder_CompositeSegment class
-## Defines a segment 1D algorithm for discretization of edges with Python function
-#
-# It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.PYTHON,geom=0)
-#
-# @ingroup l3_algos_basic
class StdMeshersBuilder_Segment_Python(Mesh_Algorithm):
- It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.PYTHON,geom=0)
+ """
+ Defines a segment 1D algorithm for discretization of edges with Python function
++ It is created by calling smeshBuilder.Mesh.Segment(smeshBuilder.PYTHON,geom=0)
+ """
+
- ## name of the dynamic method in smeshBuilder.Mesh class
- # @internal
meshMethod = "Segment"
- ## type of algorithm used with helper function in smeshBuilder.Mesh class
- # @internal
+ """
+ name of the dynamic method in smeshBuilder.Mesh class
+ """
algoType = PYTHON
- ## doc string of the method
- # @internal
+ """
+ type of algorithm used with helper function in smeshBuilder.Mesh class
+ """
docHelper = "Creates segment 1D algorithm for edges"
+ """
+ doc string of the method
+ """
- ## Private constructor.
- # @param mesh parent mesh object algorithm is assigned to
- # @param geom geometry (shape/sub-shape) algorithm is assigned to;
- # if it is @c 0 (default), the algorithm is assigned to the main shape
def __init__(self, mesh, geom=0):
+ """
+ Private constructor.
+
+ Parameters:
+ mesh: parent mesh object algorithm is assigned to
+ geom: geometry (shape/sub-shape) algorithm is assigned to;
+ if it is :code:`0` (default), the algorithm is assigned to the main shape
+ """
import Python1dPlugin
self.Create(mesh, geom, self.algoType, "libPython1dEngine.so")
pass
self.params.SetEnforcedNodes( enfVertices, pStructs )
return self.params
- ## Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
- # quadrangles are built in the transition area along the finer meshed sides,
- # iff the total quantity of segments on all four sides of the face is even.
- # @param reversed if True, transition area is located along the coarser meshed sides.
- # @param UseExisting: if ==true - searches for the existing hypothesis created with
- # the same parameters, else (default) - creates a new one
- # @ingroup l3_hypos_quad
def QuadranglePreference(self, reversed=False, UseExisting=0):
- Parameters:
+ """
+ Defines "QuadrangleParams" hypothesis with a type of quadrangulation that only
+ quadrangles are built in the transition area along the finer meshed sides,
+ if the total quantity of segments on all four sides of the face is even.
+
-
++ Parameters:
+ reversed: if True, transition area is located along the coarser meshed sides.
+ UseExisting: if ==true - searches for the existing hypothesis created with
+ the same parameters, else (default) - creates a new one
+ """
++
if reversed:
return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF_REVERSED,UseExisting=UseExisting)
return self.QuadrangleParameters(QUAD_QUADRANGLE_PREF,UseExisting=UseExisting)
pass
pass
- ## Return 3D hypothesis holding the 1D one
def Get3DHypothesis(self):
+ """
+ Returns:
+ 3D hypothesis holding the 1D one
+ """
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorithm doesn't support any hypothesis"
+ print("Prism_3D algorithm doesn't support any hypothesis")
return None
return self.distribHyp
- ## Private method creating a 1D hypothesis and storing it in the LayerDistribution
- # hypothesis. Returns the created hypothesis
def OwnHypothesis(self, hypType, args=[], so="libStdMeshersEngine.so"):
+ """
+ Private method creating a 1D hypothesis and storing it in the LayerDistribution
+ hypothesis.
+
+ Returns:
+ the created hypothesis
+ """
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorithm doesn't support any hypothesis"
+ 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 )
self.distribHyp.SetLayerDistribution( hyp )
return hyp
- ## Defines "NumberOfLayers" hypothesis, specifying the number of layers of
- # prisms to build between the inner and outer shells
- # @param n number of layers
- # @param UseExisting if ==true - searches for the existing hypothesis created with
- # the same parameters, else (default) - creates a new one
def NumberOfLayers(self, n, UseExisting=0):
+ """
+ Defines "NumberOfLayers" hypothesis, specifying the number of layers of
+ prisms to build between the inner and outer shells
+
+ Parameters:
+ n: number of layers
+ UseExisting: if ==true - searches for the existing hypothesis created with
+ the same parameters, else (default) - creates a new one
+ """
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorithm doesn't support any hypothesis"
+ print("Prism_3D algorithm doesn't support any hypothesis")
return None
self.mesh.RemoveHypothesis( self.distribHyp, self.geom )
from salome.smesh.smeshBuilder import IsEqual
self.nbLayers.SetNumberOfLayers( n )
return self.nbLayers
- ## Defines "LocalLength" hypothesis, specifying the segment length
- # to build between the inner and the outer shells
- # @param l the length of segments
- # @param p the precision of rounding
def LocalLength(self, l, p=1e-07):
+ """
+ Defines "LocalLength" hypothesis, specifying the segment length
+ to build between the inner and the outer shells
+
+ Parameters:
+ l: the length of segments
+ p: the precision of rounding
+ """
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorithm doesn't support any hypothesis"
+ print("Prism_3D algorithm doesn't support any hypothesis")
return None
hyp = self.OwnHypothesis("LocalLength", [l,p])
hyp.SetLength(l)
hyp.SetPrecision(p)
return hyp
- ## Defines "NumberOfSegments" hypothesis, specifying the number of layers of
- # prisms to build between the inner and the outer shells.
- # @param n the number of layers
- # @param s the scale factor (optional)
def NumberOfSegments(self, n, s=[]):
+ """
+ Defines "NumberOfSegments" hypothesis, specifying the number of layers of
+ prisms to build between the inner and the outer shells.
+
+ Parameters:
+ n: the number of layers
+ s: the scale factor (optional)
+ """
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorithm doesn't support any hypothesis"
+ print("Prism_3D algorithm doesn't support any hypothesis")
return None
if not s:
hyp = self.OwnHypothesis("NumberOfSegments", [n])
hyp.SetNumberOfSegments(n)
return hyp
- ## Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
- # to build between the inner and the outer shells with a length that changes
- # in arithmetic progression
- # @param start the length of the first segment
- # @param end the length of the last segment
def Arithmetic1D(self, start, end ):
+ """
+ Defines "Arithmetic1D" hypothesis, specifying the distribution of segments
+ to build between the inner and the outer shells with a length that changes
+ in arithmetic progression
+
+ Parameters:
+ start: the length of the first segment
+ end: the length of the last segment
+ """
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorithm doesn't support any hypothesis"
+ print("Prism_3D algorithm doesn't support any hypothesis")
return None
hyp = self.OwnHypothesis("Arithmetic1D", [start, end])
hyp.SetLength(start, 1)
hyp.SetLength(end , 0)
return hyp
- ## Defines "GeometricProgression" hypothesis, specifying the distribution of segments
- # to build between the inner and the outer shells with a length that changes
- # in Geometric progression
- # @param start the length of the first segment
- # @param ratio the common ratio of the geometric progression
def GeometricProgression(self, start, ratio ):
+ """
+ Defines "GeometricProgression" hypothesis, specifying the distribution of segments
+ to build between the inner and the outer shells with a length that changes
+ in Geometric progression
+
+ Parameters:
+ start: the length of the first segment
+ ratio: the common ratio of the geometric progression
+ """
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorithm doesn't support any hypothesis"
+ print("Prism_3D algorithm doesn't support any hypothesis")
return None
hyp = self.OwnHypothesis("GeometricProgression", [start, ratio])
hyp.SetStartLength( start )
hyp.SetCommonRatio( ratio )
return hyp
- ## Defines "StartEndLength" hypothesis, specifying distribution of segments
- # to build between the inner and the outer shells as geometric length increasing
- # @param start for the length of the first segment
- # @param end for the length of the last segment
def StartEndLength(self, start, end):
+ """
+ Defines "StartEndLength" hypothesis, specifying distribution of segments
+ to build between the inner and the outer shells as geometric length increasing
+
+ Parameters:
+ start: for the length of the first segment
+ end: for the length of the last segment
+ """
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorithm doesn't support any hypothesis"
+ print("Prism_3D algorithm doesn't support any hypothesis")
return None
hyp = self.OwnHypothesis("StartEndLength", [start, end])
hyp.SetLength(start, 1)
hyp.SetLength(end , 0)
return hyp
- ## Defines "AutomaticLength" hypothesis, specifying the number of segments
- # to build between the inner and outer shells
- # @param fineness defines the quality of the mesh within the range [0-1]
def AutomaticLength(self, fineness=0):
+ """
+ Defines "AutomaticLength" hypothesis, specifying the number of segments
+ to build between the inner and outer shells
+
+ Parameters:
+ fineness: defines the quality of the mesh within the range [0-1]
+ """
if self.algoType != "RadialPrism_3D":
- print "Prism_3D algorithm doesn't support any hypothesis"
+ print("Prism_3D algorithm doesn't support any hypothesis")
return None
hyp = self.OwnHypothesis("AutomaticLength")
hyp.SetFineness( fineness )
import SALOME
import SALOMEDS
import os
+ import inspect
+
+ # In case the omniORBpy EnumItem class does not fully support Python 3
+ # (for instance in version 4.2.1-2), the comparison ordering methods must be
+ # defined
+ #
+ try:
+ SMESH.Entity_Triangle < SMESH.Entity_Quadrangle
+ except TypeError:
+ def enumitem_eq(self, other):
+ try:
+ if isinstance(other, omniORB.EnumItem):
+ if other._parent_id == self._parent_id:
+ return self._v == other._v
+ else:
+ return self._parent_id == other._parent_id
+ else:
+ return id(self) == id(other)
+ except:
+ return id(self) == id(other)
+
+ def enumitem_lt(self, other):
+ try:
+ if isinstance(other, omniORB.EnumItem):
+ if other._parent_id == self._parent_id:
+ return self._v < other._v
+ else:
+ return self._parent_id < other._parent_id
+ else:
+ return id(self) < id(other)
+ except:
+ return id(self) < id(other)
+
+ def enumitem_le(self, other):
+ try:
+ if isinstance(other, omniORB.EnumItem):
+ if other._parent_id == self._parent_id:
+ return self._v <= other._v
+ else:
+ return self._parent_id <= other._parent_id
+ else:
+ return id(self) <= id(other)
+ except:
+ return id(self) <= id(other)
+
+ def enumitem_gt(self, other):
+ try:
+ if isinstance(other, omniORB.EnumItem):
+ if other._parent_id == self._parent_id:
+ return self._v > other._v
+ else:
+ return self._parent_id > other._parent_id
+ else:
+ return id(self) > id(other)
+ except:
+ return id(self) > id(other)
+
+ def enumitem_ge(self, other):
+ try:
+ if isinstance(other, omniORB.EnumItem):
+ if other._parent_id == self._parent_id:
+ return self._v >= other._v
+ else:
+ return self._parent_id >= other._parent_id
+ else:
+ return id(self) >= id(other)
+ except:
+ return id(self) >= id(other)
+
+ omniORB.EnumItem.__eq__ = enumitem_eq
+ omniORB.EnumItem.__lt__ = enumitem_lt
+ omniORB.EnumItem.__le__ = enumitem_le
+ omniORB.EnumItem.__gt__ = enumitem_gt
+ omniORB.EnumItem.__ge__ = enumitem_ge
+
-## Private class used to workaround a problem that sometimes isinstance(m, Mesh) returns False
-#
class MeshMeta(type):
+ """Private class used to workaround a problem that sometimes isinstance(m, Mesh) returns False
+ """
def __instancecheck__(cls, inst):
"""Implement isinstance(inst, cls)."""
return any(cls.__subclasscheck__(c)
pass
SMESH.PointStruct.__init__ = __initPointStruct
-## Substitute AxisStruct.__init__() to create SMESH.AxisStruct using notebook variables.
-# Parameters are stored in AxisStruct.parameters attribute
def __initAxisStruct(ax,*args):
+ """
+ Substitute AxisStruct.__init__() to create SMESH.AxisStruct using notebook variables.
+ Parameters are stored in AxisStruct.parameters attribute
+ """
if len( args ) != 6:
- raise RuntimeError,\
- "Bad nb args (%s) passed in SMESH.AxisStruct(x,y,z,dx,dy,dz)"%(len( args ))
+ raise RuntimeError("Bad nb args (%s) passed in SMESH.AxisStruct(x,y,z,dx,dy,dz)"%(len( args )))
ax.x, ax.y, ax.z, ax.vx, ax.vy, ax.vz, ax.parameters,hasVars = ParseParameters(*args)
pass
SMESH.AxisStruct.__init__ = __initAxisStruct
# unknown non-CORBA object, having GetName() method
return obj.GetName()
pass
- raise RuntimeError, "Null or invalid object"
+ raise RuntimeError("Null or invalid object")
-## Print error message if a hypothesis was not assigned.
def TreatHypoStatus(status, hypName, geomName, isAlgo, mesh):
+ """
+ Print error message if a hypothesis was not assigned.
+ """
if isAlgo:
hypType = "algorithm"
else:
pass
reason = ""
if hasattr( status, "__getitem__" ):
- status,reason = status[0],status[1]
- if status == HYP_UNKNOWN_FATAL :
+ status, reason = status[0], status[1]
+ if status == HYP_UNKNOWN_FATAL:
reason = "for unknown reason"
- elif status == HYP_INCOMPATIBLE :
+ elif status == HYP_INCOMPATIBLE:
reason = "this hypothesis mismatches the algorithm"
- elif status == HYP_NOTCONFORM :
+ elif status == HYP_NOTCONFORM:
reason = "a non-conform mesh would be built"
- elif status == HYP_ALREADY_EXIST :
+ elif status == HYP_ALREADY_EXIST:
if isAlgo: return # it does not influence anything
reason = hypType + " of the same dimension is already assigned to this shape"
- elif status == HYP_BAD_DIM :
+ elif status == HYP_BAD_DIM:
reason = hypType + " mismatches the shape"
- elif status == HYP_CONCURENT:
+ elif status == HYP_CONCURRENT :
reason = "there are concurrent hypotheses on sub-shapes"
- elif status == HYP_BAD_SUBSHAPE :
+ elif status == HYP_BAD_SUBSHAPE:
reason = "the shape is neither the main one, nor its sub-shape, nor a valid group"
elif status == HYP_BAD_GEOMETRY:
reason = "the algorithm is not applicable to this geometry"
if meshName and meshName != NO_NAME:
where = '"%s" shape in "%s" mesh ' % ( geomName, meshName )
if status < HYP_UNKNOWN_FATAL and where:
- print '"%s" was assigned to %s but %s' %( hypName, where, reason )
+ print('"%s" was assigned to %s but %s' %( hypName, where, reason ))
elif where:
- print '"%s" was not assigned to %s : %s' %( hypName, where, reason )
+ print('"%s" was not assigned to %s : %s' %( hypName, where, reason ))
else:
- print '"%s" was not assigned : %s' %( hypName, reason )
+ print('"%s" was not assigned : %s' %( hypName, reason ))
pass
-## Private method. Add geom (sub-shape of the main shape) into the study if not yet there
def AssureGeomPublished(mesh, geom, name=''):
+ """
+ Private method. Add geom (sub-shape of the main shape) into the study if not yet there
+ """
if not isinstance( geom, geomBuilder.GEOM._objref_GEOM_Object ):
return
- if not geom.GetStudyEntry() and \
- mesh.smeshpyD.GetCurrentStudy():
- ## set the study
- studyID = mesh.smeshpyD.GetCurrentStudy()._get_StudyId()
- if studyID != mesh.geompyD.myStudyId:
- mesh.geompyD.init_geom( mesh.smeshpyD.GetCurrentStudy())
+ if not geom.GetStudyEntry():
## get a name
if not name and geom.GetShapeType() != geomBuilder.GEOM.COMPOUND:
# for all groups SubShapeName() return "Compound_-1"
mesh.geompyD.addToStudyInFather( mesh.geom, geom, name )
return
-## Return the first vertex of a geometrical edge by ignoring orientation
def FirstVertexOnCurve(mesh, edge):
+ """
+ Returns:
+ the first vertex of a geometrical edge by ignoring orientation
+ """
vv = mesh.geompyD.SubShapeAll( edge, geomBuilder.geomBuilder.ShapeType["VERTEX"])
if not vv:
- raise TypeError, "Given object has no vertices"
+ raise TypeError("Given object has no vertices")
if len( vv ) == 1: return vv[0]
v0 = mesh.geompyD.MakeVertexOnCurve(edge,0.)
xyz = mesh.geompyD.PointCoordinates( v0 ) # coords of the first vertex
doLcc = False
created = False
- class smeshBuilder(object, SMESH._objref_SMESH_Gen):
-## This class allows to create, load or manipulate meshes.
-# It has a set of methods to create, load or copy meshes, to combine several meshes, etc.
-# It also has methods to get infos and measure meshes.
-class smeshBuilder(SMESH._objref_SMESH_Gen):
++class smeshBuilder( SMESH._objref_SMESH_Gen, object ):
+ """
+ This class allows to create, load or manipulate meshes.
+ It has a set of methods to create, load or copy meshes, to combine several meshes, etc.
+ It also has methods to get infos and measure meshes.
+ """
# MirrorType enumeration
POINT = SMESH_MeshEditor.POINT
global engine
global smeshInst
global doLcc
-- #print "==== __new__", engine, smeshInst, doLcc
++ #print("==== __new__", engine, smeshInst, doLcc)
if smeshInst is None:
# smesh engine is either retrieved from engine, or created
# FindOrLoadComponent called:
# 1. CORBA resolution of server
# 2. the __new__ method is called again
-- #print "==== smeshInst = lcc.FindOrLoadComponent ", engine, smeshInst, doLcc
++ #print("==== smeshInst = lcc.FindOrLoadComponent ", engine, smeshInst, doLcc)
smeshInst = salome.lcc.FindOrLoadComponent( "FactoryServer", "SMESH" )
else:
# FindOrLoadComponent not called
if smeshInst is None:
# smeshBuilder instance is created from lcc.FindOrLoadComponent
-- #print "==== smeshInst = super(smeshBuilder,cls).__new__(cls) ", engine, smeshInst, doLcc
++ #print("==== smeshInst = super(smeshBuilder,cls).__new__(cls) ", engine, smeshInst, doLcc)
smeshInst = super(smeshBuilder,cls).__new__(cls)
else:
# smesh engine not created: existing engine found
-- #print "==== existing ", engine, smeshInst, doLcc
++ #print("==== existing ", engine, smeshInst, doLcc)
pass
-- #print "====1 ", smeshInst
++ #print("====1 ", smeshInst)
return smeshInst
-- #print "====2 ", smeshInst
++ #print("====2 ", smeshInst)
return smeshInst
- def __init__(self):
+ def __init__(self, *args):
global created
-- #print "--------------- smeshbuilder __init__ ---", created
++ #print("--------------- smeshbuilder __init__ ---", created)
if not created:
- created = True
- SMESH._objref_SMESH_Gen.__init__(self)
+ created = True
+ SMESH._objref_SMESH_Gen.__init__(self, *args)
+
- ## Dump component to the Python script
- # This method overrides IDL function to allow default values for the parameters.
- # @ingroup l1_auxiliary
- def DumpPython(self, theIsPublished=True, theIsMultiFile=True):
- return SMESH._objref_SMESH_Gen.DumpPython(self, theIsPublished, theIsMultiFile)
-
- ## Set mode of DumpPython(), \a historical or \a snapshot.
- # In the \a historical mode, the Python Dump script includes all commands
- # performed by SMESH engine. In the \a snapshot mode, commands
- # relating to objects removed from the Study are excluded from the script
- # as well as commands not influencing the current state of meshes
- # @ingroup l1_auxiliary
+
+ def DumpPython(self, theStudy, theIsPublished=True, theIsMultiFile=True):
+ """
+ Dump component to the Python script.
+ This method overrides IDL function to allow default values for the parameters.
+ """
+
+ return SMESH._objref_SMESH_Gen.DumpPython(self, theStudy, theIsPublished, theIsMultiFile)
+
def SetDumpPythonHistorical(self, isHistorical):
+ """
+ Set mode of DumpPython(), *historical* or *snapshot*.
+ In the *historical* mode, the Python Dump script includes all commands
+ performed by SMESH engine. In the *snapshot* mode, commands
+ relating to objects removed from the Study are excluded from the script
+ as well as commands not influencing the current state of meshes
+ """
+
if isHistorical: val = "true"
else: val = "false"
SMESH._objref_SMESH_Gen.SetOption(self, "historical_python_dump", val)
- def init_smesh(self,theStudy,geompyD = None):
- """
- Set the current study and Geometry component
- ## Set Geometry component
- # @ingroup l1_auxiliary
- def init_smesh(self,isPublished = True,geompyD = None):
- #print "init_smesh"
++ def init_smesh(self,geompyD = None):
+ """
-
- #print "init_smesh"
- self.SetCurrentStudy(theStudy,geompyD)
- if theStudy:
- global notebook
- notebook.myStudy = theStudy
++ Set Geometry component
++ """
++ #print("init_smesh")
+ self.UpdateStudy(geompyD)
- if isPublished:
- global notebook
- notebook.myStudy = salome.myStudy
-
- ## Create a mesh. This can be either an empty mesh, possibly having an underlying geometry,
- # or a mesh wrapping a CORBA mesh given as a parameter.
- # @param obj either (1) a CORBA mesh (SMESH._objref_SMESH_Mesh) got e.g. by calling
- # salome.myStudy.FindObjectID("0:1:2:3").GetObject() or
- # (2) a Geometrical object for meshing or
- # (3) none.
- # @param name the name for the new mesh.
- # @return an instance of Mesh class.
- # @ingroup l2_construct
++ notebook.myStudy = salome.myStudy
+
def Mesh(self, obj=0, name=0):
+ """
+ Create a mesh. This mesh can be either
+
+ * an empty mesh not bound to geometry, if *obj* == 0
+ * an empty mesh bound to geometry, if *obj* is GEOM.GEOM_Object
+ * a mesh wrapping a :class:`CORBA mesh <SMESH.SMESH_Mesh>` given as *obj* parameter.
+
+ Parameters:
+ obj: either
+
+ 1. a :class:`CORBA mesh <SMESH.SMESH_Mesh>` got by calling e.g.
+ ::
+
+ salome.myStudy.FindObjectID("0:1:2:3").GetObject()
+
+ 2. a geometrical object for meshing
+ 3. none.
+ name: the name for the new mesh.
+
+ Returns:
+ an instance of class :class:`Mesh`.
+ """
+
if isinstance(obj,str):
obj,name = name,obj
-- return Mesh(self,self.geompyD,obj,name)
++ return Mesh(self, self.geompyD, obj, name)
+
+ def EnumToLong(self,theItem):
+ """
+ Return a long value from enumeration
+ """
+
+ return theItem._v
- ## Return a string representation of the color.
- # To be used with filters.
- # @param c color value (SALOMEDS.Color)
- # @ingroup l1_auxiliary
def ColorToString(self,c):
+ """
+ Convert SALOMEDS.Color to string.
+ To be used with filters.
+
+ Parameters:
+ c: color value (SALOMEDS.Color)
+
+ Returns:
+ a string representation of the color.
+ """
+
val = ""
if isinstance(c, SALOMEDS.Color):
val = "%s;%s;%s" % (c.R, c.G, c.B)
elif isinstance(c, str):
val = c
else:
- raise ValueError, "Color value should be of string or SALOMEDS.Color type"
+ raise ValueError("Color value should be of string or SALOMEDS.Color type")
return val
- ## Get PointStruct from vertex
- # @param theVertex a GEOM object(vertex)
- # @return SMESH.PointStruct
- # @ingroup l1_auxiliary
def GetPointStruct(self,theVertex):
+ """
+ Get :class:`SMESH.PointStruct` from vertex
+
+ Parameters:
+ theVertex (GEOM.GEOM_Object): vertex
+
+ Returns:
+ :class:`SMESH.PointStruct`
+ """
+
[x, y, z] = self.geompyD.PointCoordinates(theVertex)
return PointStruct(x,y,z)
- ## Get DirStruct from vector
- # @param theVector a GEOM object(vector)
- # @return SMESH.DirStruct
- # @ingroup l1_auxiliary
def GetDirStruct(self,theVector):
+ """
+ Get :class:`SMESH.DirStruct` from vector
+
+ Parameters:
+ theVector (GEOM.GEOM_Object): vector
+
+ Returns:
+ :class:`SMESH.DirStruct`
+ """
+
vertices = self.geompyD.SubShapeAll( theVector, geomBuilder.geomBuilder.ShapeType["VERTEX"] )
if(len(vertices) != 2):
- print "Error: vector object is incorrect."
+ print("Error: vector object is incorrect.")
return None
p1 = self.geompyD.PointCoordinates(vertices[0])
p2 = self.geompyD.PointCoordinates(vertices[1])
ior = salome.orb.object_to_string(obj)
SMESH._objref_SMESH_Gen.SetName(self, ior, name)
- ## Set the current mode
- # @ingroup l1_auxiliary
def SetEmbeddedMode( self,theMode ):
+ """
+ Set the current mode
+ """
+
SMESH._objref_SMESH_Gen.SetEmbeddedMode(self,theMode)
- ## Get the current mode
- # @ingroup l1_auxiliary
def IsEmbeddedMode(self):
+ """
+ Get the current mode
+ """
+
return SMESH._objref_SMESH_Gen.IsEmbeddedMode(self)
-
- ## Update the current study. Calling UpdateStudy() allows to
- # update meshes at switching GEOM->SMESH
- # @ingroup l1_auxiliary
+
- def SetCurrentStudy( self, theStudy, geompyD = None ):
- """
- Set the current study. Calling SetCurrentStudy( None ) allows to
- switch **off** automatic pubilishing in the Study of mesh objects.
- """
-
- if not geompyD:
+ def UpdateStudy( self, geompyD = None ):
++ """
++ Update the current study. Calling UpdateStudy() allows to
++ update meshes at switching GEOM->SMESH
++ """
+ #self.UpdateStudy()
- if not geompyD:
++ if not geompyD:
from salome.geom import geomBuilder
geompyD = geomBuilder.geom
pass
-- self.geompyD=geompyD
-- self.SetGeomEngine(geompyD)
- SMESH._objref_SMESH_Gen.SetCurrentStudy(self,theStudy)
- global notebook
- if theStudy:
- notebook = salome_notebook.NoteBook( theStudy )
- else:
- notebook = salome_notebook.NoteBook( salome_notebook.PseudoStudyForNoteBook() )
- if theStudy:
- sb = theStudy.NewBuilder()
- sc = theStudy.FindComponent("SMESH")
- if sc: sb.LoadWith(sc, self)
- pass
- SMESH._objref_SMESH_Gen.UpdateStudy(self)
- sb = salome.myStudy.NewBuilder()
- sc = salome.myStudy.FindComponent("SMESH")
- if sc: sb.LoadWith(sc, self)
-- pass
-
- def GetCurrentStudy(self):
- """
- Get the current study
- """
-
- ## Sets enable publishing in the study. Calling SetEnablePublish( false ) allows to
- # switch OFF publishing in the Study of mesh objects.
- # @ingroup l1_auxiliary
++ self.geompyD=geompyD
++ self.SetGeomEngine(geompyD)
++ SMESH._objref_SMESH_Gen.UpdateStudy(self)
++ sb = salome.myStudy.NewBuilder()
++ sc = salome.myStudy.FindComponent("SMESH")
++ if sc:
++ sb.LoadWith(sc, self)
++ pass
++
+ def SetEnablePublish( self, theIsEnablePublish ):
++ """
++ Sets enable publishing in the study. Calling SetEnablePublish( false ) allows to
++ switch OFF publishing in the Study of mesh objects.
++ """
+ #self.SetEnablePublish(theIsEnablePublish)
- SMESH._objref_SMESH_Gen.SetEnablePublish(self,theIsEnablePublish)
- global notebook
- notebook = salome_notebook.NoteBook( theIsEnablePublish )
++ SMESH._objref_SMESH_Gen.SetEnablePublish(self,theIsEnablePublish)
++ global notebook
++ notebook = salome_notebook.NoteBook( theIsEnablePublish )
+
- return SMESH._objref_SMESH_Gen.GetCurrentStudy(self)
- ## Create a Mesh object importing data from the given UNV file
- # @return an instance of Mesh class
- # @ingroup l2_impexp
def CreateMeshesFromUNV( self,theFileName ):
+ """
+ Create a Mesh object importing data from the given UNV file
+
+ Returns:
+ an instance of class :class:`Mesh`
+ """
+
aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromUNV(self,theFileName)
aMesh = Mesh(self, self.geompyD, aSmeshMesh)
return aMesh
aSmeshMesh, error = SMESH._objref_SMESH_Gen.CreateMeshesFromGMF(self,
theFileName,
True)
- if error.comment: print "*** CreateMeshesFromGMF() errors:\n", error.comment
+ if error.comment: print("*** CreateMeshesFromGMF() errors:\n", error.comment)
return Mesh(self, self.geompyD, aSmeshMesh), error
- ## Concatenate the given meshes into one mesh. All groups of input meshes will be
- # present in the new mesh.
- # @param meshes the meshes, sub-meshes and groups to combine into one mesh
- # @param uniteIdenticalGroups if true, groups with same names are united, else they are renamed
- # @param mergeNodesAndElements if true, equal nodes and elements are merged
- # @param mergeTolerance tolerance for merging nodes
- # @param allGroups forces creation of groups corresponding to every input mesh
- # @param name name of a new mesh
- # @return an instance of Mesh class
- # @ingroup l1_creating
def Concatenate( self, meshes, uniteIdenticalGroups,
mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False,
name = ""):
UnaryOp=FT_Undefined,
BinaryOp=FT_Undefined,
Tolerance=1e-07):
+ """
+ Create a criterion by the given parameters
+ Criterion structures allow to define complex filters by combining them with logical operations (AND / OR) (see example below)
+
+ Parameters:
+ elementType: the :class:`type of elements <SMESH.ElementType>` (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
+ CritType: the type of criterion :class:`SMESH.FunctorType` (SMESH.FT_Taper, SMESH.FT_Area, etc.).
+ Note that the items starting from FT_LessThan are not suitable for *CritType*.
+ Compare: belongs to {SMESH.FT_LessThan, SMESH.FT_MoreThan, SMESH.FT_EqualTo}
+ Threshold: the threshold value (range of ids as string, shape, numeric)
+ UnaryOp: SMESH.FT_LogicalNOT or SMESH.FT_Undefined
+ BinaryOp: a binary logical operation SMESH.FT_LogicalAND, SMESH.FT_LogicalOR or
+ SMESH.FT_Undefined
+ Tolerance: the tolerance used by SMESH.FT_BelongToGeom, SMESH.FT_BelongToSurface,
+ SMESH.FT_LyingOnGeom, SMESH.FT_CoplanarFaces criteria
+
+ Returns:
+ :class:`SMESH.Filter.Criterion`
+
+ Example: :ref:`combining_filters`
+ """
+
if not CritType in SMESH.FunctorType._items:
- raise TypeError, "CritType should be of SMESH.FunctorType"
+ raise TypeError("CritType should be of SMESH.FunctorType")
aCriterion = self.GetEmptyCriterion()
aCriterion.TypeOfElement = elementType
- aCriterion.Type = EnumToLong(CritType)
+ aCriterion.Type = self.EnumToLong(CritType)
aCriterion.Tolerance = Tolerance
aThreshold = Threshold
pass # end of class smeshBuilder
import omniORB
-#Registering the new proxy for SMESH_Gen
omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshBuilder)
+"""Registering the new proxy for SMESH.SMESH_Gen"""
-## Create a new smeshBuilder instance.The smeshBuilder class provides the Python
-# interface to create or load meshes.
-#
-# Typical use is:
-# \code
-# import salome
-# salome.salome_init()
-# from salome.smesh import smeshBuilder
-# smesh = smeshBuilder.New()
-# \endcode
-# @param isPublished If False, the notebool will not be used.
-# @param instance CORBA proxy of SMESH Engine. If None, the default Engine is used.
-# @return smeshBuilder instance
-
-def New( isPublished = True, instance=None):
+
- def New( study, instance=None, instanceGeom=None):
++def New( instance=None, instanceGeom=None):
"""
- Create a new smeshBuilder instance.The smeshBuilder class provides the Python
+ Create a new smeshBuilder instance. The smeshBuilder class provides the Python
interface to create or load meshes.
- Typical use is::
+ Typical use is:
+
import salome
salome.salome_init()
from salome.smesh import smeshBuilder
- smesh = smeshBuilder.New(salome.myStudy)
+ smesh = smeshBuilder.New()
Parameters:
- study: SALOME study, generally obtained by salome.myStudy.
- instance: CORBA proxy of SMESH Engine. If None, the default Engine is used.
- instanceGeom: CORBA proxy of GEOM Engine. If None, the default Engine is used.
+ isPublished If False, the notebool will not be used.
+ instance CORBA proxy of SMESH Engine. If None, the default Engine is used.
Returns:
- smeshBuilder instance
+ :class:`smeshBuilder` instance
"""
global engine
global smeshInst
global doLcc
engine = instance
if engine is None:
- doLcc = True
+ doLcc = True
smeshInst = smeshBuilder()
assert isinstance(smeshInst,smeshBuilder), "Smesh engine class is %s but should be smeshBuilder.smeshBuilder. Import salome.smesh.smeshBuilder before creating the instance."%smeshInst.__class__
- smeshInst.init_smesh(study, instanceGeom)
- smeshInst.init_smesh(isPublished)
++ smeshInst.init_smesh(instanceGeom)
return smeshInst
# Public class: Mesh
# ==================
- class Mesh:
-## This class allows defining and managing a mesh.
-# It has a set of methods to build a mesh on the given geometry, including the definition of sub-meshes.
-# It also has methods to define groups of mesh elements, to modify a mesh (by addition of
-# new nodes and elements and by changing the existing entities), to get information
-# about a mesh and to export a mesh in different formats.
-class Mesh(metaclass=MeshMeta):
++
++class Mesh(metaclass = MeshMeta):
+ """
+ This class allows defining and managing a mesh.
+ It has a set of methods to build a mesh on the given geometry, including the definition of sub-meshes.
+ It also has methods to define groups of mesh elements, to modify a mesh (by addition of
+ new nodes and elements and by changing the existing entities), to get information
+ about a mesh and to export a mesh in different formats.
- """
- __metaclass__ = MeshMeta
++ """
+
geom = 0
mesh = 0
editor = 0
- ## Constructor
- #
- # Create a mesh on the shape \a obj (or an empty mesh if \a obj is equal to 0) and
- # sets the GUI name of this mesh to \a name.
- # @param smeshpyD an instance of smeshBuilder class
- # @param geompyD an instance of geomBuilder class
- # @param obj Shape to be meshed or SMESH_Mesh object
- # @param name Study name of the mesh
- # @ingroup l2_construct
def __init__(self, smeshpyD, geompyD, obj=0, name=0):
- self.smeshpyD=smeshpyD
- self.geompyD=geompyD
++
+ """
+ Constructor
+
+ Create a mesh on the shape *obj* (or an empty mesh if *obj* is equal to 0) and
+ sets the GUI name of this mesh to *name*.
+
+ Parameters:
+ smeshpyD: an instance of smeshBuilder class
+ geompyD: an instance of geomBuilder class
+ obj: Shape to be meshed or :class:`SMESH.SMESH_Mesh` object
+ name: Study name of the mesh
+ """
+
+ self.smeshpyD = smeshpyD
+ self.geompyD = geompyD
if obj is None:
obj = 0
objHasName = False
pass
groups = []
- for algoName, shapes in algo2shapes.items():
+ for algoName, shapes in list(algo2shapes.items()):
while shapes:
- groupType = EnumToLong( shapes[0].GetShapeType() )
+ groupType = self.smeshpyD.EnumToLong( shapes[0].GetShapeType() )
otherTypeShapes = []
sameTypeShapes = []
group = self.geompyD.CreateGroup( self.geom, groupType )
self.geompyD.addToStudyInFather( self.geom, group, group.GetName() )
return groups
- ## Return sub-mesh objects list in meshing order
- # @return list of lists of sub-meshes
- # @ingroup l2_construct
def GetMeshOrder(self):
+ """
+ Return sub-mesh objects list in meshing order
+
+ Returns:
+ list of lists of :class:`sub-meshes <SMESH.SMESH_subMesh>`
+ """
+
return self.mesh.GetMeshOrder()
- ## Set order in which concurrent sub-meshes should be meshed
- # @param submeshes list of lists of sub-meshes
- # @ingroup l2_construct
def SetMeshOrder(self, submeshes):
+ """
+ Set order in which concurrent sub-meshes should be meshed
+
+ Parameters:
+ submeshes: list of lists of :class:`sub-meshes <SMESH.SMESH_subMesh>`
+ """
+
return self.mesh.SetMeshOrder(submeshes)
- ## Remove all nodes and elements generated on geometry. Imported elements remain.
- # @param refresh if @c True, Object browser is automatically updated (when running in GUI)
- # @ingroup l2_construct
def Clear(self, refresh=False):
+ """
+ Remove all nodes and elements generated on geometry. Imported elements remain.
+
+ Parameters:
+ refresh: if *True*, Object browser is automatically updated (when running in GUI)
+ """
+
self.mesh.Clear()
- if ( salome.sg.hasDesktop() and
- salome.myStudyManager.GetStudyByID( self.mesh.GetStudyId() ) ):
+ if ( salome.sg.hasDesktop() ):
smeshgui = salome.ImportComponentGUI("SMESH")
- smeshgui.Init(self.mesh.GetStudyId())
+ smeshgui.Init()
smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
- if refresh: salome.sg.updateObjBrowser(True)
+ if refresh: salome.sg.updateObjBrowser()
- ## Remove all nodes and elements of indicated shape
- # @param refresh if @c True, Object browser is automatically updated (when running in GUI)
- # @param geomId the ID of a sub-shape to remove elements on
- # @ingroup l2_submeshes
def ClearSubMesh(self, geomId, refresh=False):
+ """
+ Remove all nodes and elements of indicated shape
+
+ Parameters:
+ geomId: the ID of a sub-shape to remove elements on
+ refresh: if *True*, Object browser is automatically updated (when running in GUI)
+ """
+
self.mesh.ClearSubMesh(geomId)
if salome.sg.hasDesktop():
smeshgui = salome.ImportComponentGUI("SMESH")
- smeshgui.Init(self.mesh.GetStudyId())
+ smeshgui.Init()
smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
- if refresh: salome.sg.updateObjBrowser(True)
+ if refresh: salome.sg.updateObjBrowser()
- ## Compute a tetrahedral mesh using AutomaticLength + MEFISTO + Tetrahedron
- # @param fineness [0.0,1.0] defines mesh fineness
- # @return True or False
- # @ingroup l3_algos_basic
def AutomaticTetrahedralization(self, fineness=0):
+ """
+ Compute a tetrahedral mesh using AutomaticLength + MEFISTO + Tetrahedron
+
+ Parameters:
+ fineness: [0.0,1.0] defines mesh fineness
+
+ Returns:
+ True or False
+ """
+
dim = self.MeshDimension()
# assign hypotheses
self.RemoveGlobalHypotheses()
return self.mesh.RemoveHypothesis( shape, hyp )
hypName = GetName( hyp )
geoName = GetName( shape )
- print "WARNING: RemoveHypothesis() failed as '%s' is not assigned to '%s' shape" % ( hypName, geoName )
+ print("WARNING: RemoveHypothesis() failed as '%s' is not assigned to '%s' shape" % ( hypName, geoName ))
return None
- ## Get the list of hypotheses added on a geometry
- # @param geom a sub-shape of mesh geometry
- # @return the sequence of SMESH_Hypothesis
- # @ingroup l2_editing
def GetHypothesisList(self, geom):
+ """
+ Get the list of hypotheses added on a geometry
+
+ Parameters:
+ geom (GEOM.GEOM_Object): a sub-shape of mesh geometry
+
+ Returns:
+ the sequence of :class:`SMESH.SMESH_Hypothesis`
+ """
+
return self.mesh.GetHypothesisList( geom )
- ## Remove all global hypotheses
- # @ingroup l2_editing
def RemoveGlobalHypotheses(self):
+ """
+ Remove all global hypotheses
+ """
+
current_hyps = self.mesh.GetHypothesisList( self.geom )
for hyp in current_hyps:
self.mesh.RemoveHypothesis( self.geom, hyp )
pass
pass
--
- def ExportMED(self, f, auto_groups=0, version=MED_V2_2,
- overwrite=1, meshPart=None, autoDimension=True, fields=[], geomAssocFields=''):
- ## Export the mesh in a file in MED format
- ## allowing to overwrite the file if it exists or add the exported data to its contents
- # @param fileName is the file name
- # @param auto_groups boolean parameter for creating/not creating
- # the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
- # the typical use is auto_groups=False.
- # @param overwrite boolean parameter for overwriting/not overwriting the file
- # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
- # @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
- # - 1D if all mesh nodes lie on OX coordinate axis, or
- # - 2D if all mesh nodes lie on XOY coordinate plane, or
- # - 3D in the rest cases.<br>
- # If @a autoDimension is @c False, the space dimension is always 3.
- # @param fields list of GEOM fields defined on the shape to mesh.
- # @param geomAssocFields each character of this string means a need to export a
- # corresponding field; correspondence between fields and characters is following:
- # - 'v' stands for "_vertices _" field;
- # - 'e' stands for "_edges _" field;
- # - 'f' stands for "_faces _" field;
- # - 's' stands for "_solids _" field.
- # @ingroup l2_impexp
+ def ExportMED(self, *args, **kwargs):
+ """
+ Export the mesh in a file in MED format
+ allowing to overwrite the file if it exists or add the exported data to its contents
+
+ Parameters:
- f: is the file name
- auto_groups: boolean parameter for creating/not creating
- the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
- the typical use is auto_groups=False.
- version: MED format version (MED_V2_1 or MED_V2_2,
- the latter meaning any current version). The parameter is
- obsolete since MED_V2_1 is no longer supported.
- overwrite: boolean parameter for overwriting/not overwriting the file
- meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
- autoDimension: if *True* (default), a space dimension of a MED mesh can be either
-
- - 1D if all mesh nodes lie on OX coordinate axis, or
- - 2D if all mesh nodes lie on XOY coordinate plane, or
- - 3D in the rest cases.
-
++ fileName: is the file name
++ auto_groups (boolean): parameter for creating/not creating
++ the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
++ the typical use is auto_groups=False.
++ overwrite (boolean): parameter for overwriting/not overwriting the file
++ meshPart: a part of mesh (group, sub-mesh) to export instead of the mesh
++ autoDimension if @c True (default), a space dimension of a MED mesh can be either
++ - 1D if all mesh nodes lie on OX coordinate axis, or
++ - 2D if all mesh nodes lie on XOY coordinate plane, or
++ - 3D in the rest cases.
+ If *autoDimension* is *False*, the space dimension is always 3.
+ fields: list of GEOM fields defined on the shape to mesh.
+ geomAssocFields: each character of this string means a need to export a
+ corresponding field; correspondence between fields and characters is following:
+ - 'v' stands for "_vertices _" field;
+ - 'e' stands for "_edges _" field;
+ - 'f' stands for "_faces _" field;
+ - 's' stands for "_solids _" field.
+ """
-
+ # process positional arguments
+ args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+ fileName = args[0]
+ auto_groups = args[1] if len(args) > 1 else False
+ overwrite = args[2] if len(args) > 2 else True
+ meshPart = args[3] if len(args) > 3 else None
+ autoDimension = args[4] if len(args) > 4 else True
+ fields = args[5] if len(args) > 5 else []
+ geomAssocFields = args[6] if len(args) > 6 else ''
+ # process keywords arguments
+ auto_groups = kwargs.get("auto_groups", auto_groups)
+ overwrite = kwargs.get("overwrite", overwrite)
+ meshPart = kwargs.get("meshPart", meshPart)
+ autoDimension = kwargs.get("autoDimension", autoDimension)
+ fields = kwargs.get("fields", fields)
+ geomAssocFields = kwargs.get("geomAssocFields", geomAssocFields)
+ # invoke engine's function
if meshPart or fields or geomAssocFields:
unRegister = genObjUnRegister()
if isinstance( meshPart, list ):
meshPart = self.GetIDSource( meshPart, SMESH.ALL )
unRegister.set( meshPart )
- self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension,
+ self.mesh.ExportPartToMED( meshPart, fileName, auto_groups, overwrite, autoDimension,
fields, geomAssocFields)
else:
- self.mesh.ExportToMEDX(f, auto_groups, version, overwrite, autoDimension)
+ self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
- ## Export the mesh in a file in SAUV format
- # @param f is the file name
- # @param auto_groups boolean parameter for creating/not creating
- # the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
- # the typical use is auto_groups=false.
- # @ingroup l2_impexp
def ExportSAUV(self, f, auto_groups=0):
+ """
+ Export the mesh in a file in SAUV format
+
+
+ Parameters:
+ f: is the file name
+ auto_groups: boolean parameter for creating/not creating
+ the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
+ the typical use is auto_groups=False.
+ """
+
self.mesh.ExportSAUV(f, auto_groups)
- ## Export the mesh in a file in DAT format
- # @param f the file name
- # @param meshPart a part of mesh (group, sub-mesh) to export instead of the mesh
- # @ingroup l2_impexp
def ExportDAT(self, f, meshPart=None):
+ """
+ Export the mesh in a file in DAT format
+
+ Parameters:
+ f: the file name
+ meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to export instead of the mesh
+ """
+
if meshPart:
unRegister = genObjUnRegister()
if isinstance( meshPart, list ):
meshPart = self.mesh
self.mesh.ExportGMF(meshPart, f, True)
- def ExportToMED(self, f, version=MED_V2_2, opt=0, overwrite=1, autoDimension=True):
- ## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
- # Export the mesh in a file in MED format
- # allowing to overwrite the file if it exists or add the exported data to its contents
- # @param fileName the file name
- # @param opt boolean parameter for creating/not creating
- # the groups Group_On_All_Nodes, Group_On_All_Faces, ...
- # @param overwrite boolean parameter for overwriting/not overwriting the file
- # @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
- # - 1D if all mesh nodes lie on OX coordinate axis, or
- # - 2D if all mesh nodes lie on XOY coordinate plane, or
- # - 3D in the rest cases.<br>
- # If @a autoDimension is @c False, the space dimension is always 3.
- # @ingroup l2_impexp
+ def ExportToMED(self, *args, **kwargs):
+ """
+ Deprecated, used only for compatibility! Please, use :meth:`ExportMED` method instead.
+ Export the mesh in a file in MED format
+ allowing to overwrite the file if it exists or add the exported data to its contents
+
+ Parameters:
- f: the file name
- version: MED format version (MED_V2_1 or MED_V2_2,
- the latter meaning any current version). The parameter is
- obsolete since MED_V2_1 is no longer supported.
- opt: boolean parameter for creating/not creating
++ fileName: the file name
++ opt (boolean): parameter for creating/not creating
+ the groups Group_On_All_Nodes, Group_On_All_Faces, ...
+ overwrite: boolean parameter for overwriting/not overwriting the file
+ autoDimension: if *True* (default), a space dimension of a MED mesh can be either
+
+ - 1D if all mesh nodes lie on OX coordinate axis, or
+ - 2D if all mesh nodes lie on XOY coordinate plane, or
+ - 3D in the rest cases.
+
+ If **autoDimension** is *False*, the space dimension is always 3.
+ """
++
+ print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
+ # process positional arguments
+ args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+ fileName = args[0]
+ auto_groups = args[1] if len(args) > 1 else False
+ overwrite = args[2] if len(args) > 2 else True
+ autoDimension = args[3] if len(args) > 3 else True
+ # process keywords arguments
+ auto_groups = kwargs.get("opt", auto_groups) # old keyword name
+ auto_groups = kwargs.get("auto_groups", auto_groups) # new keyword name
+ overwrite = kwargs.get("overwrite", overwrite)
+ autoDimension = kwargs.get("autoDimension", autoDimension)
+ # invoke engine's function
+ self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
+
- ## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
- # Export the mesh in a file in MED format
- # allowing to overwrite the file if it exists or add the exported data to its contents
- # @param fileName the file name
- # @param opt boolean parameter for creating/not creating
- # the groups Group_On_All_Nodes, Group_On_All_Faces, ...
- # @param overwrite boolean parameter for overwriting/not overwriting the file
- # @param autoDimension if @c True (default), a space dimension of a MED mesh can be either
- # - 1D if all mesh nodes lie on OX coordinate axis, or
- # - 2D if all mesh nodes lie on XOY coordinate plane, or
- # - 3D in the rest cases.<br>
- # If @a autoDimension is @c False, the space dimension is always 3.
- # @ingroup l2_impexp
+ def ExportToMEDX(self, *args, **kwargs):
++ """
++ Deprecated, used only for compatibility! Please, use ExportMED() method instead.
++ Export the mesh in a file in MED format
++
++ Parameters:
++ fileName: the file name
++ opt (boolean): parameter for creating/not creating
++ the groups Group_On_All_Nodes, Group_On_All_Faces, ...
++ overwrite: boolean parameter for overwriting/not overwriting the file
++ autoDimension: if *True* (default), a space dimension of a MED mesh can be either
+
- self.mesh.ExportToMEDX(f, opt, version, overwrite, autoDimension)
++ - 1D if all mesh nodes lie on OX coordinate axis, or
++ - 2D if all mesh nodes lie on XOY coordinate plane, or
++ - 3D in the rest cases.
++
++ If **autoDimension** is *False*, the space dimension is always 3.
++ """
++
+ print("WARNING: ExportToMEDX() is deprecated, use ExportMED() instead")
+ # process positional arguments
+ args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
+ fileName = args[0]
+ auto_groups = args[1] if len(args) > 1 else False
+ overwrite = args[2] if len(args) > 2 else True
+ autoDimension = args[3] if len(args) > 3 else True
+ # process keywords arguments
+ auto_groups = kwargs.get("auto_groups", auto_groups)
+ overwrite = kwargs.get("overwrite", overwrite)
+ autoDimension = kwargs.get("autoDimension", autoDimension)
+ # invoke engine's function
+ self.mesh.ExportMED(fileName, auto_groups, overwrite, autoDimension)
# Operations with groups:
# ----------------------
--
- ## Create an empty mesh group
- # @param elementType the type of elements in the group; either of
- # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
- # @param name the name of the mesh group
- # @return SMESH_Group
- # @ingroup l2_grps_create
def CreateEmptyGroup(self, elementType, name):
+ """
+ Create an empty mesh group
+
+ Parameters:
+ elementType: the :class:`type <SMESH.ElementType>` of elements in the group;
+ either of (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME)
+ name: the name of the mesh group
+
+ Returns:
+ :class:`SMESH.SMESH_Group`
+ """
+
return self.mesh.CreateGroup(elementType, name)
- ## Create a mesh group based on the geometric object \a grp
- # and gives a \a name, \n if this parameter is not defined
- # the name is the same as the geometric group name \n
- # Note: Works like GroupOnGeom().
- # @param grp a geometric group, a vertex, an edge, a face or a solid
- # @param name the name of the mesh group
- # @return SMESH_GroupOnGeom
- # @ingroup l2_grps_create
def Group(self, grp, name=""):
+ """
+ Create a mesh group based on the geometric object *grp*
+ and give it a *name*.
+ If *name* is not defined the name of the geometric group is used
+
+ Note:
+ Works like :meth:`GroupOnGeom`.
+
+ Parameters:
+ grp: a geometric group, a vertex, an edge, a face or a solid
+ name: the name of the mesh group
+
+ Returns:
+ :class:`SMESH.SMESH_GroupOnGeom`
+ """
+
return self.GroupOnGeom(grp, name)
- ## Create a mesh group based on the geometrical object \a grp
- # and gives a \a name, \n if this parameter is not defined
- # the name is the same as the geometrical group name
- # @param grp a geometrical group, a vertex, an edge, a face or a solid
- # @param name the name of the mesh group
- # @param typ the type of elements in the group; either of
- # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). If not set, it is
- # automatically detected by the type of the geometry
- # @return SMESH_GroupOnGeom
- # @ingroup l2_grps_create
def GroupOnGeom(self, grp, name="", typ=None):
+ """
+ Create a mesh group based on the geometrical object *grp*
+ and gives a *name*.
+ if *name* is not defined the name of the geometric group is used
+
+ Parameters:
+ grp: a geometrical group, a vertex, an edge, a face or a solid
+ name: the name of the mesh group
+ typ: the type of elements in the group; either of
+ (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME). If not set, it is
+ automatically detected by the type of the geometry
+
+ Returns:
+ :class:`SMESH.SMESH_GroupOnGeom`
+ """
+
AssureGeomPublished( self, grp, name )
if name == "":
name = grp.GetName()
elif tgeo == "COMPOUND":
sub = self.geompyD.SubShapeAll( shape, self.geompyD.ShapeType["SHAPE"])
if not sub:
- raise ValueError,"_groupTypeFromShape(): empty geometric group or compound '%s'" % GetName(shape)
+ raise ValueError("_groupTypeFromShape(): empty geometric group or compound '%s'" % GetName(shape))
return self._groupTypeFromShape( sub[0] )
else:
- raise ValueError, \
- "_groupTypeFromShape(): invalid geometry '%s'" % GetName(shape)
+ raise ValueError("_groupTypeFromShape(): invalid geometry '%s'" % GetName(shape))
return typ
- ## Create a mesh group with given \a name based on the \a filter which
- ## is a special type of group dynamically updating it's contents during
- ## mesh modification
- # @param typ the type of elements in the group; either of
- # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
- # @param name the name of the mesh group
- # @param filter the filter defining group contents
- # @return SMESH_GroupOnFilter
- # @ingroup l2_grps_create
def GroupOnFilter(self, typ, name, filter):
+ """
+ Create a mesh group with given *name* based on the *filter* which
+ is a special type of group dynamically updating it's contents during
+ mesh modification
+
+ Parameters:
+ typ: the type of elements in the group; either of
+ (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
+ name: the name of the mesh group
+ filter (SMESH.Filter): the filter defining group contents
+
+ Returns:
+ :class:`SMESH.SMESH_GroupOnFilter`
+ """
+
return self.mesh.CreateGroupFromFilter(typ, name, filter)
- ## Create a mesh group by the given ids of elements
- # @param groupName the name of the mesh group
- # @param elementType the type of elements in the group; either of
- # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
- # @param elemIDs either the list of ids, group, sub-mesh, or filter
- # @return SMESH_Group
- # @ingroup l2_grps_create
def MakeGroupByIds(self, groupName, elementType, elemIDs):
+ """
+ Create a mesh group by the given ids of elements
+
+ Parameters:
+ groupName: the name of the mesh group
+ elementType: the type of elements in the group; either of
+ (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
+ elemIDs: either the list of ids, :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
+
+ Returns:
+ :class:`SMESH.SMESH_Group`
+ """
+
group = self.mesh.CreateGroup(elementType, groupName)
if isinstance( elemIDs, Mesh ):
elemIDs = elemIDs.GetMesh()
groups.append( group )
return groups
- ## Produce a union of two groups.
- # A new group is created. All mesh elements that are
- # present in the initial groups are added to the new one
- # @return an instance of SMESH_Group
- # @ingroup l2_grps_operon
def UnionGroups(self, group1, group2, name):
+ """
+ Produce a union of two groups.
+ A new group is created. All mesh elements that are
+ present in the initial groups are added to the new one
+
+ Parameters:
+ group1 (SMESH.SMESH_GroupBase): a group
+ group2 (SMESH.SMESH_GroupBase): another group
+
+ Returns:
+ instance of :class:`SMESH.SMESH_Group`
+ """
+
return self.mesh.UnionGroups(group1, group2, name)
- ## Produce a union list of groups.
- # New group is created. All mesh elements that are present in
- # initial groups are added to the new one
- # @return an instance of SMESH_Group
- # @ingroup l2_grps_operon
def UnionListOfGroups(self, groups, name):
-
+ """
+ Produce a union list of groups.
+ New group is created. All mesh elements that are present in
+ initial groups are added to the new one
+
+ Parameters:
+ groups: list of :class:`SMESH.SMESH_GroupBase`
+
+ Returns:
+ instance of :class:`SMESH.SMESH_Group`
+ """
return self.mesh.UnionListOfGroups(groups, name)
- ## Prodice an intersection of two groups.
- # A new group is created. All mesh elements that are common
- # for the two initial groups are added to the new one.
- # @return an instance of SMESH_Group
- # @ingroup l2_grps_operon
def IntersectGroups(self, group1, group2, name):
+ """
+ Prodice an intersection of two groups.
+ A new group is created. All mesh elements that are common
+ for the two initial groups are added to the new one.
+
+ Parameters:
+ group1 (SMESH.SMESH_GroupBase): a group
+ group2 (SMESH.SMESH_GroupBase): another group
+
+ Returns:
+ instance of :class:`SMESH.SMESH_Group`
+ """
+
return self.mesh.IntersectGroups(group1, group2, name)
- ## Produce an intersection of groups.
- # New group is created. All mesh elements that are present in all
- # initial groups simultaneously are added to the new one
- # @return an instance of SMESH_Group
- # @ingroup l2_grps_operon
def IntersectListOfGroups(self, groups, name):
-
+ """
+ Produce an intersection of groups.
+ New group is created. All mesh elements that are present in all
+ initial groups simultaneously are added to the new one
+
+ Parameters:
+ groups: a list of :class:`SMESH.SMESH_GroupBase`
+
+ Returns:
+ instance of :class:`SMESH.SMESH_Group`
+ """
return self.mesh.IntersectListOfGroups(groups, name)
- ## Produce a cut of two groups.
- # A new group is created. All mesh elements that are present in
- # the main group but are not present in the tool group are added to the new one
- # @return an instance of SMESH_Group
- # @ingroup l2_grps_operon
def CutGroups(self, main_group, tool_group, name):
+ """
+ Produce a cut of two groups.
+ A new group is created. All mesh elements that are present in
+ the main group but are not present in the tool group are added to the new one
+
+ Parameters:
+ main_group (SMESH.SMESH_GroupBase): a group to cut from
+ tool_group (SMESH.SMESH_GroupBase): a group to cut by
+
+ Returns:
+ an instance of :class:`SMESH.SMESH_Group`
+ """
+
return self.mesh.CutGroups(main_group, tool_group, name)
- ## Produce a cut of groups.
- # A new group is created. All mesh elements that are present in main groups
- # but do not present in tool groups are added to the new one
- # @return an instance of SMESH_Group
- # @ingroup l2_grps_operon
def CutListOfGroups(self, main_groups, tool_groups, name):
+ """
+ Produce a cut of groups.
+ A new group is created. All mesh elements that are present in main groups
+ but do not present in tool groups are added to the new one
+
+ Parameters:
+ main_group: groups to cut from (list of :class:`SMESH.SMESH_GroupBase`)
+ tool_group: groups to cut by (list of :class:`SMESH.SMESH_GroupBase`)
+
+ Returns:
+ an instance of :class:`SMESH.SMESH_Group`
+ """
+
return self.mesh.CutListOfGroups(main_groups, tool_groups, name)
- ##
- # Create a standalone group of entities basing on nodes of other groups.
- # \param groups - list of reference groups, sub-meshes or filters, of any type.
- # \param elemType - a type of elements to include to the new group; either of
- # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
- # \param name - a name of the new group.
- # \param nbCommonNodes - a criterion of inclusion of an element to the new group
- # basing on number of element nodes common with reference \a groups.
- # Meaning of possible values are:
- # - SMESH.ALL_NODES - include if all nodes are common,
- # - SMESH.MAIN - include if all corner nodes are common (meaningful for a quadratic mesh),
- # - SMESH.AT_LEAST_ONE - include if one or more node is common,
- # - SMEHS.MAJORITY - include if half of nodes or more are common.
- # \param underlyingOnly - if \c True (default), an element is included to the
- # new group provided that it is based on nodes of an element of \a groups;
- # in this case the reference \a groups are supposed to be of higher dimension
- # than \a elemType, which can be useful for example to get all faces lying on
- # volumes of the reference \a groups.
- # @return an instance of SMESH_Group
- # @ingroup l2_grps_operon
def CreateDimGroup(self, groups, elemType, name,
nbCommonNodes = SMESH.ALL_NODES, underlyingOnly = True):
+ """
+ Create a standalone group of entities basing on nodes of other groups.
+
+ Parameters:
+ groups: list of reference :class:`sub-meshes, groups or filters <SMESH.SMESH_IDSource>`, of any type.
+ elemType: a type of elements to include to the new group; either of
+ (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
+ name: a name of the new group.
+ nbCommonNodes: a criterion of inclusion of an element to the new group
+ basing on number of element nodes common with reference *groups*.
+ Meaning of possible values are:
+
+ - SMESH.ALL_NODES - include if all nodes are common,
+ - SMESH.MAIN - include if all corner nodes are common (meaningful for a quadratic mesh),
+ - SMESH.AT_LEAST_ONE - include if one or more node is common,
+ - SMEHS.MAJORITY - include if half of nodes or more are common.
+ underlyingOnly: if *True* (default), an element is included to the
+ new group provided that it is based on nodes of an element of *groups*;
+ in this case the reference *groups* are supposed to be of higher dimension
+ than *elemType*, which can be useful for example to get all faces lying on
+ volumes of the reference *groups*.
+
+ Returns:
+ an instance of :class:`SMESH.SMESH_Group`
+ """
+
if isinstance( groups, SMESH._objref_SMESH_IDSource ):
groups = [groups]
return self.mesh.CreateDimGroup(groups, elemType, name, nbCommonNodes, underlyingOnly)
# Get some info about mesh:
# ------------------------
- ## Return the log of nodes and elements added or removed
- # since the previous clear of the log.
- # @param clearAfterGet log is emptied after Get (safe if concurrents access)
- # @return list of log_block structures:
- # commandType
- # number
- # coords
- # indexes
- # @ingroup l1_auxiliary
def GetLog(self, clearAfterGet):
+ """
+ Return the log of nodes and elements added or removed
+ since the previous clear of the log.
+
+ Parameters:
+ clearAfterGet: log is emptied after Get (safe if concurrents access)
+
+ Returns:
+ list of SMESH.log_block structures { commandType, number, coords, indexes }
+ """
+
return self.mesh.GetLog(clearAfterGet)
- ## Clear the log of nodes and elements added or removed since the previous
- # clear. Must be used immediately after GetLog if clearAfterGet is false.
- # @ingroup l1_auxiliary
def ClearLog(self):
+ """
+ Clear the log of nodes and elements added or removed since the previous
+ clear. Must be used immediately after :meth:`GetLog` if clearAfterGet is false.
+ """
+
self.mesh.ClearLog()
- ## Toggle auto color mode on the object.
- # @param theAutoColor the flag which toggles auto color mode.
- #
- # If switched on, a default color of a new group in Create Group dialog is chosen randomly.
- # @ingroup l1_grouping
def SetAutoColor(self, theAutoColor):
+ """
+ Toggle auto color mode on the object.
+ If switched on, a default color of a new group in Create Group dialog is chosen randomly.
+
+ Parameters:
+ theAutoColor (boolean): the flag which toggles auto color mode.
+ """
+
self.mesh.SetAutoColor(theAutoColor)
- ## Get flag of object auto color mode.
- # @return True or False
- # @ingroup l1_grouping
def GetAutoColor(self):
+ """
+ Get flag of object auto color mode.
+
+ Returns:
+ True or False
+ """
+
return self.mesh.GetAutoColor()
- ## Get the internal ID
- # @return integer value, which is the internal Id of the mesh
- # @ingroup l1_auxiliary
def GetId(self):
+ """
+ Get the internal ID
+
+ Returns:
+ integer value, which is the internal Id of the mesh
+ """
+
return self.mesh.GetId()
- def GetStudyId(self):
- """
- Get the study Id
-
- Returns:
- integer value, which is the study Id of the mesh
- """
-
- return self.mesh.GetStudyId()
-
- ## Check the group names for duplications.
- # Consider the maximum group name length stored in MED file.
- # @return True or False
- # @ingroup l1_grouping
def HasDuplicatedGroupNamesMED(self):
+ """
+ Check the group names for duplications.
+ Consider the maximum group name length stored in MED file.
+
+ Returns:
+ True or False
+ """
+
return self.mesh.HasDuplicatedGroupNamesMED()
- ## Obtain the mesh editor tool
- # @return an instance of SMESH_MeshEditor
- # @ingroup l1_modifying
def GetMeshEditor(self):
+ """
+ Obtain the mesh editor tool
+
+ Returns:
+ an instance of :class:`SMESH.SMESH_MeshEditor`
+ """
+
return self.editor
- ## Wrap a list of IDs of elements or nodes into SMESH_IDSource which
- # can be passed as argument to a method accepting mesh, group or sub-mesh
- # @param ids list of IDs
- # @param elemType type of elements; this parameter is used to distinguish
- # IDs of nodes from IDs of elements; by default ids are treated as
- # IDs of elements; use SMESH.NODE if ids are IDs of nodes.
- # @return an instance of SMESH_IDSource
- # @warning call UnRegister() for the returned object as soon as it is no more useful:
- # idSrc = mesh.GetIDSource( [1,3,5], SMESH.NODE )
- # mesh.DoSomething( idSrc )
- # idSrc.UnRegister()
- # @ingroup l1_auxiliary
def GetIDSource(self, ids, elemType = SMESH.ALL):
+ """
+ Wrap a list of IDs of elements or nodes into :class:`SMESH.SMESH_IDSource` which
+ can be passed as argument to a method accepting :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
+
+ Parameters:
+ ids: list of IDs
+ elemType: type of elements; this parameter is used to distinguish
+ IDs of nodes from IDs of elements; by default ids are treated as
+ IDs of elements; use SMESH.NODE if ids are IDs of nodes.
+
+ Returns:
+ an instance of :class:`SMESH.SMESH_IDSource`
+
+ Warning:
+ call UnRegister() for the returned object as soon as it is no more useful::
+
+ idSrc = mesh.GetIDSource( [1,3,5], SMESH.NODE )
+ mesh.DoSomething( idSrc )
+ idSrc.UnRegister()
+ """
+
if isinstance( ids, int ):
ids = [ids]
return self.editor.MakeIDSource(ids, elemType)
EdgeID = Edge
try:
self.editor.SetNodeOnEdge(NodeID, EdgeID, paramOnEdge)
- except SALOME.SALOME_Exception, inst:
- raise ValueError, inst.details.text
+ except SALOME.SALOME_Exception as inst:
+ raise ValueError(inst.details.text)
return True
- ## @brief Stores node position on a face
- # @param NodeID a node ID
- # @param Face a face or face ID
- # @param u U parameter on the face where the node is located
- # @param v V parameter on the face where the node is located
- # @return True if succeed else raises an exception
- # @ingroup l2_modif_add
def SetNodeOnFace(self, NodeID, Face, u, v):
+ """
+ Stores node position on a face
+
+ Parameters:
+ NodeID: a node ID
+ Face: a face (GEOM.GEOM_Object) or face ID
+ u: U parameter on the face where the node is located
+ v: V parameter on the face where the node is located
+
+ Returns:
+ True if succeed else raises an exception
+ """
+
if ( isinstance( Face, geomBuilder.GEOM._objref_GEOM_Object)):
FaceID = self.geompyD.GetSubShapeID( self.geom, Face )
else:
FaceID = Face
try:
self.editor.SetNodeOnFace(NodeID, FaceID, u, v)
- except SALOME.SALOME_Exception, inst:
- raise ValueError, inst.details.text
+ except SALOME.SALOME_Exception as inst:
+ raise ValueError(inst.details.text)
return True
- ## @brief Binds a node to a solid
- # @param NodeID a node ID
- # @param Solid a solid or solid ID
- # @return True if succeed else raises an exception
- # @ingroup l2_modif_add
def SetNodeInVolume(self, NodeID, Solid):
+ """
+ Binds a node to a solid
+
+ Parameters:
+ NodeID: a node ID
+ Solid: a solid (GEOM.GEOM_Object) or solid ID
+
+ Returns:
+ True if succeed else raises an exception
+ """
+
if ( isinstance( Solid, geomBuilder.GEOM._objref_GEOM_Object)):
SolidID = self.geompyD.GetSubShapeID( self.geom, Solid )
else:
SolidID = Solid
try:
self.editor.SetNodeInVolume(NodeID, SolidID)
- except SALOME.SALOME_Exception, inst:
- raise ValueError, inst.details.text
+ except SALOME.SALOME_Exception as inst:
+ raise ValueError(inst.details.text)
return True
- ## @brief Bind an element to a shape
- # @param ElementID an element ID
- # @param Shape a shape or shape ID
- # @return True if succeed else raises an exception
- # @ingroup l2_modif_add
def SetMeshElementOnShape(self, ElementID, Shape):
+ """
+ Bind an element to a shape
+
+ Parameters:
+ ElementID: an element ID
+ Shape: a shape (GEOM.GEOM_Object) or shape ID
+
+ Returns:
+ True if succeed else raises an exception
+ """
+
if ( isinstance( Shape, geomBuilder.GEOM._objref_GEOM_Object)):
ShapeID = self.geompyD.GetSubShapeID( self.geom, Shape )
else:
#return preview.MoveClosestNodeToPoint(x, y, z, -1)
return self.editor.FindNodeClosestTo(x, y, z)
- ## Find the elements where a point lays IN or ON
- # @param x the X coordinate of a point
- # @param y the Y coordinate of a point
- # @param z the Z coordinate of a point
- # @param elementType type of elements to find; either of
- # (SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME); SMESH.ALL type
- # means elements of any type excluding nodes, discrete and 0D elements.
- # @param meshPart a part of mesh (group, sub-mesh) to search within
- # @return list of IDs of found elements
- # @ingroup l1_meshinfo
def FindElementsByPoint(self, x, y, z, elementType = SMESH.ALL, meshPart=None):
-
+ """
+ Find the elements where a point lays IN or ON
+
+ Parameters:
+ x,y,z (float): coordinates of the point
+ elementType (SMESH.ElementType): type of elements to find; SMESH.ALL type
+ means elements of any type excluding nodes, discrete and 0D elements.
+ meshPart: a part of mesh (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to search within
+
+ Returns:
+ list of IDs of found elements
+ """
if meshPart:
return self.editor.FindAmongElementsByPoint( meshPart, x, y, z, elementType );
else:
self.editor.ConvertToQuadratic(theForce3d)
error = self.editor.GetLastError()
if error and error.comment:
- print error.comment
+ print(error.comment)
return error
- ## Convert the mesh from quadratic to ordinary,
- # deletes old quadratic elements, \n replacing
- # them with ordinary mesh elements with the same id.
- # @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal
- # @ingroup l2_modif_tofromqu
def ConvertFromQuadratic(self, theSubMesh=None):
+ """
+ Convert the mesh from quadratic to ordinary,
+ deletes old quadratic elements,
+ replacing them with ordinary mesh elements with the same id.
+
+ Parameters:
+ theSubMesh: a :class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>` to convert
+
+ Warning:
+ If *theSubMesh* is provided, the mesh can become non-conformal
+ """
+
if theSubMesh:
self.editor.ConvertFromQuadraticObject(theSubMesh)
else:
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
+ 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.
- # @return SMESH.CoincidentFreeBorders structure
- # @ingroup l2_modif_trsf
def FindCoincidentFreeBorders (self, tolerance=0.):
+ """
+ Return groups of FreeBorder's coincident within the given tolerance.
+
+ Parameters:
+ 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.
+
+ Returns:
+ SMESH.CoincidentFreeBorders structure
+ """
+
return self.editor.FindCoincidentFreeBorders( tolerance )
- ## Sew FreeBorder's of each group
- # @param freeBorders either a SMESH.CoincidentFreeBorders structure or a list of lists
- # where each enclosed list contains node IDs of a group of coincident free
- # borders such that each consequent triple of IDs within a group describes
- # a free border in a usual way: n1, n2, nLast - i.e. 1st node, 2nd node and
- # last node of a border.
- # For example [[1, 2, 10, 20, 21, 40], [11, 12, 15, 55, 54, 41]] describes two
- # groups of coincident free borders, each group including two borders.
- # @param createPolygons if @c True faces adjacent to free borders are converted to
- # polygons if a node of opposite border falls on a face edge, else such
- # faces are split into several ones.
- # @param createPolyhedra if @c True volumes adjacent to free borders are converted to
- # polyhedra if a node of opposite border falls on a volume edge, else such
- # volumes, if any, remain intact and the mesh becomes non-conformal.
- # @return a number of successfully sewed groups
- # @ingroup l2_modif_trsf
def SewCoincidentFreeBorders (self, freeBorders, createPolygons=False, createPolyhedra=False):
+ """
+ Sew FreeBorder's of each group
+
+ Parameters:
+ freeBorders: either a SMESH.CoincidentFreeBorders structure or a list of lists
+ where each enclosed list contains node IDs of a group of coincident free
+ borders such that each consequent triple of IDs within a group describes
+ a free border in a usual way: n1, n2, nLast - i.e. 1st node, 2nd node and
+ last node of a border.
+ For example [[1, 2, 10, 20, 21, 40], [11, 12, 15, 55, 54, 41]] describes two
+ groups of coincident free borders, each group including two borders.
+ createPolygons: if :code:`True` faces adjacent to free borders are converted to
+ polygons if a node of opposite border falls on a face edge, else such
+ faces are split into several ones.
+ createPolyhedra: if :code:`True` volumes adjacent to free borders are converted to
+ polyhedra if a node of opposite border falls on a volume edge, else such
+ volumes, if any, remain intact and the mesh becomes non-conformal.
+
+ Returns:
+ a number of successfully sewed groups
+ """
+
if freeBorders and isinstance( freeBorders, list ):
# construct SMESH.CoincidentFreeBorders
if isinstance( freeBorders[0], int ):
return twoGroups[ int(theMakeNodeGroup) ]
return self.editor.DoubleNodeElemGroups(theElems, theNodesNot, theAffectedElems)
- ## Create a hole in a mesh by doubling the nodes of some particular elements
- # This method provided for convenience works as DoubleNodes() described above.
- # @param theElems - list of groups of elements (edges or faces) to be replicated
- # @param theNodesNot - list of groups of nodes not to replicated
- # @param theShape - shape to detect affected elements (element which geometric center
- # located on or inside shape).
- # The replicated nodes should be associated to affected elements.
- # @return TRUE if operation has been completed successfully, FALSE otherwise
- # @ingroup l2_modif_duplicat
def DoubleNodeElemGroupsInRegion(self, theElems, theNodesNot, theShape):
+ """
+ Create a hole in a mesh by doubling the nodes of some particular elements.
+ This method provided for convenience works as :meth:`DoubleNodes`.
+
+ Parameters:
+ theElems: list of groups of elements (edges or faces) to replicate
+ theNodesNot: list of groups of nodes NOT to replicate
+ theShape: shape to detect affected elements (element which geometric center
+ located on or inside shape).
+ The replicated nodes should be associated to affected elements
+
+ Returns:
+ True if operation has been completed successfully, False otherwise
+ """
+
return self.editor.DoubleNodeElemGroupsInRegion(theElems, theNodesNot, theShape)
- ## Identify the elements that will be affected by node duplication (actual duplication is not performed.
- # This method is the first step of DoubleNodeElemGroupsInRegion.
- # @param theElems - list of groups of nodes or elements (edges or faces) to be replicated
- # @param theNodesNot - list of groups of nodes not to replicated
- # @param theShape - shape to detect affected elements (element which geometric center
- # located on or inside shape).
- # The replicated nodes should be associated to affected elements.
- # @return groups of affected elements in order: volumes, faces, edges
- # @ingroup l2_modif_duplicat
def AffectedElemGroupsInRegion(self, theElems, theNodesNot, theShape):
+ """
+ Identify the elements that will be affected by node duplication (actual duplication is not performed).
+ This method is the first step of :meth:`DoubleNodeElemGroupsInRegion`.
+
+ Parameters:
+ theElems: list of groups of nodes or elements (edges or faces) to replicate
+ theNodesNot: list of groups of nodes NOT to replicate
+ theShape: shape to detect affected elements (element which geometric center
+ located on or inside shape).
+ The replicated nodes should be associated to affected elements
+
+ Returns:
+ groups of affected elements in order: volumes, faces, edges
+ """
+
return self.editor.AffectedElemGroupsInRegion(theElems, theNodesNot, theShape)
- ## Double nodes on shared faces between groups of volumes and create flat elements on demand.
- # The list of groups must describe a partition of the mesh volumes.
- # The nodes of the internal faces at the boundaries of the groups are doubled.
- # In option, the internal faces are replaced by flat elements.
- # Triangles are transformed in prisms, and quadrangles in hexahedrons.
- # @param theDomains - list of groups of volumes
- # @param createJointElems - if TRUE, create the elements
- # @param onAllBoundaries - if TRUE, the nodes and elements are also created on
- # the boundary between \a theDomains and the rest mesh
- # @return TRUE if operation has been completed successfully, FALSE otherwise
- # @ingroup l2_modif_duplicat
def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems, onAllBoundaries=False ):
++
+ """
+ Double nodes on shared faces between groups of volumes and create flat elements on demand.
+ The list of groups must describe a partition of the mesh volumes.
+ The nodes of the internal faces at the boundaries of the groups are doubled.
+ In option, the internal faces are replaced by flat elements.
+ Triangles are transformed to prisms, and quadrangles to hexahedrons.
+
+ Parameters:
+ theDomains: list of groups of volumes
+ createJointElems: if True, create the elements
+ onAllBoundaries: if True, the nodes and elements are also created on
+ the boundary between *theDomains* and the rest mesh
+
+ Returns:
+ True if operation has been completed successfully, False otherwise
+ """
+
return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems, onAllBoundaries )
- ## Double nodes on some external faces and create flat elements.
- # Flat elements are mainly used by some types of mechanic calculations.
- #
- # Each group of the list must be constituted of faces.
- # Triangles are transformed in prisms, and quadrangles in hexahedrons.
- # @param theGroupsOfFaces - list of groups of faces
- # @return TRUE if operation has been completed successfully, FALSE otherwise
- # @ingroup l2_modif_duplicat
def CreateFlatElementsOnFacesGroups(self, theGroupsOfFaces ):
+ """
+ Double nodes on some external faces and create flat elements.
+ Flat elements are mainly used by some types of mechanic calculations.
+
+ Each group of the list must be constituted of faces.
+ Triangles are transformed in prisms, and quadrangles in hexahedrons.
+
+ Parameters:
+ theGroupsOfFaces: list of groups of faces
+
+ Returns:
+ True if operation has been completed successfully, False otherwise
+ """
+
return self.editor.CreateFlatElementsOnFacesGroups( theGroupsOfFaces )
- ## identify all the elements around a geom shape, get the faces delimiting the hole
- #
def CreateHoleSkin(self, radius, theShape, groupName, theNodesCoords):
+ """
+ Identify all the elements around a geom shape, get the faces delimiting the hole
+ """
return self.editor.CreateHoleSkin( radius, theShape, groupName, theNodesCoords )
- ## 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 ):
+ """
+ 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 :class:`SMESH.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.
+
+ *segments* [i].vector returns the used vector which goes from the middle point to its projection.
+
+ Parameters:
+ segments: list of :class:`SMESH.PolySegment` defining positions of cutting planes.
+ groupName: optional name of a group where created mesh segments will be added.
+
+ """
editor = self.editor
if isPreview:
editor = self.mesh.GetMeshEditPreviewer()
pass # end of Mesh class
-## Private class used to compensate change of CORBA API of SMESH_Mesh for backward compatibility
-# with old dump scripts which call SMESH_Mesh directly and not via smeshBuilder.Mesh
-#
class meshProxy(SMESH._objref_SMESH_Mesh):
- def __init__(self, *args):
- SMESH._objref_SMESH_Mesh.__init__(self, *args)
+ """
+ Private class used to compensate change of CORBA API of SMESH_Mesh for backward compatibility
+ with old dump scripts which call SMESH_Mesh directly and not via smeshBuilder.Mesh
+ """
- def __init__(self):
- SMESH._objref_SMESH_Mesh.__init__(self)
++ def __init__(self,*args):
++ SMESH._objref_SMESH_Mesh.__init__(self,*args)
def __deepcopy__(self, memo=None):
- new = self.__class__()
+ new = self.__class__(self)
return new
def CreateDimGroup(self,*args): # 2 args added: nbCommonNodes, underlyingOnly
if len( args ) == 3:
omniORB.registerObjref(SMESH._objref_SMESH_Mesh._NP_RepositoryId, meshProxy)
-## Private class wrapping SMESH.SMESH_SubMesh in order to add Compute()
-#
class submeshProxy(SMESH._objref_SMESH_subMesh):
- def __init__(self, *args):
- SMESH._objref_SMESH_subMesh.__init__(self, *args)
++
+ """
+ Private class wrapping SMESH.SMESH_SubMesh in order to add Compute()
+ """
- def __init__(self):
- SMESH._objref_SMESH_subMesh.__init__(self)
++ def __init__(self,*args):
++ SMESH._objref_SMESH_subMesh.__init__(self,*args)
self.mesh = None
def __deepcopy__(self, memo=None):
- new = self.__class__()
+ new = self.__class__(self)
return new
- ## Compute the sub-mesh and return the status of the computation
- # @param refresh if @c True, Object browser is automatically updated (when running in GUI)
- # @return True or False
- #
- # This is a method of SMESH.SMESH_submesh that can be obtained via Mesh.GetSubMesh() or
- # @ref smesh_algorithm.Mesh_Algorithm.GetSubMesh() "Mesh_Algorithm.GetSubMesh()".
- # @ingroup l2_submeshes
def Compute(self,refresh=False):
+ """
+ Compute the sub-mesh and return the status of the computation
+
+ Parameters:
+ refresh: if *True*, Object Browser is automatically updated (when running in GUI)
+
+ Returns:
+ True or False
+
+ This is a method of SMESH.SMESH_submesh that can be obtained via Mesh.GetSubMesh() or
+ :meth:`smeshBuilder.Mesh.GetSubMesh`.
+ """
+
if not self.mesh:
self.mesh = Mesh( smeshBuilder(), None, self.GetMesh())
omniORB.registerObjref(SMESH._objref_SMESH_subMesh._NP_RepositoryId, submeshProxy)
-## Private class used to compensate change of CORBA API of SMESH_MeshEditor for backward
-# compatibility with old dump scripts which call SMESH_MeshEditor directly and not via
-# smeshBuilder.Mesh
-#
class meshEditor(SMESH._objref_SMESH_MeshEditor):
- def __init__(self, *args):
- SMESH._objref_SMESH_MeshEditor.__init__(self, *args)
+ """
+ Private class used to compensate change of CORBA API of SMESH_MeshEditor for backward
+ compatibility with old dump scripts which call SMESH_MeshEditor directly and not via
+ smeshBuilder.Mesh
+ """
- def __init__(self):
- SMESH._objref_SMESH_MeshEditor.__init__(self)
++ def __init__(self,*args):
++ SMESH._objref_SMESH_MeshEditor.__init__( self, *args)
self.mesh = None
def __getattr__(self, name ): # method called if an attribute not found
if not self.mesh: # look for name() method in Mesh class
self.algoTypeToClass = {}
self.method = method
- # Store a python class of algorithm
def add(self, algoClass):
- if type( algoClass ).__name__ == 'classobj' and \
+ """
+ Store a python class of algorithm
+ """
- hasattr(algoClass, "algoType"):
+ if inspect.isclass(algoClass) and \
+ hasattr( algoClass, "algoType"):
self.algoTypeToClass[ algoClass.algoType ] = algoClass
if not self.defaultAlgoType and \
hasattr( algoClass, "isDefault") and algoClass.isDefault:
self.defaultAlgoType = algoClass.algoType
-- #print "Add",algoClass.algoType, "dflt",self.defaultAlgoType
++ #print("Add",algoClass.algoType, "dflt",self.defaultAlgoType)
- # Create a copy of self and assign mesh to the copy
def copy(self, mesh):
+ """
+ Create a copy of self and assign mesh to the copy
+ """
+
other = algoCreator( self.method )
other.defaultAlgoType = self.defaultAlgoType
other.algoTypeToClass = self.algoTypeToClass
algoType = self.defaultAlgoType
if not algoType and self.algoTypeToClass:
algoType = sorted( self.algoTypeToClass.keys() )[0]
- if self.algoTypeToClass.has_key( algoType ):
- #print "Create algo",algoType
+ if algoType in self.algoTypeToClass:
- #print "Create algo",algoType
++ #print("Create algo",algoType)
+
return self.algoTypeToClass[ algoType ]( self.mesh, shape )
- raise RuntimeError, "No class found for algo type %s" % algoType
+ raise RuntimeError( "No class found for algo type %s" % algoType)
return None
-## Private class used to substitute and store variable parameters of hypotheses.
-#
class hypMethodWrapper:
+ """
+ Private class used to substitute and store variable parameters of hypotheses.
+ """
+
def __init__(self, hyp, method):
self.hyp = hyp
self.method = method
-- #print "REBIND:", method.__name__
++ #print("REBIND:", method.__name__)
return
- # call a method of hypothesis with calling SetVarParameter() before
def __call__(self,*args):
+ """
+ call a method of hypothesis with calling SetVarParameter() before
+ """
+
if not args:
return self.method( self.hyp, *args ) # hypothesis method with no args
-- #print "MethWrapper.__call__",self.method.__name__, args
++ #print("MethWrapper.__call__", self.method.__name__, args)
try:
parsed = ParseParameters(*args) # replace variables with their values
self.hyp.SetVarParameter( parsed[-2], self.method.__name__ )
if genObj and hasattr( genObj, "UnRegister" ):
genObj.UnRegister()
-
-## Bind methods creating mesher plug-ins to the Mesh class
-#
for pluginName in os.environ[ "SMESH_MeshersList" ].split( ":" ):
- #
- #print "pluginName: ", pluginName
+ """
+ Bind methods creating mesher plug-ins to the Mesh class
+ """
+
- # print "pluginName: ", pluginName
++ # print("pluginName: ", pluginName)
pluginBuilderName = pluginName + "Builder"
try:
exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName))
continue
exec( "from salome.%s import %s" % (pluginName, pluginBuilderName))
plugin = eval( pluginBuilderName )
- # print " plugin:" , str(plugin)
- #print " plugin:" , str(plugin)
++ # print(" plugin:" , str(plugin))
# add methods creating algorithms to Mesh
for k in dir( plugin ):
if k[0] == '_': continue
algo = getattr( plugin, k )
- # print " algo:", str(algo)
- if type( algo ).__name__ == 'classobj' and hasattr( algo, "meshMethod" ):
- # print " meshMethod:" , str(algo.meshMethod)
- #print " algo:", str(algo)
++ #print(" algo:", str(algo))
+ if inspect.isclass(algo) and hasattr(algo, "meshMethod"):
- #print " meshMethod:" , str(algo.meshMethod)
++ #print(" meshMethod:" , str(algo.meshMethod))
if not hasattr( Mesh, algo.meshMethod ):
setattr( Mesh, algo.meshMethod, algoCreator( algo.meshMethod ))
pass
from salome.geom import geomBuilder
import SMESH, StdMeshers
-## The base class to define meshing algorithms
-#
-# @note This class should not be used directly, it is supposed to be sub-classed
-# for implementing Python API for specific meshing algorithms
-#
-# For each meshing algorithm, a python class inheriting from class %Mesh_Algorithm
-# should be defined. This descendant class should have two attributes defining the way
-# it is created by class Mesh (see e.g. class @ref StdMeshersBuilder.StdMeshersBuilder_Segment "StdMeshersBuilder_Segment"
-# in StdMeshersBuilder package):
-# - @c meshMethod attribute defines name of method of class smesh.Mesh by calling which the
-# python class of algorithm is created; this method is dynamically added to the smesh.Mesh class
-# in runtime. For example, if in @c class MyPlugin_Algorithm this attribute is defined as
-# @code
-# meshMethod = "MyAlgorithm"
-# @endcode
-# then an instance of @c MyPlugin_Algorithm can be created by the direct invocation of the function
-# of smesh.Mesh class:
-# @code
-# my_algo = mesh.MyAlgorithm()
-# @endcode
-# - @c algoType defines type of algorithm and is used mostly to discriminate
-# algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute
-# is specified in @c MyPlugin_Algorithm class as
-# @code
-# algoType = "MyPLUGIN"
-# @endcode
-# then it's creation code can be:
-# @code
-# my_algo = mesh.MyAlgorithm(algo="MyPLUGIN")
-# @endcode
-# @ingroup l2_algorithms
class Mesh_Algorithm:
- This class should not be used directly, it is supposed to be sub-classed
+ """
+ The base class to define meshing algorithms
+
+ Note:
- - :code:`meshMethod` attribute defines name of method of class smesh.Mesh by calling which the
- python class of algorithm is created; this method is dynamically added to the smesh.Mesh class
- in runtime. For example, if in :code:`class MyPlugin_Algorithm` this attribute is defined as
- ::
++ This class should not be used directly, it is supposed to be sub-classed
+ for implementing Python API for specific meshing algorithms
+
+ For each meshing algorithm, a python class inheriting from class %Mesh_Algorithm
+ should be defined. This descendant class should have two attributes defining the way
+ it is created by class Mesh (see e.g. class :class:`~StdMeshersBuilder.StdMeshersBuilder_Segment`
+ in StdMeshersBuilder package):
+
- meshMethod = "MyAlgorithm"
++ - :code:`meshMethod` attribute defines name of method of class smesh.Mesh by calling which the
++ python class of algorithm is created; this method is dynamically added to the smesh.Mesh class
++ in runtime. For example, if in :code:`class MyPlugin_Algorithm` this attribute is defined as
++ ::
+
- then an instance of :code:`MyPlugin_Algorithm` can be created by the direct invocation of the function
- of smesh.Mesh class:
- ::
++ meshMethod = "MyAlgorithm"
+
- my_algo = mesh.MyAlgorithm()
++ then an instance of :code:`MyPlugin_Algorithm` can be created by the direct invocation of the function
++ of smesh.Mesh class:
++ ::
+
- - :code:`algoType` defines type of algorithm and is used mostly to discriminate
- algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute
- is specified in :code:`MyPlugin_Algorithm` class as
- ::
++ my_algo = mesh.MyAlgorithm()
+
- algoType = "MyPLUGIN"
++ - :code:`algoType` defines type of algorithm and is used mostly to discriminate
++ algorithms that are created by the same method of class smesh.Mesh. For example, if this attribute
++ is specified in :code:`MyPlugin_Algorithm` class as
++ ::
+
- then it's creation code can be:
- ::
++ algoType = "MyPLUGIN"
+
- my_algo = mesh.MyAlgorithm(algo="MyPLUGIN")
++ then it's creation code can be:
++ ::
+
++ my_algo = mesh.MyAlgorithm(algo="MyPLUGIN")
+ """
+
- ## Private constructor
def __init__(self):
- """
- Private constuctor
- """
++ """
++ Private constuctor
++ """
self.mesh = None
self.geom = None
self.subm = None
self.algo = None
pass
- ## Finds a hypothesis in the study by its type name and parameters.
- # Finds only the hypotheses created in smeshpyD engine.
- # @return SMESH.SMESH_Hypothesis
def FindHypothesis (self, hypname, args, CompareMethod, smeshpyD):
- """
- Finds a hypothesis in the study by its type name and parameters.
- Finds only the hypotheses created in smeshpyD engine.
- Returns:
- SMESH.SMESH_Hypothesis
- """
- study = smeshpyD.GetCurrentStudy()
++ """
++ Finds a hypothesis in the study by its type name and parameters.
++ Finds only the hypotheses created in smeshpyD engine.
++ Returns:
++ SMESH.SMESH_Hypothesis
++ """
+ study = salome.myStudy
if not study: return None
#to do: find component by smeshpyD object, not by its data type
scomp = study.FindComponent(smeshpyD.ComponentDataType())
pass
return None
- ## Finds the algorithm in the study by its type name.
- # Finds only the algorithms, which have been created in smeshpyD engine.
- # @return SMESH.SMESH_Algo
def FindAlgorithm (self, algoname, smeshpyD):
- """
- Finds the algorithm in the study by its type name.
- Finds only the algorithms, which have been created in smeshpyD engine.
-
- Returns:
- SMESH.SMESH_Algo
- """
- study = smeshpyD.GetCurrentStudy()
++ """
++ Finds the algorithm in the study by its type name.
++ Finds only the algorithms, which have been created in smeshpyD engine.
++
++ Returns:
++ SMESH.SMESH_Algo
++ """
+ study = salome.myStudy
if not study: return None
#to do: find component by smeshpyD object, not by its data type
scomp = study.FindComponent(smeshpyD.ComponentDataType())
pass
return None
- ## If the algorithm is global, returns 0; \n
- # else returns the submesh associated to this algorithm.
def GetSubMesh(self):
- """
- If the algorithm is global, returns 0;
- else returns the submesh associated to this algorithm.
- """
++ """
++ If the algorithm is global, returns 0;
++ else returns the submesh associated to this algorithm.
++ """
return self.subm
- ## Returns the wrapped mesher.
def GetAlgorithm(self):
- """
- Returns the wrapped mesher.
- """
++ """
++ Returns the wrapped mesher.
++ """
return self.algo
- ## Gets the list of hypothesis that can be used with this algorithm
def GetCompatibleHypothesis(self):
- """
- Gets the list of hypothesis that can be used with this algorithm
- """
++ """
++ Gets the list of hypothesis that can be used with this algorithm
++ """
mylist = []
if self.algo:
mylist = self.algo.GetCompatibleHypothesis()
return mylist
- ## Gets the name of the algorithm
def GetName(self):
- """
- Gets the name of the algorithm
- """
++ """
++ Gets the name of the algorithm
++ """
from salome.smesh.smeshBuilder import GetName
return GetName(self.algo)
- ## Sets the name to the algorithm
def SetName(self, name):
- """
- Sets the name to the algorithm
- """
++ """
++ Sets the name to the algorithm
++ """
self.mesh.smeshpyD.SetName(self.algo, name)
- ## Gets the id of the algorithm
def GetId(self):
- """
- Gets the id of the algorithm
- """
++ """
++ Gets the id of the algorithm
++ """
return self.algo.GetId()
- ## Private method.
def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
- """
- Private method.
- """
++ """
++ Private method.
++ """
if geom is None and mesh.mesh.HasShapeToMesh():
- raise RuntimeError, "Attempt to create " + hypo + " algorithm on None shape"
+ raise RuntimeError("Attempt to create " + hypo + " algorithm on None shape")
algo = self.FindAlgorithm(hypo, mesh.smeshpyD)
if algo is None:
algo = mesh.smeshpyD.CreateHypothesis(hypo, so)
self.Assign(algo, mesh, geom)
return self.algo
- ## Private method
def Assign(self, algo, mesh, geom):
- """
- Private method
- """
++ """
++ Private method
++ """
from salome.smesh.smeshBuilder import AssureGeomPublished, TreatHypoStatus, GetName
if geom is None and mesh.mesh.HasShapeToMesh():
- raise RuntimeError, "Attempt to create " + algo + " algorithm on None shape"
+ raise RuntimeError("Attempt to create " + algo + " algorithm on None shape")
self.mesh = mesh
if not geom or geom.IsSame( mesh.geom ):
self.geom = mesh.geom
def CompareEqualHyp (self, hyp, args):
return True
- ## Private method
def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so",
UseExisting=0, CompareMethod="", toAdd=True):
- """
- Private method
- """
++ """
++ Private method
++ """
from salome.smesh.smeshBuilder import TreatHypoStatus, GetName
hypo = None
if UseExisting:
TreatHypoStatus( status, GetName(hypo), geomName, 0, self.mesh )
return hypo
- ## Returns entry of the shape to mesh in the study
def MainShapeEntry(self):
- """
- Returns entry of the shape to mesh in the study
- """
++ """
++ Returns entry of the shape to mesh in the study
++ """
if not self.mesh or not self.mesh.GetMesh(): return ""
if not self.mesh.GetMesh().HasShapeToMesh(): return ""
shape = self.mesh.GetShape()
return shape.GetStudyEntry()
- ## Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build
- # near mesh boundary. This hypothesis can be used by several 3D algorithms:
- # NETGEN 3D, MG-Tetra, Hexahedron(i,j,k)
- # @param thickness total thickness of layers of prisms
- # @param numberOfLayers number of layers of prisms
- # @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh
- # @param faces list of geometrical faces (or their ids).
- # Viscous layers are either generated on these faces or not, depending on
- # the value of \a isFacesToIgnore parameter.
- # @param isFacesToIgnore if \c True, the Viscous layers are not generated on the
- # faces specified by the previous parameter (\a faces).
- # @param extrMethod extrusion method defines how position of new nodes are found during
- # prism construction and how creation of distorted and intersecting prisms is
- # prevented. Possible values are:
- # - StdMeshers.SURF_OFFSET_SMOOTH (default) method extrudes nodes along normal
- # to underlying geometrical surface. Smoothing of internal surface of
- # element layers can be used to avoid creation of invalid prisms.
- # - StdMeshers.FACE_OFFSET method extrudes nodes along average normal of
- # surrounding mesh faces till intersection with a neighbor mesh face
- # translated along its own normal by the layers thickness. Thickness
- # of layers can be limited to avoid creation of invalid prisms.
- # - StdMeshers.NODE_OFFSET method extrudes nodes along average normal of
- # surrounding mesh faces by the layers thickness. Thickness of
- # layers can be limited to avoid creation of invalid prisms.
- # @ingroup l3_hypos_additi
def ViscousLayers(self, thickness, numberOfLayers, stretchFactor,
faces=[], isFacesToIgnore=True, extrMethod=StdMeshers.SURF_OFFSET_SMOOTH ):
- """
- Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build
- near mesh boundary. This hypothesis can be used by several 3D algorithms:
- NETGEN 3D, MG-Tetra, Hexahedron(i,j,k)
-
- Parameters:
- thickness: total thickness of layers of prisms
- numberOfLayers: number of layers of prisms
- stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh
- faces: list of geometrical faces (or their ids).
- Viscous layers are either generated on these faces or not, depending on
- the value of **isFacesToIgnore** parameter.
- isFacesToIgnore: if *True*, the Viscous layers are not generated on the
- faces specified by the previous parameter (**faces**).
- extrMethod: extrusion method defines how position of new nodes are found during
- prism construction and how creation of distorted and intersecting prisms is
- prevented. Possible values are:
-
- - StdMeshers.SURF_OFFSET_SMOOTH (default) method extrudes nodes along normal
- to underlying geometrical surface. Smoothing of internal surface of
- element layers can be used to avoid creation of invalid prisms.
- - StdMeshers.FACE_OFFSET method extrudes nodes along average normal of
- surrounding mesh faces till intersection with a neighbor mesh face
- translated along its own normal by the layers thickness. Thickness
- of layers can be limited to avoid creation of invalid prisms.
- - StdMeshers.NODE_OFFSET method extrudes nodes along average normal of
- surrounding mesh faces by the layers thickness. Thickness of
- layers can be limited to avoid creation of invalid prisms.
- """
++ """
++ Defines "ViscousLayers" hypothesis to give parameters of layers of prisms to build
++ near mesh boundary. This hypothesis can be used by several 3D algorithms:
++ NETGEN 3D, MG-Tetra, Hexahedron(i,j,k)
++
++ Parameters:
++ thickness: total thickness of layers of prisms
++ numberOfLayers: number of layers of prisms
++ stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh
++ faces: list of geometrical faces (or their ids).
++ Viscous layers are either generated on these faces or not, depending on
++ the value of **isFacesToIgnore** parameter.
++ isFacesToIgnore: if *True*, the Viscous layers are not generated on the
++ faces specified by the previous parameter (**faces**).
++ extrMethod: extrusion method defines how position of new nodes are found during
++ prism construction and how creation of distorted and intersecting prisms is
++ prevented. Possible values are:
++
++ - StdMeshers.SURF_OFFSET_SMOOTH (default) method extrudes nodes along normal
++ to underlying geometrical surface. Smoothing of internal surface of
++ element layers can be used to avoid creation of invalid prisms.
++ - StdMeshers.FACE_OFFSET method extrudes nodes along average normal of
++ surrounding mesh faces till intersection with a neighbor mesh face
++ translated along its own normal by the layers thickness. Thickness
++ of layers can be limited to avoid creation of invalid prisms.
++ - StdMeshers.NODE_OFFSET method extrudes nodes along average normal of
++ surrounding mesh faces by the layers thickness. Thickness of
++ layers can be limited to avoid creation of invalid prisms.
++ """
+
if not isinstance(self.algo, SMESH._objref_SMESH_3D_Algo):
- raise TypeError, "ViscousLayers are supported by 3D algorithms only"
+ raise TypeError("ViscousLayers are supported by 3D algorithms only")
if not "ViscousLayers" in self.GetCompatibleHypothesis():
- raise TypeError, "ViscousLayers are not supported by %s"%self.algo.GetName()
+ raise TypeError("ViscousLayers are not supported by %s"%self.algo.GetName())
if faces and isinstance( faces, geomBuilder.GEOM._objref_GEOM_Object ):
faces = [ faces ]
if faces and isinstance( faces[0], geomBuilder.GEOM._objref_GEOM_Object ):
self.mesh.AddHypothesis( hyp, self.geom )
return hyp
- ## Defines "ViscousLayers2D" hypothesis to give parameters of layers of quadrilateral
- # elements to build near mesh boundary. This hypothesis can be used by several 2D algorithms:
- # NETGEN 2D, NETGEN 1D-2D, Quadrangle (mapping), MEFISTO, MG-CADSurf
- # @param thickness total thickness of layers of quadrilaterals
- # @param numberOfLayers number of layers
- # @param stretchFactor factor (>1.0) of growth of layer thickness towards inside of mesh
- # @param edges list of geometrical edges (or their ids).
- # Viscous layers are either generated on these edges or not, depending on
- # the value of \a isEdgesToIgnore parameter.
- # @param isEdgesToIgnore if \c True, the Viscous layers are not generated on the
- # edges specified by the previous parameter (\a edges).
- # @ingroup l3_hypos_additi
def ViscousLayers2D(self, thickness, numberOfLayers, stretchFactor,
edges=[], isEdgesToIgnore=True ):
- """
- Defines "ViscousLayers2D" hypothesis to give parameters of layers of quadrilateral
- elements to build near mesh boundary. This hypothesis can be used by several 2D algorithms:
- NETGEN 2D, NETGEN 1D-2D, Quadrangle (mapping), MEFISTO, MG-CADSurf
-
- Parameters:
- thickness: total thickness of layers of quadrilaterals
- numberOfLayers: number of layers
- stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh
- edges: list of geometrical edges (or their ids).
- Viscous layers are either generated on these edges or not, depending on
- the value of **isEdgesToIgnore** parameter.
- isEdgesToIgnore: if *True*, the Viscous layers are not generated on the
- edges specified by the previous parameter (**edges**).
- """
++ """
++ Defines "ViscousLayers2D" hypothesis to give parameters of layers of quadrilateral
++ elements to build near mesh boundary. This hypothesis can be used by several 2D algorithms:
++ NETGEN 2D, NETGEN 1D-2D, Quadrangle (mapping), MEFISTO, MG-CADSurf
++
++ Parameters:
++ thickness: total thickness of layers of quadrilaterals
++ numberOfLayers: number of layers
++ stretchFactor: factor (>1.0) of growth of layer thickness towards inside of mesh
++ edges: list of geometrical edges (or their ids).
++ Viscous layers are either generated on these edges or not, depending on
++ the value of **isEdgesToIgnore** parameter.
++ isEdgesToIgnore: if *True*, the Viscous layers are not generated on the
++ edges specified by the previous parameter (**edges**).
++ """
+
if not isinstance(self.algo, SMESH._objref_SMESH_2D_Algo):
- raise TypeError, "ViscousLayers2D are supported by 2D algorithms only"
+ raise TypeError("ViscousLayers2D are supported by 2D algorithms only")
if not "ViscousLayers2D" in self.GetCompatibleHypothesis():
- raise TypeError, "ViscousLayers2D are not supported by %s"%self.algo.GetName()
+ raise TypeError("ViscousLayers2D are not supported by %s"%self.algo.GetName())
if edges and not isinstance( edges, list ) and not isinstance( edges, tuple ):
edges = [edges]
if edges and isinstance( edges[0], geomBuilder.GEOM._objref_GEOM_Object ):
self.mesh.AddHypothesis( hyp, self.geom )
return hyp
- ## Transform a list of either edges or tuples (edge, 1st_vertex_of_edge)
- # into a list acceptable to SetReversedEdges() of some 1D hypotheses
- # @ingroup l3_hypos_1dhyps
def ReversedEdgeIndices(self, reverseList):
- """
- Transform a list of either edges or tuples (edge, 1st_vertex_of_edge)
- into a list acceptable to SetReversedEdges() of some 1D hypotheses
- """
++ """
++ Transform a list of either edges or tuples (edge, 1st_vertex_of_edge)
++ into a list acceptable to SetReversedEdges() of some 1D hypotheses
++ """
+
from salome.smesh.smeshBuilder import FirstVertexOnCurve
resList = []
geompy = self.mesh.geompyD
#include <vtkActorCollection.h>
#include <vtkRenderer.h>
-static CORBA::ORB_var anORB;
-
namespace
{
- //---------------------------------------------------------------
- inline
- CORBA::Object_var
- StringToObject(const std::string& theIOR)
+ ///////////////////////////////////////////////////////////////
+ /// \internal
+ /// \brief Print deprecation warning to termninal.
+ /// \param function Interface function's name.
+ /// \param replacement Replacement (new) function's name
+ /// (if there's any).
+ ///////////////////////////////////////////////////////////////
+ void deprecated(const char* function, const char* replacement = 0)
{
- return anORB->string_to_object(theIOR.c_str());
+ if ( replacement )
+ printf("libSMESH_Swig: method '%s' is deprecated; use '%s' instead.\n", function, replacement);
+ else
+ printf("libSMESH_Swig: method '%s' is deprecated.\n", function);
}
+ ///////////////////////////////////////////////////////////////
+ /// \internal
+ /// \brief Get CORBA object by its IOR.
+ /// \param ior Object's IOR.
+ /// \return CORBA object (nil object if it isn't found).
+ ///////////////////////////////////////////////////////////////
+ CORBA::Object_var string2object(const std::string& ior)
+ {
+ return SalomeApp_Application::orb()->string_to_object(ior.c_str());
+ }
- //---------------------------------------------------------------
- inline
- SALOMEDS::SObject_var
- GetDomainRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
- const SALOMEDS::StudyBuilder_var& theStudyBuilder,
- CORBA::Long theDomainRootTag,
- const QString& theName,
- const QString& thePixmap)
+ ///////////////////////////////////////////////////////////////
+ /// \internal
+ /// \brief Get study object by its study UID or IOR.
- /// \param studyId Study UID.
+ /// \param uid Object's study UID or IOR.
+ /// \return Pointer to study object (null object if it isn't
+ /// found).
+ ///////////////////////////////////////////////////////////////
- _PTR(SObject) uid2object(int studyId, const std::string& uid)
++ _PTR(SObject) uid2object(const std::string& uid)
{
- SALOMEDS::SObject_var aDomainRoot;
- if (!theSComponentMesh->FindSubObject(theDomainRootTag,aDomainRoot)) {
- aDomainRoot = theStudyBuilder->NewObjectToTag(theSComponentMesh,theDomainRootTag);
- SALOMEDS::GenericAttribute_var anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributeName");
- SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
- aName->SetValue(theName.toLatin1().data());
- aName->UnRegister();
- anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributePixMap");
- SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
- aPixmap->SetPixMap(thePixmap.toLatin1().data());
- aPixmap->UnRegister();
- anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributeSelectable");
- SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
- aSelAttr->SetSelectable(false);
- aSelAttr->UnRegister();
+ _PTR(SObject) sobject;
- if ( studyId > 0 )
+ {
- _PTR(Study) study = SalomeApp_Application::studyMgr()->GetStudyByID( studyId );
++ _PTR(Study) study = SMESH::getStudy();
+ if ( study )
+ {
+ sobject = study->FindObjectID( uid );
+ if ( !sobject )
+ sobject = study->FindObjectIOR( uid );
+ }
}
-
- return aDomainRoot;
+ return sobject;
}
-
- //---------------------------------------------------------------
- inline
- SALOMEDS::SObject_var
- GetHypothesisRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
- const SALOMEDS::StudyBuilder_var& theStudyBuilder)
+ ///////////////////////////////////////////////////////////////
+ /// \internal
+ /// \brief Get view window by its identifier.
+ /// \param uid Window's identifier.
+ /// \return Pointer to the view window (0 if it isn't found).
+ ///////////////////////////////////////////////////////////////
+ SALOME_View* uid2wnd(int uid, bool create = false)
{
- return GetDomainRoot(theSComponentMesh,
- theStudyBuilder,
- SMESH::Tag_HypothesisRoot,
- QObject::tr("SMESH_MEN_HYPOTHESIS"),
- "ICON_SMESH_TREE_HYPO");
- }
+ SALOME_View* window = 0;
+ SUIT_Session* session = SUIT_Session::session();
+ SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( session->activeApplication() );
+ if ( app )
+ {
+ if ( uid )
+ {
+ ViewManagerList vms = app->viewManagers();
+ for ( int i = 0; i < vms.count() && !window; i++ )
+ {
+ SUIT_ViewManager* vm = vms[i];
+ QVector<SUIT_ViewWindow*> vws = vm->getViews();
+ for ( int j = 0; j < vws.count() && !window; j++)
+ {
+ SUIT_ViewWindow* vw = vws[0];
+ if ( uid == vw->getId() )
+ window = dynamic_cast<SALOME_View*>( vm->getViewModel() );
+ }
+ }
+ }
+ else
+ {
+ SUIT_ViewManager* vm = app->getViewManager( SVTK_Viewer::Type(), create );
+ if ( vm )
+ {
+ window = dynamic_cast<SALOME_View*>( vm->getViewModel() );
+ }
+ }
+ }
+ return window;
+ }
- //---------------------------------------------------------------
- inline
- SALOMEDS::SObject_var
- GetAlgorithmsRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
- const SALOMEDS::StudyBuilder_var& theStudyBuilder)
+ ///////////////////////////////////////////////////////////////
+ /// \internal
+ /// \brief Get all view windows.
+ /// \return List of view windows.
+ ///////////////////////////////////////////////////////////////
+ QList<SALOME_View*> windows()
{
- return GetDomainRoot(theSComponentMesh,
- theStudyBuilder,
- SMESH::Tag_AlgorithmsRoot,
- QObject::tr("SMESH_MEN_ALGORITHMS"),
- "ICON_SMESH_TREE_ALGO");
+ QList<SALOME_View*> views;
+ SUIT_Session* session = SUIT_Session::session();
+ SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( session->activeApplication() );
+ if ( app )
+ {
+ ViewManagerList vms = app->viewManagers();
+ foreach( SUIT_ViewManager* vm, vms )
+ {
+ if ( vm && vm->getType() == SVTK_Viewer::Type() )
+ {
+ SALOME_View* view = dynamic_cast<SALOME_View*>( vm->getViewModel() );
+ if ( view )
+ views << view;
+ }
+ }
+ }
+ return views;
}
-
- //---------------------------------------------------------------
- inline
- SALOMEDS::SObject_var
- AddToDomain(const std::string& theIOR,
- const SALOMEDS::SComponent_var& theSComponentMesh,
- const SALOMEDS::StudyBuilder_var& theStudyBuilder,
- CORBA::Long theDomainRootTag,
- const QString& theDomainName,
- const QString& theDomainPixmap)
+ ///////////////////////////////////////////////////////////////
+ /// \internal
+ /// \brief Get mesh actor from view.
+ /// \param view Pointer to the view window.
+ /// \param uid Mesh object's study UID.
+ /// \return Mesh actor (0 if it isn't found).
+ ///////////////////////////////////////////////////////////////
+ SMESH_Actor* actorFromView(SALOME_View* view, const char* uid)
{
- SALOMEDS::SObject_var aDomain = GetDomainRoot(theSComponentMesh,
- theStudyBuilder,
- SMESH::Tag_AlgorithmsRoot,
- theDomainName,
- theDomainPixmap);
- // Add New Hypothesis
- SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(aDomain);
- aDomain->UnRegister();
- SALOMEDS::GenericAttribute_var anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
- SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
- CORBA::Object_var anObject = StringToObject(theIOR);
- SMESH::SMESH_Hypothesis_var aDomainItem = SMESH::SMESH_Hypothesis::_narrow(anObject.in());
- CORBA::String_var aType = aDomainItem->GetName();
- QString aPixmapName = theDomainPixmap + "_" + aType.in();
- aPixmap->SetPixMap(aPixmapName.toLatin1().data());
- aPixmap->UnRegister();
- anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
- SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
- anIOR->SetValue(theIOR.c_str());
- anIOR->UnRegister();
-
- return aSObject;
+ SMESH_Actor* actor = 0;
+ SVTK_Viewer* model = dynamic_cast<SVTK_Viewer*>( view );
+ if ( model )
+ {
+ SUIT_ViewWindow* vw = model->getViewManager()->getActiveView();
+ if ( vw )
+ {
+ actor = SMESH::FindActorByEntry( vw, uid );
+ }
+ }
+ return actor;
}
-
- //---------------------------------------------------------------
- SALOMEDS::SObject_var
- AddHypothesis(const std::string& theIOR,
- const SALOMEDS::SComponent_var& theSComponentMesh,
- const SALOMEDS::StudyBuilder_var& theStudyBuilder)
+ ///////////////////////////////////////////////////////////////
+ /// \internal
+ /// \brief Get mesh object's visual properties.
+ /// \param view Pointer to the view window.
+ /// \param uid Mesh object's study UID.
+ /// \return Properties data structure.
+ ///////////////////////////////////////////////////////////////
+ Properties properties(SALOME_View* view, const char* uid)
{
- return AddToDomain(theIOR,
- theSComponentMesh,
- theStudyBuilder,
- SMESH::Tag_HypothesisRoot,
- QObject::tr("SMESH_MEN_HYPOTHESIS"),
- "ICON_SMESH_TREE_HYPO");
+ Properties props;
+ SMESH_Actor* actor = actorFromView( view, uid );
+ if ( actor )
+ {
+ actor->GetNodeColor( props.nodeColor.r,
+ props.nodeColor.g,
+ props.nodeColor.b );
+ props.markerType = actor->GetMarkerType();
+ props.markerScale = actor->GetMarkerScale();
+
+ actor->GetEdgeColor( props.edgeColor.r,
+ props.edgeColor.g,
+ props.edgeColor.b );
+ props.edgeWidth = qMax( (int)actor->GetLineWidth(), 1 );
+
+ actor->GetSufaceColor( props.surfaceColor.r,
+ props.surfaceColor.g,
+ props.surfaceColor.b,
+ props.surfaceColor.delta );
+
+ actor->GetVolumeColor( props.volumeColor.r,
+ props.volumeColor.g,
+ props.volumeColor.b,
+ props.volumeColor.delta );
+
+ actor->Get0DColor( props.elem0dColor.r,
+ props.elem0dColor.g,
+ props.elem0dColor.b );
+ props.elem0dSize = qMax( (int)actor->Get0DSize(), 1 );
+
+ actor->GetBallColor( props.ballColor.r,
+ props.ballColor.g,
+ props.ballColor.b );
+ props.ballScale = qMax( actor->GetBallScale(), 1e-2 );
+
+ actor->GetOutlineColor( props.outlineColor.r,
+ props.outlineColor.g,
+ props.outlineColor.b );
+ props.outlineWidth = qMax( (int)actor->GetOutlineWidth(), 1 );
+
+ actor->GetFacesOrientationColor( props.orientationColor.r,
+ props.orientationColor.g,
+ props.orientationColor.b );
+ props.orientationScale = actor->GetFacesOrientationScale();
+ props.orientation3d = actor->GetFacesOrientation3DVectors();
+
+ props.shrinkFactor = actor->GetShrinkFactor();
+
+ props.opacity = actor->GetOpacity();
+ }
+ return props;
}
-
- //---------------------------------------------------------------
- SALOMEDS::SObject_var
- AddAlgorithms(const std::string& theIOR,
- const SALOMEDS::SComponent_var& theSComponentMesh,
- const SALOMEDS::StudyBuilder_var& theStudyBuilder)
+ ///////////////////////////////////////////////////////////////
+ /// \internal
+ /// \brief Set mesh object's visual properties.
+ /// \param view Pointer to the view window.
+ /// \param uid Mesh object's study UID.
+ /// \param props Properties data structure.
+ ///////////////////////////////////////////////////////////////
+ void setProperties(SALOME_View* view, const char* uid, const Properties& props)
{
- return AddToDomain(theIOR,
- theSComponentMesh,
- theStudyBuilder,
- SMESH::Tag_AlgorithmsRoot,
- QObject::tr("SMESH_MEN_ALGORITHMS"),
- "ICON_SMESH_TREE_ALGO");
+ SMESH_Actor* actor = actorFromView( view, uid );
+ if ( actor )
+ {
+ actor->SetNodeColor( props.nodeColor.r,
+ props.nodeColor.g,
+ props.nodeColor.b );
+ if ( props.markerType != VTK::MT_USER )
+ actor->SetMarkerStd( props.markerType, props.markerScale );
+
+ actor->SetEdgeColor( props.edgeColor.r,
+ props.edgeColor.g,
+ props.edgeColor.b );
+ actor->SetLineWidth( qMax( (double)props.edgeWidth, 1. ) );
+
+ actor->SetSufaceColor( props.surfaceColor.r,
+ props.surfaceColor.g,
+ props.surfaceColor.b,
+ props.surfaceColor.delta );
+
+ actor->SetVolumeColor( props.volumeColor.r,
+ props.volumeColor.g,
+ props.volumeColor.b,
+ props.volumeColor.delta );
+
+ actor->Set0DColor( props.elem0dColor.r,
+ props.elem0dColor.g,
+ props.elem0dColor.b );
+ actor->Set0DSize( qMax( (double)props.elem0dSize, 1. ) );
+
+ actor->SetBallColor( props.ballColor.r,
+ props.ballColor.g,
+ props.ballColor.b );
+ actor->SetBallScale( qMax( props.ballScale, 1e-2 ) );
+
+ actor->SetOutlineColor( props.outlineColor.r,
+ props.outlineColor.g,
+ props.outlineColor.b );
+ actor->SetOutlineWidth( qMax( (double)props.outlineWidth, 1. ) );
+
+ actor->SetFacesOrientationColor( props.orientationColor.r,
+ props.orientationColor.g,
+ props.orientationColor.b );
+ actor->SetFacesOrientationScale( props.orientationScale );
+ actor->SetFacesOrientation3DVectors( props.orientation3d );
+
+ actor->SetShrinkFactor( props.shrinkFactor );
+
+ actor->SetOpacity( props.opacity );
+
+ view->Repaint();
+ }
}
- : myCachedStudyId( 0 )
+} // end of anonymous namespace
+
+/////////////////////////////////////////////////////////////////
+/// \enum EntityMode
+/// \brief Enumeration for mesh entities.
+/// \var EntityMode Entity0d
+/// \brief 0D elements.
+/// \var EntityMode EntityEdges
+/// \brief Edges.
+/// \var EntityMode EntityFaces
+/// \brief Faces.
+/// \var EntityMode EntityVolumes
+/// \brief Volumes.
+/// \var EntityMode EntityBalls
+/// \brief Ball elements.
+/// \var EntityMode EntityAll
+/// \brief All elements.
+/////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////
+/// \enum SelectionMode
+/// \brief Selection mode.
+/// \var SelectionMode Undefined
+/// \brief Undefined selection mode.
+/// \var SelectionMode Node
+/// \brief Selection of mesh nodes.
+/// \var SelectionMode Cell
+/// \brief Selection of any mesh cells.
+/// \var SelectionMode EdgeOfCell
+/// \brief Selection of pseudo-edges specified by couple of nodes.
+/// \var SelectionMode Edge
+/// \brief Selection of edges.
+/// \var SelectionMode Face
+/// \brief Selection of faces.
+/// \var SelectionMode Volume
+/// \brief Selection of volumes
+/// \var SelectionMode Actor
+/// \brief Selection of whole actors (meshes, sub-meshes, groups).
+/// \var SelectionMode Elem0D
+/// \brief Selection of 0D elements.
+/// \var SelectionMode Ball
+/// \brief Selection of ball ellements.
+/////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////
+/// \enum DisplayMode
+/// \brief Display mode.
+/// \var DisplayMode UndefinedMode
+/// \brief Undefined display mode.
+/// \var DisplayMode PointMode
+/// \brief Point representation.
+/// \var DisplayMode EdgeMode
+/// \brief Wireframe representation.
+/// \var DisplayMode SurfaceMode
+/// \brief Surface representation.
+/////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////
+/// \struct ColorData
+/// \brief Color data, in RGBf format.
+/// \var ColorData::r
+/// \brief Red color's component (0.0:1.0).
+/// \var ColorData::g
+/// \brief Green color's component (0.0:1.0).
+/// \var ColorData::b
+/// \brief Blue color's component (0.0:1.0).
+/////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////
+/// \brief Constructor.
+/////////////////////////////////////////////////////////////////
+ColorData::ColorData()
+ : r( 0 ), g( 0 ), b( 0 )
+{}
+
+/////////////////////////////////////////////////////////////////
+/// \struct BicolorData
+/// \brief Bi-color data, in RGBf format.
+/// \var BicolorData::r
+/// \brief Red color's component (0.0:1.0).
+/// \var BicolorData::g
+/// \brief Green color's component (0.0:1.0).
+/// \var BicolorData::b
+/// \brief Blue color's component (0.0:1.0).
+/// \var BicolorData::delta
+/// \brief Shift for backface color (-100:100).
+/////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////
+/// \brief Constructor.
+/////////////////////////////////////////////////////////////////
+BicolorData::BicolorData()
+ : r( 0 ), g( 0 ), b( 0 ), delta( 0 )
+{}
+
+/////////////////////////////////////////////////////////////////
+/// \struct Properties
+/// \brief Mesh object presentation's properties.
+/// \var Properties::nodeColor
+/// \brief Node color.
+/// \var Properties::markerType
+/// \brief Node standard marker type.
+/// \var Properties::markerScale
+/// \brief Node scale factor.
+/// \var Properties::edgeColor
+/// \brief Edges color.
+/// \var Properties::edgeWidth
+/// \brief Edges width.
+/// \var Properties::surfaceColor
+/// \brief Faces color.
+/// \var Properties::volumeColor
+/// \brief Volumes color.
+/// \var Properties::elem0dColor
+/// \brief 0D elements color.
+/// \var Properties::elem0dSize
+/// \brief 0D elements size.
+/// \var Properties::ballColor
+/// \brief Ball elements color.
+/// \var Properties::ballScale
+/// \brief Ball elements scale factor.
+/// \var Properties::outlineColor
+/// \brief Outlines color.
+/// \var Properties::outlineWidth
+/// \brief Outlines width.
+/// \var Properties::orientationColor
+/// \brief Face orientation vectors color.
+/// \var Properties::orientationScale
+/// \brief Face orientation vectors scale factor.
+/// \var Properties::orientation3d
+/// \brief Face orientation vectors 3d flag.
+/// \var Properties::shrinkFactor
+/// \brief Shrink coefficient.
+/// \var Properties::opacity
+/// \brief Opacity.
+/////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////
+/// \brief Constructor.
+/////////////////////////////////////////////////////////////////
+Properties::Properties()
+ : markerType( VTK::MT_NONE ), markerScale( VTK::MS_NONE ),
+ edgeWidth( 1 ), elem0dSize( 1 ), ballScale( 1 ), outlineWidth( 1 ),
+ orientationScale( 0 ), orientation3d( false ), shrinkFactor( 0 ),
+ opacity( 1 )
+{}
+
+/////////////////////////////////////////////////////////////////
+/// \typedef nodeColorStruct
+/// \deprecated Use ColorData instead.
+/// \typedef edgeColorStruct
+/// \deprecated Use ColorData instead.
+/// \typedef surfaceColorStruct
+/// \deprecated Use BicolorData instead.
+/// \typedef volumeColorStruct
+/// \deprecated Use BicolorData instead.
+/// \typedef actorAspect
+/// \deprecated Use Properties instead.
+/////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////
+/// \class SMESH_Swig
+/// \brief %SMESH GUI Python interface.
+/////////////////////////////////////////////////////////////////
+
+/////////////////////////////////////////////////////////////////
+/// \brief Constructor.
+/////////////////////////////////////////////////////////////////
+SMESH_Swig::SMESH_Swig()
+{
+ init();
+}
+/////////////////////////////////////////////////////////////////
+/// \brief Destructor.
+/////////////////////////////////////////////////////////////////
+SMESH_Swig::~SMESH_Swig()
+{
+}
- //---------------------------------------------------------------
- void
- SetDomain(const char* theMeshOrSubMeshEntry,
- const char* theDomainEntry,
- const SALOMEDS::StudyBuilder_var& theStudyBuilder,
- long theRefOnAppliedDomainTag,
- const QString& theAppliedDomainMEN,
- const QString& theAppliedDomainICON)
+/////////////////////////////////////////////////////////////////
+/// \internal
+/// \brief Initialize interface.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::init()
+{
+ class TInitEvent: public SALOME_Event
{
- SALOMEDS::SObject_var aMeshOrSubMeshSO = KERNEL::getStudyServant()->FindObjectID(theMeshOrSubMeshEntry);
- SALOMEDS::SObject_var aHypothesisSO = KERNEL::getStudyServant()->FindObjectID(theDomainEntry);
+ public:
+ TInitEvent() {}
+ virtual void Execute()
+ {
+ SUIT_Session* session = SUIT_Session::session();
+ SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( session->activeApplication() );
- if(!aMeshOrSubMeshSO->_is_nil() && !aHypothesisSO->_is_nil()){
- //Find or Create Applied Hypothesis root
- SALOMEDS::SObject_var anAppliedDomainSO;
- if( !aMeshOrSubMeshSO->FindSubObject( theRefOnAppliedDomainTag, anAppliedDomainSO ))
- {
- anAppliedDomainSO = theStudyBuilder->NewObjectToTag(aMeshOrSubMeshSO,theRefOnAppliedDomainTag);
- SALOMEDS::GenericAttribute_var anAttr =
- theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeName");
- SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
- aName->SetValue(theAppliedDomainMEN.toLatin1().data());
- aName->UnRegister();
- anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeSelectable");
- SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
- aSelAttr->SetSelectable(false);
- aSelAttr->UnRegister();
- anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributePixMap");
- SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
- aPixmap->SetPixMap(theAppliedDomainICON.toLatin1().data());
- aPixmap->UnRegister();
- }
- SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(anAppliedDomainSO);
- theStudyBuilder->Addreference(aSObject,aHypothesisSO);
- aSObject->UnRegister();
- anAppliedDomainSO->UnRegister();
+ if ( !SMESHGUI::GetSMESHGUI() )
+ app->loadModule( "Mesh" );
}
- if ( !aMeshOrSubMeshSO->_is_nil() ) aMeshOrSubMeshSO->UnRegister();
- if ( !aHypothesisSO->_is_nil()) aHypothesisSO->UnRegister();
- }
+ };
-
- // set current study
- std::vector<std::string> studies = SalomeApp_Application::studyMgr()->GetOpenStudies();
- if ( studies.size() > 0 )
- {
- _PTR(Study) study = SalomeApp_Application::studyMgr()->GetStudyByName( studies[0] );
- int studyId = study->StudyId();
- if ( myCachedStudyId != studyId )
- {
- myCachedStudyId = studyId;
- SMESHGUI::GetSMESHGen()->SetCurrentStudy( _CAST(Study, study)->GetStudy() );
- }
- }
- else
- {
- myCachedStudyId = 0;
- }
+ // load SMESH GUI if it's not yet loaded
+ ProcessVoidEvent( new TInitEvent() );
++ SMESHGUI::GetSMESHGen()->UpdateStudy();
+}
- //---------------------------------------------------------------
- void
- SetHypothesis(const char* theMeshOrSubMeshEntry,
- const char* theDomainEntry,
- const SALOMEDS::StudyBuilder_var& theStudyBuilder)
- {
- SetDomain(theMeshOrSubMeshEntry,
- theDomainEntry,
- theStudyBuilder,
- SMESH::Tag_RefOnAppliedHypothesis,
- QObject::tr("SMESH_MEN_APPLIED_HYPOTHESIS"),
- "ICON_SMESH_TREE_HYPO");
- }
+/////////////////////////////////////////////////////////////////
+/// \brief Publish object.
+/// \param ior IOR of the mesh object to publish.
+/// \param name Study name of the object; if not given,
+/// name is assigned automatically.
+/// \return UID of the data object.
+/////////////////////////////////////////////////////////////////
+const char* SMESH_Swig::publish(const char* ior, const char* name)
+{
+ init();
-
- if ( myCachedStudyId > 0 )
- {
- _PTR(Study) study = SalomeApp_Application::studyMgr()->GetStudyByID( myCachedStudyId );
- CORBA::Object_var object = string2object( ior );
- if ( study && !CORBA::is_nil( object ) )
+ std::string uid;
- SMESHGUI::GetSMESHGen()->PublishInStudy( _CAST(Study, study)->GetStudy(),
- SALOMEDS::SObject::_nil(),
++ CORBA::Object_var object = string2object( ior );
++ if ( !CORBA::is_nil( object ) )
+ {
+ SALOMEDS::SObject_var sobject =
- {
- uid = sobject->GetID();
- }
++ SMESHGUI::GetSMESHGen()->PublishInStudy( SALOMEDS::SObject::_nil(),
+ object.in(),
+ name );
+ if ( !CORBA::is_nil( sobject ) )
- }
++ {
++ uid = sobject->GetID();
++ }
+ sobject->UnRegister();
+ }
- //---------------------------------------------------------------
- void
- SetAlgorithms(const char* theMeshOrSubMeshEntry,
- const char* theDomainEntry,
- const SALOMEDS::StudyBuilder_var& theStudyBuilder)
- {
- SetDomain(theMeshOrSubMeshEntry,
- theDomainEntry,
- theStudyBuilder,
- SMESH::Tag_RefOnAppliedAlgorithms,
- QObject::tr("SMESH_MEN_APPLIED_ALGORIHTMS"),
- "ICON_SMESH_TREE_ALGO");
- }
+ return strdup( uid.c_str() );
}
+/////////////////////////////////////////////////////////////////
+/// \brief Set new study name of given object.
+/// \param uid Object's study UID or IOR.
+/// \param name New name of the object.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::rename(const char* uid, const char* name)
+{
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
-//===============================================================
-SMESH_Swig::SMESH_Swig()
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ sobject->SetAttrString( "AttributeName", name );
+}
+
+/////////////////////////////////////////////////////////////////
+/// \brief Display mesh object.
+/// \param uid Object's study UID or IOR.
+/// \param viewUid View window UID (0 means currently active view
+/// window; if there's no view, it is created).
+/// Default: 0.
+/// \param updateViewer "Update view" flag. Default: \c true.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::display(const char* uid, int viewUid, bool updateViewer)
{
- class TEvent: public SALOME_Event
+ class TDisplayEvent: public SALOME_Event
{
- CORBA::ORB_var& myORB;
+ private:
+ const char* myUid;
+ int myViewUid;
+ bool myIsUpdate;
public:
+ TDisplayEvent(const char* uid, int viewUid, bool updateViewer)
+ : myUid( uid ), myViewUid( viewUid ), myIsUpdate( updateViewer ) {}
+ virtual void Execute()
+ {
+ SALOME_View* view = uid2wnd( myViewUid, true ); // create view if it's not present
+ if ( view )
+ LightApp_Displayer::FindDisplayer( "Mesh", true )->Display( myUid, myIsUpdate, view );
+ }
+ };
+
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
- TEvent(CORBA::ORB_var& theORB):
- myORB(theORB)
- {}
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TDisplayEvent( sobject->GetID().c_str(), viewUid, updateViewer ) );
+}
- virtual
- void
- Execute()
+/////////////////////////////////////////////////////////////////
+/// \brief Erase mesh object.
+/// \param uid Object's study UID or IOR.
+/// \param viewUid View window UID (0 means currently active view
+/// window); -1 means "all view windows".
+/// Default: 0.
+/// \param updateViewer "Update view" flag. Default: \c true.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::erase(const char* uid, int viewUid, bool updateViewer)
+{
+ class TEraseEvent: public SALOME_Event
+ {
+ private:
+ const char* myUid;
+ int myViewUid;
+ bool myIsUpdate;
+ public:
+ TEraseEvent(const char* uid, int viewUid, bool updateViewer)
+ : myUid( uid ), myViewUid( viewUid ), myIsUpdate( updateViewer ) {}
+ virtual void Execute()
{
- try {
- ORB_INIT &anORBInit = *SINGLETON_<ORB_INIT>::Instance();
- ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
- myORB = anORBInit( 0, 0 );
- } catch (...) {
- INFOS("internal error : orb not found");
+ if ( myViewUid == -1 )
+ {
+ QList<SALOME_View*> views = windows();
+ foreach( SALOME_View* view, views )
+ LightApp_Displayer::FindDisplayer( "Mesh", true )->Erase( myUid, true, myIsUpdate, view );
+ }
+ else
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ if ( view )
+ LightApp_Displayer::FindDisplayer( "Mesh", true )->Erase( myUid, true, myIsUpdate, view );
}
}
};
- //MESSAGE("Constructeur");
-
- if(CORBA::is_nil(anORB))
- ProcessVoidEvent(new TEvent(anORB));
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
- ASSERT(!CORBA::is_nil(anORB));
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TEraseEvent( sobject->GetID().c_str(), viewUid, updateViewer ) );
}
-
-//===============================================================
-void
-SMESH_Swig::Init()
+/////////////////////////////////////////////////////////////////
+/// \brief Update mesh object.
+/// \param uid Object's study UID or IOR.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::update(const char* uid)
{
- class TEvent: public SALOME_Event
+ class TUpdateEvent: public SALOME_Event
{
- SALOMEDS::StudyBuilder_var& myStudyBuilder;
- SALOMEDS::SComponent_var& mySComponentMesh;
+ private:
+ const char* myUid;
public:
- TEvent(SALOMEDS::StudyBuilder_var& theStudyBuilder,
- SALOMEDS::SComponent_var& theSComponentMesh):
- myStudyBuilder (theStudyBuilder),
- mySComponentMesh(theSComponentMesh)
- {}
-
- ~TEvent()
+ TUpdateEvent( const char* uid ) : myUid( uid ) {}
+ virtual void Execute()
{
- if ( !mySComponentMesh->_is_nil() ) mySComponentMesh->UnRegister();
+ Handle(SALOME_InteractiveObject) io =
+ new SALOME_InteractiveObject( myUid, "SMESH", "" );
+ SMESH::Update( io, true );
}
+ };
- virtual
- void
- Execute()
- {
- SUIT_Session* aSession = SUIT_Session::session();
- SUIT_Application* anApplication = aSession->activeApplication();
- SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>(anApplication);
-
- SALOMEDS::Study_var aStudy = KERNEL::getStudyServant();
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
- SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen();
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TUpdateEvent( uid ) );
+}
- myStudyBuilder = aStudy->NewBuilder();
+/////////////////////////////////////////////////////////////////
+/// \internal
+class TGetPropsEvent: public SALOME_Event
+{
+public:
+ typedef Properties TResult;
+ TResult myResult;
+ const char* myUid;
+ int myViewUid;
- SALOMEDS::GenericAttribute_var anAttr;
- SALOMEDS::AttributeName_var aName;
- SALOMEDS::AttributePixMap_var aPixmap;
+ TGetPropsEvent( const char* uid, int viewUid )
+ : myUid( uid ), myViewUid( viewUid ) {}
- SALOMEDS::SComponent_var aSComponent = aStudy->FindComponent("SMESH");
- if ( aSComponent->_is_nil() )
- {
- bool aLocked = aStudy->GetProperties()->IsLocked();
- if (aLocked)
- aStudy->GetProperties()->SetLocked(false);
-
- SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
- //SRN: BugID IPAL9186, load a SMESH gui if it hasn't been loaded
- if (!aSMESHGUI) {
- CAM_Module* aModule = anApp->module("Mesh");
- if(!aModule)
- aModule = anApp->loadModule("Mesh");
- aSMESHGUI = dynamic_cast<SMESHGUI*>(aModule);
- } //SRN: BugID IPAL9186: end of a fix
-
- aSComponent = myStudyBuilder->NewComponent("SMESH");
-
- anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributeName");
- aName = SALOMEDS::AttributeName::_narrow(anAttr);
- aName->SetValue(aSMESHGUI->moduleName().toLatin1().data());
- aName->UnRegister();
-
- anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributePixMap");
- aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
- aPixmap->SetPixMap( "ICON_OBJBROWSER_SMESH" );
- aPixmap->UnRegister();
-
- SALOMEDS::UseCaseBuilder_var useCaseBuilder = KERNEL::getStudyServant()->GetUseCaseBuilder();
- useCaseBuilder->SetRootCurrent();
- useCaseBuilder->Append( aSComponent.in() );
-
- myStudyBuilder->DefineComponentInstance(aSComponent,aSMESHGen);
- if (aLocked)
- KERNEL::getStudyServant()->GetProperties()->SetLocked(true);
- }
+ virtual void Execute()
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ myResult = properties( view, myUid );
+ }
+};
- mySComponentMesh = SALOMEDS::SComponent::_narrow(aSComponent);
+/////////////////////////////////////////////////////////////////
+/// \brief Get mesh object's visual properties.
+/// \param uid Mesh object's study UID or IOR.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/// \return Properties data structure.
+/////////////////////////////////////////////////////////////////
+Properties SMESH_Swig::properties(const char* uid, int viewUid)
+{
+ Properties props;
- qApp->processEvents(); // Workaround for bug 12662
- }
- };
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
- //MESSAGE("Init");
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ props = ProcessEvent( new TGetPropsEvent( sobject->GetID().c_str(), viewUid ) );
- ProcessVoidEvent(new TEvent(myStudyBuilder,
- mySComponentMesh));
+ return props;
}
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TSetPropsEvent: public SALOME_Event
+{
+public:
+ const char* myUid;
+ Properties myProps;
+ int myViewUid;
-//===============================================================
-SMESH_Swig::~SMESH_Swig()
+ TSetPropsEvent( const char* uid, const Properties& props, int viewUid )
+ : myUid( uid ), myProps( props), myViewUid( viewUid ) {}
+
+ virtual void Execute()
+ {
+ if ( myViewUid == -1 )
+ {
+ QList<SALOME_View*> views = windows();
+ foreach( SALOME_View* view, views )
+ {
+ setProperties( view, myUid, myProps );
+ }
+ }
+ else
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ setProperties( view, myUid, myProps );
+ }
+ }
+};
+
+/////////////////////////////////////////////////////////////////
+/// \brief Set mesh object's visual properties.
+/// \param uid Mesh object's study UID or IOR.
+/// \param props Properties data structure.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::setProperties(const char* uid, const Properties& props, int viewUid)
{
- //MESSAGE("Destructeur");
-}
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSetPropsEvent( sobject->GetID().c_str(), props, viewUid ) );
+}
-//===============================================================
-const char* SMESH_Swig::AddNewMesh(const char* theIOR)
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TGetNodeNumberingEvent: public SALOME_Event
{
+public:
+ typedef bool TResult;
+ TResult myResult;
+ const char* myUid;
+ int myViewUid;
+
+ TGetNodeNumberingEvent( const char* uid, int viewUid )
+ : myResult( false ), myUid( uid ), myViewUid( viewUid ) {}
- // VSR: added temporarily - to be removed - objects are published automatically by engine
- SALOMEDS::SObject_var aSObject = KERNEL::getStudyServant()->FindObjectIOR(theIOR);
- if (aSObject->_is_nil())
+ virtual void Execute()
{
- //Find or Create Hypothesis root
- SALOMEDS::SObject_var hroot = GetHypothesisRoot(mySComponentMesh,myStudyBuilder);
- SALOMEDS::SObject_var aroot = GetAlgorithmsRoot(mySComponentMesh,myStudyBuilder);
- hroot->UnRegister();
- aroot->UnRegister();
-
- // Add New Mesh
- aSObject = myStudyBuilder->NewObject(mySComponentMesh);
- SALOMEDS::GenericAttribute_var anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
- SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
- aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH" );
- aPixmap->UnRegister();
-
- anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject, "AttributeIOR");
- SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
- anIOR->SetValue(theIOR);
- anIOR->UnRegister();
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ myResult = actor->GetPointsLabeled();
}
+};
+
+/////////////////////////////////////////////////////////////////
+/// \brief Check if nodes numbering is switched on.
+/// \param uid Mesh object's study UID or IOR.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/// \return \c true if nodes numbering is switched on;
+/// \c false otherwise.
+/////////////////////////////////////////////////////////////////
+bool SMESH_Swig::nodesNumbering(const char* uid, int viewUid)
+{
+ bool numbering = false;
+
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
- CORBA::String_var anEntry = aSObject->GetID();
- aSObject->UnRegister();
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ numbering = ProcessEvent( new TGetNodeNumberingEvent( sobject->GetID().c_str(), viewUid ) );
- return anEntry._retn();
+ return numbering;
}
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TSetNodeNumberingEvent: public SALOME_Event
+{
+public:
+ const char* myUid;
+ bool myNumbering;
+ int myViewUid;
+
+ TSetNodeNumberingEvent( const char* uid, bool numbering, int viewUid )
+ : myUid( uid ), myNumbering( numbering ), myViewUid( viewUid ) {}
+
+ virtual void Execute()
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ {
+ actor->SetPointsLabeled( myNumbering );
+ if ( view )
+ view->Repaint();
+ }
+ }
+};
-//===============================================================
-const char* SMESH_Swig::AddNewHypothesis(const char* theIOR)
+/////////////////////////////////////////////////////////////////
+/// \brief Switch nodes numbering on/off.
+/// \param uid Mesh object's study UID or IOR.
+/// \param numbering \c true to switch nodes numbering on;
+/// \c false otherwise.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::setNodesNumbering(const char* uid, bool numbering, int viewUid)
{
- SALOMEDS::SObject_var aSObject = ::AddHypothesis(theIOR,
- mySComponentMesh,
- myStudyBuilder);
- CORBA::String_var anEntry = aSObject->GetID();
- aSObject->UnRegister();
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
- return anEntry._retn();
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSetNodeNumberingEvent( sobject->GetID().c_str(), numbering, viewUid ) );
}
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TGetElementNumberingEvent: public SALOME_Event
+{
+public:
+ typedef bool TResult;
+ TResult myResult;
+ const char* myUid;
+ int myViewUid;
-//===============================================================
-const char* SMESH_Swig::AddNewAlgorithms(const char* theIOR)
+ TGetElementNumberingEvent( const char* uid, int viewUid )
+ : myResult( false ), myUid( uid ), myViewUid( viewUid ) {}
+
+ virtual void Execute()
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ myResult = actor->GetCellsLabeled();
+ }
+};
+
+/////////////////////////////////////////////////////////////////
+/// \brief Check if elements numbering is switched on.
+/// \param uid Mesh object's study UID or IOR.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/// \return \c true if elements numbering is switched on;
+/// \c false otherwise.
+/////////////////////////////////////////////////////////////////
+bool SMESH_Swig::elementsNumbering(const char* uid, int viewUid)
{
- SALOMEDS::SObject_var aSObject = ::AddAlgorithms(theIOR,
- mySComponentMesh,
- myStudyBuilder);
- CORBA::String_var anEntry = aSObject->GetID();
- aSObject->UnRegister();
+ bool numbering = false;
- return anEntry._retn();
-}
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ numbering = ProcessEvent( new TGetElementNumberingEvent( sobject->GetID().c_str(), viewUid ) );
+ return numbering;
+}
-//===============================================================
-void SMESH_Swig::SetShape(const char* theShapeEntry,
- const char* theMeshEntry)
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TSetElementNumberingEvent: public SALOME_Event
{
- SALOMEDS::SObject_var aGeomShapeSO = KERNEL::getStudyServant()->FindObjectID( theShapeEntry );
- SALOMEDS::SObject_var aMeshSO = KERNEL::getStudyServant()->FindObjectID( theMeshEntry );
+public:
+ const char* myUid;
+ bool myNumbering;
+ int myViewUid;
+
+ TSetElementNumberingEvent( const char* uid, bool numbering, int viewUid )
+ : myUid( uid ), myNumbering( numbering ), myViewUid( viewUid ) {}
- if(!aMeshSO->_is_nil() && !aGeomShapeSO->_is_nil()){
- SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObjectToTag(aMeshSO, SMESH::Tag_RefOnShape);
- myStudyBuilder->Addreference(aSObject,aGeomShapeSO);
- aSObject->UnRegister();
+ virtual void Execute()
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ {
+ actor->SetCellsLabeled( myNumbering );
+ if ( view )
+ view->Repaint();
+ }
}
- if ( !aMeshSO->_is_nil() ) aMeshSO->UnRegister();
- if ( !aGeomShapeSO->_is_nil() ) aGeomShapeSO->UnRegister();
+};
+
+/////////////////////////////////////////////////////////////////
+/// \brief Switch elements numbering on/off.
+/// \param uid Mesh object's study UID or IOR.
+/// \param numbering \c true to switch elements numbering on;
+/// \c false otherwise.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::setElementsNumbering(const char* uid, bool numbering, int viewUid)
+{
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSetElementNumberingEvent( sobject->GetID().c_str(), numbering, viewUid ) );
}
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TGetDisplayModeEvent: public SALOME_Event
+{
+public:
+ typedef DisplayMode TResult;
+ TResult myResult;
+ const char* myUid;
+ int myViewUid;
+
+ TGetDisplayModeEvent( const char* uid, int viewUid )
+ : myResult( UndefinedMode ), myUid( uid ), myViewUid( viewUid ) {}
-//===============================================================
-void SMESH_Swig::SetHypothesis(const char* theMeshOrSubMeshEntry,
- const char* theDomainEntry)
+ virtual void Execute()
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ myResult = (DisplayMode)actor->GetRepresentation();
+ }
+};
+
+/////////////////////////////////////////////////////////////////
+/// \brief Get mesh object's display mode.
+/// \param uid Mesh object's study UID or IOR.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/// \return Display mode (UndefinedMode if actor isn't found).
+/////////////////////////////////////////////////////////////////
+DisplayMode SMESH_Swig::displayMode(const char* uid, int viewUid)
{
- ::SetHypothesis(theMeshOrSubMeshEntry,
- theDomainEntry,
- myStudyBuilder);
+ DisplayMode mode = UndefinedMode;
+
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ mode = ProcessEvent( new TGetDisplayModeEvent( sobject->GetID().c_str(), viewUid ) );
+
+ return mode;
}
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TSetDisplayModeEvent: public SALOME_Event
+{
+public:
+ const char* myUid;
+ DisplayMode myMode;
+ int myViewUid;
+
+ TSetDisplayModeEvent( const char* uid, DisplayMode mode, int viewUid )
+ : myUid( uid ), myMode( mode), myViewUid( viewUid ) {}
+
+ virtual void Execute()
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor && myMode != UndefinedMode )
+ {
+ actor->SetRepresentation( myMode );
+ if ( view )
+ view->Repaint();
+ }
+ }
+};
-//===============================================================
-void SMESH_Swig::SetAlgorithms(const char* theMeshOrSubMeshEntry,
- const char* theDomainEntry)
+/////////////////////////////////////////////////////////////////
+/// \brief Set mesh object's display mode.
+/// \param uid Mesh object's study UID or IOR.
+/// \param mode Display mode.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::setDisplayMode(const char* uid, DisplayMode mode, int viewUid)
{
- ::SetAlgorithms(theMeshOrSubMeshEntry,
- theDomainEntry,
- myStudyBuilder);
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSetDisplayModeEvent( sobject->GetID().c_str(), mode, viewUid ) );
}
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TGetShrinkModeEvent: public SALOME_Event
+{
+public:
+ typedef bool TResult;
+ TResult myResult;
+ const char* myUid;
+ int myViewUid;
-//===============================================================
-void
-SMESH_Swig::UnSetHypothesis(const char* theDomainEntry)
+ TGetShrinkModeEvent( const char* uid, int viewUid )
+ : myResult( false ), myUid( uid ), myViewUid( viewUid ) {}
+
+ virtual void Execute()
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ myResult = actor->IsShrunk();
+ }
+};
+
+/////////////////////////////////////////////////////////////////
+/// \brief Check if shrink mode is switched on.
+/// \param uid Mesh object's study UID or IOR.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/// \return \c true if shrink mode is switched on;
+/// \c false otherwise.
+/////////////////////////////////////////////////////////////////
+bool SMESH_Swig::shrinkMode(const char* uid, int viewUid)
{
- SALOMEDS::SObject_var aDomainSO = KERNEL::getStudyServant()->FindObjectID(theDomainEntry);
- if(!aDomainSO->_is_nil())
- myStudyBuilder->RemoveObject(aDomainSO);
+ bool shrinkMode = false;
+
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ shrinkMode = ProcessEvent( new TGetShrinkModeEvent( sobject->GetID().c_str(), viewUid ) );
+
+ return shrinkMode;
}
-const char* SMESH_Swig::AddSubMesh(const char* theMeshEntry,
- const char* theSubMeshIOR,
- int theShapeType)
-{
- SALOMEDS::SObject_var aMeshSO = KERNEL::getStudyServant()->FindObjectID(theMeshEntry);
- if(!aMeshSO->_is_nil()) {
- long aShapeTag;
- QString aSubMeshName;
- switch(theShapeType) {
- case TopAbs_SOLID:
- aShapeTag = SMESH::Tag_SubMeshOnSolid;
- aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnSolid");
- break;
- case TopAbs_FACE:
- aShapeTag = SMESH::Tag_SubMeshOnFace;
- aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnFace");
- break;
- case TopAbs_EDGE:
- aShapeTag = SMESH::Tag_SubMeshOnEdge;
- aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnEdge");
- break;
- case TopAbs_VERTEX:
- aShapeTag = SMESH::Tag_SubMeshOnVertex;
- aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnVertex");
- break;
- default:
- aShapeTag = SMESH::Tag_SubMeshOnCompound;
- aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnCompound");
- }
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TSetShrinkModeEvent: public SALOME_Event
+{
+public:
+ const char* myUid;
+ bool myShrink;
+ int myViewUid;
+
+ TSetShrinkModeEvent( const char* uid, bool shrink, int viewUid )
+ : myUid( uid ), myShrink( shrink ), myViewUid( viewUid ) {}
- SALOMEDS::GenericAttribute_var anAttr;
- SALOMEDS::SObject_var aSubMeshesRoot;
- if ( !aMeshSO->FindSubObject( aShapeTag, aSubMeshesRoot ) )
+ virtual void Execute()
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
{
- aSubMeshesRoot = myStudyBuilder->NewObjectToTag(aMeshSO,aShapeTag);
- anAttr = myStudyBuilder->FindOrCreateAttribute(aSubMeshesRoot,"AttributeName");
- SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
- aName->SetValue(aSubMeshName.toLatin1().data());
- aName->UnRegister();
- anAttr = myStudyBuilder->FindOrCreateAttribute(aSubMeshesRoot,"AttributeSelectable");
- SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
- aSelAttr->SetSelectable(false);
- aSelAttr->UnRegister();
+ if ( myShrink )
+ actor->SetShrink();
+ else
+ actor->UnShrink();
+ if ( view )
+ view->Repaint();
}
- aSubMeshesRoot->UnRegister();
- aMeshSO->UnRegister();
+ }
+};
- SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObject(aSubMeshesRoot);
- anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
- SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
- anIOR->SetValue(theSubMeshIOR);
- anIOR->UnRegister();
+/////////////////////////////////////////////////////////////////
+/// \brief Switch shrink mode on/off.
+/// \param uid Mesh object's study UID or IOR.
+/// \param shrink \c true to switch shrink mode on;
+/// \c false otherwise.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::setShrinkMode(const char* uid, bool shrink, int viewUid)
+{
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
- CORBA::String_var aString = aSObject->GetID();
- aSObject->UnRegister();
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSetShrinkModeEvent( sobject->GetID().c_str(), shrink, viewUid ) );
+}
- return aString._retn();
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TGetOpacityEvent: public SALOME_Event
+{
+public:
+ typedef double TResult;
+ TResult myResult;
+ const char* myUid;
+ int myViewUid;
+
+ TGetOpacityEvent( const char* uid, int viewUid )
+ : myResult( 0 ), myUid( uid ), myViewUid( viewUid ) {}
+
+ virtual void Execute()
+ {
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ myResult = actor->GetOpacity();
}
+};
+
+/////////////////////////////////////////////////////////////////
+/// \brief Get mesh object's opacity.
+/// \param uid Mesh object's study UID or IOR.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/// \return Opacity value.
+/////////////////////////////////////////////////////////////////
+double SMESH_Swig::opacity(const char* uid, int viewUid)
+{
+ double opacity = 0;
+
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
- return "";
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ opacity = ProcessEvent( new TGetOpacityEvent( sobject->GetID().c_str(), viewUid ) );
+
+ return opacity;
}
-const char* SMESH_Swig::AddSubMeshOnShape(const char* theMeshEntry,
- const char* theGeomShapeEntry,
- const char* theSubMeshIOR,
- int ShapeType)
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TSetOpacityEvent: public SALOME_Event
{
- SALOMEDS::SObject_var aGeomShapeSO = KERNEL::getStudyServant()->FindObjectID(theGeomShapeEntry);
- if(!aGeomShapeSO->_is_nil())
+public:
+ const char* myUid;
+ double myOpacity;
+ int myViewUid;
+
+ TSetOpacityEvent( const char* uid, double opacity, int viewUid )
+ : myUid( uid ), myOpacity( opacity ), myViewUid( viewUid ) {}
+
+ virtual void Execute()
{
- const char * aSubMeshEntry = AddSubMesh(theMeshEntry,theSubMeshIOR,ShapeType);
- SALOMEDS::SObject_var aSubMeshSO = KERNEL::getStudyServant()->FindObjectID(aSubMeshEntry);
- if ( !aSubMeshSO->_is_nil()) {
- SetShape( theGeomShapeEntry, aSubMeshEntry );
- CORBA::String_var aString = aSubMeshSO->GetID();
- aSubMeshSO->UnRegister();
- return aString._retn();
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ {
+ actor->SetOpacity( myOpacity );
+ if ( view )
+ view->Repaint();
}
- aGeomShapeSO->UnRegister();
}
+};
- return "";
-}
+/////////////////////////////////////////////////////////////////
+/// \brief Set mesh object's opacity.
+/// \param uid Mesh object's study UID or IOR.
+/// \param opacity Opacity value.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::setOpacity(const char* uid, double opacity, int viewUid)
+{
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
-/*!
- \brief Gets window with specified identifier
- \internal
- \param id window identifier
- \return pointer on the window
-*/
-
-SUIT_ViewWindow* getWnd( const int id )
-{
- SUIT_ViewWindow* resWnd = 0;
- SUIT_Session* aSession = SUIT_Session::session();
- SUIT_Application* anApplication = aSession->activeApplication();
- SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(anApplication);
- if ( app ) {
- ViewManagerList vmlist = app->viewManagers();
- foreach( SUIT_ViewManager* vm, vmlist ) {
- QVector<SUIT_ViewWindow*> vwlist = vm->getViews();
- foreach ( SUIT_ViewWindow* vw, vwlist ) {
- if ( id == vw->getId() ) {
- resWnd = vw;
- break;
- }
- }
- }
- }
- return resWnd;
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSetOpacityEvent( sobject->GetID().c_str(), opacity, viewUid ) );
}
-class TGetActorAspect: public SALOME_Event
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TGetOrientationEvent: public SALOME_Event
{
public:
- typedef actorAspect TResult;
+ typedef bool TResult;
TResult myResult;
- const char* _entry;
- int _wid;
- TGetActorAspect( const char* Mesh_Entry, int viewId )
+ const char* myUid;
+ int myViewUid;
+
+ TGetOrientationEvent( const char* uid, int viewUid )
+ : myResult( false ), myUid( uid ), myViewUid( viewUid ) {}
+
+ virtual void Execute()
{
- _entry = Mesh_Entry;
- _wid = viewId;
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ myResult = actor->GetFacesOriented();
}
- virtual void Execute()
- {
- SMESH_Actor* anActor;
- if (_wid)
- {
- SUIT_ViewWindow* w = getWnd(_wid);
- anActor = SMESH::FindActorByEntry( w, _entry );
- }
- else
- anActor = SMESH::FindActorByEntry( _entry );
- if ( !anActor )
- {
- MESSAGE("GetActorAspect: no actor corresponding to: " << _entry);
- return;
- }
- anActor->GetSufaceColor(myResult.surfaceColor.r,
- myResult.surfaceColor.g,
- myResult.surfaceColor.b,
- myResult.surfaceColor.delta);
- anActor->GetVolumeColor(myResult.volumeColor.r,
- myResult.volumeColor.g,
- myResult.volumeColor.b,
- myResult.volumeColor.delta);
- anActor->GetEdgeColor(myResult.edgeColor.r,
- myResult.edgeColor.g,
- myResult.edgeColor.b);
- anActor->GetNodeColor(myResult.nodeColor.r,
- myResult.nodeColor.g,
- myResult.nodeColor.b);
- myResult.opacity= anActor->GetOpacity();
- MESSAGE("opacity: " << myResult.opacity);
- }
};
-actorAspect SMESH_Swig::GetActorAspect( const char* Mesh_Entry, int viewId )
+/////////////////////////////////////////////////////////////////
+/// \brief Check if faces orientation vectors are shown.
+/// \param uid Mesh object's study UID or IOR.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/// \return \c true if faces orientation vectors are shown;
+/// \c false otherwise.
+/////////////////////////////////////////////////////////////////
+bool SMESH_Swig::isOrientationShown(const char* uid, int viewUid)
{
- return ProcessEvent(new TGetActorAspect( Mesh_Entry, viewId));
+ bool shown = false;
+
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ shown = ProcessEvent( new TGetOrientationEvent( sobject->GetID().c_str(), viewUid ) );
+
+ return shown;
}
-void SMESH_Swig::SetActorAspect( const actorAspect& actorPres, const char* Mesh_Entry, int viewId )
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TSetOrientationEvent: public SALOME_Event
{
- class TSetActorAspect: public SALOME_Event
+public:
+ const char* myUid;
+ bool myShown;
+ int myViewUid;
+
+ TSetOrientationEvent( const char* uid, bool shown, int viewUid )
+ : myUid( uid ), myShown( shown ), myViewUid( viewUid ) {}
+
+ virtual void Execute()
{
- public:
- const char* _entry;
- actorAspect _actorPres;
- int _wid;
- TSetActorAspect(const actorAspect& actorPres, const char* Mesh_Entry, int viewId )
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
{
- _entry = Mesh_Entry;
- _actorPres = actorPres;
- _wid = viewId;
+ actor->SetFacesOriented( myShown );
+ if ( view )
+ view->Repaint();
}
- virtual void Execute()
- {
- SMESH_Actor* anActor;
- if (_wid)
- {
- SUIT_ViewWindow* w = getWnd(_wid);
- anActor = SMESH::FindActorByEntry( w, _entry );
- }
- else
- anActor = SMESH::FindActorByEntry( _entry );
- if ( !anActor )
- {
- MESSAGE("SetActorAspect: no actor corresponding to: " << _entry);
- return;
- }
- anActor->SetSufaceColor(_actorPres.surfaceColor.r,
- _actorPres.surfaceColor.g,
- _actorPres.surfaceColor.b,
- _actorPres.surfaceColor.delta);
- anActor->SetVolumeColor(_actorPres.volumeColor.r,
- _actorPres.volumeColor.g,
- _actorPres.volumeColor.b,
- _actorPres.volumeColor.delta);
- anActor->SetEdgeColor(_actorPres.edgeColor.r,
- _actorPres.edgeColor.g,
- _actorPres.edgeColor.b);
- anActor->SetNodeColor(_actorPres.nodeColor.r,
- _actorPres.nodeColor.g,
- _actorPres.nodeColor.b);
- anActor->SetOpacity(_actorPres.opacity);
- if (_wid)
- {
- SUIT_ViewWindow* w = getWnd(_wid);
- w->repaint();
- }
- else
- {
- SUIT_Session* aSession = SUIT_Session::session();
- SUIT_Application* anApplication = aSession->activeApplication();
- SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>(anApplication);
- SUIT_ViewManager* vman = anApp->getViewManager(VTKViewer_Viewer::Type(),true);
- vman->getActiveView()->repaint();
- }
- }
- };
+ }
+};
+
+/////////////////////////////////////////////////////////////////
+/// \brief Show/hide faces orientation vectors.
+/// \param uid Mesh object's study UID or IOR.
+/// \param shown \c true to show faces orientation vectors;
+/// \c false otherwise.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::setOrientationShown(const char* uid, bool shown, int viewUid)
+{
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
- ProcessVoidEvent(new TSetActorAspect(actorPres, Mesh_Entry, viewId));
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSetOrientationEvent( sobject->GetID().c_str(), shown, viewUid ) );
}
-void SMESH_Swig::CreateAndDisplayActor( const char* Mesh_Entry )
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TGetEntitiesEvent: public SALOME_Event
{
- // SMESH_Actor* Mesh = smeshGUI->ReadScript(aM);
- class TEvent: public SALOME_Event
+public:
+ typedef int TResult;
+ TResult myResult;
+ const char* myUid;
+ int myViewUid;
+
+ TGetEntitiesEvent( const char* uid, int viewUid )
+ : myResult( EntityNone ), myUid( uid ), myViewUid( viewUid ) {}
+
+ virtual void Execute()
{
- private:
- const char* _entry;
- public:
- TEvent(const char* Mesh_Entry) {
- _entry = Mesh_Entry;
- }
- virtual void Execute() {
- //SMESH::UpdateView(SMESH::eDisplay, _entry);
- SUIT_Session* aSession = SUIT_Session::session();
- SUIT_Application* anApplication = aSession->activeApplication();
- SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>(anApplication);
- /*SUIT_ViewManager* vman = */anApp->getViewManager(VTKViewer_Viewer::Type(),true);
- SMESHGUI_Displayer* aDisp = new SMESHGUI_Displayer(anApp);
- aDisp->Display(_entry,1);
- }
- };
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ myResult = actor->GetEntityMode();
+ }
+};
+
+/////////////////////////////////////////////////////////////////
+/// \brief Get mesh object's visible entities.
+/// \param uid Mesh object's study UID or IOR.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/// \return Enumerator describing entities being visible.
+/////////////////////////////////////////////////////////////////
+int SMESH_Swig::entitiesShown(const char* uid, int viewUid)
+{
+ int entities = EntityNone;
+
+ init();
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
- ProcessVoidEvent(new TEvent(Mesh_Entry));
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ entities = ProcessEvent( new TGetEntitiesEvent( sobject->GetID().c_str(), viewUid ) );
+
+ return entities;
}
-void SMESH_Swig::EraseActor( const char* Mesh_Entry, const bool allViewers )
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TSetEntitiesEvent: public SALOME_Event
{
- class TEvent: public SALOME_Event
+public:
+ const char* myUid;
+ int myEntities;
+ int myViewUid;
+
+ TSetEntitiesEvent( const char* uid, int entities, int viewUid )
+ : myUid( uid ), myEntities( entities ), myViewUid( viewUid ) {}
+
+ virtual void Execute()
{
- private:
- const char* _entry;
- bool _allViewers;
- public:
- TEvent(const char* Mesh_Entry, const bool allViewers ) {
- _entry = Mesh_Entry;
- _allViewers = allViewers;
- }
- virtual void Execute() {
- SUIT_Session* aSession = SUIT_Session::session();
- SUIT_Application* anApplication = aSession->activeApplication();
- SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>(anApplication);
- SMESHGUI_Displayer* aDisp = new SMESHGUI_Displayer(anApp);
- ViewManagerList aManagers;
- if ( !_allViewers ) {
- aManagers << anApp->activeViewManager();
- }
- else {
- aManagers = anApp->viewManagers();
- }
- foreach( SUIT_ViewManager* aMgr, aManagers ) {
- if ( aMgr && aMgr->getType() == VTKViewer_Viewer::Type() ) {
- SALOME_View* aSalomeView = dynamic_cast<SALOME_View*>(aMgr->getViewModel());
- if (aSalomeView) {
- aDisp->Erase(_entry,true, true, aSalomeView);
- }
- }
- }
+ SALOME_View* view = uid2wnd( myViewUid );
+ SMESH_Actor* actor = actorFromView( view, myUid );
+ if ( actor )
+ {
+ actor->SetEntityMode( myEntities );
+ if ( view )
+ view->Repaint();
}
- };
+ }
+};
- ProcessVoidEvent(new TEvent(Mesh_Entry, allViewers));
+/////////////////////////////////////////////////////////////////
+/// \brief Set mesh object's visible entities.
+/// \param uid Mesh object's study UID or IOR.
+/// \param entities Enumerator describing entities to be shown.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::setEntitiesShown(const char* uid, int entities, int viewUid)
+{
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSetEntitiesEvent( sobject->GetID().c_str(), entities, viewUid ) );
}
-void SMESH_Swig::UpdateActor( const char* Mesh_Entry ) {
- class TEvent: public SALOME_Event
+/////////////////////////////////////////////////////////////////
+/// \brief Check if given mesh object's entity is shown.
+/// \param uid Mesh object's study UID or IOR.
+/// \param entity Mesh entity.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/// \return \c true if entity is shown; \c false otherwise.
+/////////////////////////////////////////////////////////////////
+bool SMESH_Swig::isEntityShown(const char* uid, EntityMode entity, int viewUid)
+{
+ bool shown = false;
+
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
{
- 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 );
- }
- };
+ int entities = ProcessEvent( new TGetEntitiesEvent( sobject->GetID().c_str(), viewUid ) );
+ shown = (bool)( entities & entity );
+ }
- ProcessVoidEvent( new TEvent(Mesh_Entry) );
+ return shown;
}
-void SMESH_Swig::SetName(const char* theEntry,
- const char* theName)
-{
- SALOMEDS::SObject_var aSObject = KERNEL::getStudyServant()->FindObjectID(theEntry);
- SALOMEDS::GenericAttribute_var anAttr;
- SALOMEDS::AttributeName_var aName;
- if(!aSObject->_is_nil()){
- anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeName");
- aName = SALOMEDS::AttributeName::_narrow(anAttr);
- aName->SetValue(theName);
- aName->UnRegister();
- aSObject->UnRegister();
+/////////////////////////////////////////////////////////////////
+/// \brief Show/hide entity for given mesh object.
+/// \param uid Mesh object's study UID or IOR.
+/// \param entity Mesh entity.
+/// \param show Visibility status.
+/// \param viewUid View window UID (0 means currently active view
+/// window); Default: 0.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::setEntityShown(const char* uid, EntityMode entity, bool show, int viewUid)
+{
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ {
+ int entities = ProcessEvent( new TGetEntitiesEvent( sobject->GetID().c_str(), viewUid ) );
+ if ( show )
+ entities |= entity;
+ else
+ entities &= ~entity;
+ ProcessVoidEvent( new TSetEntitiesEvent( sobject->GetID().c_str(), entities, viewUid ) );
}
}
-//================================================================================
-/*!
- * \brief Set mesh icon according to compute status
- * \param Mesh_Entry - entry of a mesh
- * \param isComputed - is mesh computed or not
- */
-//================================================================================
+/////////////////////////////////////////////////////////////////
+/// \brief Initialize %SMESH GUI Python interface.
+/// \deprecated Interface is initialized automatically.
- /// \param studyID Study UID (not used).
+/////////////////////////////////////////////////////////////////
- void SMESH_Swig::Init(int /*studyID*/)
++void SMESH_Swig::Init()
+{
+ deprecated("SMESH_Swig::Init");
+ // does nothing; initialization is done automatically.
+}
-void SMESH_Swig::SetMeshIcon(const char* theMeshEntry,
- const bool theIsComputed,
- const bool isEmpty)
+/////////////////////////////////////////////////////////////////
+/// \brief Publish mesh in the active study.
+/// \deprecated Publishing is done automatically.
+/// \param ior IOR of the mesh.
+/// \param name Name of the mesh (optional).
+/// \return UID of the data object.
+/////////////////////////////////////////////////////////////////
+const char* SMESH_Swig::AddNewMesh(const char* ior, const char* name)
{
- class TEvent: public SALOME_Event
- {
- std::string myMeshEntry;
- bool myIsComputed, myIsEmpty;
- public:
- TEvent(const std::string& theMeshEntry,
- const bool theIsComputed,
- const bool isEmpty):
- myMeshEntry (theMeshEntry),
- myIsComputed(theIsComputed),
- myIsEmpty (isEmpty)
- {}
-
- virtual
- void
- Execute()
- {
- SALOMEDS::SObject_ptr aMeshSO = KERNEL::getStudyServant()->FindObjectID(myMeshEntry.c_str());
- if(_PTR(SObject) aMesh = ClientFactory::SObject(aMeshSO))
- SMESH::ModifiedMesh(aMesh,myIsComputed,myIsEmpty);
- // aMeshSO->UnRegister(); ~aMesh() already called UnRegister()!
- }
- };
+ deprecated("SMESH_Swig::AddNewMesh", "SMESH_Swig::publish");
+ return publish( ior, name );
+}
+
+/////////////////////////////////////////////////////////////////
+/// \brief Publish hypothesis in the active study.
+/// \deprecated Publishing is done automatically.
+/// \param ior IOR of the hypothesis.
+/// \param name Name of the hypothesis (optional).
+/// \return UID of the data object.
+/////////////////////////////////////////////////////////////////
+const char* SMESH_Swig::AddNewHypothesis(const char* ior, const char* name)
+{
+ deprecated("SMESH_Swig::AddNewHypothesis", "SMESH_Swig::publish");
+ return publish( ior, name );
+}
+
+/////////////////////////////////////////////////////////////////
+/// \brief Publish algorithm in the active study.
+/// \deprecated Publishing is done automatically.
+/// \param ior IOR of the algorithm.
+/// \param name Name of the algorithm (optional).
+/// \return UID of the data object.
+/////////////////////////////////////////////////////////////////
+const char* SMESH_Swig::AddNewAlgorithm(const char* ior, const char* name)
+{
+ deprecated("SMESH_Swig::AddNewAlgorithm", "SMESH_Swig::publish");
+ return publish( ior, name );
+}
+
+/////////////////////////////////////////////////////////////////
+/// \deprecated Publishing is done automatically.
+/// \deprecated Synonim of AddNewAlgorithm().
+/// \param ior IOR of the algorithm.
+/// \param name Name of the algorithm (optional).
+/// \return UID of the data object.
+/////////////////////////////////////////////////////////////////
+const char* SMESH_Swig::AddNewAlgorithms(const char* ior, const char* name)
+{
+ deprecated("SMESH_Swig::AddNewAlgorithms", "SMESH_Swig::publish");
+ return publish( ior, name );
+}
+
+/////////////////////////////////////////////////////////////////
+/// \brief Add reference on a shape for mesh in a study.
+/// \deprecated Publishing is done automatically.
+/// \param shapeUid GEOM shape's study UID (not used).
+/// \param meshUid Mesh's study UID (not used).
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::SetShape(const char* /*shapeUid*/, const char* /*meshUid*/)
+{
+ deprecated("SMESH_Swig::SetShape", "SMESH_Swig::publish");
+ // does nothing: publishing is done automatically
+}
+
+/////////////////////////////////////////////////////////////////
+/// \brief Assign hypothesis to mesh or sub-mesh.
+/// \deprecated Publishing is done automatically.
+/// \param meshUid Mesh's or sub-mesh's study UID (not used).
+/// \param hypoUID Hypothesis's study UID (not used).
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::SetHypothesis(const char* /*meshUid*/, const char* /*hypoUID*/)
+{
+ deprecated("SMESH_Swig::SetHypothesis", "SMESH_Swig::publish");
+ // does nothing: publishing is done automatically
+}
+
+/////////////////////////////////////////////////////////////////
+/// \brief Assign algorithm to mesh or sub-mesh.
+/// \deprecated Publishing is done automatically.
+/// \param meshUid Mesh's or sub-mesh's study UID (not used).
+/// \param algoUID Algorithm's study UID (not used).
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::SetAlgorithms(const char* /*meshUid*/, const char* /*algoUID*/)
+{
+ deprecated("SMESH_Swig::SetAlgorithms", "SMESH_Swig::publish");
+ // does nothing: publishing is done automatically
+}
+
+/////////////////////////////////////////////////////////////////
+/// \brief Anassign hypothesis or algorithm from mesh or sub-mesh.
+/// \deprecated Unpublishing is done automatically.
+/// \param uid Hypothesis's or algorithm's study UID (not used).
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::UnSetHypothesis(const char* /*uid*/)
+{
+ deprecated("SMESH_Swig::UnSetHypothesis");
+ // does nothing: unpublishing is done automatically
+}
+
+/////////////////////////////////////////////////////////////////
+/// \brief Publish sub-mesh in the active study.
+/// \deprecated Publishing is done automatically.
+/// \param meshUid Parent mesh's study UID (not used).
+/// \param ior IOR of the sub-mesh.
+/// \param shapeType GEOM shape's type (not used).
+/// \param name Name of the sub-mesh (optional).
+/// \return UID of the data object.
+/////////////////////////////////////////////////////////////////
+const char* SMESH_Swig::AddSubMesh(const char* /*meshUid*/,
+ const char* ior,
+ int /*shapeType*/,
+ const char* name)
+{
+ deprecated("SMESH_Swig::AddSubMesh", "SMESH_Swig::publish");
+ return publish( ior, name );
+}
+
+/////////////////////////////////////////////////////////////////
+/// \brief Publish sub-mesh in the active study.
+/// \deprecated Publishing is done automatically.
+/// \param meshUid Parent mesh's study UID (not used).
+/// \param shapeUid GEOM shape's study UID (not used).
+/// \param ior IOR of the sub-mesh.
+/// \param shapeType GEOM shape's type (not used).
+/// \param name Name of the sub-mesh (optional).
+/// \return UID of the data object.
+/////////////////////////////////////////////////////////////////
+const char* SMESH_Swig::AddSubMeshOnShape(const char* /*meshUid*/,
+ const char* /*shapeUid*/,
+ const char* ior,
+ int /*shapeType*/,
+ const char* name)
+{
+ deprecated("SMESH_Swig::AddSubMeshOnShape", "SMESH_Swig::publish");
+ return publish( ior, name );
+}
- ProcessVoidEvent(new TEvent(theMeshEntry,
- theIsComputed,
- isEmpty));
+/////////////////////////////////////////////////////////////////
+/// \brief Set new study name of given object.
+/// \deprecated Use rename() method.
+/// \param uid Object's study UID or IOR.
+/// \param name New name of the object.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::SetName(const char* uid, const char* name)
+{
+ deprecated("SMESH_Swig::SetName", "SMESH_Swig::rename");
+ rename( uid, name );
}
-/*!
- \brief Helper class for selection event.
-*/
+/////////////////////////////////////////////////////////////////
+/// \brief Set mesh icon according to compute status
+/// \deprecated Publishing is done automatically.
+/// \param meshUid Mesh's study UID (not used).
+/// \param isComputed Flag pointing that mesh is computed or no
+/// (not used).
+/// \param isEmpty Flag pointing that mesh is empty or no
+/// (not used).
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::SetMeshIcon(const char* /*meshUid*/,
+ const bool /*isComputed*/,
+ const bool /*isEmpty*/)
+{
+ deprecated("SMESH_Swig::SetMeshIcon", "SMESH_Swig::publish");
+ // does nothing: publishing is done automatically
+}
+
+/////////////////////////////////////////////////////////////////
+/// Display mesh in the currently active view window.
+/// \deprecated Use display() method.
+/// \param meshUid Mesh's study UID.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::CreateAndDisplayActor(const char* meshUid)
+{
+ deprecated("SMESH_Swig::CreateAndDisplayActor", "SMESH_Swig::display");
+ display( meshUid );
+}
+
+/////////////////////////////////////////////////////////////////
+/// Erase mesh in the view window(s).
+/// \deprecated Use erase() method.
+/// \param meshUid Mesh's study UID.
+/// \param allViewers If \c true, mesh is removed from all views.
+/// Default: \c false.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::EraseActor(const char* meshUid, const bool allViewers)
+{
+ deprecated("SMESH_Swig::EraseActor", "SMESH_Swig::erase");
+ erase( meshUid, allViewers ? -1 : 0 );
+}
+
+/////////////////////////////////////////////////////////////////
+/// Update mesh object.
+/// \deprecated Use update() method.
+/// \param meshUid Mesh's study UID.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::UpdateActor(const char* meshUid)
+{
+ deprecated("SMESH_Swig::UpdateActor", "SMESH_Swig::update");
+ update( meshUid );
+}
+
+/////////////////////////////////////////////////////////////////
+/// Get mesh object's properties.
+/// \deprecated Use properties() method.
+/// \param meshUid Mesh's study UID.
+/// \param viewUid View window UID (0 means currently active view
+/// window). Default: 0.
+/////////////////////////////////////////////////////////////////
+actorAspect SMESH_Swig::GetActorAspect(const char* meshUid, int viewUid)
+{
+ deprecated("SMESH_Swig::GetActorAspect", "SMESH_Swig::properties");
+ return properties( meshUid, viewUid );
+}
+
+/////////////////////////////////////////////////////////////////
+/// Set mesh object's properties.
+/// \deprecated Use setProperties() method.
+/// \param meshUid Mesh's study UID.
+/// \param viewUid View window UID (0 means currently active view
+/// window). Default: 0.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::SetActorAspect(const actorAspect& aspect, const char* meshUid, int viewUid)
+{
+ deprecated("SMESH_Swig::SetActorAspect", "SMESH_Swig::setProperties");
+ setProperties( meshUid, aspect, viewUid );
+}
+
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
class TSelectListEvent: public SALOME_Event
{
- const char* myId;
- std::vector<int> myIdsList;
- bool myIsAppend;
+ const char* myUid;
+ std::vector<int> myIds;
+ bool myIsAppend;
public:
- TSelectListEvent(const char* id, std::vector<int> ids, bool append) :
- myId(id),
- myIdsList(ids),
- myIsAppend(append)
+ TSelectListEvent(const char* uid, std::vector<int> ids, bool append)
+ : myUid( uid ), myIds( 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() );
+ SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
+ if ( app )
+ selMgr = dynamic_cast<LightApp_SelectionMgr*>( app->selectionMgr() );
- if( !selMgr )
+ if ( !selMgr )
return;
selMgr->clearFilters();
}
};
-/*!
- \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<int> ids, bool append ) {
- ProcessVoidEvent( new TSelectListEvent( id, ids, append ) );
+/////////////////////////////////////////////////////////////////
+/// \brief Select elements of the mesh, sub-mesh or group.
+/// \param uid Mesh object's study UID or IOR.
+/// \param ids List of mesh elements.
+/// \param append If \c true, elements are added to current
+/// selection; otherwise, previous selection is
+/// cleared.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::select(const char* uid, std::vector<int> ids, bool append)
+{
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSelectListEvent( sobject->GetID().c_str(), ids, append ) );
}
-/*!
- \brief Select the elements on the mesh, sub-mesh or group.
- \param id object entry
- \param id id of the element
- \param mode selection mode
-*/
-void SMESH_Swig::select( const char* id, int id1, bool append ) {
+/////////////////////////////////////////////////////////////////
+/// \brief Select element of the mesh, sub-mesh or group.
+/// \param uid Mesh object's study UID or IOR.
+/// \param id Mesh element.
+/// \param append If \c true, element is added to current
+/// selection; otherwise, previous selection is
+/// cleared.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::select(const char* uid, int id, bool append)
+{
+ init();
+
std::vector<int> ids;
- ids.push_back( id1 );
- ProcessVoidEvent( new TSelectListEvent( id, ids, append ) );
+ ids.push_back( id );
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSelectListEvent( sobject->GetID().c_str(), ids, append ) );
}
-/*!
- \brief Helper class for selection edges of cell event
-*/
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
class TSelectListOfPairEvent: public SALOME_Event
{
- const char* myId;
- std::vector<std::pair<int, int> > myIdsList;
- bool myIsAppend;
+ const char* myUid;
+ std::vector<std::pair<int, int> > myIds;
+ bool myIsAppend;
public:
- TSelectListOfPairEvent(const char* id, std::vector<std::pair<int, int> > ids, bool append) :
- myId(id),
- myIdsList(ids),
- myIsAppend(append)
+ TSelectListOfPairEvent(const char* uid, std::vector<std::pair<int, int> > ids, bool append)
+ : myUid( uid ), myIds( 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() );
+ SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
+ if ( app )
+ selMgr = dynamic_cast<LightApp_SelectionMgr*>( app->selectionMgr() );
- if( !selMgr )
+ if ( !selMgr )
return;
selMgr->clearFilters();
}
};
-/*!
- \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 ) );
+/////////////////////////////////////////////////////////////////
+/// \brief Select pseudo-edges (specified by two nodes)
+/// of the mesh, sub-mesh or group.
+/// \param uid Mesh object's study UID or IOR.
+/// \param ids List of pairs containing two nodes IDs.
+/// \param append If \c true, pseudo-edges are added to current
+/// selection; otherwise, previous selection is
+/// cleared.
+/////////////////////////////////////////////////////////////////
+void SMESH_Swig::select(const char* uid, std::vector<std::pair<int,int> > ids, bool append)
+{
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ProcessVoidEvent( new TSelectListOfPairEvent( sobject->GetID().c_str(), ids, append ) );
}
-class TGetSelectionModeEvent : public SALOME_Event
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
+class TGetSelectionModeEvent: public SALOME_Event
{
public:
typedef SelectionMode TResult;
}
};
-std::vector<int> SMESH_Swig::getSelected( const char* Mesh_Entry ) {
- return ProcessEvent( new TGetSelectedEvent(Mesh_Entry) );
+/////////////////////////////////////////////////////////////////
+/// \brief Get selected elements of the mesh, sub-mesh or group.
+/// \param uid Mesh object's study UID or IOR.
+/// \return List of selected mesh elements.
+/////////////////////////////////////////////////////////////////
+std::vector<int> SMESH_Swig::getSelected(const char* uid)
+{
+ std::vector<int> ids;
+
+ init();
+
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ ids = ProcessEvent( new TGetSelectedEvent( sobject->GetID().c_str() ) );
+
+ return ids;
}
+/////////////////////////////////////////////////////////////////
+/// \internal
+/////////////////////////////////////////////////////////////////
class TGetSelectedPairEvent : public SALOME_Event
{
public:
}
};
-std::vector<std::pair<int,int> > SMESH_Swig::getSelectedEdgeOfCell( const char* Mesh_Entry ) {
- return ProcessEvent( new TGetSelectedPairEvent(Mesh_Entry) );
-}
+/////////////////////////////////////////////////////////////////
+/// \brief Get selected pseudo-edges (specified by two nodes)
+/// of the mesh, sub-mesh or group.
+/// \param uid Mesh object's study UID or IOR.
+/// \param ids List of pairs containing two nodes IDs.
+/// \param append If \c true, pseudo-edges are added to current
+/// selection; otherwise, previous selection is
+/// cleared.
+/////////////////////////////////////////////////////////////////
+std::vector<std::pair<int,int> > SMESH_Swig::getSelectedEdgeOfCell(const char* uid)
+{
+ std::vector<std::pair<int,int> > pairs;
- _PTR(SObject) sobject = uid2object( myCachedStudyId, uid );
+ init();
+
++ _PTR(SObject) sobject = uid2object( uid );
+ if ( sobject )
+ pairs = ProcessEvent( new TGetSelectedPairEvent( sobject->GetID().c_str() ) );
+
+ return pairs;
+}
public:
SMESH_Swig();
~SMESH_Swig();
-
-
- void Init();
+
- const char* AddNewMesh( const char* );
+
- const char* AddNewHypothesis( const char* );
- const char* AddNewAlgorithms( const char* );
+ // Initialization =============================================
-
- void Init(int); // deprecated
++
++ void Init(); // deprecated
+
+ // Publishing =================================================
+
+ const char* publish(const char*, const char* = 0);
+ void rename(const char*, const char*);
- void SetShape( const char*, const char* );
+ const char* AddNewMesh(const char*, const char* = 0); // deprecated
+ const char* AddNewHypothesis(const char*, const char* = 0); // deprecated
+ const char* AddNewAlgorithm(const char*, const char* = 0); // deprecated
+ const char* AddNewAlgorithms(const char*, const char* = 0); // deprecated
- void SetHypothesis( const char*, const char* );
- void SetAlgorithms( const char*, const char* );
+ void SetShape(const char*, const char*); // deprecated
- void UnSetHypothesis( const char* );
+ void SetHypothesis(const char*, const char*); // deprecated
+ void SetAlgorithms(const char*, const char*); // deprecated
- const char* AddSubMesh( const char*, const char*, int );
- const char* AddSubMeshOnShape( const char*, const char*, const char*, int );
+ void UnSetHypothesis(const char*); // deprecated
- void CreateAndDisplayActor( const char* );
+ const char* AddSubMesh(const char*, const char*, int, const char* = 0); // deprecated
+ const char* AddSubMeshOnShape(const char*, const char*, const char*, int, const char* = 0); // deprecated
- void SetName( const char*, const char* );
+ void SetName(const char*, const char*); // deprecated
- void EraseActor( const char*, const bool allViewers = false );
+ void SetMeshIcon(const char*, const bool, const bool); // deprecated
- void UpdateActor( const char* Mesh_Entry );
+ // Visualization =============================================
- /*!
- * \brief Set mesh icon according to compute status
- * \param Mesh_Entry - entry of a mesh
- * \param isComputed - is mesh computed or not
- */
- void SetMeshIcon( const char*, const bool, const bool );
+ void display(const char*, int = 0, bool = true);
+ void erase(const char*, int = 0, bool = true);
+ void update(const char*);
- actorAspect GetActorAspect(const char* Mesh_Entry, int viewId = 0 );
- void SetActorAspect( const actorAspect& actorPres, const char* Mesh_Entry, int viewId = 0 );
+ Properties properties(const char*, int = 0);
+ void setProperties(const char*, const Properties&, int = 0);
- void setSelectionMode( SelectionMode selectionMode );
- std::vector<int> getSelected( const char* Mesh_Entry );
- std::vector<std::pair<int, int> > getSelectedEdgeOfCell( const char* Mesh_Entry );
+ bool nodesNumbering(const char*, int = 0);
+ void setNodesNumbering(const char*, bool, int = 0);
+ bool elementsNumbering(const char*, int = 0);
+ void setElementsNumbering(const char*, bool, int = 0);
- // --------------------- 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 );
+ DisplayMode displayMode(const char*, int = 0);
+ void setDisplayMode(const char*, DisplayMode, int = 0);
+
+ bool shrinkMode(const char*, int = 0);
+ void setShrinkMode(const char*, bool, int = 0);
+
+ double opacity(const char*, int = 0);
+ void setOpacity(const char*, double, int = 0);
+
+ bool isOrientationShown(const char*, int = 0);
+ void setOrientationShown(const char*, bool, int = 0);
+
+ int entitiesShown(const char*, int = 0);
+ void setEntitiesShown(const char*, int, int = 0);
+ bool isEntityShown(const char*, EntityMode, int = 0);
+ void setEntityShown(const char*, EntityMode, bool, int = 0);
+
+ void CreateAndDisplayActor(const char*); // deprecated
+ void EraseActor(const char*, const bool = false); // deprecated
+ void UpdateActor(const char* Mesh_Entry); // deprecated
+
+ actorAspect GetActorAspect(const char*, int = 0); // deprecated
+ void SetActorAspect(const actorAspect&, const char*, int = 0); // deprecated
+
+ // Selection =================================================
+
+ SelectionMode getSelectionMode(int = 0);
+ void setSelectionMode(SelectionMode, int = 0);
+ std::vector<int> getSelected(const char*);
+ std::vector<std::pair<int, int> > getSelectedEdgeOfCell(const char*);
+
+ void select(const char*, std::vector<int>, bool = false);
+ void select(const char*, int, bool = false);
+ void select(const char*, std::vector<std::pair<int,int> >, bool = false);
private:
- SALOMEDS::StudyBuilder_var myStudyBuilder;
- SALOMEDS::SComponent_var mySComponentMesh;
+ void init();
+
- private:
- int myCachedStudyId;
};
#endif // LIBSMESH_SWIG_H
SMESH_Swig();
~SMESH_Swig();
- void Init();
+
- const char* AddNewMesh(const char* IOR);
- const char* AddNewHypothesis(const char* IOR);
- const char* AddNewAlgorithms(const char* IOR);
+ // Initialization =============================================
+
- void Init(int); // deprecated
++ void Init(); // deprecated
+
+ // Publishing =================================================
+
+ const char* publish(const char*, const char* = 0);
+ void rename(const char*, const char*);
+
+ const char* AddNewMesh(const char*, const char* = 0); // deprecated
+ const char* AddNewHypothesis(const char*, const char* = 0); // deprecated
+ const char* AddNewAlgorithms(const char*, const char* = 0); // deprecated
+ const char* AddNewAlgorithm(const char*, const char* = 0); // deprecated
+
+ void SetShape(const char*, const char*); // deprecated
+
+ void SetHypothesis(const char*, const char*); // deprecated
+ void SetAlgorithms(const char*, const char*); // deprecated
+
+ void UnSetHypothesis(const char*); // deprecated
+
+ const char* AddSubMesh(const char*, const char*, int, const char* = 0); // deprecated
+ const char* AddSubMeshOnShape (const char*, const char*, const char*, int, const char* = 0); // deprecated
+
+ void SetName(const char*, const char*); // deprecated
+
+ void SetMeshIcon(const char*, const bool, const bool); // deprecated
+
+ // Visualization =============================================
+
+ void display(const char*, int = 0, bool = true);
+ void erase(const char*, int = 0, bool = true);
+ void update(const char*);
+
+ Properties properties(const char*, int = 0);
+ void setProperties(const char*, const Properties&, int = 0);
- void SetShape(const char* ShapeEntry, const char* MeshEntry);
+ bool nodesNumbering(const char*, int = 0);
+ void setNodesNumbering(const char*, bool, int = 0);
+ bool elementsNumbering(const char*, int = 0);
+ void setElementsNumbering(const char*, bool, int = 0);
- void SetHypothesis(const char* Mesh_Or_SubMesh_Entry, const char* Hypothesis_Entry);
- void SetAlgorithms(const char* Mesh_Or_SubMesh_Entry, const char* Algorithms_Entry);
+ DisplayMode displayMode(const char*, int = 0);
+ void setDisplayMode(const char*, DisplayMode, int = 0);
- void UnSetHypothesis(const char* Applied_Hypothesis_Entry );
+ bool shrinkMode(const char*, int = 0);
+ void setShrinkMode(const char*, bool, int = 0);
- const char* AddSubMesh (const char* Mesh_Entry, const char* SM_IOR, int ST);
- const char* AddSubMeshOnShape (const char* Mesh_Entry, const char* GeomShape_Entry, const char* SM_IOR, int ST);
+ double opacity(const char*, int = 0);
+ void setOpacity(const char*, double, int = 0);
- void SetName(const char* Entry, const char* Name);
+ bool isOrientationShown(const char*, int = 0);
+ void setOrientationShown(const char*, bool, int = 0);
- void SetMeshIcon(const char* Mesh_Entry, const bool isComputed, const bool isEmpty);
+ int entitiesShown(const char*, int = 0);
+ void setEntitiesShown(const char*, int, int = 0);
+ bool isEntityShown(const char*, EntityMode, int = 0);
+ void setEntityShown(const char*, EntityMode, bool, int = 0);
- void CreateAndDisplayActor( const char* Mesh_Entry );
- void EraseActor( const char* Mesh_Entry, const bool allViewers = false );
- void UpdateActor( const char* Mesh_Entry );
+ void CreateAndDisplayActor(const char*); // deprecated
+ void EraseActor(const char*, const bool = false); // deprecated
+ void UpdateActor(const char*); // deprecated
- 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*, int = 0); // deprecated
+ void SetActorAspect(const actorAspect&, const char*, int = 0); // deprecated
- actorAspect GetActorAspect(const char* Mesh_Entry, int viewId = 0 );
- void SetActorAspect( const actorAspect& actorPres, const char* Mesh_Entry, int viewId = 0 );
+ // Selection =================================================
- void setSelectionMode( SelectionMode selectionMode);
- std::vector<int> getSelected( const char* Mesh_Entry );
+ SelectionMode getSelectionMode(int = 0);
+ void setSelectionMode(SelectionMode, int = 0);
- // --------------------- 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 );
+ std::vector<int> getSelected(const char*);
+ std::vector<std::pair<int,int> > getSelectedEdgeOfCell(const char*);
+ void select(const char*, std::vector<int>, bool = false);
+ void select(const char*, int, bool = false);
+ void select(const char*, std::vector<std::pair<int,int> >, bool = false);
};
##########################################################################################################
def PublishGroups ():
- TempNames = []
- for MacroObj in Config.ListObj :
- if group in MacroObj.GroupNames :
- Occurences = IndexMultiOcc(MacroObj.GroupNames, group)
- for Occ in Occurences :
- TempGEOList += MacroObj.GetBorder(Occ)
- GroupGEO.append(geompy.MakeCompound(TempGEOList))
- geompy.addToStudyInFather(FinalCompound,GroupGEO[-1],'GR_'+group)
-
- # Mesh groups definition
- Criterion = smesh.GetCriterion(SMESH.EDGE, SMESH.FT_BelongToGeom,'=',GroupGEO[-1],Tolerance=1e-06)
- #Criterion = smesh.Filter.Criterion(18,39,0,'GR_'+group,'GR_'+group,39,39,1e-06,smesh.EDGE,7)
- MeshCompound.MakeGroupByCriterion(group,Criterion)
-
- StudyBuilder = Config.theStudy.NewBuilder()
- for MeshObj in TempMESHList:
- SO = Config.theStudy.FindObjectIOR(Config.theStudy.ConvertObjectToIOR(MeshObj))
- if SO is not None: StudyBuilder.RemoveObjectWithChildren(SO)
-
- return MeshCompound
+ aFilterManager = smesh.CreateFilterManager()
+
+ # Building geometric and mesh compounds and groups ##############################################
+ if Config.debug : print("Searching for geometric groups and publishing final compound")
+
+ TempGEOList = []
+ TempMESHList = []
+
+ for MacroObj in Config.ListObj :
+ TempGEOList += MacroObj.GeoChildren
+ TempMESHList += MacroObj.Mesh
+
+ FinalCompound = geompy.MakeCompound(TempGEOList)
+ geompy.addToStudy (FinalCompound,Config.StudyName)
+ MeshCompound = smesh.Concatenate(TempMESHList, 1, 1, 1e-5)
+ MeshCompound.SetName(Config.StudyName)
+
+ GroupGEO = []
+ for group in Config.Groups :
+
+ # Geometric groups definition
+ TempGEOList = []
+ aFilterManager = smesh.CreateFilterManager()
- if Config.debug : print "Searching for geometric groups and publishing final compound"
+ # Building geometric and mesh compounds and groups ##############################################
++ if Config.debug : print("Searching for geometric groups and publishing final compound")
+
+ TempGEOList = []
+ TempMESHList = []
+
+ for MacroObj in Config.ListObj :
+ TempGEOList += MacroObj.GeoChildren
+ TempMESHList += MacroObj.Mesh
+
+ FinalCompound = geompy.MakeCompound(TempGEOList)
+ geompy.addToStudy (FinalCompound,Config.StudyName)
+ MeshCompound = smesh.Concatenate(TempMESHList, 1, 1, 1e-5)
+ MeshCompound.SetName(Config.StudyName)
+
+ GroupGEO = []
+ for group in Config.Groups :
+
+ # Geometric groups definition
+ TempGEOList = []
+ TempNames = []
+ for MacroObj in Config.ListObj :
+ if group in MacroObj.GroupNames :
+ Occurrences = IndexMultiOcc(MacroObj.GroupNames, group)
+ for Occ in Occurrences :
+ TempGEOList += MacroObj.GetBorder(Occ)
+ GroupGEO.append(geompy.MakeCompound(TempGEOList))
+ geompy.addToStudyInFather(FinalCompound,GroupGEO[-1],'GR_'+group)
+
+ # Mesh groups definition
+ Criterion = smesh.GetCriterion(SMESH.EDGE, SMESH.FT_BelongToGeom,'=',GroupGEO[-1],Tolerance=1e-06)
+ #Criterion = smesh.Filter.Criterion(18,39,0,'GR_'+group,'GR_'+group,39,39,1e-06,smesh.EDGE,7)
+ MeshCompound.MakeGroupByCriterion(group,Criterion)
+
+ StudyBuilder = Config.theStudy.NewBuilder()
+ for MeshObj in TempMESHList:
+ SO = Config.theStudy.FindObjectIOR(Config.theStudy.ConvertObjectToIOR(MeshObj))
+ if SO is not None: StudyBuilder.RemoveObjectWithChildren(SO)
+
+ return MeshCompound
+
def IndexMultiOcc (Array,Element) :
- """
- This function returns the occurrences indices of Element in Array.
- As opposed to Array.index(Element) method, this allows determining
- multiple entries rather than just the first one!
- """
- Output = []
- try : Array.index(Element)
- except ValueError : print "No more occurrences"
- else : Output.append(Array.index(Element))
-
- if not(Output == [-1]) and len(Array) > 1 :
- for index, ArrElem in enumerate(Array[Output[0]+1:]) :
- if ArrElem is Element : Output.append(index+Output[0]+1)
-
- return Output
-
+ """
+ This function returns the occurrences indices of Element in Array.
+ As opposed to Array.index(Element) method, this allows determining
+ multiple entries rather than just the first one!
+ """
+ Output = []
+ try : Array.index(Element)
+ except ValueError : print("No more occurrences")
+ else : Output.append(Array.index(Element))
+
+ if not(Output == [-1]) and len(Array) > 1 :
+ for index, ArrElem in enumerate(Array[Output[0]+1:]) :
+ if ArrElem is Element : Output.append(index+Output[0]+1)
+
+ return Output
+
def Publish (ObjToPublish):
- for i,GeoObj in enumerate(ObjToPublish) : geompy.addToStudy(GeoObj,"Sub_"+str(i))
-
+ for i,GeoObj in enumerate(ObjToPublish) : geompy.addToStudy(GeoObj,"Sub_"+str(i))
+
def RevolveMesh(MainMesh,**args):
"""
This function permits to revolute and scale a 2D mesh while transforming the edge
