ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-11-11 16:19:16 +05:00
Code Issues Packages Projects Releases Wiki Activity

Merge tag 'V8_3_0a2' into ngr/python3_dev

Browse Source 
Version 8.3.0 alpha 2
This commit is contained in:
Nicolas Geimer 2017-03-20 18:20:10 +01:00
commit 0003e6b4fc
30 changed files with 1006 additions and 572 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
doc/salome/gui/SMESH/images/mergenodes.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 40 KiB

After

Width:  |  Height:  |  Size: 40 KiB

BIN
doc/salome/gui/SMESH/images/mergenodes_auto.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 28 KiB

After

Width:  |  Height:  |  Size: 30 KiB

3
doc/salome/gui/SMESH/input/merging_nodes.doc
View File

@ -26,6 +26,9 @@ merging.</li>
cells</b> check-box prevents merging medium nodes of quadratic
elements with corner nodes. This check-box is enabled provided
that the selected mesh includes quadratic elements.</li>
<li>Activation of <b>Avoid making holes</b> check-box prevents merging
nodes that make elements invalid (but not degenerated) and hence
removed. Thus, no holes in place of removed elements appear. </li>
<li><b>Exclude groups from detection</b> group allows to ignore the
nodes which belong to the specified mesh groups. This control is
active provided that the mesh includes groups.</li>

3
idl/SMESH_MeshEditor.idl
View File

@ -689,7 +689,8 @@ module SMESH
raises (SALOME::SALOME_Exception);
void MergeNodes (in array_of_long_array GroupsOfNodes,
in SMESH::ListOfIDSources NodesToKeep)
in SMESH::ListOfIDSources NodesToKeep,
in boolean AvoidMakingHoles)
raises (SALOME::SALOME_Exception);
/*!

52
src/DriverSTL/DriverSTL_R_SMDS_Mesh.cxx
View File

@ -69,7 +69,7 @@ namespace
};
typedef NCollection_DataMap<gp_Pnt,SMDS_MeshNode*,Hasher> TDataMapOfPntNodePtr;
const int HEADER_SIZE = 84;
const int HEADER_SIZE = 84; // 80 chars + int
const int SIZEOF_STL_FACET = 50;
const int ASCII_LINES_PER_FACET = 7;
const int SIZE_OF_FLOAT = 4;
@ -150,11 +150,12 @@ Driver_Mesh::Status DriverSTL_R_SMDS_Mesh::Perform()
static Standard_Real readFloat(SMESH_File& theFile)
{
union {
Standard_Boolean i;
Standard_ShortReal f;
int i;
float f;
} u;
const char* c = theFile;
u.i = 0;
u.i = c[0] & 0xFF;
u.i |= (c[1] & 0xFF) << 0x08;
u.i |= (c[2] & 0xFF) << 0x10;
@ -205,30 +206,48 @@ static SMDS_MeshNode* readNode(SMESH_File& theFile,
//=======================================================================
//function : readAscii
//purpose :
//purpose :
//=======================================================================
Driver_Mesh::Status DriverSTL_R_SMDS_Mesh::readAscii(SMESH_File& theFile) const
{
Status aResult = DRS_OK;
// get a solid name
if ( strncmp( "solid ", theFile, strlen("solid ")) == 0 ) // not empty
{
const char * header = theFile;
std::string& name = const_cast<std::string&>( myName );
for ( header += strlen("solid "); !iscntrl( *header ); ++header )
name.push_back( *header );
std::string::iterator i = name.begin();
while ( i != name.end() && isspace( *i )) ++i;
name.erase( name.begin(), i );
size_t n = name.size();
while ( n > 0 && isspace( name[ n - 1 ] )) --n;
name.resize( n );
}
// get the file size
long filesize = theFile.size();
theFile.close();
// Open the file
// Open the file
FILE* file = fopen( myFile.c_str(),"r");
// count the number of lines
Standard_Integer nbLines = 0;
for (long ipos = 0; ipos < filesize; ++ipos) {
for (long ipos = 0; ipos < filesize; ++ipos)
{
if (getc(file) == '\n')
nbLines++;
}
// go back to the beginning of the file
rewind(file);
Standard_Integer nbTri = (nbLines / ASCII_LINES_PER_FACET);
TDataMapOfPntNodePtr uniqnodes;
@ -236,8 +255,8 @@ Driver_Mesh::Status DriverSTL_R_SMDS_Mesh::readAscii(SMESH_File& theFile) const
while (getc(file) != '\n');
// main reading
for (Standard_Integer iTri = 0; iTri < nbTri; ++iTri) {
for (Standard_Integer iTri = 0; iTri < nbTri; ++iTri)
{
// skipping the facet normal
Standard_ShortReal normal[3];
fscanf(file,"%*s %*s %f %f %f\n",&normal[0],&normal[1],&normal[2]);
@ -278,7 +297,7 @@ Driver_Mesh::Status DriverSTL_R_SMDS_Mesh::readBinary(SMESH_File& file) const
long filesize = file.size();
if ( (filesize - HEADER_SIZE) % SIZEOF_STL_FACET !=0
if ( (filesize - HEADER_SIZE) % SIZEOF_STL_FACET != 0
// Commented to allow reading small files (ex: 1 face)
/*|| (filesize < STL_MIN_FILE_SIZE)*/) {
Standard_NoMoreObject::Raise("DriverSTL_R_SMDS_MESH::readBinary (wrong file size)");
@ -288,6 +307,19 @@ Driver_Mesh::Status DriverSTL_R_SMDS_Mesh::readBinary(SMESH_File& file) const
// sometimes it is wrong, and with this technique we don't need to swap endians for integer
Standard_Integer nbTri = ((filesize - HEADER_SIZE) / SIZEOF_STL_FACET);
// get a solid name
if ( strncmp( "name: ", file, strlen("name: ")) == 0 ) // name present
{
const char * header = file;
std::string& name = const_cast<std::string&>( myName );
header += strlen("name: ");
name.assign( header, HEADER_SIZE - strlen("name: ") - 4);
size_t n = name.size();
while ( n > 0 && isspace( name[ n - 1 ] )) --n;
name.resize( n );
}
// skip the header
file += HEADER_SIZE;

12
src/DriverSTL/DriverSTL_R_SMDS_Mesh.h
View File

@ -35,16 +35,18 @@ class MESHDRIVERSTL_EXPORT DriverSTL_R_SMDS_Mesh: public Driver_SMDS_Mesh
DriverSTL_R_SMDS_Mesh();
virtual Status Perform();
void SetIsCreateFaces( const bool theIsCreate = true );
std::string GetName() const { return myName; }
private:
// PRIVATE METHODS
Status readAscii (SMESH_File& file) const;
Status readBinary(SMESH_File& file) const;
Status readAscii (SMESH_File& file) const;
Status readBinary(SMESH_File& file) const;
private:
// PRIVATE FIELDS
bool myIsCreateFaces;
bool myIsAscii;
bool myIsCreateFaces;
bool myIsAscii;
std::string myName;
};
#endif

13
src/DriverSTL/DriverSTL_W_SMDS_Mesh.cxx
View File

@ -176,7 +176,7 @@ static void writeFloat( const Standard_ShortReal& theVal, SMESH_File& ofile)
{
union {
Standard_ShortReal f;
char c[4];
char c[4];
} u;
u.f = theVal;
@ -485,7 +485,8 @@ Driver_Mesh::Status DriverSTL_W_SMDS_Mesh::writeAscii() const
SMESH_File aFile( myFile, /*openForReading=*/false );
aFile.openForWriting();
std::string buf("solid\n");
std::string buf("solid ");
buf += myName + "\n";
aFile.writeRaw( buf.c_str(), buf.size() );
char sval[128];
@ -520,7 +521,8 @@ Driver_Mesh::Status DriverSTL_W_SMDS_Mesh::writeAscii() const
" endfacet\n", 21 );
}
}
aFile.writeRaw ("endsolid\n" , 9 );
buf = "endsolid " + myName + "\n";
aFile.writeRaw( buf.c_str(), buf.size() );
return aResult;
}
@ -554,6 +556,11 @@ Driver_Mesh::Status DriverSTL_W_SMDS_Mesh::writeBinary() const
}
}
std::string sval( LABEL_SIZE, ' ' );
if ( !myName.empty() )
{
sval = "name: " + myName;
sval.resize( LABEL_SIZE, ' ' );
}
aFile.write( sval.c_str(), LABEL_SIZE );
// write number of triangles

4
src/DriverSTL/DriverSTL_W_SMDS_Mesh.h
View File

@ -45,6 +45,7 @@ class MESHDRIVERSTL_EXPORT DriverSTL_W_SMDS_Mesh: public Driver_SMDS_Mesh
~DriverSTL_W_SMDS_Mesh();
virtual Status Perform();
void SetIsAscii( const bool theIsAscii = false );
void SetName( const std::string name ) { myName = name; }
private:
// PRIVATE METHODS
@ -56,7 +57,8 @@ class MESHDRIVERSTL_EXPORT DriverSTL_W_SMDS_Mesh: public Driver_SMDS_Mesh
private:
// PRIVATE FIELDS
bool myIsAscii;
bool myIsAscii;
std::string myName;
int myNbVolumeTrias;
std::vector<const SMDS_MeshElement*> myVolumeFacets; // tmp faces
};

24
src/SMDS/SMDS_VolumeTool.cxx
View File

@ -471,8 +471,9 @@ SMDS_VolumeTool::~SMDS_VolumeTool()
//purpose : Set volume to iterate on
//=======================================================================
bool SMDS_VolumeTool::Set (const SMDS_MeshElement* theVolume,
const bool ignoreCentralNodes)
bool SMDS_VolumeTool::Set (const SMDS_MeshElement* theVolume,
const bool ignoreCentralNodes,
const std::vector<const SMDS_MeshNode*>* otherNodes)
{
// reset fields
myVolume = 0;
@ -510,11 +511,22 @@ bool SMDS_VolumeTool::Set (const SMDS_MeshElement* theVolume,
}
// set nodes
int iNode = 0;
myVolumeNodes.resize( myVolume->NbNodes() );
SMDS_ElemIteratorPtr nodeIt = myVolume->nodesIterator();
while ( nodeIt->more() )
myVolumeNodes[ iNode++ ] = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
if ( otherNodes )
{
if ( otherNodes->size() != myVolumeNodes.size() )
return ( myVolume = 0 );
for ( size_t i = 0; i < otherNodes->size(); ++i )
if ( ! ( myVolumeNodes[i] = (*otherNodes)[0] ))
return ( myVolume = 0 );
}
else
{
int iNode = 0;
SMDS_ElemIteratorPtr nodeIt = myVolume->nodesIterator();
while ( nodeIt->more() )
myVolumeNodes[ iNode++ ] = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
}
// check validity
if ( !setFace(0) )

16
src/SMDS/SMDS_VolumeTool.hxx
View File

@ -58,15 +58,17 @@ class SMDS_EXPORT SMDS_VolumeTool
SMDS_VolumeTool ();
~SMDS_VolumeTool ();
SMDS_VolumeTool (const SMDS_MeshElement* theVolume,
const bool ignoreCentralNodes=true);
SMDS_VolumeTool( const SMDS_MeshElement* theVolume,
const bool ignoreCentralNodes = true);
bool Set (const SMDS_MeshElement* theVolume,
const bool ignoreCentralNodes=true);
bool Set( const SMDS_MeshElement* theVolume,
const bool ignoreCentralNodes = true,
const std::vector<const SMDS_MeshNode*>* nodes = 0);
// Set volume.
// Return false if theVolume is not of type SMDSAbs_Volume.
// ignoreCentralNodes makes skip nodes at face centers when returning
// nodes of faces of SMDSEntity_TriQuad_Hexa
// nodes of faces of SMDSEntity_TriQuad_Hexa.
// alternative nodes can be provided
const SMDS_MeshVolume* Element() const;
// return element
@ -91,10 +93,10 @@ class SMDS_EXPORT SMDS_VolumeTool
// top and bottom faces are reversed.
// Result of IsForward() and methods returning nodes change
const SMDS_MeshNode** GetNodes() { return &myVolumeNodes[0]; }
const SMDS_MeshNode** GetNodes() const { return (const SMDS_MeshNode**) &myVolumeNodes[0]; }
// Return array of volume nodes
int NbNodes() { return myVolumeNodes.size(); }
int NbNodes() const { return myVolumeNodes.size(); }
// Return array of volume nodes
double GetSize() const;

6
src/SMESH/SMESH_Mesh.cxx
View File

@ -559,7 +559,7 @@ int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName)
//purpose :
//=======================================================================
int SMESH_Mesh::STLToMesh(const char* theFileName)
std::string SMESH_Mesh::STLToMesh(const char* theFileName)
{
if(_isShapeToMesh)
throw SALOME_Exception(LOCALIZED("a shape to mesh has already been defined"));
@ -571,7 +571,7 @@ int SMESH_Mesh::STLToMesh(const char* theFileName)
myReader.SetMeshId(-1);
myReader.Perform();
return 1;
return myReader.GetName();
}
//================================================================================
@ -1560,6 +1560,7 @@ void SMESH_Mesh::ExportUNV(const char * file,
void SMESH_Mesh::ExportSTL(const char * file,
const bool isascii,
const char * name,
const SMESHDS_Mesh* meshPart) throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
@ -1568,6 +1569,7 @@ void SMESH_Mesh::ExportSTL(const char * file,
myWriter.SetIsAscii( isascii );
myWriter.SetMesh( meshPart ? (SMESHDS_Mesh*) meshPart : _myMeshDS);
myWriter.SetMeshId(_id);
if ( name ) myWriter.SetName( name );
myWriter.Perform();
}

3
src/SMESH/SMESH_Mesh.hxx
View File

@ -121,7 +121,7 @@ class SMESH_EXPORT SMESH_Mesh
int MEDToMesh(const char* theFileName, const char* theMeshName);
int STLToMesh(const char* theFileName);
std::string STLToMesh(const char* theFileName);
int CGNSToMesh(const char* theFileName, const int theMeshIndex, std::string& theMeshName);
@ -263,6 +263,7 @@ class SMESH_EXPORT SMESH_Mesh
const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
void ExportSTL(const char * file,
const bool isascii,
const char * name = 0,
const SMESHDS_Mesh* meshPart = 0) throw(SALOME_Exception);
void ExportCGNS(const char * file,
const SMESHDS_Mesh* mesh,

1001
src/SMESH/SMESH_MeshEditor.cxx
View File

File diff suppressed because it is too large Load Diff

31
src/SMESH/SMESH_MeshEditor.hxx
View File

@ -83,11 +83,12 @@ public:
// --------------------------------------------------------------------------------
struct ElemFeatures //!< Features of element to create
{
SMDSAbs_ElementType myType;
bool myIsPoly, myIsQuad;
int myID;
double myBallDiameter;
std::vector<int> myPolyhedQuantities;
SMDSAbs_ElementType myType;
bool myIsPoly, myIsQuad;
int myID;
double myBallDiameter;
std::vector<int> myPolyhedQuantities;
std::vector<const SMDS_MeshNode*> myNodes; // not managed by ElemFeatures
SMESH_EXPORT ElemFeatures( SMDSAbs_ElementType type=SMDSAbs_All, bool isPoly=false, bool isQuad=false )
:myType( type ), myIsPoly(isPoly), myIsQuad(isQuad), myID(-1), myBallDiameter(0) {}
@ -750,6 +751,20 @@ public:
const size_t nbSteps,
SMESH_SequenceOfElemPtr& srcElements);
/*!
* \brief Computes new connectivity of an element after merging nodes
* \param [in] elems - the element
* \param [out] newElemDefs - definition(s) of result element(s)
* \param [inout] nodeNodeMap - nodes to merge
* \param [in] avoidMakingHoles - if true and and the element becomes invalid
* after merging (but not degenerated), removes nodes causing
* the invalidity from \a nodeNodeMap.
* \return bool - true if the element should be removed
*/
bool applyMerge( const SMDS_MeshElement* elems,
std::vector< ElemFeatures >& newElemDefs,
TNodeNodeMap& nodeNodeMap,
const bool avoidMakingHoles );
/*!
* \brief Create 1D and 2D elements around swept elements
* \param mapNewNodes - source nodes and ones generated from them
@ -782,11 +797,11 @@ public:
double Angle ()const { return myAngle; }
double Parameter ()const { return myPrm; }
};
Extrusion_Error MakeEdgePathPoints(std::list<double>& aPrms,
Extrusion_Error makeEdgePathPoints(std::list<double>& aPrms,
const TopoDS_Edge& aTrackEdge,
bool aFirstIsStart,
std::list<SMESH_MeshEditor_PathPoint>& aLPP);
Extrusion_Error MakeExtrElements(TIDSortedElemSet theElements[2],
Extrusion_Error makeExtrElements(TIDSortedElemSet theElements[2],
std::list<SMESH_MeshEditor_PathPoint>& theFullList,
const bool theHasAngles,
std::list<double>& theAngles,
@ -794,7 +809,7 @@ public:
const bool theHasRefPoint,
const gp_Pnt& theRefPoint,
const bool theMakeGroups);
static void LinearAngleVariation(const int NbSteps,
static void linearAngleVariation(const int NbSteps,
std::list<double>& theAngles);
bool doubleNodes( SMESHDS_Mesh* theMeshDS,

79
src/SMESHGUI/SMESHGUI.cxx
View File

@ -215,29 +215,34 @@ namespace
QStringList filter;
std::string myExtension;
if ( theCommandID == SMESHOp::OpImportMED ) {
if ( theCommandID == SMESHOp::OpImportMED ||
theCommandID == SMESHOp::OpPopupImportMED ) {
filter.append( QObject::tr( "MED_FILES_FILTER" ) + " (*.*med)" );
filter.append( QObject::tr( "ALL_FILES_FILTER" ) + " (*)" );
}
else if ( theCommandID == SMESHOp::OpImportUNV ) {
else if ( theCommandID == SMESHOp::OpImportUNV ||
theCommandID == SMESHOp::OpPopupImportUNV ) {
filter.append( QObject::tr( "IDEAS_FILES_FILTER" ) + " (*.unv)" );
}
else if ( theCommandID == SMESHOp::OpImportDAT ) {
else if ( theCommandID == SMESHOp::OpImportDAT ||
theCommandID == SMESHOp::OpPopupImportDAT ) {
filter.append( QObject::tr( "DAT_FILES_FILTER" ) + " (*.dat)" );
}
else if ( theCommandID == SMESHOp::OpImportSTL ) {
else if ( theCommandID == SMESHOp::OpImportSTL ||
theCommandID == SMESHOp::OpPopupImportSTL ) {
filter.append( QObject::tr( "STL_FILES_FILTER" ) + " (*.stl)" );
}
#ifdef WITH_CGNS
else if ( theCommandID == SMESHOp::OpImportCGNS ) {
else if ( theCommandID == SMESHOp::OpImportCGNS ||
theCommandID == SMESHOp::OpPopupImportCGNS ) {
filter.append( QObject::tr( "CGNS_FILES_FILTER" ) + " (*.cgns)" );
}
#endif
else if ( theCommandID == SMESHOp::OpImportSAUV ) {
else if ( theCommandID == SMESHOp::OpImportSAUV ||
theCommandID == SMESHOp::OpPopupImportSAUV ) {
filter.append( QObject::tr( "SAUV files (*.sauv*)" ) );
filter.append( QObject::tr( "All files (*)" ) );
}
else if ( theCommandID == SMESHOp::OpImportGMF ) {
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)" );
}
@ -283,6 +288,7 @@ namespace
try {
switch ( theCommandID ) {
case SMESHOp::OpImportDAT:
case SMESHOp::OpPopupImportDAT:
{
// DAT format (currently unsupported)
errors.append( QString( "%1 :\n\t%2" ).arg( filename ).
@ -290,6 +296,7 @@ namespace
break;
}
case SMESHOp::OpImportUNV:
case SMESHOp::OpPopupImportUNV:
{
// UNV format
aMeshes->length( 1 );
@ -300,6 +307,7 @@ namespace
break;
}
case SMESHOp::OpImportMED:
case SMESHOp::OpPopupImportMED:
{
// MED format
SMESH::DriverMED_ReadStatus res;
@ -311,6 +319,7 @@ namespace
break;
}
case SMESHOp::OpImportSTL:
case SMESHOp::OpPopupImportSTL:
{
// STL format
aMeshes->length( 1 );
@ -321,8 +330,8 @@ namespace
}
break;
}
#ifdef WITH_CGNS
case SMESHOp::OpImportCGNS:
case SMESHOp::OpPopupImportCGNS:
{
// CGNS format
SMESH::DriverMED_ReadStatus res;
@ -333,8 +342,8 @@ namespace
}
break;
}
#endif
case SMESHOp::OpImportSAUV:
case SMESHOp::OpPopupImportSAUV:
{
// SAUV format
SMESH::DriverMED_ReadStatus res;
@ -346,6 +355,7 @@ namespace
break;
}
case SMESHOp::OpImportGMF:
case SMESHOp::OpPopupImportGMF:
{
// GMF format
SMESH::ComputeError_var res;
@ -433,12 +443,8 @@ namespace
theCommandID == SMESHOp::OpPopupExportUNV );
const bool isSTL = ( theCommandID == SMESHOp::OpExportSTL ||
theCommandID == SMESHOp::OpPopupExportSTL );
#ifdef WITH_CGNS
const bool isCGNS= ( theCommandID == SMESHOp::OpExportCGNS ||
theCommandID == SMESHOp::OpPopupExportCGNS );
#else
const bool isCGNS= false;
#endif
const bool isSAUV= ( theCommandID == SMESHOp::OpExportSAUV ||
theCommandID == SMESHOp::OpPopupExportSAUV );
const bool isGMF = ( theCommandID == SMESHOp::OpExportGMF ||
@ -2451,11 +2457,16 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
case SMESHOp::OpImportUNV:
case SMESHOp::OpImportMED:
case SMESHOp::OpImportSTL:
#ifdef WITH_CGNS
case SMESHOp::OpImportCGNS:
#endif
case SMESHOp::OpImportSAUV:
case SMESHOp::OpImportGMF:
case SMESHOp::OpPopupImportDAT:
case SMESHOp::OpPopupImportUNV:
case SMESHOp::OpPopupImportMED:
case SMESHOp::OpPopupImportSTL:
case SMESHOp::OpPopupImportCGNS:
case SMESHOp::OpPopupImportSAUV:
case SMESHOp::OpPopupImportGMF:
{
if(checkLock(aStudy)) break;
::ImportMeshesFromFile(GetSMESHGen(),theCommandID);
@ -2484,18 +2495,14 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
case SMESHOp::OpExportMED:
case SMESHOp::OpExportUNV:
case SMESHOp::OpExportSTL:
#ifdef WITH_CGNS
case SMESHOp::OpExportCGNS:
#endif
case SMESHOp::OpExportSAUV:
case SMESHOp::OpExportGMF:
case SMESHOp::OpPopupExportDAT:
case SMESHOp::OpPopupExportMED:
case SMESHOp::OpPopupExportUNV:
case SMESHOp::OpPopupExportSTL:
#ifdef WITH_CGNS
case SMESHOp::OpPopupExportCGNS:
#endif
case SMESHOp::OpPopupExportSAUV:
case SMESHOp::OpPopupExportGMF:
{
@ -2671,9 +2678,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
extractContainers( sel_objects, to_process );
try {
#if (OCC_VERSION_MAJOR << 16 | OCC_VERSION_MINOR << 8 | OCC_VERSION_MAINTENANCE) > 0x060100
OCC_CATCH_SIGNALS;
#endif
if (vtkwnd) {
SALOME_ListIteratorOfListIO It( to_process );
for ( ; It.More(); It.Next())
@ -3821,13 +3826,21 @@ void SMESHGUI::initialize( CAM_Application* app )
//createSMESHAction( SMESHOp::OpImportDAT, "IMPORT_DAT", "", (Qt::CTRL+Qt::Key_B) );
createSMESHAction( SMESHOp::OpImportUNV, "IMPORT_UNV", "", (Qt::CTRL+Qt::Key_I) );
createSMESHAction( SMESHOp::OpImportMED, "IMPORT_MED", "", (Qt::CTRL+Qt::Key_M) );
//createSMESHAction( 114, "NUM" );
createSMESHAction( SMESHOp::OpImportSTL, "IMPORT_STL" );
#ifdef WITH_CGNS
createSMESHAction( SMESHOp::OpImportCGNS, "IMPORT_CGNS" );
#endif
createSMESHAction( SMESHOp::OpImportSAUV, "IMPORT_SAUV" );
createSMESHAction( SMESHOp::OpImportGMF, "IMPORT_GMF" );
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" );
createSMESHAction( SMESHOp::OpExportMED, "MED" );
createSMESHAction( SMESHOp::OpExportUNV, "UNV" );
@ -4364,6 +4377,7 @@ void SMESHGUI::initialize( CAM_Application* app )
group = pat.arg( SMESHGUI_Selection::typeName( SMESH::GROUP ) ),
hypo = pat.arg( SMESHGUI_Selection::typeName( SMESH::HYPOTHESIS ) ),
algo = pat.arg( SMESHGUI_Selection::typeName( SMESH::ALGORITHM ) ),
smesh = pat.arg( SMESHGUI_Selection::typeName( SMESH::COMPONENT ) ),
elems = QString( "'%1' '%2' '%3' '%4' '%5' '%6'" ).
arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_VERTEX ) ).
arg( SMESHGUI_Selection::typeName( SMESH::SUBMESH_EDGE ) ).
@ -4442,6 +4456,17 @@ void SMESHGUI::initialize( CAM_Application* app )
createPopupItem( SMESHOp::OpPopupExportDAT, OB, mesh_group, only_one_non_empty, anId );
createPopupItem( SMESHOp::OpDelete, OB, mesh_part + " " + hyp_alg );
createPopupItem( SMESHOp::OpDeleteGroup, OB, group );
anId = popupMgr()->insert( tr( "MEN_IMPORT" ), -1, -1 ); // IMPORT submenu
createPopupItem( SMESHOp::OpPopupImportMED, OB, smesh, "", anId );
createPopupItem( SMESHOp::OpPopupImportUNV, OB, smesh, "", anId );
createPopupItem( SMESHOp::OpPopupImportSTL, 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 );
// popup for viewer
@ -4580,9 +4605,9 @@ void SMESHGUI::initialize( CAM_Application* app )
// Controls
//-------------------------------------------------
QString
aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
aMeshInVtkHasNodes = aMeshInVTK + "&&" + hasNodes,
aMeshInVtkHasEdges = aMeshInVTK + "&&" + hasEdges,
aMeshInVtkHasFaces = aMeshInVTK + "&&" + hasFaces,
aMeshInVtkHasVolumes = aMeshInVTK + "&&" + hasVolumes;
anId = popupMgr()->insert( tr( "MEN_CTRL" ), -1, -1 );

9
src/SMESHGUI/SMESHGUI_BuildCompoundDlg.cxx
View File

@ -135,7 +135,7 @@ SMESHGUI_BuildCompoundDlg::SMESHGUI_BuildCompoundDlg( SMESHGUI* theModule )
CheckBoxMerge = new QCheckBox(tr("MERGE_NODES_AND_ELEMENTS"), GroupArgs);
TextLabelTol = new QLabel(tr("SMESH_TOLERANCE"), GroupArgs);
TextLabelTol->setAlignment(Qt::AlignCenter);
//TextLabelTol->setAlignment(Qt::AlignCenter);
SpinBoxTol = new SMESHGUI_SpinBox(GroupArgs);
SpinBoxTol->RangeStepAndValidator(0.0, COORD_MAX, 0.00001, "len_tol_precision" );
@ -146,8 +146,8 @@ SMESHGUI_BuildCompoundDlg::SMESHGUI_BuildCompoundDlg( SMESHGUI* theModule )
GroupArgsLayout->addWidget(ComboBoxUnion, 1, 3);
GroupArgsLayout->addWidget(CheckBoxCommon, 2, 0, 1, 4);
GroupArgsLayout->addWidget(CheckBoxMerge, 3, 0, 1, 4);
GroupArgsLayout->addWidget(TextLabelTol, 4, 0, 1, 2);
GroupArgsLayout->addWidget(SpinBoxTol, 4, 2, 1, 2);
GroupArgsLayout->addWidget(TextLabelTol, 4, 0);
GroupArgsLayout->addWidget(SpinBoxTol, 4, 1, 1, 3);
/***************************************************************/
GroupButtons = new QGroupBox(this);
@ -289,6 +289,8 @@ bool SMESHGUI_BuildCompoundDlg::ClickOnApply()
if (!isValid())
return false;
SUIT_OverrideCursor aWaitCursor;
SMESH::SMESH_Mesh_var aMesh;
if (!myMesh->_is_nil())
@ -298,7 +300,6 @@ bool SMESHGUI_BuildCompoundDlg::ClickOnApply()
QStringList anEntryList;
try {
SUIT_OverrideCursor aWaitCursor;
aMesh = myMeshArray[0]->GetMesh();
aMesh->SetParameters( aParameters.join(":").toLatin1().constData() );

10
src/SMESHGUI/SMESHGUI_MergeDlg.cxx
View File

@ -191,6 +191,9 @@ SMESHGUI_MergeDlg::SMESHGUI_MergeDlg (SMESHGUI* theModule, int theAction)
SeparateCornersAndMedium = new QCheckBox(tr("SEPARATE_CORNERS_AND_MEDIUM"), NodeSpecWidget );
SeparateCornersAndMedium->setEnabled( false );
AvoidMakingHoles = new QCheckBox(tr("AVOID_MAKING_HOLES"), NodeSpecWidget );
AvoidMakingHoles->setChecked( false );
QGridLayout* NodeSpecLayout = new QGridLayout(NodeSpecWidget);
NodeSpecLayout->setSpacing(SPACING);
NodeSpecLayout->setMargin(0);
@ -198,6 +201,7 @@ SMESHGUI_MergeDlg::SMESHGUI_MergeDlg (SMESHGUI* theModule, int theAction)
NodeSpecLayout->addWidget(TextLabelTolerance, 0, 0 );
NodeSpecLayout->addWidget(SpinBoxTolerance, 0, 1 );
NodeSpecLayout->addWidget(SeparateCornersAndMedium, 1, 0, 1, 2 );
NodeSpecLayout->addWidget(AvoidMakingHoles, 2, 0, 1, 2 );
/***************************************************************/
// Exclude groups
@ -585,12 +589,12 @@ bool SMESHGUI_MergeDlg::ClickOnApply()
}
if( myAction == MERGE_NODES )
aMeshEditor->MergeNodes (aGroupsOfElements.inout(), nodesToKeep);
aMeshEditor->MergeNodes( aGroupsOfElements.inout(), nodesToKeep, AvoidMakingHoles->isChecked() );
else
aMeshEditor->MergeElements (aGroupsOfElements.inout());
aMeshEditor->MergeElements( aGroupsOfElements.inout() );
if ( myTypeId == TYPE_AUTO ) {
if (myAction == MERGE_NODES )
if ( myAction == MERGE_NODES )
SUIT_MessageBox::information(SMESHGUI::desktop(), tr("SMESH_INFORMATION"),
tr("SMESH_MERGED_NODES").arg(QString::number(ListCoincident->count()).toLatin1().data()));
else

1
src/SMESHGUI/SMESHGUI_MergeDlg.h
View File

@ -130,6 +130,7 @@ private:
QWidget* NodeSpecWidget;
SMESHGUI_SpinBox* SpinBoxTolerance;
QCheckBox* SeparateCornersAndMedium;
QCheckBox* AvoidMakingHoles;
QGroupBox* GroupCoincident;
//QWidget* GroupCoincidentWidget;

15
src/SMESHGUI/SMESHGUI_Operations.h
View File

@ -32,37 +32,36 @@ namespace SMESHOp {
OpShowScalarBar = 1022, // SHOW SCALAR BAR
OpSaveDistribution = 1030, // SAVE DISTRIBUTION
OpShowDistribution = 1031, // SHOW DISTRIBUTION
#ifndef DISABLE_PLOT2DVIEWER
OpPlotDistribution = 1032, // PLOT DISTRIBUTION
#endif
OpFileInformation = 1040, // POPUP MENU - FILE INFORMATION
// Import -------------------------//--------------------------------
OpImportDAT = 1100, // MENU FILE - IMPORT - DAT FILE
OpImportUNV = 1101, // MENU FILE - IMPORT - UNV FILE
OpImportMED = 1102, // MENU FILE - IMPORT - MED FILE
OpImportSTL = 1103, // MENU FILE - IMPORT - STL FILE
#ifdef WITH_CGNS
OpImportCGNS = 1104, // MENU FILE - IMPORT - CGNS FILE
#endif
OpImportSAUV = 1105, // MENU FILE - IMPORT - SAUV FILE
OpImportGMF = 1106, // MENU FILE - IMPORT - GMF FILE
OpPopupImportDAT = 1120, // POPUP MENU - IMPORT - DAT FILE
OpPopupImportUNV = 1121, // POPUP MENU - IMPORT - UNV FILE
OpPopupImportMED = 1122, // POPUP MENU - IMPORT - MED FILE
OpPopupImportSTL = 1123, // POPUP MENU - IMPORT - STL FILE
OpPopupImportCGNS = 1124, // POPUP MENU - IMPORT - CGNS FILE
OpPopupImportSAUV = 1125, // POPUP MENU - IMPORT - SAUV FILE
OpPopupImportGMF = 1126, // POPUP MENU - IMPORT - GMF FILE
// Export -------------------------//--------------------------------
OpExportDAT = 1200, // MENU FILE - EXPORT - DAT FILE
OpExportMED = 1201, // MENU FILE - EXPORT - MED FILE
OpExportUNV = 1202, // MENU FILE - EXPORT - UNV FILE
OpExportSTL = 1203, // MENU FILE - EXPORT - STL FILE
#ifdef WITH_CGNS
OpExportCGNS = 1204, // MENU FILE - EXPORT - CGNS FILE
#endif
OpExportSAUV = 1205, // MENU FILE - EXPORT - SAUV FILE
OpExportGMF = 1206, // MENU FILE - EXPORT - GMF FILE
OpPopupExportDAT = 1210, // POPUP MENU - EXPORT - DAT FILE
OpPopupExportMED = 1211, // POPUP MENU - EXPORT - MED FILE
OpPopupExportUNV = 1212, // POPUP MENU - EXPORT - UNV FILE
OpPopupExportSTL = 1213, // POPUP MENU - EXPORT - STL FILE
#ifdef WITH_CGNS
OpPopupExportCGNS = 1214, // POPUP MENU - EXPORT - CGNS FILE
#endif
OpPopupExportSAUV = 1215, // POPUP MENU - EXPORT - SAUV FILE
OpPopupExportGMF = 1216, // POPUP MENU - EXPORT - GMF FILE
// Mesh ---------------------------//--------------------------------

1
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
View File

@ -762,6 +762,7 @@ namespace SMESH
if ((anActor = CreateActor(aDocument,theEntry,true))) {
bool needFitAll = noSmeshActors(theWnd); // fit for the first object only
DisplayActor(theWnd,anActor);
anActor->SetVisibility(true);
aStudy->setVisibilityState(theEntry, Qtx::ShownState);
// FitAll(); - PAL16770(Display of a group performs an automatic fit all)
if (needFitAll) FitAll();

4
src/SMESHGUI/SMESH_msg_en.ts
View File

@ -5322,6 +5322,10 @@ Please select a group and try again</translation>
<source>SEPARATE_CORNERS_AND_MEDIUM</source>
<translation>No merge of corner and medium nodes of quadratic cells</translation>
</message>
<message>
<source>AVOID_MAKING_HOLES</source>
<translation>Avoid making holes</translation>
</message>
<message>
<source>KEEP_NODES</source>
<translation>Nodes to keep during the merge</translation>

3
src/SMESHUtils/CMakeLists.txt
View File

@ -83,7 +83,8 @@ SET(SMESHUtils_SOURCES
SMESH_MAT2d.cxx
SMESH_FreeBorders.cxx
SMESH_ControlPnt.cxx
)
SMESH_DeMerge.cxx
)
# --- rules ---

215
src/SMESHUtils/SMESH_DeMerge.cxx Normal file
View File

@ -0,0 +1,215 @@
// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
// File : SMESH_DeMerge.hxx
// Created : Fri Mar 10 16:06:54 2017
// Author : Edward AGAPOV (eap)
// Implementation of SMESH_MeshAlgos::DeMerge()
#include "SMESH_MeshAlgos.hxx"
#include "SMDS_VolumeTool.hxx"
#include "SMDS_MeshVolume.hxx"
namespace
{
bool isDegenFace(const std::vector< const SMDS_MeshNode* >& nodes)
{
// in a degenerated face each link sticks to another
typedef std::map< SMESH_TLink , int > TLink2Nb;
TLink2Nb link2nb;
for ( size_t iPrev = nodes.size() - 1, i = 0; i < nodes.size(); iPrev = i++ )
{
SMESH_TLink link( nodes[iPrev], nodes[i] );
TLink2Nb::iterator l2n = link2nb.insert( std::make_pair( link, 0 )).first;
l2n->second++;
}
if ( link2nb.size() == 1 )
return true;
for ( TLink2Nb::iterator l2n = link2nb.begin(); l2n != link2nb.end(); ++l2n )
if ( l2n->second == 1 )
return false;
return true;
}
void deMergeFace(const SMDS_MeshElement* face,
std::vector< const SMDS_MeshNode* >& newNodes,
std::vector< const SMDS_MeshNode* >& noMergeNodes)
{
if ( face->IsQuadratic() )
{
const int nbCorners = face->NbCornerNodes();
const int nbNodes = (int) newNodes.size();
// de-merge sticking medium nodes
for ( int i = 1; i < nbNodes; i += 2 ) // loop om medium nodes
{
int iPrev = ( i - 1 );
int iNext = ( i + 1 ) % nbNodes;
if ( newNodes[ iPrev ] == newNodes[ iNext ] )
{
if ( newNodes[ iPrev ] != newNodes[ i ] || nbCorners == 3 )
{
// corners stick but the medium does not, or a link of triangle collapses
noMergeNodes.push_back( face->GetNode( iPrev / 2 ));
noMergeNodes.push_back( face->GetNode( iNext / 2 ));
noMergeNodes.push_back( face->GetNode( nbCorners + i / 2 ));
}
}
else if ( newNodes[ i ] == newNodes[ iPrev ] )
{
// the medium node sticks to a neighbor corner one
noMergeNodes.push_back( face->GetNode( nbCorners + i / 2 ));
noMergeNodes.push_back( face->GetNode( iPrev / 2 ));
}
else if ( newNodes[ i ] == newNodes[ iNext ] )
{
// the medium node sticks to a neighbor corner one
noMergeNodes.push_back( face->GetNode( nbCorners + i / 2 ));
noMergeNodes.push_back( face->GetNode( iNext / 2 ));
}
else
{
// find if the medium sticks to any other node
std::vector<const SMDS_MeshNode*>::iterator pos;
pos = std::find( newNodes.begin(), newNodes.begin() + iPrev, newNodes[i] );
if ( pos == newNodes.begin() + iPrev )
pos = std::find( newNodes.begin() + i + 1, newNodes.end(), newNodes[i] );
if ( pos == newNodes.end() )
continue;
int iStick = std::distance( newNodes.begin(), pos );
if ( iStick % 2 == 0 )
{
// the medium sticks to a distant corner
noMergeNodes.push_back( face->GetNode( nbCorners + i / 2 ));
noMergeNodes.push_back( face->GetNode( iStick / 2 ));
}
else
{
// the medium sticks to a distant medium;
// it's OK if two links stick
int iPrev2 = ( iStick - 1 );
int iNext2 = ( iStick + 1 ) % nbNodes;
if (( newNodes[ iPrev ] == newNodes[ iPrev2 ] &&
newNodes[ iNext ] == newNodes[ iNext2 ] )
||
( newNodes[ iPrev ] == newNodes[ iNext2 ] &&
newNodes[ iNext ] == newNodes[ iPrev2 ] ))
; // OK
else
{
noMergeNodes.push_back( face->GetNode( nbCorners + i / 2 ));
noMergeNodes.push_back( face->GetNode( nbCorners + iStick / 2 ));
}
}
}
}
}
} // deMergeFace()
bool isDegenVolume(const SMDS_VolumeTool& vt)
{
// TMP: it's necessary to use a topological check instead of a geometrical one
return vt.GetSize() < 1e-100;
}
void deMergeVolume(const SMDS_VolumeTool& vt,
std::vector< const SMDS_MeshNode* >& noMergeNodes)
{
// temporary de-merge all nodes
for ( int i = 0; i < vt.NbNodes(); ++i )
{
const SMDS_MeshNode* n = vt.GetNodes()[i];
if ( n != vt.Element()->GetNode( i ))
noMergeNodes.push_back( n );
}
}
} // namespace
//================================================================================
/*!
* \brief Find nodes whose merge makes the element invalid. (Degenerated elem is OK)
* \param [in] elem - the element
* \param [in] newNodes - nodes of the element after the merge
* \param [out] noMergeNodes - nodes to undo merge
*/
//================================================================================
void SMESH_MeshAlgos::DeMerge(const SMDS_MeshElement* elem,
std::vector< const SMDS_MeshNode* >& newNodes,
std::vector< const SMDS_MeshNode* >& noMergeNodes)
{
switch ( elem->GetType() )
{
case SMDSAbs_Face:
{
if ( newNodes.size() <= 4 )
return; // degenerated
if ( elem->IsQuadratic() )
SMDS_MeshCell::applyInterlace // interlace medium and corner nodes
( SMDS_MeshCell::interlacedSmdsOrder( elem->GetEntityType(), newNodes.size() ), newNodes );
if ( isDegenFace( newNodes ))
return;
deMergeFace( elem, newNodes, noMergeNodes );
}
break;
case SMDSAbs_Volume:
{
if ( newNodes.size() <= 4 )
return; // degenerated
SMDS_VolumeTool vt;
if ( !vt.Set( elem, /*skipCentral=*/true, &newNodes ))
return; // strange
if ( isDegenVolume( vt ))
return;
deMergeVolume( elem, noMergeNodes );
}
break;
case SMDSAbs_Edge:
{
if ( newNodes.size() == 3 )
if (( newNodes[2] == newNodes[0] && newNodes[2] != newNodes[1] ) ||
( newNodes[2] == newNodes[1] && newNodes[2] != newNodes[0]))
{
// the medium node sticks to a corner
noMergeNodes.push_back( newNodes[2] );
noMergeNodes.push_back( newNodes[ newNodes[2] == newNodes[1] ]);
}
}
break;
default:;
}
}

12
src/SMESHUtils/SMESH_MeshAlgos.hxx
View File

@ -206,6 +206,16 @@ namespace SMESH_MeshAlgos
CoincidentFreeBorders & foundFreeBordes);
} // SMESH_MeshAlgos
/*!
* \brief Find nodes whose merge makes the element invalid
*
* (Implemented in SMESH_DeMerge.cxx)
*/
SMESHUtils_EXPORT
void DeMerge(const SMDS_MeshElement* elem,
std::vector< const SMDS_MeshNode* >& newNodes,
std::vector< const SMDS_MeshNode* >& noMergeNodes);
} // namespace SMESH_MeshAlgos
#endif

2
src/SMESH_I/SMESH_Group_i.cxx
View File

@ -480,7 +480,6 @@ SMESH::long_array* SMESH_GroupBase_i::GetListOfID()
if ( 0 < aSize && aSize < 100 ) // for comfortable testing ;)
std::sort( &aRes[0], &aRes[0]+aSize );
}
MESSAGE("get list of IDs of a vague group");
return aRes._retn();
}
@ -673,7 +672,6 @@ void SMESH_GroupBase_i::SetColorNumber(CORBA::Long color)
aGroupDS->SetColorGroup(color);
TPythonDump()<<SMESH::SMESH_GroupBase_var(_this())<<".SetColorNumber( "<<color<<" )";
}
MESSAGE("set color number of a group");
return ;
}

7
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

@ -4159,7 +4159,8 @@ FindCoincidentNodesOnPartBut(SMESH::SMESH_IDSource_ptr theObject,
//=======================================================================
void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
const SMESH::ListOfIDSources& NodesToKeep)
const SMESH::ListOfIDSources& NodesToKeep,
CORBA::Boolean AvoidMakingHoles)
throw (SALOME::SALOME_Exception)
{
SMESH_TRY;
@ -4203,9 +4204,9 @@ void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfN
aTPythonDump << aNodeGroup;
}
getEditor().MergeNodes( aListOfListOfNodes );
getEditor().MergeNodes( aListOfListOfNodes, AvoidMakingHoles );
aTPythonDump << "], " << NodesToKeep << ")";
aTPythonDump << "], " << NodesToKeep << ", " << AvoidMakingHoles << ")";
declareMeshModified( /*isReComputeSafe=*/false );

3
src/SMESH_I/SMESH_MeshEditor_i.hxx
View File

@ -495,7 +495,8 @@ public:
CORBA::Boolean SeparateCornersAndMedium)
throw (SALOME::SALOME_Exception);
void MergeNodes (const SMESH::array_of_long_array& GroupsOfNodes,
const SMESH::ListOfIDSources& NodesToKeep )
const SMESH::ListOfIDSources& NodesToKeep,
CORBA::Boolean AvoidMakingHoles )
throw (SALOME::SALOME_Exception);
void FindEqualElements(SMESH::SMESH_IDSource_ptr Object,
SMESH::array_of_long_array_out GroupsOfElementsID)

26
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -496,7 +496,13 @@ int SMESH_Mesh_i::ImportSTLFile( const char* theFileName )
SMESH_TRY;
// Read mesh with name = <theMeshName> into SMESH_Mesh
_impl->STLToMesh( theFileName );
std::string name = _impl->STLToMesh( theFileName );
if ( !name.empty() )
{
SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
SALOMEDS::SObject_wrap meshSO = _gen_i->ObjectToSObject( study, _this() );
_gen_i->SetName( meshSO, name.c_str() );
}
SMESH_CATCH( SMESH::throwCorbaException );
@ -3144,9 +3150,15 @@ void SMESH_Mesh_i::ExportSTL (const char *file, const bool isascii)
TPythonDump() << SMESH::SMESH_Mesh_var(_this())
<< ".ExportSTL( r'" << file << "', " << isascii << " )";
CORBA::String_var name;
SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
SALOMEDS::SObject_wrap so = _gen_i->ObjectToSObject( study, _this() );
if ( !so->_is_nil() )
name = so->GetName();
// Perform Export
PrepareForWriting(file);
_impl->ExportSTL(file, isascii);
PrepareForWriting( file );
_impl->ExportSTL( file, isascii, name.in() );
}
//================================================================================
@ -3595,8 +3607,14 @@ void SMESH_Mesh_i::ExportPartToSTL(::SMESH::SMESH_IDSource_ptr meshPart,
PrepareForWriting(file);
CORBA::String_var name;
SALOMEDS::Study_var study = _gen_i->GetCurrentStudy();
SALOMEDS::SObject_wrap so = _gen_i->ObjectToSObject( study, meshPart );
if ( !so->_is_nil() )
name = so->GetName();
SMESH_MeshPartDS partDS( meshPart );
_impl->ExportSTL(file, isascii, &partDS);
_impl->ExportSTL( file, isascii, name.in(), &partDS );
TPythonDump() << SMESH::SMESH_Mesh_var(_this()) << ".ExportPartToSTL( "
<< meshPart<< ", r'" << file << "', " << isascii << ")";

13
src/SMESH_SWIG/smeshBuilder.py
View File

@ -4561,10 +4561,12 @@ class Mesh(metaclass=MeshMeta):
# @param NodesToKeep nodes to keep in the mesh: a list of groups, sub-meshes or node IDs.
# If @a NodesToKeep does not include a node to keep for some group to merge,
# then the first node in the group is kept.
# @param AvoidMakingHoles prevent merging nodes which cause removal of elements becoming
# invalid
# @ingroup l2_modif_trsf
def MergeNodes (self, GroupsOfNodes, NodesToKeep=[]):
def MergeNodes (self, GroupsOfNodes, NodesToKeep=[], AvoidMakingHoles=False):
# NodesToKeep are converted to SMESH_IDSource in meshEditor.MergeNodes()
self.editor.MergeNodes(GroupsOfNodes,NodesToKeep)
self.editor.MergeNodes( GroupsOfNodes, NodesToKeep, AvoidMakingHoles )
## Find the elements built on the same nodes.
# @param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching
@ -5120,17 +5122,18 @@ class meshEditor(SMESH._objref_SMESH_MeshEditor):
def FindCoincidentNodesOnPart(self,*args): # a 3d arg added (SeparateCornerAndMediumNodes)
if len( args ) == 2: args += False,
return SMESH._objref_SMESH_MeshEditor.FindCoincidentNodesOnPart( self, *args )
def MergeNodes(self,*args): # a 2nd arg added (NodesToKeep)
def MergeNodes(self,*args): # 2 args added (NodesToKeep,AvoidMakingHoles)
if len( args ) == 1:
return SMESH._objref_SMESH_MeshEditor.MergeNodes( self, args[0], [] )
return SMESH._objref_SMESH_MeshEditor.MergeNodes( self, args[0], [], False )
NodesToKeep = args[1]
AvoidMakingHoles = args[2] if len( args ) == 3 else False
unRegister = genObjUnRegister()
if NodesToKeep:
if isinstance( NodesToKeep, list ) and isinstance( NodesToKeep[0], int ):
NodesToKeep = self.MakeIDSource( NodesToKeep, SMESH.NODE )
if not isinstance( NodesToKeep, list ):
NodesToKeep = [ NodesToKeep ]
return SMESH._objref_SMESH_MeshEditor.MergeNodes( self, args[0], NodesToKeep )
return SMESH._objref_SMESH_MeshEditor.MergeNodes( self, args[0], NodesToKeep, AvoidMakingHoles )
pass
omniORB.registerObjref(SMESH._objref_SMESH_MeshEditor._NP_RepositoryId, meshEditor)

10
src/StdMeshers/StdMeshers_ViscousLayers.cxx
View File

@ -1865,15 +1865,19 @@ SMESH_ComputeErrorPtr _ViscousBuilder::Compute(SMESH_Mesh& theMesh,
size_t iSD = 0;
for ( iSD = 0; iSD < _sdVec.size(); ++iSD ) // find next SOLID to compute
if ( _sdVec[iSD]._before.IsEmpty() &&
!_sdVec[iSD]._solid.IsNull() &&
_sdVec[iSD]._n2eMap.empty() )
break;
if ( ! makeLayer(_sdVec[iSD]) ) // create _LayerEdge's
return _error;
if ( _sdVec[iSD]._n2eMap.size() == 0 )
if ( _sdVec[iSD]._n2eMap.size() == 0 ) // no layers in a SOLID
{
_sdVec[iSD]._solid.Nullify();
continue;
}
if ( ! inflate(_sdVec[iSD]) ) // increase length of _LayerEdge's
return _error;
@ -9049,7 +9053,7 @@ void _LayerEdge::Block( _SolidData& data )
minDist = Min( pSrc.SquareDistance( pTgtN ), minDist );
minDist = Min( pTgt.SquareDistance( pSrcN ), minDist );
double newMaxLen = edge->_maxLen + 0.5 * Sqrt( minDist );
if ( edge->_nodes[0]->getshapeId() == neibor->_nodes[0]->getshapeId() )
//if ( edge->_nodes[0]->getshapeId() == neibor->_nodes[0]->getshapeId() ) viscous_layers_00/A3
{
newMaxLen *= edge->_lenFactor / neibor->_lenFactor;
}