-// Copyright (C) 2007-2021 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024 CEA, EDF, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// File : SMESHGUI.cxx
// Author : Nicolas REJNERI, Open CASCADE S.A.S.
+#include <Basics_OCCTVersion.hxx>
+
+#if OCC_VERSION_LARGE < 0x07080000
+
#include <Standard_math.hxx> // E.A. must be included before Python.h to fix compilation on windows
+
+#else
+
+#ifdef _MSC_VER
+#ifndef _USE_MATH_DEFINES
+#define _USE_MATH_DEFINES
+#endif
+#include <math.h>
+#endif
+
+#endif
+
#ifdef HAVE_FINITE
#undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined
#endif
#include "SMESHGUI_MG_ADAPTDRIVER.h"
#include "SMESHGUI_HomardAdaptDlg.h"
#include "SMESHGUI_Make2DFrom3DOp.h"
+#include "SMESHGUI_MakeFull2DFrom3DOp.h"
#include "SMESHGUI_MakeNodeAtPointDlg.h"
#include "SMESHGUI_Measurements.h"
#include "SMESHGUI_MergeDlg.h"
#include "SMESHGUI_MeshInfo.h"
+#include "SMESHGUI_Meshio.h"
#include "SMESHGUI_MeshOp.h"
#include "SMESHGUI_MeshOrderOp.h"
#include "SMESHGUI_MeshPatternDlg.h"
#include "SMESHGUI_SymmetryDlg.h"
#include "SMESHGUI_TranslationDlg.h"
#include "SMESHGUI_TransparencyDlg.h"
+#include "SMESHGUI_CreateDualMeshDlg.h"
+#include "SMESHGUI_CreateDualMeshOp.h"
#include "SMESHGUI_Utils.h"
#include "SMESHGUI_VTKUtils.h"
void Control( int theCommandID );
// Definitions
+
//================================================================================
/*!
* \brief Reads meshes from file
filter.append( QObject::tr( "GMF_ASCII_FILES_FILTER" ) + " (*.mesh)" );
filter.append( QObject::tr( "GMF_BINARY_FILES_FILTER") + " (*.meshb)" );
}
+ else if (theCommandID == SMESHOp::OpImportMESHIO) {
+ if (!SMESHGUI_Meshio::IsMeshioInstalled())
+ return;
+
+ filter = SMESHGUI_Meshio::GetImportFileFilter();
+ }
QString anInitialPath = "";
if ( SUIT_FileDlg::getLastVisitedPath().isEmpty() )
}
break;
}
+ case SMESHOp::OpImportMESHIO:
+ {
+ aMeshes = SMESHGUI_Meshio::ImportMesh(theComponentMesh, filename, errors);
+ break;
+ }
}
}
catch ( const SALOME::SALOME_Exception& S_ex ) {
- errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
- arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
+ const QString exText(S_ex.details.text);
+ if (exText.startsWith("MESHIO"))
+ errors.append('\n' + exText);
+ else
+ errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
+ arg( QObject::tr( "SMESH_ERR_UNKNOWN_IMPORT_ERROR" ) ) );
}
for ( int i = 0, iEnd = aMeshes->length(); i < iEnd; i++ )
theCommandID == SMESHOp::OpPopupExportCGNS );
const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
theCommandID == SMESHOp::OpPopupExportGMF );
+ const bool isMESHIO = (theCommandID == SMESHOp::OpExportMESHIO);
- const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
+ if (isMESHIO && !SMESHGUI_Meshio::IsMeshioInstalled())
+ {
+ return;
+ }
+
+ const bool multiMeshSupported = isMED || isCGNS || isMESHIO; // file can hold several meshes
if ( selected.Extent() == 0 || ( selected.Extent() > 1 && !multiMeshSupported ))
return;
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
SMESH::SMESH_Mesh_var aMesh = aMeshOrGroup->GetMesh();
QString aMeshName = (*aMeshIter).second;
- if ( isMED || isCGNS ) // formats where group names must be unique
+ if (isMED || isCGNS || isMESHIO) // formats where group names must be unique
{
// check for equal group names within each mesh
for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ ) {
{
format = "CGNS";
notSupportedElemTypes.push_back( SMESH::Entity_Ball );
- }
+ }
else if ( isGMF )
{
format = "GMF";
// Get parameters of export operation
QString aFilename;
+ QString aSelectedFilter; // for meshio to get a filter selected by user
int aFormat =-1; // for MED version used for write
bool isOkToWrite = true; // to check MED file version compatibility before adding a mesh in an existing file
bool toFindOutDim = true;
bool saveNumbers = resMgr->booleanValue( "SMESH", "med_save_numbers", true );
bool toRenumber = true;
+ bool structureCGNS = false;
double zTol = resMgr->doubleValue( "SMESH", "med_ztolerance", 0. );
QString aFilter, aTitle = QObject::tr("SMESH_EXPORT_MESH");
anInitialPath + QString("/") + aMeshName,
aFilter, aTitle, false);
}
- else if ( isCGNS || isUNV || isDAT ) // Export to [ CGNS | UNV | DAT ] - one option
+ else if ( isCGNS )
+ {
+ const char* theOptionResource = "cgns_group_elems_by_type";
+ bool option = resMgr->booleanValue( "SMESH", theOptionResource, false );
+
+ QStringList checkBoxes;
+ checkBoxes << QObject::tr( "CGNS_EXPORT_ELEMS_BY_TYPE" ) << QObject::tr("STRUCTUREDCGNS");
+
+ SalomeApp_CheckFileDlg* fd = new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
+
+ fd->setWindowTitle( aTitle );
+ fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
+
+ if ( !anInitialPath.isEmpty() )
+ fd->setDirectory( anInitialPath );
+ fd->selectFile( aMeshName );
+ SMESHGUI_FileValidator* fv = new SMESHGUI_FileValidator( fd );
+ fd->setValidator( fv );
+ fd->SetChecked( option, 0 );
+
+ if ( fd->exec() )
+ {
+ aFilename = fd->selectedFile();
+ structureCGNS = fd->IsChecked( 1 );
+ }
+
+ toOverwrite = fv->isOverwrite( aFilename );
+ option = fd->IsChecked( 0 );
+ SMESHGUI::resourceMgr()->setValue("SMESH", theOptionResource, option );
+ toCreateGroups = option;
+
+ delete fd;
+ }
+ else if ( isUNV || isDAT ) // Export to [ UNV | DAT ] - one option
{
- const char* theOptionResource = isCGNS ? "cgns_group_elems_by_type" : "export_renumber";
+ const char* theOptionResource = "export_renumber";
bool option = resMgr->booleanValue( "SMESH", theOptionResource, false );
QStringList checkBoxes;
- checkBoxes << QObject::tr( isCGNS ? "CGNS_EXPORT_ELEMS_BY_TYPE" : "SMESH_RENUMBER" );
+ checkBoxes << QObject::tr( "SMESH_RENUMBER" );
SalomeApp_CheckFileDlg* fd =
new SalomeApp_CheckFileDlg ( SMESHGUI::desktop(), false, checkBoxes, true, true );
fd->setWindowTitle( aTitle );
- if ( isCGNS )
- fd->setNameFilter( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
- else if ( isUNV )
+ if ( isUNV )
fd->setNameFilter( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
else if ( isDAT )
fd->setNameFilter( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
toOverwrite = fv->isOverwrite( aFilename );
option = fd->IsChecked( 0 );
SMESHGUI::resourceMgr()->setValue("SMESH", theOptionResource, option );
- ( isCGNS ? toCreateGroups : toRenumber ) = option;
+ toRenumber = option;
delete fd;
}
else if ( isSTL ) // Export to STL
{
QMap<QString, int> aFilterMap;
+ QStringList filters;
aFilterMap.insert( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)", 1 );
aFilterMap.insert( QObject::tr( "STL_BIN_FILES_FILTER" ) + " (*.stl)", 0 );
-
- QStringList filters;
+
QMap<QString, int>::const_iterator it = aFilterMap.begin();
for ( ; it != aFilterMap.end(); ++it )
- filters.push_back( it.key() );
-
+ filters.push_back( it.key() );
+
SUIT_FileDlg* fd = new SUIT_FileDlg( SMESHGUI::desktop(), false, true, true );
fd->setWindowTitle( aTitle );
fd->setNameFilters( filters );
- fd->selectNameFilter( QObject::tr( "STL_ASCII_FILES_FILTER" ) + " (*.stl)" );
+
if ( !anInitialPath.isEmpty() )
fd->setDirectory( anInitialPath );
fd->selectFile(aMeshName);
while (!is_ok) {
if ( fd->exec() )
aFilename = fd->selectedFile();
- aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
+ if ( isSTL )
+ aIsASCII_STL = (aFilterMap[fd->selectedNameFilter()]) == 1 ? true: false;
is_ok = true;
}
delete fd;
delete zTolWdg;
delete fd;
}
+ else if (isMESHIO)
+ {
+ if (SMESHGUI_Meshio::CheckMeshCount(aMeshList))
+ {
+ aFilename = SMESHGUI_Meshio::GetFileName(aSelectedFilter);
+ MESSAGE("aSelectedFilter: " << aSelectedFilter.toStdString());
+ }
+ }
else
{
return;
else if ( isCGNS )
{
aMeshIter = aMeshList.begin();
+
for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
{
SMESH::SMESH_IDSource_var aMeshOrGroup = (*aMeshIter).first;
SMESH::SMESH_Mesh_var aMeshItem = aMeshOrGroup->GetMesh();
- aMeshItem->ExportCGNS( aMeshOrGroup,
- aFilename.toUtf8().data(),
- toOverwrite && aMeshIndex == 0,
- toCreateGroups );
+
+ if ( !structureCGNS )
+ aMeshItem->ExportCGNS( aMeshOrGroup,
+ aFilename.toUtf8().data(),
+ toOverwrite && aMeshIndex == 0,
+ toCreateGroups );
+ else
+ aMeshItem->ExportStructuredCGNS( aMeshOrGroup,
+ aFilename.toUtf8().data(),
+ toOverwrite && aMeshIndex == 0 );
}
}
else if ( isGMF )
toCreateGroups = true;
aMesh->ExportGMF( aMeshOrGroup, aFilename.toUtf8().data(), toCreateGroups );
}
+ else if (isMESHIO)
+ {
+ SMESHGUI_Meshio::ExportMesh(aMeshList, aFilename, aSelectedFilter);
+ }
}
catch (const SALOME::SALOME_Exception& S_ex)
{
wc.suspend();
+ const QString exText(S_ex.details.text);
+
if ( S_ex.details.type == SALOME::COMM && // communicate about too large mesh
strncmp( "format=", S_ex.details.sourceFile.in(), 7 ) == 0 )
SUIT_MessageBox::critical(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
QObject::tr(S_ex.details.text.in() ));
- else
+ else if (exText.startsWith("MESHIO"))
+ {
+ SUIT_MessageBox::warning(SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ QObject::tr("SMESH_EXPORT_FAILED_SHORT") + "\n\n" + exText);
+ }
+ else if ( isMED )
+ {
SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
QObject::tr("SMESH_EXPORT_FAILED") + SalomeApp_Tools::ExceptionToString(S_ex));
+ }
+ else
+ SUIT_MessageBox::warning(SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ SalomeApp_Tools::ExceptionToString(S_ex));
wc.resume();
}
}
type = QObject::tr( "ASPECTRATIO_3D_ELEMENTS" );
else if ( dynamic_cast< SMESH::Controls::Warping* >( f.get() ) )
type = QObject::tr( "WARP_ELEMENTS" );
+ else if (dynamic_cast<SMESH::Controls::Warping3D*>(f.get()))
+ type = QObject::tr("WARP_3D_ELEMENTS");
else if ( dynamic_cast< SMESH::Controls::Taper* >( f.get() ) )
type = QObject::tr( "TAPER_ELEMENTS" );
else if ( dynamic_cast< SMESH::Controls::Skew* >( f.get() ) )
type = QObject::tr( "EQUAL_VOLUME" );
else if ( dynamic_cast< SMESH::Controls::NodeConnectivityNumber* >( f.get() ) )
type = QObject::tr( "NODE_CONNECTIVITY_NB" );
+ else if ( dynamic_cast< SMESH::Controls::ScaledJacobian* >( f.get() ) )
+ type = QObject::tr( "SCALED_JACOBIAN" );
return type;
}
ActionControl.Bind( SMESHOp::OpMaxElementLength2D, SMESH_Actor::eMaxElementLength2D );
ActionControl.Bind( SMESHOp::OpEqualFace, SMESH_Actor::eCoincidentElems2D );
ActionControl.Bind( SMESHOp::OpAspectRatio3D, SMESH_Actor::eAspectRatio3D );
+ ActionControl.Bind( SMESHOp::OpWarping3D, SMESH_Actor::eWarping3D );
ActionControl.Bind( SMESHOp::OpVolume, SMESH_Actor::eVolume3D );
+ ActionControl.Bind( SMESHOp::OpScaledJacobian, SMESH_Actor::eScaledJacobian );
ActionControl.Bind( SMESHOp::OpMaxElementLength3D, SMESH_Actor::eMaxElementLength3D );
ActionControl.Bind( SMESHOp::OpBareBorderVolume, SMESH_Actor::eBareBorderVolume );
ActionControl.Bind( SMESHOp::OpOverConstrainedVolume, SMESH_Actor::eOverConstrainedVolume );
{
CORBA::Boolean anIsEmbeddedMode;
myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
-
+
//MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
// 0019923: EDF 765 SMESH : default values of hypothesis
SVTK_ViewWindow* vtkwnd = dynamic_cast<SVTK_ViewWindow*>( view );
//QAction* act = action( theCommandID );
+ bool logAction(false);
switch (theCommandID) {
case SMESHOp::OpDelete:
case SMESHOp::OpImportSTL:
case SMESHOp::OpImportCGNS:
case SMESHOp::OpImportGMF:
+ case SMESHOp::OpImportMESHIO:
case SMESHOp::OpPopupImportDAT:
case SMESHOp::OpPopupImportUNV:
case SMESHOp::OpPopupImportMED:
case SMESHOp::OpExportSTL:
case SMESHOp::OpExportCGNS:
case SMESHOp::OpExportGMF:
+ case SMESHOp::OpExportMESHIO:
case SMESHOp::OpPopupExportDAT:
case SMESHOp::OpPopupExportMED:
case SMESHOp::OpPopupExportUNV:
break;
case SMESHOp::OpCopyMesh:
{
+ logAction = true;
if (isStudyLocked()) break;
EmitSignalDeactivateDialog();
( new SMESHGUI_CopyMeshDlg( this ) )->show();
// Adaptation - end
case SMESHOp::OpSplitBiQuadratic:
case SMESHOp::OpConvertMeshToQuadratic:
+ case SMESHOp::OpCreateDualMesh:
case SMESHOp::OpCreateBoundaryElements: // create 2D mesh from 3D
+ case SMESHOp::OpCreate2DElements: // create full 2D mesh from 3D
case SMESHOp::OpReorientFaces:
case SMESHOp::OpCreateGeometryGroup:
{
}
case SMESHOp::OpTranslation:
{
+ logAction = true;
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
break; // action forbidden as geometry modified
}
case SMESHOp::OpRotation:
{
+ logAction = true;
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
break; // action forbidden as geometry modified
}
case SMESHOp::OpSymmetry:
{
+ logAction = true;
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
break; // action forbidden as geometry modified
}
case SMESHOp::OpScale:
{
+ logAction = true;
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
break; // action forbidden as geometry modified
case SMESHOp::OpOffset:
{
+ logAction = true;
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
break; // action forbidden as geometry modified
case SMESHOp::OpSewing:
{
+ logAction = true;
if(isStudyLocked()) break;
if ( warnOnGeomModif() )
break; // action forbidden as geometry modified
case SMESHOp::OpMaxElementLength2D:
case SMESHOp::OpEqualFace:
case SMESHOp::OpAspectRatio3D:
+ case SMESHOp::OpWarping3D:
case SMESHOp::OpVolume:
+ case SMESHOp::OpScaledJacobian:
case SMESHOp::OpMaxElementLength3D:
case SMESHOp::OpBareBorderVolume:
case SMESHOp::OpOverConstrainedVolume:
anApp->updateActions(); //SRN: To update a Save button in the toolbar
//updateObjBrowser();
+ if(logAction)
+ {
+ QAction* anAction = action( theCommandID );
+ CAM_Application::logStructuredUserEvent( "Mesh",
+ "Operation",
+ anAction->text(),
+ "activated" );
+ }
return true;
}
pix = resMgr->loadPixmap( "SMESH", tr( QString( "ICON_%1" ).arg( po_id ).toLatin1().data() ), false );
if ( !pix.isNull() )
icon = QIcon( pix );
-
+
QString tooltip = tr( QString( "TOP_%1" ).arg( po_id ).toLatin1().data() ),
menu = tr( QString( "MEN_%1" ).arg( po_id ).toLatin1().data() ),
status_bar = tr( QString( "STB_%1" ).arg( po_id ).toLatin1().data() );
createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
#endif
createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
+ createSMESHAction( SMESHOp::OpImportMESHIO, "IMPORT_MESHIO" );
createSMESHAction( SMESHOp::OpPopupImportUNV, "IMPORT_UNV");
createSMESHAction( SMESHOp::OpPopupImportMED, "IMPORT_MED");
createSMESHAction( SMESHOp::OpPopupImportSTL, "IMPORT_STL" );
createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
#endif
createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
+ createSMESHAction( SMESHOp::OpExportMESHIO, "EXPORT_MESHIO" );
createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
createSMESHAction( SMESHOp::OpMaxElementLength2D, "MAX_ELEMENT_LENGTH_2D", "ICON_MAX_ELEMENT_LENGTH_2D", 0, true );
createSMESHAction( SMESHOp::OpEqualFace, "EQUAL_FACE", "ICON_EQUAL_FACE", 0, true );
createSMESHAction( SMESHOp::OpAspectRatio3D, "ASPECT_3D", "ICON_ASPECT_3D", 0, true );
+ createSMESHAction( SMESHOp::OpWarping3D, "WARP_3D", "ICON_WARP", 0, true);
createSMESHAction( SMESHOp::OpVolume, "VOLUME_3D", "ICON_VOLUME_3D", 0, true );
createSMESHAction( SMESHOp::OpMaxElementLength3D, "MAX_ELEMENT_LENGTH_3D", "ICON_MAX_ELEMENT_LENGTH_3D", 0, true );
createSMESHAction( SMESHOp::OpBareBorderVolume, "BARE_BORDER_VOLUME", "ICON_BARE_BORDER_VOLUME", 0, true );
createSMESHAction( SMESHOp::OpOverConstrainedVolume, "OVER_CONSTRAINED_VOLUME", "ICON_OVER_CONSTRAINED_VOLUME", 0, true );
createSMESHAction( SMESHOp::OpEqualVolume, "EQUAL_VOLUME", "ICON_EQUAL_VOLUME", 0, true );
+ createSMESHAction( SMESHOp::OpScaledJacobian, "SCALED_JACOBIAN", "ICON_SCALED_JACOBIAN", 0, true );
createSMESHAction( SMESHOp::OpOverallMeshQuality, "OVERALL_MESH_QUALITY", "ICON_OVL_MESH_QUALITY" );
createSMESHAction( SMESHOp::OpNode, "NODE", "ICON_DLG_NODE" );
createSMESHAction( SMESHOp::OpRevolution, "REVOLUTION", "ICON_REVOLUTION" );
createSMESHAction( SMESHOp::OpPatternMapping, "MAP", "ICON_MAP" );
createSMESHAction( SMESHOp::OpConvertMeshToQuadratic, "CONV_TO_QUAD", "ICON_CONV_TO_QUAD" );
+ createSMESHAction( SMESHOp::OpCreateDualMesh, "CREATE_DUAL_MESH","ICON_CREATE_DUAL_MESH" );
createSMESHAction( SMESHOp::OpCreateBoundaryElements, "2D_FROM_3D", "ICON_2D_FROM_3D" );
+ createSMESHAction( SMESHOp::OpCreate2DElements, "2D_FROM_3D_ELEMENTS","ICON_2D_FROM_3D_ELEMENTS" );
createSMESHAction( SMESHOp::OpReset, "RESET" );
createSMESHAction( SMESHOp::OpScalarBarProperties, "SCALAR_BAR_PROP" );
<< SMESHOp::OpMinimumAngle << SMESHOp::OpWarpingAngle << SMESHOp::OpSkew
<< SMESHOp::OpMaxElementLength2D << SMESHOp::OpBareBorderFace
<< SMESHOp::OpOverConstrainedFace << SMESHOp::OpEqualFace // face controls
- << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume
+ << SMESHOp::OpAspectRatio3D << SMESHOp::OpVolume << SMESHOp::OpWarping3D
<< SMESHOp::OpMaxElementLength3D << SMESHOp::OpBareBorderVolume
- << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume; // volume controls
+ << SMESHOp::OpOverConstrainedVolume << SMESHOp::OpEqualVolume << SMESHOp::OpScaledJacobian; // volume controls
QActionGroup* aCtrlGroup = new QActionGroup( application()->desktop() );
aCtrlGroup->setExclusive( true );
for( int i = 0; i < aCtrlActions.size(); i++ )
transfId = createMenu( tr( "MEN_TRANSF" ), modifyId, 405 ),
basicPropId = createMenu( tr( "MEN_BASIC_PROPERTIES" ), measureId, -1, 10 );
+ // Import menu
//createMenu( SMESHOp::OpImportDAT, importId, -1 );
createMenu( SMESHOp::OpImportUNV, importId, -1 );
createMenu( SMESHOp::OpImportMED, importId, -1 );
createMenu( SMESHOp::OpImportCGNS, importId, -1 );
#endif
createMenu( SMESHOp::OpImportGMF, importId, -1 );
+ createMenu( SMESHOp::OpImportMESHIO, importId, -1 ); // formats supported by meshio lib
+
+ // Export menu
createMenu( SMESHOp::OpExportDAT, exportId, -1 );
createMenu( SMESHOp::OpExportMED, exportId, -1 );
createMenu( SMESHOp::OpExportUNV, exportId, -1 );
createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
#endif
createMenu( SMESHOp::OpExportGMF, exportId, -1 );
+ createMenu( SMESHOp::OpExportMESHIO, exportId, -1 ); // formats supported by meshio lib
createMenu( separator(), fileId, 10 );
createMenu( SMESHOp::OpDelete, editId, -1 );
createMenu( SMESHOp::OpEditMeshOrSubMesh, meshId, -1 );
createMenu( SMESHOp::OpBuildCompoundMesh, meshId, -1 );
createMenu( SMESHOp::OpCopyMesh, meshId, -1 );
+ createMenu( SMESHOp::OpCreateDualMesh, meshId, -1 );
createMenu( separator(), meshId, -1 );
createMenu( SMESHOp::OpCompute, meshId, -1 );
createMenu( SMESHOp::OpPreCompute, meshId, -1 );
createMenu( SMESHOp::OpEqualFace, faceId, -1 );
createMenu( SMESHOp::OpDeflection2D, faceId, -1 );
createMenu( SMESHOp::OpAspectRatio3D, volumeId, -1 );
+ createMenu( SMESHOp::OpWarping3D, volumeId, -1 );
createMenu( SMESHOp::OpVolume, volumeId, -1 );
createMenu( SMESHOp::OpMaxElementLength3D, volumeId, -1 );
createMenu( SMESHOp::OpBareBorderVolume, volumeId, -1 );
createMenu( SMESHOp::OpOverConstrainedVolume, volumeId, -1 );
createMenu( SMESHOp::OpEqualVolume, volumeId, -1 );
+ createMenu( SMESHOp::OpScaledJacobian, volumeId, -1 );
createMenu( separator(), ctrlId, -1 );
createMenu( SMESHOp::OpReset, ctrlId, -1 );
createMenu( separator(), ctrlId, -1 );
createMenu( SMESHOp::OpConvertMeshToQuadratic, modifyId, -1 );
createMenu( SMESHOp::OpCreateBoundaryElements, modifyId, -1 );
+ createMenu( SMESHOp::OpCreate2DElements, modifyId, -1 );
createMenu( SMESHOp::OpExtrusion, modifyId, -1 );
createMenu( SMESHOp::OpExtrusionAlongAPath, modifyId, -1 );
createMenu( SMESHOp::OpRevolution, modifyId, -1 );
int ctrl3dTb = createTool( tr( "TB_CTRL3D" ), QString( "SMESHVolumeControlsToolbar" ) ) ;
createTool( SMESHOp::OpAspectRatio3D, ctrl3dTb );
+ createTool( SMESHOp::OpWarping3D, ctrl3dTb );
createTool( SMESHOp::OpVolume, ctrl3dTb );
createTool( SMESHOp::OpMaxElementLength3D, ctrl3dTb );
createTool( SMESHOp::OpBareBorderVolume, ctrl3dTb );
createTool( SMESHOp::OpOverConstrainedVolume, ctrl3dTb );
createTool( SMESHOp::OpEqualVolume, ctrl3dTb );
+ createTool( SMESHOp::OpScaledJacobian, ctrl3dTb );
int addElemTb = createTool( tr( "TB_ADD" ), QString( "SMESHAddElementToolbar" ) ) ;
createTool( SMESHOp::OpNode, addElemTb );
int modifyTb = createTool( tr( "TB_MODIFY" ), QString( "SMESHModificationToolbar" ) ) ;
createTool( SMESHOp::OpConvertMeshToQuadratic, modifyTb );
createTool( SMESHOp::OpCreateBoundaryElements, modifyTb );
+ createTool( SMESHOp::OpCreate2DElements, modifyTb );
createTool( SMESHOp::OpExtrusion, modifyTb );
createTool( SMESHOp::OpExtrusionAlongAPath, modifyTb );
createTool( SMESHOp::OpRevolution, modifyTb );
#endif
createPopupItem( SMESHOp::OpPopupExportGMF, OB, mesh_group, only_one_non_empty, anId );
createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
+ createPopupItem( SMESHOp::OpExportMESHIO, OB, mesh_group, only_one_non_empty, anId );
anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
popupMgr()->setRule( action( SMESHOp::OpAspectRatio3D ), "controlMode = 'eAspectRatio3D'", QtxPopupMgr::ToggleRule );
+ popupMgr()->insert ( action( SMESHOp::OpWarping3D ), aSubId, -1 );
+ popupMgr()->setRule( action( SMESHOp::OpWarping3D ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
+ popupMgr()->setRule( action( SMESHOp::OpWarping3D), "controlMode = 'eWarping3D'", QtxPopupMgr::ToggleRule );
+
popupMgr()->insert ( action( SMESHOp::OpVolume ), aSubId, -1 );
popupMgr()->setRule( action( SMESHOp::OpVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
popupMgr()->setRule( action( SMESHOp::OpVolume ), "controlMode = 'eVolume3D'", QtxPopupMgr::ToggleRule );
popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
popupMgr()->setRule( action( SMESHOp::OpEqualVolume ), "controlMode = 'eCoincidentElems3D'", QtxPopupMgr::ToggleRule );
+ popupMgr()->insert ( action( SMESHOp::OpScaledJacobian ), aSubId, -1 );
+ popupMgr()->setRule( action( SMESHOp::OpScaledJacobian ), aMeshInVtkHasVolumes, QtxPopupMgr::VisibleRule );
+ popupMgr()->setRule( action( SMESHOp::OpScaledJacobian ), "controlMode = 'eScaledJacobian'", QtxPopupMgr::ToggleRule );
+
popupMgr()->insert( separator(), anId, -1 );
popupMgr()->insert( action( SMESHOp::OpShowScalarBar ), anId, -1 );
case SMESHOp::OpCreateBoundaryElements: // create 2D mesh as boundary on 3D
op = new SMESHGUI_Make2DFrom3DOp();
break;
+ case SMESHOp::OpCreateDualMesh:
+ op = new SMESHGUI_CreateDualMeshOp();
+ break;
+ case SMESHOp::OpCreate2DElements:
+ op = new SMESHGUI_MakeFull2DFrom3DOp();
+ break;
case SMESHOp::OpReorientFaces:
op = new SMESHGUI_ReorientFacesOp();
break;