-// 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.h"
#include "SMESHGUI_Add0DElemsOnAllNodesDlg.h"
#include "SMESHGUI_AddMeshElementDlg.h"
+#include "SMESHGUI_AddNodeOnSegmentDlg.h"
+#include "SMESHGUI_AddNodeOnFaceDlg.h"
#include "SMESHGUI_AddQuadraticElementDlg.h"
#include "SMESHGUI_BuildCompoundDlg.h"
#include "SMESHGUI_ClippingDlg.h"
#include "SMESHGUI_Hypotheses.h"
#include "SMESHGUI_HypothesesUtils.h"
#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_Preferences_ScalarBarDlg.h"
#include "SMESHGUI_PropertiesDlg.h"
#include "SMESHGUI_RemoveElementsDlg.h"
+#include "SMESHGUI_RemoveNodeReconnectionDlg.h"
#include "SMESHGUI_RemoveNodesDlg.h"
#include "SMESHGUI_RenumberingDlg.h"
#include "SMESHGUI_ReorientFacesDlg.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"
#include "SMESH_ControlsDef.hxx"
#include "SMESH_ScalarBarActor.h"
#include "SMESH_TypeFilter.hxx"
-#include "SMESH_Component_Generator.hxx"
// SALOME GUI includes
#include <LightApp_DataOwner.h>
#include CORBA_CLIENT_HEADER(SMESH_MeshEditor)
#include CORBA_CLIENT_HEADER(SMESH_Measurements)
#include CORBA_CLIENT_HEADER(SMESH_Mesh)
+#include CORBA_CLIENT_HEADER(SMESH_Homard)
// Qt includes
// #define INCLUDE_MENUITEM_DEF // VSR commented ????????
void Control( int theCommandID );
// Definitions
+
//================================================================================
/*!
* \brief Reads meshes from file
theCommandID == SMESHOp::OpPopupImportCGNS ) {
filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
}
- else if ( theCommandID == SMESHOp::OpImportSAUV ||
- theCommandID == SMESHOp::OpPopupImportSAUV ) {
- filter.append( QObject::tr( "SAUV_FILES_FILTER" ) + " (*.sauv *.sauve)" );
- filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
- }
else if ( theCommandID == SMESHOp::OpImportGMF ||
theCommandID == SMESHOp::OpPopupImportGMF ) {
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::OpImportSAUV:
- case SMESHOp::OpPopupImportSAUV:
- {
- // SAUV format
- SMESH::DriverMED_ReadStatus res;
- aMeshes = theComponentMesh->CreateMeshesFromSAUV( filename.toUtf8().constData(), res );
- if ( res != SMESH::DRS_OK ) {
- errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
- arg( QObject::tr( QString( "SMESH_DRS_%1" ).arg( res ).toLatin1().data() ) ) );
- }
- break;
- }
case SMESHOp::OpImportGMF:
case SMESHOp::OpPopupImportGMF:
{
}
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::OpPopupExportSTL );
const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
theCommandID == SMESHOp::OpPopupExportCGNS );
- const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
- theCommandID == SMESHOp::OpPopupExportSAUV );
const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
theCommandID == SMESHOp::OpPopupExportGMF );
+ const bool isMESHIO = (theCommandID == SMESHOp::OpExportMESHIO);
+
+ if (isMESHIO && !SMESHGUI_Meshio::IsMeshioInstalled())
+ {
+ return;
+ }
- const bool multiMeshSupported = ( isMED || isCGNS ); // file can hold several meshes
+ 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 || isSAUV ) // 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 ( isSAUV )
- {
- format = "SAUV";
- notSupportedElemTypes.push_back( SMESH::Entity_Ball );
- notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Triangle );
- notSupportedElemTypes.push_back( SMESH::Entity_BiQuad_Quadrangle );
- notSupportedElemTypes.push_back( SMESH::Entity_TriQuad_Hexa );
- notSupportedElemTypes.push_back( SMESH::Entity_Hexagonal_Prism );
- notSupportedElemTypes.push_back( SMESH::Entity_Polygon );
- notSupportedElemTypes.push_back( SMESH::Entity_Quad_Polygon );
- notSupportedElemTypes.push_back( SMESH::Entity_Polyhedra );
- }
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 toCreateGroups = resMgr->booleanValue( "SMESH", "auto_groups", false );
bool toOverwrite = true;
bool toFindOutDim = true;
+ bool saveNumbers = resMgr->booleanValue( "SMESH", "med_save_numbers", true );
bool toRenumber = true;
double zTol = resMgr->doubleValue( "SMESH", "med_ztolerance", 0. );
}
delete fd;
}
- else if ( isMED || isSAUV ) // Export to MED or SAUV
+ else if ( isMED ) // Export to MED
{
int defaultVersion = 0;
QMap<QString, int> aFilterMap;
- if ( isMED ) {
- //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
- //QString vmed (aMesh->GetVersionString(-1, 2));
- SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
- if ( mvok->length() > 0)
- defaultVersion = mvok[0]; // the current version to set the default filter on it
- for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
- {
- QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
- aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
- }
- }
- else { // isSAUV
- aFilterMap.insert("All files (*)", -1 );
- aFilterMap.insert("SAUV files (*.sauv)", defaultVersion ); // 0 = default filter (defaultVersion)
- aFilterMap.insert("SAUV files (*.sauve)", -1 );
+ //filters << QObject::tr( "MED_FILES_FILTER" ) + " (*.med)";
+ //QString vmed (aMesh->GetVersionString(-1, 2));
+ SMESH::long_array_var mvok = aMesh->GetMEDVersionsCompatibleForAppend();
+ if ( mvok->length() > 0)
+ defaultVersion = mvok[0]; // the current version to set the default filter on it
+ for ( CORBA::ULong i = 0; i < mvok->length(); ++i )
+ {
+ QString vs = (char*)( SMESH_Comment( mvok[i]/10 ) << "." << mvok[i]%10 );
+ aFilterMap.insert( QObject::tr( "MED_VX_FILES_FILTER" ).arg( vs ) + " (*.med)", mvok[i]);
}
QStringList filters;
QMap<QString, int>::const_iterator it = aFilterMap.begin();
aDefaultFilter = it.key();
}
QStringList checkBoxes;
- checkBoxes << QObject::tr("SMESH_AUTO_GROUPS") << QObject::tr("SMESH_AUTO_DIM");
+ checkBoxes << QObject::tr("SMESH_AUTO_GROUPS")
+ << QObject::tr("SMESH_AUTO_DIM")
+ << QObject::tr("SMESH_MED_SAVE_NUMS");
SMESHGUI_FieldSelectorWdg* fieldSelWdg = new SMESHGUI_FieldSelectorWdg();
QList< QWidget* > wdgList;
fd->selectNameFilter( aDefaultFilter );
fd->SetChecked( toCreateGroups, 0 );
fd->SetChecked( toFindOutDim, 1 );
+ fd->SetChecked( saveNumbers, 2 );
if ( !anInitialPath.isEmpty() )
fd->setDirectory( anInitialPath );
fd->selectFile(aMeshName);
}
toCreateGroups = fd->IsChecked(0);
toFindOutDim = fd->IsChecked(1);
+ saveNumbers = fd->IsChecked(2);
zTol = zTolCheck->isChecked() ? zTolSpin->value() : -1;
fieldSelWdg->GetSelectedFields();
if ( resMgr ) resMgr->setValue( "SMESH", "enable_ztolerance", zTolCheck->isChecked() );
delete zTolWdg;
delete fd;
}
+ else if (isMESHIO)
+ {
+ if (SMESHGUI_Meshio::CheckMeshCount(aMeshList))
+ {
+ aFilename = SMESHGUI_Meshio::GetFileName(aSelectedFilter);
+ MESSAGE("aSelectedFilter: " << aSelectedFilter.toStdString());
+ }
+ }
else
{
return;
// }
if ( isMED && isOkToWrite )
{
- const bool saveNumbers = resMgr->booleanValue( "SMESH", "med_save_numbers", true );
aMeshIter = aMeshList.begin();
for( int aMeshIndex = 0; aMeshIter != aMeshList.end(); aMeshIter++, aMeshIndex++ )
{
fields, geoAssFields.toLatin1().data(), zTol, saveNumbers );
}
}
- else if ( isSAUV )
- {
- for( aMeshIter = aMeshList.begin(); aMeshIter != aMeshList.end(); aMeshIter++ )
- {
- SMESH::SMESH_Mesh_var aMeshItem = SMESH::SMESH_Mesh::_narrow( (*aMeshIter).first );
- if( !aMeshItem->_is_nil() )
- aMeshItem->ExportSAUV( aFilename.toUtf8().data(), toCreateGroups );
- }
- }
else if ( isDAT )
{
if ( aMeshOrGroup->_is_equivalent( aMesh ))
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 if (exText.startsWith("MESHIO"))
+ {
+ SUIT_MessageBox::warning(SMESHGUI::desktop(),
+ QObject::tr("SMESH_WRN_WARNING"),
+ QObject::tr("SMESH_EXPORT_FAILED_SHORT") + "\n\n" + exText);
+ }
else
SUIT_MessageBox::warning(SMESHGUI::desktop(),
QObject::tr("SMESH_WRN_WARNING"),
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 );
aStudyBuilder->RemoveObjectWithChildren( SO );
}
else {// default action: remove SObject from the study
+ // Find Sub-Meshes and Group and delete corresopning visual objects and actors
+ _PTR(ChildIterator) it1 = aStudy->NewChildIterator(SO);
+ for (it1->InitEx(false); it1->More(); it1->Next()) {
+ _PTR(SObject) SObj = it1->Value();
+ if (!SObj) continue;
+ if (SObj->FindAttribute(anAttr, "AttributeIOR")) {
+ SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow(SMESH::SObjectToObject(SObj));
+ SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow(SMESH::SObjectToObject(SObj));
+ if (!aGroup->_is_nil() || !aSubMesh->_is_nil()) {
+ SMESH::RemoveVisualObjectWithActors(SObj->GetID().c_str(), true);
+ }
+ }
+ }
// san - it's no use opening a transaction here until UNDO/REDO is provided in SMESH
//SUIT_Operation *op = new SALOMEGUI_ImportOperation(myActiveStudy);
//op->start();
if ( CORBA::is_nil( myComponentSMESH ) )
{
CORBA::Boolean anIsEmbeddedMode;
- SALOME_NamingService_Abstract *ns = SalomeApp_Application::namingService();
- if( dynamic_cast<SALOME_NamingService *>(ns) )
- myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
- else
- {
- Engines::EngineComponent_var comp = RetrieveSMESHInstance();
- myComponentSMESH = SMESH::SMESH_Gen::_narrow(comp);
- }
-
+ 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::OpImportMED:
case SMESHOp::OpImportSTL:
case SMESHOp::OpImportCGNS:
- case SMESHOp::OpImportSAUV:
case SMESHOp::OpImportGMF:
+ case SMESHOp::OpImportMESHIO:
case SMESHOp::OpPopupImportDAT:
case SMESHOp::OpPopupImportUNV:
case SMESHOp::OpPopupImportMED:
case SMESHOp::OpPopupImportSTL:
case SMESHOp::OpPopupImportCGNS:
- case SMESHOp::OpPopupImportSAUV:
case SMESHOp::OpPopupImportGMF:
{
if(isStudyLocked()) break;
case SMESHOp::OpExportUNV:
case SMESHOp::OpExportSTL:
case SMESHOp::OpExportCGNS:
- case SMESHOp::OpExportSAUV:
case SMESHOp::OpExportGMF:
+ case SMESHOp::OpExportMESHIO:
case SMESHOp::OpPopupExportDAT:
case SMESHOp::OpPopupExportMED:
case SMESHOp::OpPopupExportUNV:
case SMESHOp::OpPopupExportSTL:
case SMESHOp::OpPopupExportCGNS:
- case SMESHOp::OpPopupExportSAUV:
case SMESHOp::OpPopupExportGMF:
{
::ExportMeshToFile(theCommandID);
break;
case SMESHOp::OpCopyMesh:
{
+ logAction = true;
if (isStudyLocked()) break;
EmitSignalDeactivateDialog();
( new SMESHGUI_CopyMeshDlg( this ) )->show();
( new SMESHGUI_MG_ADAPTDRIVER( this, model, isCreation ))->show();
break;
}
+#endif
+#ifndef DISABLE_HOMARD_ADAPT
+ case SMESHOp::OpHomardAdapt:
+ {
+ if ( isStudyLocked() )
+ break;
+ EmitSignalDeactivateDialog();
+
+ SALOME::GenericObj_wrap< SMESHHOMARD::HOMARD_Gen > homardGen;
+ try {
+ homardGen = GetSMESHGen()->CreateHOMARD_ADAPT();
+ }
+ catch ( const SALOME::SALOME_Exception& S_ex ) {
+ SUIT_MessageBox::critical(SMESHGUI::desktop(),
+ QObject::tr("SMESH_ERROR"),
+ QObject::tr(S_ex.details.text.in()));
+ }
+ if (!homardGen->_is_nil()) {
+ SMESHGUI_HomardAdaptDlg *aDlg = new SMESHGUI_HomardAdaptDlg(homardGen);
+ aDlg->show();
+ }
+ break;
+ }
#endif
// 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:
{
}
break;
}
+ case SMESHOp::OpRemoveNodeWithReconn:
+ {
+ if(isStudyLocked()) break;
+ if ( warnOnGeomModif() )
+ break; // action forbidden as geometry modified
+ startOperation( SMESHOp::OpRemoveNodeWithReconn );
+ break;
+ }
case SMESHOp::OpRemoveElements: // REMOVES ELEMENTS
{
if(isStudyLocked()) break;
}
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
startOperation( SMESHOp::OpMoveNode );
break;
+ case SMESHOp::OpMoveNodeInteractive:
+ if ( warnOnGeomModif() )
+ break; // action forbidden as geometry modified
+ startOperation( SMESHOp::OpMoveNodeInteractive );
+ break;
+
+ case SMESHOp::OpSplitEdgeInteract:
+ if ( warnOnGeomModif() )
+ break; // action forbidden as geometry modified
+ startOperation( SMESHOp::OpSplitEdgeInteract );
+ break;
+
+ case SMESHOp::OpSplitFaceInteract:
+ if ( warnOnGeomModif() )
+ break; // action forbidden as geometry modified
+ startOperation( SMESHOp::OpSplitFaceInteract );
+ break;
+
case SMESHOp::OpDuplicateNodes:
{
if(isStudyLocked()) break;
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;
}
#ifdef WITH_CGNS
createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
#endif
- createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
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" );
#ifdef WITH_CGNS
createSMESHAction( SMESHOp::OpPopupImportCGNS, "IMPORT_CGNS" );
#endif
- createSMESHAction( SMESHOp::OpPopupImportSAUV, "IMPORT_SAUV" );
createSMESHAction( SMESHOp::OpPopupImportGMF, "IMPORT_GMF" );
createSMESHAction( SMESHOp::OpExportDAT, "DAT" );
#ifdef WITH_CGNS
createSMESHAction( SMESHOp::OpExportCGNS, "CGNS");
#endif
- createSMESHAction( SMESHOp::OpExportSAUV, "SAUV");
createSMESHAction( SMESHOp::OpExportGMF, "GMF" );
+ createSMESHAction( SMESHOp::OpExportMESHIO, "EXPORT_MESHIO" );
createSMESHAction( SMESHOp::OpPopupExportDAT, "DAT" );
createSMESHAction( SMESHOp::OpPopupExportMED, "MED" );
createSMESHAction( SMESHOp::OpPopupExportUNV, "UNV" );
#ifdef WITH_CGNS
createSMESHAction( SMESHOp::OpPopupExportCGNS, "CGNS");
#endif
- createSMESHAction( SMESHOp::OpPopupExportSAUV, "SAUV");
createSMESHAction( SMESHOp::OpPopupExportGMF, "GMF" );
createSMESHAction( SMESHOp::OpFileInformation, "FILE_INFO" );
createSMESHAction( SMESHOp::OpDelete, "DELETE", "ICON_DELETE", Qt::Key_Delete );
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::OpRemoveNodes, "REMOVE_NODES", "ICON_DLG_REM_NODE" );
createSMESHAction( SMESHOp::OpRemoveElements, "REMOVE_ELEMENTS", "ICON_DLG_REM_ELEMENT" );
createSMESHAction( SMESHOp::OpRemoveOrphanNodes, "REMOVE_ORPHAN_NODES", "ICON_DLG_REM_ORPHAN_NODES" );
+ createSMESHAction( SMESHOp::OpRemoveNodeWithReconn, "REMOVE_NODE_RECON", "ICON_REM_NODE_RECON" );
createSMESHAction( SMESHOp::OpClearMesh, "CLEAR_MESH", "ICON_CLEAR_MESH" );
//createSMESHAction( SMESHOp::OpRenumberingNodes, "RENUM_NODES", "ICON_DLG_RENUMBERING_NODES" );
createSMESHAction( SMESHOp::OpMergeNodes, "MERGE", "ICON_SMESH_MERGE_NODES" );
createSMESHAction( SMESHOp::OpMergeElements, "MERGE_ELEMENTS", "ICON_DLG_MERGE_ELEMENTS" );
createSMESHAction( SMESHOp::OpMoveNode, "MESH_THROU_POINT","ICON_DLG_MOVE_NODE" );
+ createSMESHAction( SMESHOp::OpMoveNodeInteractive, "MOVE_NODE_INTRCT","ICON_DLG_MOVE_NODE_INTERACTIVE" );
+ createSMESHAction( SMESHOp::OpSplitEdgeInteract, "SPLIT_DIAG_INTRC","ICON_SPLIT_DIAG_INTERACTIVE" );
+ createSMESHAction( SMESHOp::OpSplitFaceInteract, "SPLIT_FACE_INTRC","ICON_SPLIT_FACE_INTERACTIVE" );
createSMESHAction( SMESHOp::OpDuplicateNodes, "DUPLICATE_NODES", "ICON_SMESH_DUPLICATE_NODES" );
createSMESHAction( SMESHOp::OpDiagonalInversion, "INV", "ICON_DLG_MESH_DIAGONAL" );
createSMESHAction( SMESHOp::OpUnionOfTwoTriangle, "UNION2", "ICON_UNION2TRI" );
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" );
// Adaptation - begin
#ifndef DISABLE_MG_ADAPT
createSMESHAction( SMESHOp::OpMGAdapt, "MG_ADAPT", "ICON_MG_ADAPT" );
+#endif
+#ifndef DISABLE_HOMARD_ADAPT
+ createSMESHAction( SMESHOp::OpHomardAdapt, "HOMARD_ADAPT", "ICON_HOMARD_ADAPT" );
#endif
// Adaptation - end
<< 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++ )
meshId = createMenu( tr( "MEN_MESH" ), -1, 70, 10 ),
ctrlId = createMenu( tr( "MEN_CTRL" ), -1, 60, 10 ),
modifyId = createMenu( tr( "MEN_MODIFY" ), -1, 40, 10 ),
-#ifndef DISABLE_MG_ADAPT
+#if !defined(DISABLE_MG_ADAPT) || !defined(DISABLE_HOMARD_ADAPT)
adaptId = createMenu( tr( "MEN_ADAPT" ), -1, 80, 10 ),
#endif
measureId = createMenu( tr( "MEN_MEASURE" ), -1, 50, 10 ),
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 );
#ifdef WITH_CGNS
createMenu( SMESHOp::OpImportCGNS, importId, -1 );
#endif
- createMenu( SMESHOp::OpImportSAUV, importId, -1 );
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 );
#ifdef WITH_CGNS
createMenu( SMESHOp::OpExportCGNS, exportId, -1 );
#endif
- createMenu( SMESHOp::OpExportSAUV, exportId, -1 );
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::OpBiQuadraticPentahedron, addId, -1 );
createMenu( SMESHOp::OpQuadraticHexahedron, addId, -1 );
createMenu( SMESHOp::OpTriQuadraticHexahedron, addId, -1 );
-
- createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
- createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
- createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
- createMenu( separator(), removeId, -1 );
- createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
- createMenu( separator(), removeId, -1 );
- createMenu( SMESHOp::OpClearMesh, removeId, -1 );
+ createMenu( separator(), addId, -1 );
+ createMenu( SMESHOp::OpSplitEdgeInteract, addId, -1 );
+ createMenu( SMESHOp::OpSplitFaceInteract, addId, -1 );
+
+ createMenu( SMESHOp::OpRemoveNodes, removeId, -1 );
+ createMenu( SMESHOp::OpRemoveElements, removeId, -1 );
+ createMenu( SMESHOp::OpRemoveOrphanNodes, removeId, -1 );
+ createMenu( SMESHOp::OpRemoveNodeWithReconn, removeId, -1 );
+ createMenu( separator(), removeId, -1 );
+ createMenu( SMESHOp::OpDeleteGroup, removeId, -1 );
+ createMenu( separator(), removeId, -1 );
+ createMenu( SMESHOp::OpClearMesh, removeId, -1 );
//createMenu( SMESHOp::OpRenumberingNodes, renumId, -1 );
//createMenu( SMESHOp::OpRenumberingElements, renumId, -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 );
// Adaptation - begin
#ifndef DISABLE_MG_ADAPT
createMenu( SMESHOp::OpMGAdapt, adaptId, -1 );
+#endif
+#ifndef DISABLE_HOMARD_ADAPT
+ createMenu( SMESHOp::OpHomardAdapt, adaptId, -1 );
#endif
// Adaptation - end
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 );
createTool( SMESHOp::OpSmoothing, modifyTb );
createTool( SMESHOp::OpPatternMapping, modifyTb );
+ int interactTb = createTool( tr( "TB_INTERACT" ), QString( "SMESHInteractiveToolbar" ) ) ;
+ createTool( SMESHOp::OpMoveNodeInteractive, interactTb );
+ createTool( SMESHOp::OpRemoveNodeWithReconn, interactTb );
+ createTool( SMESHOp::OpSplitEdgeInteract, interactTb );
+ createTool( SMESHOp::OpSplitFaceInteract, interactTb );
+
// Adaptation - begin
-#ifndef DISABLE_MG_ADAPT
+#if !defined(DISABLE_MG_ADAPT) || !defined(DISABLE_HOMARD_ADAPT)
int adaptTb = createTool( tr( "TB_ADAPTATION" ), QString( "SMESHAdaptationToolbar" ) ) ;
+#endif
+#ifndef DISABLE_MG_ADAPT
createTool( SMESHOp::OpMGAdapt, adaptTb );
+#endif
+#ifndef DISABLE_HOMARD_ADAPT
+ createTool( SMESHOp::OpHomardAdapt, adaptTb );
#endif
// Adaptation - end
createPopupItem( SMESHOp::OpCreateBoundaryElements, OB, mesh_group, "&& selcount=1 && dim>=2");
// Adaptation - begin
-#ifndef DISABLE_MG_ADAPT
popupMgr()->insert( separator(), -1, 0 );
+#ifndef DISABLE_MG_ADAPT
createPopupItem( SMESHOp::OpMGAdapt, OB, mesh );
- popupMgr()->insert( separator(), -1, 0 );
#endif
+#ifndef DISABLE_HOMARD_ADAPT
+ createPopupItem( SMESHOp::OpHomardAdapt, OB, mesh );
+#endif
+ popupMgr()->insert( separator(), -1, 0 );
// Adaptation - end
QString only_one_non_empty = QString( " && %1=1 && numberOfNodes>0" ).arg( dc );
#ifdef WITH_CGNS
createPopupItem( SMESHOp::OpPopupExportCGNS, OB, mesh_group, multiple_non_empty, anId );
#endif
- createPopupItem( SMESHOp::OpPopupExportSAUV, OB, mesh_group, only_one_non_empty, anId );
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 );
#ifdef WITH_CGNS
createPopupItem( SMESHOp::OpPopupImportCGNS, OB, smesh, "", anId );
#endif
- createPopupItem( SMESHOp::OpPopupImportSAUV, OB, smesh, "", anId );
createPopupItem( SMESHOp::OpPopupImportGMF, OB, smesh, "", anId );
createPopupItem( SMESHOp::OpPopupImportDAT, OB, smesh, "", anId );
popupMgr()->insert( separator(), -1, 0 );
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 );
<< wrap("MED", "li")
<< wrap("STL", "li")
<< wrap("CGNS", "li")
- << wrap("SAUV", "li")
<< wrap("GMF", "li");
lab = tr("INFO_AVAILABLE_FORMATS") + ":" + wrap(items.join(""), "ul");
items.clear();
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;
case SMESHOp::OpMoveNode: // Make mesh pass through point
op = new SMESHGUI_MakeNodeAtPointOp();
break;
+ case SMESHOp::OpMoveNodeInteractive: // Make mesh pass through point / by mouse
+ op = new SMESHGUI_MakeNodeAtPointOp( 2 );
+ break;
+ case SMESHOp::OpRemoveNodeWithReconn:
+ op = new SMESHGUI_RemoveNodeReconnectionOp();
+ break;
+ case SMESHOp::OpSplitEdgeInteract:
+ op = new SMESHGUI_AddNodeOnSegmentOp();
+ break;
+ case SMESHOp::OpSplitFaceInteract:
+ op = new SMESHGUI_AddNodeOnFaceOp();
+ break;
case SMESHOp::OpElem0DOnElemNodes: // Create 0D elements on all nodes
op = new SMESHGUI_Add0DElemsOnAllNodesOp();
break;