ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-26 17:30:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote branch 'origin/V7_dev'

Browse Source
This commit is contained in:
vsr 2016-05-24 18:17:28 +03:00
commit 004925bca4
146 changed files with 5743 additions and 1959 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
doc/salome/gui/SMESH/input/over_constrained_faces.doc
View File

@ -4,10 +4,11 @@
\n This mesh quality control highlights faces sharing only one border
with other faces. In other words, the faces having all thier nodes on
the external border of the mesh are highlighted.
the free border of the 2D mesh are highlighted.
\note The highlighted faces are actually over-constrained only if, at the computation time,
the boundary conditions on the borders where the nodes are located are all Dirichlet boundary conditions.
\note The highlighted faces are actually over-constrained only if, at
the computation time, the boundary conditions on the borders where the
nodes are located are all Dirichlet boundary conditions.
\image html over_constrained_faces.png

2
resources/SalomeApp.xml.in
View File

@ -122,7 +122,7 @@
<parameter name="Plug-ins/MGCleaner plugin User's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/MGCleaner/index.html"/>
<parameter name="Plug-ins/Z-cracks plugin User's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/zcracks/index.html"/>
<parameter name="Plug-ins/MacMesh plugin" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/MacMesh/index.html"/>
<parameter name="Plug-ins/plugin blocFissure" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/blocFissure/index.html"/>
<parameter name="Plug-ins/blocFissure plugin" value="%SMESH_ROOT_DIR%/share/doc/salome/gui/SMESH/blocFissure/index.html"/>
<parameter name="Developer's Guide" value="%SMESH_ROOT_DIR%/share/doc/salome/tui/SMESH/index.html"/>
</section>
<section name="resources">

10
src/Controls/SMESH_Controls.cxx
View File

@ -1832,10 +1832,10 @@ void Length2D::GetValues(TValues& theValues)
dynamic_cast<const SMDS_VtkFace*>(anElem);
// use special nodes iterator
SMDS_ElemIteratorPtr anIter = F->interlacedNodesElemIterator();
long aNodeId[4];
long aNodeId[4] = { 0,0,0,0 };
gp_Pnt P[4];
double aLength;
double aLength = 0;
const SMDS_MeshElement* aNode;
if(anIter->more()){
aNode = anIter->next();
@ -1957,7 +1957,7 @@ double MultiConnection2D::GetValue( long theElementId )
SMDS_ElemIteratorPtr anIter = aFaceElem->nodesIterator();
if (!anIter) break;
const SMDS_MeshNode *aNode, *aNode0;
const SMDS_MeshNode *aNode, *aNode0 = 0;
TColStd_MapOfInteger aMap, aMapPrev;
for (i = 0; i <= len; i++) {
@ -2038,7 +2038,7 @@ void MultiConnection2D::GetValues(MValues& theValues)
(anElem)->interlacedNodesElemIterator();
else
aNodesIter = anElem->nodesIterator();
long aNodeId[3];
long aNodeId[3] = {0,0,0};
//int aNbConnects=0;
const SMDS_MeshNode* aNode0;
@ -2511,7 +2511,7 @@ void FreeEdges::GetBoreders(TBorders& theBorders)
interlacedNodesElemIterator();
else
aNodesIter = anElem->nodesIterator();
long aNodeId[2];
long aNodeId[2] = {0,0};
const SMDS_MeshElement* aNode;
if(aNodesIter->more()){
aNode = aNodesIter->next();

2
src/DriverMED/DriverMED_R_SMESHDS_Mesh.cxx
View File

@ -42,7 +42,7 @@
//#include <stdlib.h>
#ifdef _DEBUG_
static int MYDEBUG = 1;
static int MYDEBUG = 0;
//#define _DEXCEPT_
#else
static int MYDEBUG = 0;

2
src/MEDWrapper/Base/MED_Wrapper.cxx
View File

@ -644,7 +644,7 @@ namespace MED
TIntVector aVec;
aVec.resize(theMeshInfo->GetDim());
for(int aAxe=0;aAxe<theMeshInfo->GetDim();aAxe++){
ETable aATable;
ETable aATable = eCOOR_IND1;
switch(aAxe){
case 0:
aATable = eCOOR_IND1;

2
src/MEDWrapper/V2_2/MED_V2_2_Wrapper.cxx
View File

@ -2739,7 +2739,7 @@ namespace MED
}
if(aMaillageType == eSTRUCTURE && aGrilleType != eGRILLE_STANDARD){
ETable aTable;
ETable aTable = eCOOR_IND1;
for(med_int anAxis = 1; anAxis <= aMeshInfo.myDim; anAxis++){
switch(anAxis){
case 1 :

7
src/OBJECT/SMESH_Actor.cxx
View File

@ -82,9 +82,9 @@
#include "utilities.h"
#ifdef _DEBUG_
static int MYDEBUG = 1;
static int MYDEBUG = 0;
#else
static int MYDEBUG = 1;
static int MYDEBUG = 0;
#endif
static int aLineWidthInc = 2;
@ -799,8 +799,7 @@ SetControlMode(eControl theMode)
void
SMESH_ActorDef::
SetControlMode(eControl theMode,
bool theCheckEntityMode)
SetControlMode( eControl theMode, bool theCheckEntityMode )
{
vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
bool isLogarithmic = lookupTable->GetScale() == VTK_SCALE_LOG10;

2
src/OBJECT/SMESH_DeviceActor.cxx
View File

@ -311,7 +311,7 @@ SMESH_DeviceActor
vtkIdType aNbCells = aGrid->GetNumberOfCells();
aScalars->SetNumberOfComponents(1);
aScalars->SetNumberOfTuples(aNbCells);
double* range;// = aScalars->GetRange();
double* range = 0;// = aScalars->GetRange();
myVisualObj->UpdateFunctor(theFunctor);

21
src/OBJECT/SMESH_Object.cxx
View File

@ -67,7 +67,7 @@ using namespace std;
#endif
#ifdef _DEBUG_
static int MYDEBUG = 1;
static int MYDEBUG = 0;
static int MYDEBUGWITHFILES = 0;//1;
#else
static int MYDEBUG = 0;
@ -133,7 +133,7 @@ static int MYDEBUGWITHFILES = 0;
//=================================================================================
SMESH_VisualObjDef::SMESH_VisualObjDef()
{
MESSAGE("---------------------------------------------SMESH_VisualObjDef::SMESH_VisualObjDef");
if ( MYDEBUG ) MESSAGE("-------------------------------SMESH_VisualObjDef::SMESH_VisualObjDef");
myGrid = vtkUnstructuredGrid::New();
myLocalGrid = false;
ClearEntitiesFlags();
@ -141,9 +141,8 @@ SMESH_VisualObjDef::SMESH_VisualObjDef()
}
SMESH_VisualObjDef::~SMESH_VisualObjDef()
{
MESSAGE("---------------------------------------------SMESH_VisualObjDef::~SMESH_VisualObjDef");
//if ( MYDEBUG )
MESSAGE( "~SMESH_MeshObj - myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );
if ( MYDEBUG ) MESSAGE("--------------------------------SMESH_VisualObjDef::~SMESH_VisualObjDef");
if ( MYDEBUG ) MESSAGE( "myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );
myGrid->Delete();
}
@ -248,7 +247,7 @@ void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
//=================================================================================
void SMESH_VisualObjDef::buildPrs(bool buildGrid)
{
MESSAGE("----------------------------------------------------------SMESH_VisualObjDef::buildPrs " << buildGrid);
if ( MYDEBUG ) MESSAGE("---------------------------SMESH_VisualObjDef::buildPrs " << buildGrid);
if (buildGrid)
{
myLocalGrid = true;
@ -281,7 +280,7 @@ void SMESH_VisualObjDef::buildPrs(bool buildGrid)
myLocalGrid = false;
if (!GetMesh()->isCompacted())
{
MESSAGE("*** buildPrs ==> compactMesh!");
if ( MYDEBUG ) MESSAGE("*** buildPrs ==> compactMesh!");
GetMesh()->compactMesh();
}
vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();
@ -697,9 +696,9 @@ SMESH_MeshObj::~SMESH_MeshObj()
bool SMESH_MeshObj::Update( int theIsClear )
{
// Update SMDS_Mesh on client part
MESSAGE("SMESH_MeshObj::Update " << this);
if ( MYDEBUG ) MESSAGE("SMESH_MeshObj::Update " << this);
if ( myClient.Update(theIsClear) || GetUnstructuredGrid()->GetNumberOfPoints()==0) {
MESSAGE("buildPrs");
if ( MYDEBUG ) MESSAGE("buildPrs");
buildPrs(); // Fill unstructured grid
return true;
}
@ -708,7 +707,7 @@ bool SMESH_MeshObj::Update( int theIsClear )
bool SMESH_MeshObj::NulData()
{
MESSAGE ("SMESH_MeshObj::NulData() ==================================================================================");
if ( MYDEBUG ) MESSAGE ("SMESH_MeshObj::NulData() =============================================");
if (!myEmptyGrid)
{
myEmptyGrid = SMDS_UnstructuredGrid::New();
@ -901,7 +900,7 @@ void SMESH_SubMeshObj::UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunc
//=================================================================================
bool SMESH_SubMeshObj::Update( int theIsClear )
{
MESSAGE("SMESH_SubMeshObj::Update " << this)
if ( MYDEBUG ) MESSAGE("SMESH_SubMeshObj::Update " << this)
bool changed = myMeshObj->Update( theIsClear );
buildPrs(true);
return changed;

4
src/OBJECT/SMESH_ScalarBarActor.cxx
View File

@ -321,8 +321,8 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
// rnv begin
// Customization of the vtkScalarBarActor to show distribution histogram.
bool distrVisibility = (numColors == (int)this->myNbValues.size());
vtkPoints *distrPts;
vtkCellArray *distrPolys;
vtkPoints *distrPts = 0;
vtkCellArray *distrPolys = 0;
vtkUnsignedCharArray *distColors = 0;
int numDistrPts = 0, numPositiveVal=0, maxValue=0;
if(!distrVisibility)

199
src/SMDS/SMDS_Mesh.cxx
View File

@ -525,7 +525,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1,
if ( !e1 || !e2 || !e3 ) return 0;
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
MESSAGE("AddFaceWithID" << ID);
SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3);
adjustmyCellsCapacity(ID);
@ -552,7 +551,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshEdge * e1,
{
if (!hasConstructionEdges())
return NULL;
//MESSAGE("AddFaceWithID" );
return AddFaceWithID(e1,e2,e3,e4, myElementIDFactory->GetFreeID());
}
@ -568,7 +566,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1,
{
if (!hasConstructionEdges())
return NULL;
MESSAGE("AddFaceWithID" << ID);
if ( !e1 || !e2 || !e3 || !e4 ) return 0;
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3,e4);
@ -596,7 +593,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n4)
{
int ID = myElementIDFactory->GetFreeID();
//MESSAGE("AddVolumeWithID " << ID);
SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
if(v==NULL) myElementIDFactory->ReleaseID(ID);
return v;
@ -615,7 +611,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
int idnode4,
int ID)
{
//MESSAGE("AddVolumeWithID" << ID);
SMDS_MeshNode *node1, *node2, *node3, *node4;
node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
@ -637,7 +632,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n4,
int ID)
{
//MESSAGE("AddVolumeWithID " << ID);
SMDS_MeshVolume* volume = 0;
if ( !n1 || !n2 || !n3 || !n4) return volume;
if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -652,7 +646,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
myInfo.myNbTetras++;
}
else if(hasConstructionEdges()) {
MESSAGE("Error : Not implemented");
return NULL;
}
else {
@ -697,7 +690,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n5)
{
int ID = myElementIDFactory->GetFreeID();
//MESSAGE("AddVolumeWithID " << ID);
SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
if(v==NULL) myElementIDFactory->ReleaseID(ID);
return v;
@ -718,7 +710,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
int idnode5,
int ID)
{
//MESSAGE("AddVolumeWithID " << ID);
SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
@ -743,7 +734,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n5,
int ID)
{
//MESSAGE("AddVolumeWithID " << ID);
SMDS_MeshVolume* volume = 0;
if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume;
if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -758,7 +748,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
myInfo.myNbPyramids++;
}
else if(hasConstructionEdges()) {
MESSAGE("Error : Not implemented");
return NULL;
}
else {
@ -805,7 +794,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n6)
{
int ID = myElementIDFactory->GetFreeID();
//MESSAGE("AddVolumeWithID " << ID);
SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
if(v==NULL) myElementIDFactory->ReleaseID(ID);
return v;
@ -827,7 +815,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
int idnode6,
int ID)
{
//MESSAGE("AddVolumeWithID " << ID);
SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
@ -854,7 +841,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n6,
int ID)
{
//MESSAGE("AddVolumeWithID " << ID);
SMDS_MeshVolume* volume = 0;
if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume;
if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -870,7 +856,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
myInfo.myNbPrisms++;
}
else if(hasConstructionEdges()) {
MESSAGE("Error : Not implemented");
return NULL;
}
else {
@ -994,11 +979,9 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
return volume;
if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if(hasConstructionFaces()) {
MESSAGE("Error : Not implemented");
return NULL;
}
else if(hasConstructionEdges()) {
MESSAGE("Error : Not implemented");
return NULL;
}
else {
@ -1074,7 +1057,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
int idnode8,
int ID)
{
//MESSAGE("AddVolumeWithID " << ID);
SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
@ -1108,7 +1090,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n8,
int ID)
{
//MESSAGE("AddVolumeWithID " << ID);
SMDS_MeshVolume* volume = 0;
if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume;
if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@ -1125,7 +1106,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
myInfo.myNbHexas++;
}
else if(hasConstructionEdges()) {
MESSAGE("Error : Not implemented");
return NULL;
}
else {
@ -1171,7 +1151,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
const SMDS_MeshFace * f3,
const SMDS_MeshFace * f4)
{
//MESSAGE("AddVolumeWithID");
if (!hasConstructionFaces())
return NULL;
return AddVolumeWithID(f1,f2,f3,f4, myElementIDFactory->GetFreeID());
@ -1189,7 +1168,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
const SMDS_MeshFace * f4,
int ID)
{
MESSAGE("AddVolumeWithID" << ID);
if (!hasConstructionFaces())
return NULL;
if ( !f1 || !f2 || !f3 || !f4) return 0;
@ -1218,7 +1196,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
const SMDS_MeshFace * f4,
const SMDS_MeshFace * f5)
{
//MESSAGE("AddVolumeWithID");
if (!hasConstructionFaces())
return NULL;
return AddVolumeWithID(f1,f2,f3,f4,f5, myElementIDFactory->GetFreeID());
@ -1237,7 +1214,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
const SMDS_MeshFace * f5,
int ID)
{
MESSAGE("AddVolumeWithID" << ID);
if (!hasConstructionFaces())
return NULL;
if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0;
@ -1267,7 +1243,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
const SMDS_MeshFace * f5,
const SMDS_MeshFace * f6)
{
//MESSAGE("AddVolumeWithID" );
if (!hasConstructionFaces())
return NULL;
return AddVolumeWithID(f1,f2,f3,f4,f5,f6, myElementIDFactory->GetFreeID());
@ -1287,7 +1262,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
const SMDS_MeshFace * f6,
int ID)
{
MESSAGE("AddVolumeWithID" << ID);
if (!hasConstructionFaces())
return NULL;
if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0;
@ -1334,7 +1308,6 @@ SMDS_Mesh::AddPolygonalFaceWithID (const vector<const SMDS_MeshNode*> & nodes,
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if (hasConstructionEdges())
{
MESSAGE("Error : Not implemented");
return NULL;
}
else
@ -1399,7 +1372,6 @@ SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector<const SMDS_MeshNode*> & node
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if (hasConstructionEdges())
{
MESSAGE("Error : Not implemented");
return NULL;
}
else
@ -1472,18 +1444,15 @@ SMDS_Mesh::AddPolyhedralVolumeWithID (const vector<const SMDS_MeshNode*>& nodes,
if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if (hasConstructionFaces())
{
MESSAGE("Error : Not implemented");
return NULL;
}
else if (hasConstructionEdges())
{
MESSAGE("Error : Not implemented");
return NULL;
}
else
{
//#ifdef VTK_HAVE_POLYHEDRON
//MESSAGE("AddPolyhedralVolumeWithID vtk " << ID);
myNodeIds.resize( nodes.size() );
for ( size_t i = 0; i < nodes.size(); ++i )
myNodeIds[i] = nodes[i]->getVtkId();
@ -1498,7 +1467,6 @@ SMDS_Mesh::AddPolyhedralVolumeWithID (const vector<const SMDS_MeshNode*>& nodes,
}
volume = volvtk;
//#else
// MESSAGE("AddPolyhedralVolumeWithID smds " << ID);
// for ( int i = 0; i < nodes.size(); ++i )
// if ( !nodes[ i ] ) return 0;
// volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities);
@ -1648,7 +1616,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceFromVtkIdsWithID(const std::vector<vtkIdType>&
///////////////////////////////////////////////////////////////////////////////
bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
{
//MESSAGE("registerElement " << ID);
if ((ID >=0) && (ID < (int)myCells.size()) && myCells[ID]) // --- already bound
{
MESSAGE(" ------------------ already bound "<< ID << " " << myCells[ID]->getVtkId());
@ -1666,7 +1633,6 @@ bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
if (vtkId >= (int)myCellIdVtkToSmds.size()) // --- resize local vector
{
// MESSAGE(" --------------------- resize myCellIdVtkToSmds " << vtkId << " --> " << vtkId + SMDS_Mesh::chunkSize);
myCellIdVtkToSmds.resize(vtkId + SMDS_Mesh::chunkSize, -1);
}
myCellIdVtkToSmds[vtkId] = ID;
@ -1693,9 +1659,6 @@ const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
{
if (ID < 1 || ID >= (int)myNodes.size())
{
// MESSAGE("------------------------------------------------------------------------- ");
// MESSAGE("----------------------------------- bad ID " << ID << " " << myNodes.size());
// MESSAGE("------------------------------------------------------------------------- ");
return 0;
}
return (const SMDS_MeshNode *)myNodes[ID];
@ -1762,7 +1725,6 @@ SMDS_MeshFace * SMDS_Mesh::createTriangle(const SMDS_MeshNode * node1,
face = facevtk;
adjustmyCellsCapacity(ID);
myCells[ID] = face;
//MESSAGE("createTriangle " << ID << " " << face);
myInfo.myNbTriangles++;
return face;
}
@ -1782,7 +1744,6 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
if(hasConstructionEdges())
{
//MESSAGE("createQuadrangle hasConstructionEdges "<< ID);
SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
edge1=FindEdgeOrCreate(node1,node2);
edge2=FindEdgeOrCreate(node2,node3);
@ -1827,7 +1788,6 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
{
MESSAGE("RemoveNode");
RemoveElement(node, true);
}
@ -1837,7 +1797,6 @@ void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
{
MESSAGE("Remove0DElement");
RemoveElement(elem0d,true);
}
@ -1847,7 +1806,6 @@ void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
{
MESSAGE("RemoveEdge");
RemoveElement(edge,true);
}
@ -1857,7 +1815,6 @@ void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
{
MESSAGE("RemoveFace");
RemoveElement(face, true);
}
@ -1867,7 +1824,6 @@ void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
{
MESSAGE("RemoveVolume");
RemoveElement(volume, true);
}
@ -1914,7 +1870,6 @@ bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element,
const SMDS_MeshNode * nodes[],
const int nbnodes)
{
MESSAGE("SMDS_Mesh::ChangeElementNodes");
// keep current nodes of elem
set<const SMDS_MeshNode*> oldNodes( element->begin_nodes(), element->end_nodes() );
@ -2428,11 +2383,6 @@ const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const
{
if ( IDelem <= 0 || IDelem >= (int)myCells.size() )
{
MESSAGE("--------------------------------------------------------------------------------- ");
MESSAGE("----------------------------------- bad IDelem " << IDelem << " " << myCells.size());
MESSAGE("--------------------------------------------------------------------------------- ");
// TODO raise an exception
//assert(0);
return 0;
}
return myCells[IDelem];
@ -2505,9 +2455,8 @@ const SMDS_MeshElement* SMDS_Mesh::FindElement (const vector<const SMDS_MeshNode
void SMDS_Mesh::DumpNodes() const
{
MESSAGE("dump nodes of mesh : ");
SMDS_NodeIteratorPtr itnode=nodesIterator();
while(itnode->more()) ; //MESSAGE(itnode->next());
SMDS_NodeIteratorPtr itnode=nodesIterator();
while(itnode->more()) ; //MESSAGE(itnode->next());
}
//=======================================================================
@ -2516,7 +2465,6 @@ void SMDS_Mesh::DumpNodes() const
//=======================================================================
void SMDS_Mesh::Dump0DElements() const
{
MESSAGE("dump 0D elements of mesh : ");
SMDS_ElemIteratorPtr it0d = elementsIterator(SMDSAbs_0DElement);
while(it0d->more()) ; //MESSAGE(it0d->next());
}
@ -2528,9 +2476,8 @@ void SMDS_Mesh::Dump0DElements() const
void SMDS_Mesh::DumpEdges() const
{
MESSAGE("dump edges of mesh : ");
SMDS_EdgeIteratorPtr itedge=edgesIterator();
while(itedge->more()) ; //MESSAGE(itedge->next());
SMDS_EdgeIteratorPtr itedge=edgesIterator();
while(itedge->more()) ; //MESSAGE(itedge->next());
}
//=======================================================================
@ -2540,9 +2487,8 @@ void SMDS_Mesh::DumpEdges() const
void SMDS_Mesh::DumpFaces() const
{
MESSAGE("dump faces of mesh : ");
SMDS_FaceIteratorPtr itface=facesIterator();
while(itface->more()) ; //MESSAGE(itface->next());
SMDS_FaceIteratorPtr itface=facesIterator();
while(itface->more()) ; //MESSAGE(itface->next());
}
//=======================================================================
@ -2552,9 +2498,8 @@ void SMDS_Mesh::DumpFaces() const
void SMDS_Mesh::DumpVolumes() const
{
MESSAGE("dump volumes of mesh : ");
SMDS_VolumeIteratorPtr itvol=volumesIterator();
while(itvol->more()) ; //MESSAGE(itvol->next());
SMDS_VolumeIteratorPtr itvol=volumesIterator();
while(itvol->more()) ; //MESSAGE(itvol->next());
}
//=======================================================================
@ -2612,10 +2557,7 @@ void SMDS_Mesh::DebugStats() const
///////////////////////////////////////////////////////////////////////////////
int SMDS_Mesh::NbNodes() const
{
//MESSAGE(myGrid->GetNumberOfPoints());
//MESSAGE(myInfo.NbNodes());
//MESSAGE(myNodeMax);
return myInfo.NbNodes();
return myInfo.NbNodes();
}
///////////////////////////////////////////////////////////////////////////////
@ -2718,7 +2660,6 @@ SMDS_Mesh::~SMDS_Mesh()
void SMDS_Mesh::Clear()
{
MESSAGE("SMDS_Mesh::Clear");
if (myParent!=NULL)
{
SMDS_ElemIteratorPtr eIt = elementsIterator();
@ -3077,34 +3018,31 @@ static set<const SMDS_MeshElement*> * intersectionOfSets(
///////////////////////////////////////////////////////////////////////////////
static set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement * element)
{
int numberOfSets=element->NbNodes();
set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];
int numberOfSets=element->NbNodes();
set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];
SMDS_ElemIteratorPtr itNodes=element->nodesIterator();
SMDS_ElemIteratorPtr itNodes=element->nodesIterator();
int i=0;
while(itNodes->more())
{
const SMDS_MeshElement* node = itNodes->next();
MYASSERT(node);
const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(node);
SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
int i = 0;
while ( itNodes->more() )
{
const SMDS_MeshElement* node = itNodes->next();
MYASSERT(node);
const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(node);
SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
//initSet[i]=set<const SMDS_MeshElement*>();
while(itFe->more())
{
const SMDS_MeshElement* elem = itFe->next();
MYASSERT(elem);
initSet[i].insert(elem);
while ( itFe->more() )
{
const SMDS_MeshElement* elem = itFe->next();
MYASSERT(elem);
initSet[i].insert(elem);
}
}
i++;
}
set<const SMDS_MeshElement*> *retSet=intersectionOfSets(initSet, numberOfSets);
// MESSAGE("nb elems " << i << " intersection " << retSet->size());
delete [] initSet;
return retSet;
i++;
}
set<const SMDS_MeshElement*> *retSet = intersectionOfSets( initSet, numberOfSets );
delete [] initSet;
return retSet;
}
///////////////////////////////////////////////////////////////////////////////
@ -3401,11 +3339,9 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
{
int elemId = elem->GetID();
int vtkId = elem->getVtkId();
//MESSAGE("RemoveFreeElement " << elemId);
SMDSAbs_ElementType aType = elem->GetType();
SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
if (aType == SMDSAbs_Node) {
//MESSAGE("Remove free node " << elemId);
// only free node can be removed by this method
const SMDS_MeshNode* n = static_cast<SMDS_MeshNode*>(todest);
SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
@ -3422,7 +3358,6 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
// this methods is only for meshes without descendants
return;
//MESSAGE("Remove free element " << elemId);
// Remove element from <InverseElements> of its nodes
SMDS_ElemIteratorPtr itn = elem->nodesIterator();
while (itn->more()) {
@ -3538,7 +3473,6 @@ int SMDS_Mesh::MinElementID() const
void SMDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
{
MESSAGE("Renumber");
if ( deltaID == 0 )
return;
@ -4709,17 +4643,14 @@ void SMDS_Mesh::incrementNodesCapacity(int nbNodes)
// MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << val << " --> " << val + nbNodes);
// myCellIdSmdsToVtk.resize(val + nbNodes, -1); // fill new elements with -1
int val = myNodes.size();
MESSAGE(" ------------------- resize myNodes " << val << " --> " << val + nbNodes);
myNodes.resize(val +nbNodes, 0);
}
void SMDS_Mesh::incrementCellsCapacity(int nbCells)
{
int val = myCellIdVtkToSmds.size();
MESSAGE(" ------------------- resize myCellIdVtkToSmds " << val << " --> " << val + nbCells);
myCellIdVtkToSmds.resize(val + nbCells, -1); // fill new elements with -1
val = myCells.size();
MESSAGE(" ------------------- resize myCells " << val << " --> " << val + nbCells);
myNodes.resize(val +nbCells, 0);
}
@ -4730,48 +4661,45 @@ void SMDS_Mesh::adjustStructure()
void SMDS_Mesh::dumpGrid(string ficdump)
{
MESSAGE("SMDS_Mesh::dumpGrid " << ficdump);
// vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
// aWriter->SetFileName(ficdump.c_str());
// aWriter->SetInput(myGrid);
// if(myGrid->GetNumberOfCells())
// {
// aWriter->Write();
// }
// aWriter->Delete();
// vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
// aWriter->SetFileName(ficdump.c_str());
// aWriter->SetInput(myGrid);
// if(myGrid->GetNumberOfCells())
// {
// aWriter->Write();
// }
// aWriter->Delete();
ficdump = ficdump + "_connectivity";
ofstream ficcon(ficdump.c_str(), ios::out);
int nbPoints = myGrid->GetNumberOfPoints();
ficcon << "-------------------------------- points " << nbPoints << endl;
for (int i=0; i<nbPoints; i++)
{
ficcon << i << " " << *(myGrid->GetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl;
ficcon << i << " " << *(myGrid->GetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl;
}
int nbCells = myGrid->GetNumberOfCells();
ficcon << "-------------------------------- cells " << nbCells << endl;
for (int i=0; i<nbCells; i++)
{
// MESSAGE(i << " " << myGrid->GetCell(i));
// MESSAGE(" " << myGrid->GetCell(i)->GetCellType());
ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -";
int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints();
vtkIdList *listid = myGrid->GetCell(i)->GetPointIds();
for (int j=0; j<nbptcell; j++)
{
ficcon << " " << listid->GetId(j);
}
ficcon << endl;
ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -";
int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints();
vtkIdList *listid = myGrid->GetCell(i)->GetPointIds();
for (int j=0; j<nbptcell; j++)
{
ficcon << " " << listid->GetId(j);
}
ficcon << endl;
}
ficcon << "-------------------------------- connectivity " << nbPoints << endl;
vtkCellLinks *links = myGrid->GetCellLinks();
vtkCellLinks *links = myGrid->GetCellLinks();
for (int i=0; i<nbPoints; i++)
{
int ncells = links->GetNcells(i);
vtkIdType *cells = links->GetCells(i);
ficcon << i << " - " << ncells << " -";
for (int j=0; j<ncells; j++)
{
ficcon << " " << cells[j];
int ncells = links->GetNcells(i);
vtkIdType *cells = links->GetCells(i);
ficcon << i << " - " << ncells << " -";
for (int j=0; j<ncells; j++)
{
ficcon << " " << cells[j];
}
ficcon << endl;
}
@ -4820,7 +4748,6 @@ double SMDS_Mesh::getMaxDim()
if ((xmax - xmin) > dmax) dmax = xmax -xmin;
if ((ymax - ymin) > dmax) dmax = ymax -ymin;
if ((zmax - zmin) > dmax) dmax = zmax -zmin;
MESSAGE("getMaxDim " << dmax);
return dmax;
}
@ -4828,11 +4755,10 @@ double SMDS_Mesh::getMaxDim()
void SMDS_Mesh::Modified()
{
if (this->myModified)
{
this->myModifTime++;
MESSAGE("modified");
myModified = false;
}
{
this->myModifTime++;
myModified = false;
}
}
//! get last modification timeStamp
@ -4844,10 +4770,9 @@ unsigned long SMDS_Mesh::GetMTime() const
bool SMDS_Mesh::isCompacted()
{
if (this->myModifTime > this->myCompactTime)
{
MESSAGE(" *** isCompacted " << myCompactTime << " < " << myModifTime);
this->myCompactTime = this->myModifTime;
return false;
}
{
this->myCompactTime = this->myModifTime;
return false;
}
return true;
}

41
src/SMDS/SMDS_MeshIDFactory.cxx
View File

@ -42,25 +42,23 @@ SMDS_MeshIDFactory::SMDS_MeshIDFactory():myMaxID(0), myMesh(0)
int SMDS_MeshIDFactory::GetFreeID()
{
int newid;
if (myPoolOfID.empty())
{
newid = ++myMaxID;
//MESSAGE("GetFreeID new " << newid);
}
else
{
set<int>::iterator i = myPoolOfID.begin();
newid = *i;//myPoolOfID.top();
myPoolOfID.erase( i );//myPoolOfID.pop();
//MESSAGE("GetFreeID pool " << newid);
}
return newid;
int newid;
if (myPoolOfID.empty())
{
newid = ++myMaxID;
}
else
{
set<int>::iterator i = myPoolOfID.begin();
newid = *i;//myPoolOfID.top();
myPoolOfID.erase( i );//myPoolOfID.pop();
}
return newid;
}
//=======================================================================
//function : ReleaseID
//purpose :
//purpose :
//=======================================================================
void SMDS_MeshIDFactory::ReleaseID(int ID, int vtkId)
{
@ -91,24 +89,23 @@ void SMDS_MeshIDFactory::ReleaseID(int ID, int vtkId)
void SMDS_MeshIDFactory::Clear()
{
myMaxID = 0;
myPoolOfID.clear();
myMaxID = 0;
myPoolOfID.clear();
}
void SMDS_MeshIDFactory::SetMesh(SMDS_Mesh *mesh)
{
myMesh = mesh;
myMesh = mesh;
}
SMDS_Mesh* SMDS_MeshIDFactory::GetMesh()
{
return myMesh;
return myMesh;
}
void SMDS_MeshIDFactory::emptyPool(int maxId)
{
MESSAGE("SMDS_MeshIDFactory::emptyPool " << myMaxID << " --> " << maxId);
myMaxID = maxId;
myPoolOfID.clear();
myMaxID = maxId;
myPoolOfID.clear();
}

138
src/SMDS/SMDS_UnstructuredGrid.cxx
View File

@ -40,7 +40,6 @@ using namespace std;
SMDS_CellLinks* SMDS_CellLinks::New()
{
MESSAGE("SMDS_CellLinks::New");
return new SMDS_CellLinks();
}
@ -65,7 +64,6 @@ SMDS_CellLinks::~SMDS_CellLinks()
SMDS_UnstructuredGrid* SMDS_UnstructuredGrid::New()
{
MESSAGE("SMDS_UnstructuredGrid::New");
return new SMDS_UnstructuredGrid();
}
@ -85,27 +83,23 @@ SMDS_UnstructuredGrid::~SMDS_UnstructuredGrid()
unsigned long SMDS_UnstructuredGrid::GetMTime()
{
unsigned long mtime = vtkUnstructuredGrid::GetMTime();
MESSAGE("vtkUnstructuredGrid::GetMTime: " << mtime);
return mtime;
}
// OUV_PORTING_VTK6: seems to be useless
/*
void SMDS_UnstructuredGrid::Update()
{
MESSAGE("SMDS_UnstructuredGrid::Update");
return vtkUnstructuredGrid::Update();
}
void SMDS_UnstructuredGrid::UpdateInformation()
{
MESSAGE("SMDS_UnstructuredGrid::UpdateInformation");
return vtkUnstructuredGrid::UpdateInformation();
}
*/
vtkPoints* SMDS_UnstructuredGrid::GetPoints()
{
// TODO erreur incomprehensible de la macro vtk GetPoints apparue avec la version paraview de fin aout 2010
//MESSAGE("*********************** SMDS_UnstructuredGrid::GetPoints " << this->Points << " " << vtkUnstructuredGrid::GetPoints());
return this->Points;
}
@ -116,7 +110,6 @@ int SMDS_UnstructuredGrid::InsertNextLinkedCell(int type, int npts, vtkIdType *p
return vtkUnstructuredGrid::InsertNextLinkedCell(type, npts, pts);
// --- type = VTK_POLYHEDRON
//MESSAGE("InsertNextLinkedCell VTK_POLYHEDRON");
int cellid = this->InsertNextCell(type, npts, pts);
set<vtkIdType> setOfNodes;
@ -129,7 +122,6 @@ int SMDS_UnstructuredGrid::InsertNextLinkedCell(int type, int npts, vtkIdType *p
i++;
for (int k = 0; k < nbnodes; k++)
{
//MESSAGE(" cell " << cellid << " face " << nf << " node " << pts[i]);
setOfNodes.insert(pts[i]);
i++;
}
@ -138,7 +130,6 @@ int SMDS_UnstructuredGrid::InsertNextLinkedCell(int type, int npts, vtkIdType *p
set<vtkIdType>::iterator it = setOfNodes.begin();
for (; it != setOfNodes.end(); ++it)
{
//MESSAGE("reverse link for node " << *it << " cell " << cellid);
this->Links->ResizeCellList(*it, 1);
this->Links->AddCellReference(cellid, *it);
}
@ -155,7 +146,7 @@ void SMDS_UnstructuredGrid::setSMDS_mesh(SMDS_Mesh *mesh)
void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int newNodeSize,
std::vector<int>& idCellsOldToNew, int newCellSize)
{
MESSAGE("------------------------- SMDS_UnstructuredGrid::compactGrid " << newNodeSize << " " << newCellSize);//CHRONO(1);
//MESSAGE("------------------------- compactGrid " << newNodeSize << " " << newCellSize);//CHRONO(1);
int alreadyCopied = 0;
// --- if newNodeSize, create a new compacted vtkPoints
@ -165,7 +156,6 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
newPoints->SetNumberOfPoints(newNodeSize);
if (newNodeSize)
{
MESSAGE("-------------- compactGrid, newNodeSize " << newNodeSize);
// rnv: to fix bug "21125: EDF 1233 SMESH: Degradation of precision in a test case for quadratic conversion"
// using double type for storing coordinates of nodes instead float.
int oldNodeSize = idNodesOldToNew.size();
@ -194,7 +184,6 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
newConnectivity->Initialize();
int oldCellDataSize = this->Connectivity->GetData()->GetSize();
newConnectivity->Allocate(oldCellDataSize);
MESSAGE("oldCellSize="<< oldCellSize << " oldCellDataSize=" << oldCellDataSize);
vtkUnsignedCharArray *newTypes = vtkUnsignedCharArray::New();
newTypes->Initialize();
@ -230,11 +219,9 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
newConnectivity->Squeeze();
if (1/*newNodeSize*/)
{
MESSAGE("------- newNodeSize, setPoints");
this->SetPoints(newPoints);
MESSAGE("NumberOfPoints: " << this->GetNumberOfPoints());
}
{
this->SetPoints(newPoints);
}
if (vtkDoubleArray* diameters =
vtkDoubleArray::SafeDownCast( vtkDataSet::CellData->GetScalars() )) // Balls
@ -250,46 +237,46 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
}
if (this->FaceLocations)
{
vtkIdTypeArray *newFaceLocations = vtkIdTypeArray::New();
newFaceLocations->Initialize();
newFaceLocations->Allocate(newTypes->GetSize());
vtkIdTypeArray *newFaces = vtkIdTypeArray::New();
newFaces->Initialize();
newFaces->Allocate(this->Faces->GetSize());
for (int i = 0; i < oldCellSize; i++)
{
vtkIdTypeArray *newFaceLocations = vtkIdTypeArray::New();
newFaceLocations->Initialize();
newFaceLocations->Allocate(newTypes->GetSize());
vtkIdTypeArray *newFaces = vtkIdTypeArray::New();
newFaces->Initialize();
newFaces->Allocate(this->Faces->GetSize());
for (int i = 0; i < oldCellSize; i++)
if (this->Types->GetValue(i) == VTK_EMPTY_CELL)
continue;
int newCellId = idCellsOldToNew[i];
if (newTypes->GetValue(newCellId) == VTK_POLYHEDRON)
{
newFaceLocations->InsertNextValue(newFaces->GetMaxId()+1);
int oldFaceLoc = this->FaceLocations->GetValue(i);
int nCellFaces = this->Faces->GetValue(oldFaceLoc++);
newFaces->InsertNextValue(nCellFaces);
for (int n=0; n<nCellFaces; n++)
{
if (this->Types->GetValue(i) == VTK_EMPTY_CELL)
continue;
int newCellId = idCellsOldToNew[i];
if (newTypes->GetValue(newCellId) == VTK_POLYHEDRON)
{
newFaceLocations->InsertNextValue(newFaces->GetMaxId()+1);
int oldFaceLoc = this->FaceLocations->GetValue(i);
int nCellFaces = this->Faces->GetValue(oldFaceLoc++);
newFaces->InsertNextValue(nCellFaces);
for (int n=0; n<nCellFaces; n++)
{
int nptsInFace = this->Faces->GetValue(oldFaceLoc++);
newFaces->InsertNextValue(nptsInFace);
for (int k=0; k<nptsInFace; k++)
{
int oldpt = this->Faces->GetValue(oldFaceLoc++);
newFaces->InsertNextValue(idNodesOldToNew[oldpt]);
}
}
}
else
{
newFaceLocations->InsertNextValue(-1);
}
int nptsInFace = this->Faces->GetValue(oldFaceLoc++);
newFaces->InsertNextValue(nptsInFace);
for (int k=0; k<nptsInFace; k++)
{
int oldpt = this->Faces->GetValue(oldFaceLoc++);
newFaces->InsertNextValue(idNodesOldToNew[oldpt]);
}
}
newFaceLocations->Squeeze();
newFaces->Squeeze();
this->SetCells(newTypes, newLocations, newConnectivity, newFaceLocations, newFaces);
newFaceLocations->Delete();
newFaces->Delete();
}
else
{
newFaceLocations->InsertNextValue(-1);
}
}
newFaceLocations->Squeeze();
newFaces->Squeeze();
this->SetCells(newTypes, newLocations, newConnectivity, newFaceLocations, newFaces);
newFaceLocations->Delete();
newFaces->Delete();
}
else
{
this->SetCells(newTypes, newLocations, newConnectivity, FaceLocations, Faces);
@ -302,10 +289,12 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector<int>& idNodesOldToNew, int n
this->BuildLinks();
}
void SMDS_UnstructuredGrid::copyNodes(vtkPoints *newPoints, std::vector<int>& idNodesOldToNew, int& alreadyCopied,
int start, int end)
void SMDS_UnstructuredGrid::copyNodes(vtkPoints * newPoints,
std::vector<int>& idNodesOldToNew,
int& alreadyCopied,
int start,
int end)
{
MESSAGE("copyNodes " << alreadyCopied << " " << start << " " << end << " size: " << end - start << " total: " << alreadyCopied + end - start);
void *target = newPoints->GetVoidPointer(3 * alreadyCopied);
void *source = this->Points->GetVoidPointer(3 * start);
int nbPoints = end - start;
@ -327,7 +316,6 @@ void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray *newTypes,
int start,
int end)
{
//MESSAGE("copyBloc " << alreadyCopied << " " << start << " " << end << " size: " << end - start << " total: " << alreadyCopied + end - start);
for (int j = start; j < end; j++)
{
newTypes->SetValue(alreadyCopied, this->Types->GetValue(j));
@ -337,16 +325,13 @@ void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray *newTypes,
vtkIdType *oldPtsCell = 0;
this->Connectivity->GetCell(oldLoc, nbpts, oldPtsCell);
assert(nbpts < NBMAXNODESINCELL);
//MESSAGE(j << " " << alreadyCopied << " " << (int)this->Types->GetValue(j) << " " << oldLoc << " " << nbpts );
for (int l = 0; l < nbpts; l++)
{
int oldval = oldPtsCell[l];
pointsCell[l] = idNodesOldToNew[oldval];
//MESSAGE(" " << oldval << " " << pointsCell[l]);
}
/*int newcnt = */newConnectivity->InsertNextCell(nbpts, pointsCell);
int newLoc = newConnectivity->GetInsertLocation(nbpts);
//MESSAGE(newcnt << " " << newLoc);
newLocations->SetValue(alreadyCopied, newLoc);
alreadyCopied++;
}
@ -356,8 +341,6 @@ int SMDS_UnstructuredGrid::CellIdToDownId(int vtkCellId)
{
if ((vtkCellId < 0) || (vtkCellId >= (int)_cellIdToDownId.size()))
{
//MESSAGE("SMDS_UnstructuredGrid::CellIdToDownId structure not up to date: vtkCellId="
// << vtkCellId << " max="<< _cellIdToDownId.size());
return -1;
}
return _cellIdToDownId[vtkCellId];
@ -1016,12 +999,13 @@ void SMDS_UnstructuredGrid::BuildLinks()
* @param nodeDomains: map(original id --> map(domain --> duplicated node id))
* @return ok if success.
*/
SMDS_MeshCell* SMDS_UnstructuredGrid::extrudeVolumeFromFace(int vtkVolId,
int domain1,
int domain2,
std::set<int>& originalNodes,
std::map<int, std::map<int, int> >& nodeDomains,
std::map<int, std::map<long, int> >& nodeQuadDomains)
SMDS_MeshCell*
SMDS_UnstructuredGrid::extrudeVolumeFromFace(int vtkVolId,
int domain1,
int domain2,
std::set<int>& originalNodes,
std::map<int, std::map<int, int> >& nodeDomains,
std::map<int, std::map<long, int> >& nodeQuadDomains)
{
//MESSAGE("extrudeVolumeFromFace " << vtkVolId);
vector<vtkIdType> orderedOriginals;
@ -1037,16 +1021,16 @@ SMDS_MeshCell* SMDS_UnstructuredGrid::extrudeVolumeFromFace(int vtkVolId,
bool isQuadratic = false;
switch (orderedOriginals.size())
{
case 3:
if (dim == 2)
isQuadratic = true;
break;
case 6:
case 8:
case 3:
if (dim == 2)
isQuadratic = true;
break;
default:
isQuadratic = false;
break;
case 6:
case 8:
isQuadratic = true;
break;
default:
isQuadratic = false;
break;
}

16
src/SMESH/SMESH_Gen.cxx
View File

@ -64,12 +64,10 @@ using namespace std;
SMESH_Gen::SMESH_Gen()
{
MESSAGE("SMESH_Gen::SMESH_Gen");
_localId = 0;
_hypId = 0;
_segmentation = _nbSegments = 10;
SMDS_Mesh::_meshList.clear();
MESSAGE(SMDS_Mesh::_meshList.size());
_compute_canceled = false;
//vtkDebugLeaks::SetExitError(0);
}
@ -82,7 +80,6 @@ SMESH_Gen::SMESH_Gen()
SMESH_Gen::~SMESH_Gen()
{
MESSAGE("SMESH_Gen::~SMESH_Gen");
std::map < int, StudyContextStruct * >::iterator i_sc = _mapStudyContext.begin();
for ( ; i_sc != _mapStudyContext.end(); ++i_sc )
{
@ -102,7 +99,6 @@ SMESH_Mesh* SMESH_Gen::CreateMesh(int theStudyId, bool theIsEmbeddedMode)
throw(SALOME_Exception)
{
Unexpect aCatch(SalomeException);
MESSAGE("SMESH_Gen::CreateMesh");
// Get studyContext, create it if it does'nt exist, with a SMESHDS_Document
StudyContextStruct *aStudyContext = GetStudyContext(theStudyId);
@ -131,7 +127,6 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
const ::MeshDimension aDim /*=::MeshDim_3D*/,
TSetOfInt* aShapesId /*=0*/)
{
MESSAGE("SMESH_Gen::Compute");
MEMOSTAT;
bool ret = true;
@ -369,11 +364,10 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
ret = Compute( aMesh, aShape, aShapeOnly, /*anUpward=*/true, aDim, aShapesId );
}
MESSAGE( "VSR - SMESH_Gen::Compute() finished, OK = " << ret);
MEMOSTAT;
SMESHDS_Mesh *myMesh = aMesh.GetMeshDS();
MESSAGE("*** compactMesh after compute");
//MESSAGE("*** compactMesh after compute");
myMesh->compactMesh();
// fix quadratic mesh by bending iternal links near concave boundary
@ -463,8 +457,6 @@ bool SMESH_Gen::Evaluate(SMESH_Mesh & aMesh,
const bool anUpward,
TSetOfInt* aShapesId)
{
MESSAGE("SMESH_Gen::Evaluate");
bool ret = true;
SMESH_subMesh *sm = aMesh.GetSubMesh(aShape);
@ -707,8 +699,6 @@ static bool checkMissing(SMESH_Gen* aGen,
if ( aCheckedMap.count( aSubMesh ))
return true;
//MESSAGE("=====checkMissing");
int ret = true;
SMESH_Algo* algo = 0;
@ -829,8 +819,6 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh,
const TopoDS_Shape& theShape,
list< TAlgoStateError > & theErrors)
{
//MESSAGE("SMESH_Gen::CheckAlgoState");
bool ret = true;
bool hasAlgo = false;
@ -908,8 +896,6 @@ bool SMESH_Gen::GetAlgoState(SMESH_Mesh& theMesh,
// well defined
// ----------------------------------------------------------------
//MESSAGE( "---info on missing hypothesis and find out if all needed algos are");
// find max dim of global algo
int aTopAlgoDim = 0;
for (dim = 3; dim > 0; dim--)

3
src/SMESH/SMESH_Hypothesis.cxx
View File

@ -59,7 +59,6 @@ SMESH_Hypothesis::SMESH_Hypothesis(int hypId,
SMESH_Hypothesis::~SMESH_Hypothesis()
{
MESSAGE("SMESH_Hypothesis::~SMESH_Hypothesis");
StudyContextStruct* myStudyContext = _gen->GetStudyContext(_studyId);
myStudyContext->mapHypothesis[_hypId] = 0;
}
@ -115,8 +114,6 @@ int SMESH_Hypothesis::GetStudyId() const
void SMESH_Hypothesis::NotifySubMeshesHypothesisModification()
{
MESSAGE("SMESH_Hypothesis::NotifySubMeshesHypothesisModification");
// for all meshes in study
StudyContextStruct* myStudyContext = _gen->GetStudyContext(_studyId);

19
src/SMESH/SMESH_Mesh.cxx
View File

@ -112,7 +112,7 @@ SMESH_Mesh::SMESH_Mesh(int theLocalId,
SMESHDS_Document* theDocument):
_groupId( 0 ), _nbSubShapes( 0 )
{
MESSAGE("SMESH_Mesh::SMESH_Mesh(int localId)");
if(MYDEBUG) MESSAGE("SMESH_Mesh::SMESH_Mesh(int localId)");
_id = theLocalId;
_studyId = theStudyId;
_gen = theGen;
@ -179,7 +179,7 @@ namespace
SMESH_Mesh::~SMESH_Mesh()
{
MESSAGE("SMESH_Mesh::~SMESH_Mesh");
if(MYDEBUG) MESSAGE("SMESH_Mesh::~SMESH_Mesh");
// avoid usual removal of elements while processing RemoveHypothesis( algo ) event
SMESHDS_SubMeshIteratorPtr smIt = _myMeshDS->SubMeshes();
@ -361,10 +361,19 @@ double SMESH_Mesh::GetShapeDiagonalSize(const TopoDS_Shape & aShape)
int nbFaces = 0;
for ( TopExp_Explorer f( aShape, TopAbs_FACE ); f.More() && nbFaces < maxNbFaces; f.Next() )
++nbFaces;
bool isPrecise = false;
if ( nbFaces < maxNbFaces )
GEOMUtils::PreciseBoundingBox(aShape, Box);
else
BRepBndLib::Add( aShape, Box);
try {
GEOMUtils::PreciseBoundingBox( aShape, Box );
isPrecise = true;
}
catch (...) {
isPrecise = false;
}
if ( !isPrecise )
{
BRepBndLib::Add( aShape, Box );
}
if ( !Box.IsVoid() )
return sqrt( Box.SquareExtent() );
}

58
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -683,7 +683,6 @@ static bool getNodesFromTwoTria(const SMDS_MeshElement * theTria1,
bool SMESH_MeshEditor::InverseDiag (const SMDS_MeshElement * theTria1,
const SMDS_MeshElement * theTria2 )
{
MESSAGE("InverseDiag");
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
@ -888,8 +887,6 @@ bool SMESH_MeshEditor::InverseDiag (const SMDS_MeshNode * theNode1,
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
MESSAGE( "::InverseDiag()" );
const SMDS_MeshElement *tr1, *tr2;
if ( !findTriangles( theNode1, theNode2, tr1, tr2 ))
return false;
@ -1011,8 +1008,6 @@ bool SMESH_MeshEditor::DeleteDiag (const SMDS_MeshNode * theNode1,
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
MESSAGE( "::DeleteDiag()" );
const SMDS_MeshElement *tr1, *tr2;
if ( !findTriangles( theNode1, theNode2, tr1, tr2 ))
return false;
@ -1105,7 +1100,6 @@ bool SMESH_MeshEditor::DeleteDiag (const SMDS_MeshNode * theNode1,
bool SMESH_MeshEditor::Reorient (const SMDS_MeshElement * theElem)
{
MESSAGE("Reorient");
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
@ -1518,7 +1512,7 @@ void SMESH_MeshEditor::QuadTo4Tri (TIDSortedElemSet & theElems)
gp_XY uv [9]; uv[8] = gp_XY(0,0);
gp_XYZ xyz[9];
vector< const SMDS_MeshNode* > nodes;
SMESHDS_SubMesh* subMeshDS;
SMESHDS_SubMesh* subMeshDS = 0;
TopoDS_Face F;
Handle(Geom_Surface) surface;
TopLoc_Location loc;
@ -2931,8 +2925,6 @@ bool SMESH_MeshEditor::QuadToTri (TIDSortedElemSet & theElems,
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
MESSAGE( "::QuadToTri()" );
SMESHDS_Mesh * aMesh = GetMeshDS();
Handle(Geom_Surface) surface;
@ -3153,8 +3145,6 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet & theElems,
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
MESSAGE( "::TriToQuad()" );
if ( !theCrit.get() )
return false;
@ -3259,7 +3249,7 @@ bool SMESH_MeshEditor::TriToQuad (TIDSortedElemSet & theElems,
if ( startElem ) {
// Get candidates to be fused
const SMDS_MeshElement *tr1 = startElem, *tr2 = 0, *tr3 = 0;
const SMESH_TLink *link12, *link13;
const SMESH_TLink *link12 = 0, *link13 = 0;
startElem = 0;
ASSERT( mapEl_setLi.find( tr1 ) != mapEl_setLi.end() );
set< SMESH_TLink >& setLi = mapEl_setLi[ tr1 ];
@ -3938,8 +3928,6 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet & theElems,
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
MESSAGE((theSmoothMethod==LAPLACIAN ? "LAPLACIAN" : "CENTROIDAL") << "--::Smooth()");
if ( theTgtAspectRatio < 1.0 )
theTgtAspectRatio = 1.0;
@ -4476,7 +4464,6 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement* elem,
const size_t nbSteps,
SMESH_SequenceOfElemPtr& srcElements)
{
//MESSAGE("sweepElement " << nbSteps);
SMESHDS_Mesh* aMesh = GetMeshDS();
const int nbNodes = elem->NbNodes();
@ -5368,7 +5355,6 @@ SMESH_MeshEditor::RotationSweep(TIDSortedElemSet theElemSets[2],
// source elements for each generated one
SMESH_SequenceOfElemPtr srcElems, srcNodes;
MESSAGE( "RotationSweep()");
gp_Trsf aTrsf;
aTrsf.SetRotation( theAxis, theAngle );
gp_Trsf aTrsf2;
@ -5939,7 +5925,6 @@ SMESH_MeshEditor::ExtrusionAlongTrack (TIDSortedElemSet theElements[2],
const gp_Pnt& theRefPoint,
const bool theMakeGroups)
{
MESSAGE("ExtrusionAlongTrack");
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
@ -6732,37 +6717,29 @@ SMESH_MeshEditor::Transform (TIDSortedElemSet & theElems,
string groupPostfix;
switch ( theTrsf.Form() ) {
case gp_PntMirror:
MESSAGE("gp_PntMirror");
needReverse = true;
groupPostfix = "mirrored";
break;
case gp_Ax1Mirror:
MESSAGE("gp_Ax1Mirror");
groupPostfix = "mirrored";
break;
case gp_Ax2Mirror:
MESSAGE("gp_Ax2Mirror");
needReverse = true;
groupPostfix = "mirrored";
break;
case gp_Rotation:
MESSAGE("gp_Rotation");
groupPostfix = "rotated";
break;
case gp_Translation:
MESSAGE("gp_Translation");
groupPostfix = "translated";
break;
case gp_Scale:
MESSAGE("gp_Scale");
groupPostfix = "scaled";
break;
case gp_CompoundTrsf: // different scale by axis
MESSAGE("gp_CompoundTrsf");
groupPostfix = "scaled";
break;
default:
MESSAGE("default");
needReverse = false;
groupPostfix = "transformed";
}
@ -7271,7 +7248,6 @@ int SMESH_MeshEditor::SimplifyFace (const vector<const SMDS_MeshNode *>& faceNod
void SMESH_MeshEditor::MergeNodes (TListOfListOfNodes & theGroupsOfNodes)
{
MESSAGE("MergeNodes");
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
@ -8120,7 +8096,6 @@ SMESH_MeshEditor::SewFreeBorder (const SMDS_MeshNode* theBordFirstNode,
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
MESSAGE("::SewFreeBorder()");
Sew_Error aResult = SEW_OK;
// ====================================
@ -8228,7 +8203,7 @@ SMESH_MeshEditor::SewFreeBorder (const SMDS_MeshNode* theBordFirstNode,
//const SMDS_MeshNode* faceNodes[ 4 ];
const SMDS_MeshNode* sideNode;
const SMDS_MeshElement* sideElem;
const SMDS_MeshElement* sideElem = 0;
const SMDS_MeshNode* prevSideNode = theSideFirstNode;
const SMDS_MeshNode* prevBordNode = theBordFirstNode;
nBordIt = bordNodes.begin();
@ -8253,7 +8228,7 @@ SMESH_MeshEditor::SewFreeBorder (const SMDS_MeshNode* theBordFirstNode,
{
const SMDS_MeshElement* elem = invElemIt->next();
// prepare data for a loop on links coming to prevSideNode, of a face or a volume
int iPrevNode, iNode = 0, nbNodes = elem->NbNodes();
int iPrevNode = 0, iNode = 0, nbNodes = elem->NbNodes();
vector< const SMDS_MeshNode* > faceNodes( nbNodes, (const SMDS_MeshNode*)0 );
bool isVolume = volume.Set( elem );
const SMDS_MeshNode** nodes = isVolume ? volume.GetNodes() : & faceNodes[0];
@ -8801,7 +8776,7 @@ void SMESH_MeshEditor::InsertNodesIntoLink(const SMDS_MeshElement* theElemen
}
// decide how to split a quadrangle: compare possible variants
// and choose which of splits to be a quadrangle
int i1, i2, iSplit, nbSplits = nbLinkNodes - 1, iBestQuad;
int i1, i2, iSplit, nbSplits = nbLinkNodes - 1, iBestQuad = 0;
if ( nbFaceNodes == 3 ) {
iBestQuad = nbSplits;
i4 = i3;
@ -9757,7 +9732,6 @@ SMESH_MeshEditor::SewSideElements (TIDSortedElemSet& theSide1,
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
MESSAGE ("::::SewSideElements()");
if ( theSide1.size() != theSide2.size() )
return SEW_DIFF_NB_OF_ELEMENTS;
@ -10436,7 +10410,7 @@ void SMESH_MeshEditor::DoubleElements( const TIDSortedElemSet& theElements )
// get an element type and an iterator over elements
SMDSAbs_ElementType type;
SMDSAbs_ElementType type = SMDSAbs_All;
SMDS_ElemIteratorPtr elemIt;
vector< const SMDS_MeshElement* > allElems;
if ( theElements.empty() )
@ -10538,7 +10512,6 @@ bool SMESH_MeshEditor::doubleNodes(SMESHDS_Mesh* theMeshDS,
TNodeNodeMap& theNodeNodeMap,
const bool theIsDoubleElem )
{
MESSAGE("doubleNodes");
// iterate through element and duplicate them (by nodes duplication)
bool res = false;
std::vector<const SMDS_MeshNode*> newNodes;
@ -10603,7 +10576,6 @@ bool SMESH_MeshEditor::doubleNodes(SMESHDS_Mesh* theMeshDS,
bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes,
const std::list< int >& theListOfModifiedElems )
{
MESSAGE("DoubleNodes");
myLastCreatedElems.Clear();
myLastCreatedNodes.Clear();
@ -10677,10 +10649,9 @@ bool SMESH_MeshEditor::DoubleNodes( const std::list< int >& theListOfNodes,
const SMDS_MeshElement* anElem = anElemToNodesIter->first;
vector<const SMDS_MeshNode*> aNodeArr = anElemToNodesIter->second;
if ( anElem )
{
MESSAGE("ChangeElementNodes");
{
aMeshDS->ChangeElementNodes( anElem, &aNodeArr[ 0 ], anElem->NbNodes() );
}
}
}
return true;
@ -10788,7 +10759,6 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
continue;
gp_XYZ normal;
SMESH_MeshAlgos::FaceNormal( anElem, normal, /*normalized=*/true );
MESSAGE("element " << ielem++ << " normal " << normal.X() << " " << normal.Y() << " " << normal.Z());
std::set<const SMDS_MeshNode*> nodesElem;
nodesElem.clear();
SMDS_ElemIteratorPtr nodeItr = anElem->nodesIterator();
@ -10800,7 +10770,6 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
std::set<const SMDS_MeshNode*>::iterator nodit = nodesElem.begin();
for (; nodit != nodesElem.end(); nodit++)
{
MESSAGE(" noeud ");
const SMDS_MeshNode* aNode = *nodit;
if ( !aNode || theNodesNot.find(aNode) != theNodesNot.end() )
continue;
@ -10810,7 +10779,6 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
SMDS_ElemIteratorPtr backElemItr = aNode->GetInverseElementIterator();
while ( backElemItr->more() )
{
MESSAGE(" backelem ");
const SMDS_MeshElement* curElem = backElemItr->next();
if (alreadyCheckedElems.find(curElem) != alreadyCheckedElems.end())
continue;
@ -10832,10 +10800,8 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
p.SetCoord( x/nb -aNode->X(),
y/nb -aNode->Y(),
z/nb -aNode->Z() );
MESSAGE(" check " << p.X() << " " << p.Y() << " " << p.Z());
if (normal*p > 0)
{
MESSAGE(" --- inserted")
theAffectedElems.insert( curElem );
}
else if (curElem->GetType() == SMDSAbs_Edge)
@ -10861,7 +10827,6 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
}
if (onside)
{
MESSAGE(" --- edge onside inserted")
theAffectedElems.insert(anEdge);
}
}
@ -10886,21 +10851,18 @@ bool SMESH_MeshEditor::AffectedElemGroupsInRegion( const TIDSortedElemSet& theEl
int ielem;
for ( ielem = 1; elemItr != theElems.end(); ++elemItr )
{
MESSAGE("element " << ielem++);
SMDS_MeshElement* anElem = (SMDS_MeshElement*)*elemItr;
if (!anElem)
continue;
SMDS_ElemIteratorPtr nodeItr = anElem->nodesIterator();
while ( nodeItr->more() )
{
MESSAGE(" noeud ");
const SMDS_MeshNode* aNode = cast2Node(nodeItr->next());
if ( !aNode || theNodesNot.find(aNode) != theNodesNot.end() )
continue;
SMDS_ElemIteratorPtr backElemItr = aNode->GetInverseElementIterator();
while ( backElemItr->more() )
{
MESSAGE(" backelem ");
const SMDS_MeshElement* curElem = backElemItr->next();
if ( curElem && theElems.find(curElem) == theElems.end() &&
( bsc3d.get() ?
@ -10986,10 +10948,6 @@ bool SMESH_MeshEditor::DoubleNodesInRegion( const TIDSortedElemSet& theElems,
*/
double SMESH_MeshEditor::OrientedAngle(const gp_Pnt& p0, const gp_Pnt& p1, const gp_Pnt& g1, const gp_Pnt& g2)
{
// MESSAGE(" p0: " << p0.X() << " " << p0.Y() << " " << p0.Z());
// MESSAGE(" p1: " << p1.X() << " " << p1.Y() << " " << p1.Z());
// MESSAGE(" g1: " << g1.X() << " " << g1.Y() << " " << g1.Z());
// MESSAGE(" g2: " << g2.X() << " " << g2.Y() << " " << g2.Z());
gp_Vec vref(p0, p1);
gp_Vec v1(p0, g1);
gp_Vec v2(p0, g2);

42
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -308,11 +308,18 @@ void SMESH_MesherHelper::SetSubShape(const TopoDS_Shape& aSh)
{
double f,l, r = 0.2345;
Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface( edge, face, f, l );
uv2 = C2d->Value( f * r + l * ( 1.-r ));
if ( du < Precision::PConfusion() )
isSeam = ( Abs( uv1.Coord(1) - uv2.Coord(1) ) < Precision::PConfusion() );
if ( C2d.IsNull() )
{
isSeam = false;
}
else
isSeam = ( Abs( uv1.Coord(2) - uv2.Coord(2) ) < Precision::PConfusion() );
{
uv2 = C2d->Value( f * r + l * ( 1.-r ));
if ( du < Precision::PConfusion() )
isSeam = ( Abs( uv1.Coord(1) - uv2.Coord(1) ) < Precision::PConfusion() );
else
isSeam = ( Abs( uv1.Coord(2) - uv2.Coord(2) ) < Precision::PConfusion() );
}
}
}
if ( isSeam )
@ -653,8 +660,7 @@ gp_XY SMESH_MesherHelper::GetNodeUV(const TopoDS_Face& F,
{
if ( !IsSubShape( V, F ))
{
MESSAGE ( "SMESH_MesherHelper::GetNodeUV(); Vertex " << vertexID
<< " not in face " << GetMeshDS()->ShapeToIndex( F ) );
MESSAGE("GetNodeUV() Vertex "<< vertexID <<" not in face "<< GetMeshDS()->ShapeToIndex(F));
// get UV of a vertex closest to the node
double dist = 1e100;
gp_Pnt pn = XYZ( n );
@ -1073,7 +1079,6 @@ bool SMESH_MesherHelper::CheckNodeU(const TopoDS_Edge& E,
}
Quantity_Parameter U = projector->LowerDistanceParameter();
u = double( U );
MESSAGE(" f " << f << " l " << l << " u " << u);
curvPnt = curve->Value( u );
dist = nodePnt.Distance( curvPnt );
if ( distXYZ ) {
@ -1083,8 +1088,7 @@ bool SMESH_MesherHelper::CheckNodeU(const TopoDS_Edge& E,
}
if ( dist > tol )
{
MESSAGE( "SMESH_MesherHelper::CheckNodeU(), invalid projection" );
MESSAGE("distance " << dist << " " << tol );
MESSAGE( "CheckNodeU(), invalid projection; distance " << dist << "; tol " << tol );
return false;
}
// store the fixed U on the edge
@ -1609,7 +1613,7 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
// get type of shape for the new medium node
int faceID = -1, edgeID = -1;
TopoDS_Edge E; double u [2];
TopoDS_Edge E; double u [2] = {0.,0.};
TopoDS_Face F; gp_XY uv[2];
bool uvOK[2] = { true, true };
const bool useCurSubShape = ( !myShape.IsNull() && myShape.ShapeType() == TopAbs_EDGE );
@ -3049,8 +3053,6 @@ bool SMESH_MesherHelper::IsSubShape( const TopoDS_Shape& shape,
if ( shape.IsSame( exp.Current() ))
return true;
}
SCRUTE((shape.IsNull()));
SCRUTE((mainShape.IsNull()));
return false;
}
@ -5324,3 +5326,19 @@ void SMESH_MesherHelper::FixQuadraticElements(SMESH_ComputeErrorPtr& compError,
}
}
}
//================================================================================
/*!
* \brief DEBUG
*/
//================================================================================
void SMESH_MesherHelper::WriteShape(const TopoDS_Shape& s)
{
const char* name = "/tmp/shape.brep";
BRepTools::Write( s, name );
#ifdef _DEBUG_
std::cout << name << std::endl;
#endif
}

2
src/SMESH/SMESH_MesherHelper.hxx
View File

@ -684,6 +684,8 @@ public:
virtual ~SMESH_MesherHelper();
static void WriteShape(const TopoDS_Shape& s);
protected:
/*!

4
src/SMESH/SMESH_Pattern.cxx
View File

@ -499,7 +499,7 @@ static gp_XY project (const SMDS_MeshNode* theNode,
MESSAGE( "SMESH_Pattern: point projection FAILED");
return gp_XY(0.,0.);
}
double u, v, minVal = DBL_MAX;
double u =0, v =0, minVal = DBL_MAX;
for ( int i = theProjectorPS.NbExt(); i > 0; i-- )
if ( theProjectorPS.SquareDistance( i ) < minVal ) {
minVal = theProjectorPS.SquareDistance( i );
@ -2339,7 +2339,7 @@ bool SMESH_Pattern::sortSameSizeWires (TListOfEdgesList & theWire
// " \t vertex: " << vGcVec[iW].X() << " " << vGcVec[iW].Y() << endl;
double minDist = DBL_MAX;
gp_XY & wGc = vGcVec[ iW ];
int bIndex;
int bIndex = 0;
for ( int iB = 0; iB < nbWires; iB++ ) {
if ( bndFound[ iB ] ) continue;
double dist = ( wGc - gcVec[ iB ] ).SquareModulus();

8
src/SMESH/memoire.h
View File

@ -30,14 +30,18 @@ void memostat(const char* f, int l)
#ifdef WIN32
//rnv: TODO: find alternative of the malloc_stats() on windows platform
#else
/* struct mallinfo mem = mallinfo(); */
/* std::cerr << f << ":"<< l << " " << mem.arena << " " << mem.ordblks << " " << mem.hblks << " " << mem.hblkhd << " " << mem.uordblks << " " << mem.fordblks << " " << mem.keepcost << std::endl; */
struct mallinfo mem = mallinfo();
std::cerr << f << ":"<< l << " " << mem.arena << " " << mem.ordblks << " " << mem.hblks << " " << mem.hblkhd << " " << mem.uordblks << " " << mem.fordblks << " " << mem.keepcost << std::endl;
std::cerr << f << ":" << l << " --------------------------" << std::endl;
malloc_stats();
std::cerr << f << ":" << l << " --------------------------" << std::endl;
#endif
}
#if defined(_DEBUG_) || defined(_DEBUG)
#define MEMOSTAT //memostat( __FILE__, __LINE__ )
#else
#define MEMOSTAT
#endif
#endif

18
src/SMESHClient/SMESH_Client.cxx
View File

@ -54,7 +54,7 @@
#endif
#ifdef _DEBUG_
static int MYDEBUG = 1;
static int MYDEBUG = 0;
#else
static int MYDEBUG = 0;
#endif
@ -886,20 +886,22 @@ bool
SMESH_Client::Update(bool theIsClear)
{
bool anIsModified = true;
if(mySMESHDSMesh){
MESSAGE("Update mySMESHDSMesh");
if(mySMESHDSMesh)
{
if ( MYDEBUG ) MESSAGE("Update mySMESHDSMesh");
SMESHDS_Script* aScript = mySMESHDSMesh->GetScript();
anIsModified = aScript->IsModified();
aScript->SetModified(false);
}else{
MESSAGE("Update CORBA");
}
else
{
if ( MYDEBUG ) MESSAGE("Update CORBA");
SMESH::log_array_var aSeq = myMeshServer->GetLog( theIsClear );
CORBA::Long aLength = aSeq->length();
anIsModified = aLength > 0;
if( MYDEBUG )
MESSAGE( "Update: length of the script is "<<aLength );
if ( MYDEBUG ) MESSAGE( "Update: length of the script is "<<aLength );
if(!anIsModified)
if ( !anIsModified )
return false;
// update client mesh structure by logged changes commands

130
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -220,7 +220,6 @@ bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
const SMDS_MeshNode * nodes[],
const int nbnodes)
{
//MESSAGE("SMESHDS_Mesh::ChangeElementNodes");
if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
return false;
@ -978,7 +977,6 @@ void SMESHDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elt,
SMESHDS_SubMesh * subMesh,
bool fromGroups)
{
//MESSAGE(" --------------------------------> SMESHDS_Mesh::RemoveFreeElement " << subMesh << " " << fromGroups);
if (elt->GetType() == SMDSAbs_Node) {
RemoveFreeNode( static_cast<const SMDS_MeshNode*>(elt), subMesh, fromGroups);
return;
@ -1345,7 +1343,6 @@ int SMESHDS_Mesh::AddCompoundSubmesh(const TopoDS_Shape& S,
bool all = ( type == TopAbs_SHAPE );
if ( all ) // corresponding simple submesh may exist
aMainIndex = -aMainIndex;
//MESSAGE("AddCompoundSubmesh index = " << aMainIndex );
SMESHDS_SubMesh * aNewSub = NewSubMesh( aMainIndex );
if ( !aNewSub->IsComplexSubmesh() ) // is empty
{
@ -2116,18 +2113,18 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
const SMDS_MeshNode * n2,
const SMDS_MeshNode * n3,
const SMDS_MeshNode * n4,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n5,
const SMDS_MeshNode * n6,
const SMDS_MeshNode * n7,
const SMDS_MeshNode * n8,
const SMDS_MeshNode * n8,
const SMDS_MeshNode * n12,
const SMDS_MeshNode * n23,
const SMDS_MeshNode * n34,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n41,
const SMDS_MeshNode * n56,
const SMDS_MeshNode * n67,
const SMDS_MeshNode * n78,
const SMDS_MeshNode * n85,
const SMDS_MeshNode * n85,
const SMDS_MeshNode * n15,
const SMDS_MeshNode * n26,
const SMDS_MeshNode * n37,
@ -2155,7 +2152,7 @@ void SMESHDS_Mesh::compactMesh()
int newNodeSize = 0;
int nbNodes = myNodes.size();
int nbVtkNodes = myGrid->GetNumberOfPoints();
MESSAGE("nbNodes=" << nbNodes << " nbVtkNodes=" << nbVtkNodes);
//MESSAGE("nbNodes=" << nbNodes << " nbVtkNodes=" << nbVtkNodes);
int nbNodeTemp = nbVtkNodes;
if (nbNodes > nbVtkNodes)
nbNodeTemp = nbNodes;
@ -2164,22 +2161,22 @@ void SMESHDS_Mesh::compactMesh()
idNodesOldToNew.resize(nbNodeTemp, -1); // all unused id will be -1
for (int i = 0; i < nbNodes; i++)
{
if (myNodes[i])
{
if (myNodes[i])
{
int vtkid = myNodes[i]->getVtkId();
idNodesOldToNew[vtkid] = i; // old vtkId --> old smdsId (valid smdsId are >= 0)
newNodeSize++;
}
int vtkid = myNodes[i]->getVtkId();
idNodesOldToNew[vtkid] = i; // old vtkId --> old smdsId (valid smdsId are >= 0)
newNodeSize++;
}
}
bool areNodesModified = (newNodeSize < nbVtkNodes);
MESSAGE("------------------------- compactMesh Nodes Modified: " << areNodesModified);
//MESSAGE("------------------------- compactMesh Nodes Modified: " << areNodesModified);
areNodesModified = true;
int newCellSize = 0;
int nbCells = myCells.size();
int nbVtkCells = myGrid->GetNumberOfCells();
MESSAGE("nbCells=" << nbCells << " nbVtkCells=" << nbVtkCells);
//MESSAGE("nbCells=" << nbCells << " nbVtkCells=" << nbVtkCells);
int nbCellTemp = nbVtkCells;
if (nbCells > nbVtkCells)
nbCellTemp = nbCells;
@ -2188,15 +2185,15 @@ void SMESHDS_Mesh::compactMesh()
idCellsOldToNew.resize(nbCellTemp, -1); // all unused id will be -1
for (int i = 0; i < nbCells; i++)
{
if (myCells[i])
{
if (myCells[i])
{
// //idCellsOldToNew[i] = myCellIdVtkToSmds[i]; // valid vtk indexes are > = 0
// int vtkid = myCells[i]->getVtkId();
// idCellsOldToNew[vtkid] = i; // old vtkId --> old smdsId (not used in input)
newCellSize++;
}
// //idCellsOldToNew[i] = myCellIdVtkToSmds[i]; // valid vtk indexes are > = 0
// int vtkid = myCells[i]->getVtkId();
// idCellsOldToNew[vtkid] = i; // old vtkId --> old smdsId (not used in input)
newCellSize++;
}
}
if (areNodesModified)
myGrid->compactGrid(idNodesOldToNew, newNodeSize, idCellsOldToNew, newCellSize);
else
@ -2205,62 +2202,62 @@ void SMESHDS_Mesh::compactMesh()
int nbVtkPts = myGrid->GetNumberOfPoints();
nbVtkCells = myGrid->GetNumberOfCells();
if (nbVtkPts != newNodeSize)
{
MESSAGE("===> nbVtkPts != newNodeSize " << nbVtkPts << " " << newNodeSize);
if (nbVtkPts > newNodeSize) newNodeSize = nbVtkPts; // several points with same SMDS Id
}
{
MESSAGE("===> nbVtkPts != newNodeSize " << nbVtkPts << " " << newNodeSize);
if (nbVtkPts > newNodeSize) newNodeSize = nbVtkPts; // several points with same SMDS Id
}
if (nbVtkCells != newCellSize)
{
MESSAGE("===> nbVtkCells != newCellSize " << nbVtkCells << " " << newCellSize);
if (nbVtkCells > newCellSize) newCellSize = nbVtkCells; // several cells with same SMDS Id
}
{
MESSAGE("===> nbVtkCells != newCellSize " << nbVtkCells << " " << newCellSize);
if (nbVtkCells > newCellSize) newCellSize = nbVtkCells; // several cells with same SMDS Id
}
// --- SMDS_MeshNode and myNodes (id in SMDS and in VTK are the same), myNodeIdFactory
if (areNodesModified)
{
//MESSAGE("-------------- modify myNodes");
SetOfNodes newNodes;
newNodes.resize(newNodeSize+1,0); // 0 not used, SMDS numbers 1..n
int newSmdsId = 0;
for (int i = 0; i < nbNodes; i++)
{
MESSAGE("-------------- modify myNodes");
SetOfNodes newNodes;
newNodes.resize(newNodeSize+1,0); // 0 not used, SMDS numbers 1..n
int newSmdsId = 0;
for (int i = 0; i < nbNodes; i++)
{
if (myNodes[i])
{
newSmdsId++; // SMDS id start to 1
int oldVtkId = myNodes[i]->getVtkId();
int newVtkId = idNodesOldToNew[oldVtkId];
//MESSAGE("myNodes["<< i << "] vtkId " << oldVtkId << " --> " << newVtkId);
myNodes[i]->setVtkId(newVtkId);
myNodes[i]->setId(newSmdsId);
newNodes[newSmdsId] = myNodes[i];
//MESSAGE("myNodes["<< i << "] --> newNodes[" << newSmdsId << "]");
}
}
myNodes.swap(newNodes);
this->myNodeIDFactory->emptyPool(newSmdsId); // newSmdsId = number of nodes
MESSAGE("myNodes.size " << myNodes.size());
if (myNodes[i])
{
newSmdsId++; // SMDS id start to 1
int oldVtkId = myNodes[i]->getVtkId();
int newVtkId = idNodesOldToNew[oldVtkId];
//MESSAGE("myNodes["<< i << "] vtkId " << oldVtkId << " --> " << newVtkId);
myNodes[i]->setVtkId(newVtkId);
myNodes[i]->setId(newSmdsId);
newNodes[newSmdsId] = myNodes[i];
//MESSAGE("myNodes["<< i << "] --> newNodes[" << newSmdsId << "]");
}
}
myNodes.swap(newNodes);
this->myNodeIDFactory->emptyPool(newSmdsId); // newSmdsId = number of nodes
//MESSAGE("myNodes.size " << myNodes.size());
}
// --- SMDS_MeshCell, myCellIdVtkToSmds, myCellIdSmdsToVtk, myCells
int vtkIndexSize = myCellIdVtkToSmds.size();
int maxVtkId = -1;
for (int oldVtkId = 0; oldVtkId < vtkIndexSize; oldVtkId++)
{
int oldSmdsId = this->myCellIdVtkToSmds[oldVtkId];
if (oldSmdsId > 0)
{
int oldSmdsId = this->myCellIdVtkToSmds[oldVtkId];
if (oldSmdsId > 0)
{
int newVtkId = idCellsOldToNew[oldVtkId];
if (newVtkId > maxVtkId)
maxVtkId = newVtkId;
//MESSAGE("myCells["<< oldSmdsId << "] vtkId " << oldVtkId << " --> " << newVtkId);
myCells[oldSmdsId]->setVtkId(newVtkId);
}
int newVtkId = idCellsOldToNew[oldVtkId];
if (newVtkId > maxVtkId)
maxVtkId = newVtkId;
//MESSAGE("myCells["<< oldSmdsId << "] vtkId " << oldVtkId << " --> " << newVtkId);
myCells[oldSmdsId]->setVtkId(newVtkId);
}
// MESSAGE("myCells.size()=" << myCells.size()
// << " myCellIdSmdsToVtk.size()=" << myCellIdSmdsToVtk.size()
// << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
}
// MESSAGE("myCells.size()=" << myCells.size()
// << " myCellIdSmdsToVtk.size()=" << myCellIdSmdsToVtk.size()
// << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
SetOfCells newCells;
//vector<int> newSmdsToVtk;
@ -2292,8 +2289,7 @@ void SMESHDS_Mesh::compactMesh()
myCells.swap(newCells);
//myCellIdSmdsToVtk.swap(newSmdsToVtk);
myCellIdVtkToSmds.swap(newVtkToSmds);
MESSAGE("myCells.size()=" << myCells.size()
<< " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
//MESSAGE("myCells.size()="<< myCells.size()<<" myCellIdVtkToSmds.size()="<<myCellIdVtkToSmds.size() );
this->myElementIDFactory->emptyPool(newSmdsId);
this->myScript->SetModified(true); // notify GUI client for buildPrs when update

67
src/SMESHDS/SMESHDS_SubMesh.cxx
View File

@ -154,7 +154,7 @@ bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME, bool isElemDele
//=======================================================================
//function : AddNode
//purpose :
//purpose :
//=======================================================================
void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
@ -240,7 +240,7 @@ int SMESHDS_SubMesh::NbElements() const
//=======================================================================
//function : NbNodes
//purpose :
//purpose :
//=======================================================================
int SMESHDS_SubMesh::NbNodes() const
@ -299,10 +299,10 @@ public:
template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
{
public:
public:
MyIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
: myMore(false), mySubIt( theSubMeshes.begin() ), mySubEnd( theSubMeshes.end() )
{}
{}
bool more()
{
while (( !myElemIt.get() || !myElemIt->more() ) && mySubIt != mySubEnd)
@ -320,11 +320,11 @@ template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
elem = myElemIt->next();
return elem;
}
protected:
protected:
virtual boost::shared_ptr< SMDS_Iterator<VALUE> >
getElements(const SMESHDS_SubMesh*) const = 0;
getElements(const SMESHDS_SubMesh*) const = 0;
private:
private:
bool myMore;
set<const SMESHDS_SubMesh*>::const_iterator mySubIt, mySubEnd;
boost::shared_ptr< SMDS_Iterator<VALUE> > myElemIt;
@ -336,7 +336,7 @@ template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
class MyElemIterator: public MyIterator<const SMDS_MeshElement*>
{
public:
public:
MyElemIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
:MyIterator<const SMDS_MeshElement*>( theSubMeshes ) {}
SMDS_ElemIteratorPtr getElements(const SMESHDS_SubMesh* theSubMesh) const
@ -349,28 +349,30 @@ class MyElemIterator: public MyIterator<const SMDS_MeshElement*>
class MyNodeIterator: public MyIterator<const SMDS_MeshNode*>
{
public:
public:
MyNodeIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
:MyIterator<const SMDS_MeshNode*>( theSubMeshes ) {}
SMDS_NodeIteratorPtr getElements(const SMESHDS_SubMesh* theSubMesh) const
{ return theSubMesh->GetNodes(); }
};
//=======================================================================
//function : GetElements
//purpose :
//purpose :
//=======================================================================
SMDS_ElemIteratorPtr SMESHDS_SubMesh::GetElements() const
{
if ( IsComplexSubmesh() )
return SMDS_ElemIteratorPtr( new MyElemIterator( mySubMeshes ));
return SMDS_ElemIteratorPtr(new MySetIterator<const SMDS_MeshElement*, std::vector<const SMDS_MeshElement*> >(myElements));
return SMDS_ElemIteratorPtr
(new MySetIterator<const SMDS_MeshElement*, std::vector<const SMDS_MeshElement*> >(myElements));
}
//=======================================================================
//function : GetNodes
//purpose :
//purpose :
//=======================================================================
SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes() const
@ -378,7 +380,8 @@ SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes() const
if ( IsComplexSubmesh() )
return SMDS_NodeIteratorPtr( new MyNodeIterator( mySubMeshes ));
return SMDS_NodeIteratorPtr(new MySetIterator<const SMDS_MeshNode*, std::vector<const SMDS_MeshNode*> >(myNodes));
return SMDS_NodeIteratorPtr
(new MySetIterator<const SMDS_MeshNode*, std::vector<const SMDS_MeshNode*> >(myNodes));
}
//=======================================================================
@ -444,7 +447,7 @@ bool SMESHDS_SubMesh::IsQuadratic() const
//=======================================================================
//function : AddSubMesh
//purpose :
//purpose :
//=======================================================================
void SMESHDS_SubMesh::AddSubMesh( const SMESHDS_SubMesh* theSubMesh )
@ -503,6 +506,24 @@ SMESHDS_SubMeshIteratorPtr SMESHDS_SubMesh::GetSubMeshIterator() const
void SMESHDS_SubMesh::Clear()
{
if ( myParent && myParent->NbNodes() > 0 )
{
for ( size_t i = 0; i < myElements.size(); ++i )
{
if ( myElements[i] &&
myElements[i]->GetID() > 0 &&
myElements[i] == myParent->FindElement( myElements[i]->GetID() )) // not deleted
const_cast< SMDS_MeshElement* >( myElements[i] )->setShapeId( 0 );
}
for ( size_t i = 0; i < myNodes.size(); ++i )
{
if ( myNodes[i] &&
myNodes[i]->GetID() > 0 &&
myNodes[i] == myParent->FindNode( myNodes[i]->GetID() )) // not deleted
const_cast< SMDS_MeshNode* >( myNodes[i] )->setShapeId( 0 );
}
}
clearVector( myElements );
clearVector( myNodes );
myUnusedIdNodes = 0;
@ -530,12 +551,12 @@ void SMESHDS_SubMesh::compactList()
{
std::vector<const SMDS_MeshElement*> newElems;
newElems.reserve( myElements.size() - myUnusedIdElements );
for (size_t i = 0; i < myElements.size(); i++)
if (myElements[i])
for ( size_t i = 0; i < myElements.size(); i++)
if ( myElements[i] )
{
SMDS_MeshElement* elem = (SMDS_MeshElement*)myElements[i];
elem->setIdInShape(newElems.size());
newElems.push_back(elem);
elem->setIdInShape( newElems.size() );
newElems.push_back( elem );
}
myElements.swap(newElems);
myUnusedIdElements = 0;
@ -545,12 +566,12 @@ void SMESHDS_SubMesh::compactList()
{
std::vector<const SMDS_MeshNode*> newNodes;
newNodes.reserve( myNodes.size() - myUnusedIdNodes );
for (size_t i = 0; i < myNodes.size(); i++)
if (myNodes[i])
for ( size_t i = 0; i < myNodes.size(); i++ )
if ( myNodes[i] )
{
SMDS_MeshNode* node = (SMDS_MeshNode*)myNodes[i];
node->setIdInShape(newNodes.size());
newNodes.push_back(node);
node->setIdInShape( newNodes.size() );
newNodes.push_back( node );
}
myNodes.swap(newNodes);
myUnusedIdNodes = 0;

80
src/SMESHGUI/SMESHGUI.cxx
View File

@ -608,7 +608,7 @@ namespace
// Get parameters of export operation
QString aFilename;
SMESH::MED_VERSION aFormat;
SMESH::MED_VERSION aFormat = SMESH::MED_V2_2;
// Init the parameters with the default values
bool aIsASCII_STL = true;
bool toCreateGroups = false;
@ -1649,19 +1649,17 @@ namespace
if(!anIO.IsNull()){
_PTR(SObject) SO = aStudy->FindObjectID( It.Value()->getEntry() );
if ( SO ) {
CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
SMESH::SMESH_Mesh_var aMesh = SMESH::SMESH_Mesh::_narrow( aObject );
SMESH::SMESH_subMesh_var aSubMesh = SMESH::SMESH_subMesh::_narrow( aObject );
SMESH::SMESH_GroupBase_var aGroup = SMESH::SMESH_GroupBase::_narrow( aObject );
if ( !aMesh->_is_nil() || !aSubMesh->_is_nil() || !aGroup->_is_nil() ) {
if ( SMESH_Actor *anActor = SMESH::FindActorByEntry(anIO->getEntry()) ) {
anActor->SetControlMode(aControl);
anActor->GetScalarBarActor()->SetTitle( functorToString( anActor->GetFunctor() ).toLatin1().constData() );
CORBA::Object_var aObject = SMESH::SObjectToObject( SO );
SMESH::SMESH_IDSource_var anIDSrc = SMESH::SMESH_IDSource::_narrow( aObject );
if ( !anIDSrc->_is_nil() ) {
if ( SMESH_Actor *anActor = SMESH::FindActorByEntry( anIO->getEntry()) ) {
QString functorName = functorToString( anActor->GetFunctor() );
anActor->SetControlMode( aControl );
anActor->GetScalarBarActor()->SetTitle( functorName.toLatin1().constData() );
SMESH::RepaintCurrentView();
#ifndef DISABLE_PLOT2DVIEWER
if ( anActor->GetPlot2Histogram() ) {
SPlot2d_Histogram* aHistogram = anActor->UpdatePlot2Histogram();
QString functorName = functorToString( anActor->GetFunctor() );
QString aHistogramName("%1 : %2");
aHistogramName = aHistogramName.arg( anIO->getName() ).arg( functorName );
aHistogram->setName( aHistogramName );
@ -1956,7 +1954,7 @@ SalomeApp_Module( "SMESH" )
{
CORBA::Boolean anIsEmbeddedMode;
myComponentSMESH = SMESH_Client::GetSMESHGen(getApp()->orb(),anIsEmbeddedMode);
MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
//MESSAGE("-------------------------------> anIsEmbeddedMode=" << anIsEmbeddedMode);
// 0019923: EDF 765 SMESH : default values of hypothesis
SUIT_ResourceMgr* aResourceMgr = SMESH::GetResourceMgr(this);
@ -2596,6 +2594,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
case SMESHOp::OpShow:
case SMESHOp::OpShowOnly:
{
SUIT_OverrideCursor wc;
SMESH::EDisplaing anAction;
switch (theCommandID) {
case SMESHOp::OpHide: anAction = SMESH::eErase; break;
@ -2610,7 +2609,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
if ( theCommandID==SMESHOp::OpShowOnly )
{
MESSAGE("anAction = SMESH::eDisplayOnly");
//MESSAGE("anAction = SMESH::eDisplayOnly");
startOperation( myEraseAll );
}
@ -2639,7 +2638,6 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
// PAL13338 + PAL15161 -->
if ( ( theCommandID==SMESHOp::OpShow || theCommandID==SMESHOp::OpShowOnly ) && !checkLock(aStudy)) {
MESSAGE("anAction = SMESH::eDisplayOnly");
SMESH::UpdateView();
SMESHGUI::GetSMESHGUI()->EmitSignalVisibilityChanged();
}
@ -2650,7 +2648,6 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
}
if (anAction == SMESH::eErase) {
MESSAGE("anAction == SMESH::eErase");
SALOME_ListIO l1;
aSel->setSelectedObjects( l1 );
}
@ -2670,9 +2667,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
( new SMESHGUI_NodesDlg( this ) )->show();
}
else {
SUIT_MessageBox::warning(desktop(),
tr("SMESH_WRN_WARNING"),
tr("SMESH_WRN_VIEWER_VTK"));
SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"),tr("SMESH_WRN_VIEWER_VTK"));
}
break;
}
@ -2706,8 +2701,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
{
if ( !vtkwnd )
{
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
tr( "NOT_A_VTK_VIEWER" ) );
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
break;
}
@ -2737,8 +2731,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
{
if ( !vtkwnd )
{
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
tr( "NOT_A_VTK_VIEWER" ) );
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ), tr( "NOT_A_VTK_VIEWER" ) );
break;
}
@ -2767,8 +2760,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
( new SMESHGUI_SmoothingDlg( this ) )->show();
}
else {
SUIT_MessageBox::warning(desktop(),
tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
SUIT_MessageBox::warning(desktop(), tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
}
break;
}
@ -2779,8 +2771,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
EmitSignalDeactivateDialog();
( new SMESHGUI_ExtrusionDlg ( this ) )->show();
} else {
SUIT_MessageBox::warning(desktop(),
tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
}
break;
}
@ -2791,8 +2782,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
EmitSignalDeactivateDialog();
( new SMESHGUI_ExtrusionAlongPathDlg( this ) )->show();
} else {
SUIT_MessageBox::warning(desktop(),
tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
}
break;
}
@ -2804,8 +2794,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
( new SMESHGUI_RevolutionDlg( this ) )->show();
}
else {
SUIT_MessageBox::warning(desktop(),
tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
}
break;
}
@ -2819,8 +2808,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
( new SMESHGUI_MeshPatternDlg( this ) )->show();
}
else {
SUIT_MessageBox::warning(desktop(),
tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
}
break;
}
@ -2837,8 +2825,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
{
if ( !vtkwnd )
{
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
tr( "NOT_A_VTK_VIEWER" ) );
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
break;
}
@ -2865,8 +2852,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
{
if ( !vtkwnd )
{
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
tr( "NOT_A_VTK_VIEWER" ) );
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
break;
}
@ -2943,8 +2929,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
{
if ( !vtkwnd )
{
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
tr( "NOT_A_VTK_VIEWER" ) );
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
break;
}
@ -3000,8 +2985,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
{
if ( !vtkwnd )
{
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
tr( "NOT_A_VTK_VIEWER" ) );
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
break;
}
@ -3041,8 +3025,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
{
if ( !vtkwnd )
{
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
tr( "NOT_A_VTK_VIEWER" ) );
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
break;
}
@ -3080,8 +3063,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
{
if ( !vtkwnd )
{
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),
tr( "NOT_A_VTK_VIEWER" ) );
SUIT_MessageBox::warning( desktop(), tr( "SMESH_WRN_WARNING" ),tr( "NOT_A_VTK_VIEWER" ) );
break;
}
@ -3223,8 +3205,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
( new SMESHGUI_AddMeshElementDlg( this, type ) )->show();
}
else {
SUIT_MessageBox::warning(desktop(),
tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
}
break;
}
@ -3236,8 +3217,7 @@ bool SMESHGUI::OnGUIEvent( int theCommandID )
( new SMESHGUI_CreatePolyhedralVolumeDlg( this ) )->show();
}
else {
SUIT_MessageBox::warning(SMESHGUI::desktop(),
tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
SUIT_MessageBox::warning(desktop(),tr("SMESH_WRN_WARNING"), tr("SMESH_WRN_VIEWER_VTK"));
}
break;
}
@ -6067,6 +6047,12 @@ void SMESHGUI::restoreVisualParameters (int savePoint)
continue;
TPlaneData aPlaneData;
aPlaneData.AbsoluteOrientation = false;
aPlaneData.RelativeOrientation = 0;
aPlaneData.Distance = aPlaneData.Angle[0] = aPlaneData.Angle[1] = 0;
aPlaneData.X = aPlaneData.Y = aPlaneData.Z = 0;
aPlaneData.Dx = aPlaneData.Dy = aPlaneData.Dz = 0;
aPlaneData.Id = aClippingPlaneId;
ok = false;

10
src/SMESHGUI/SMESHGUI_AddQuadraticElementDlg.cxx
View File

@ -537,7 +537,7 @@ void SMESHGUI_AddQuadraticElementDlg::Init()
myNbMidFaceNodes = 0;
myNbCenterNodes = 0;
int aNumRows;
int aNumRows = 0;
switch (myGeomType) {
case SMDSEntity_Quad_Edge:
@ -768,7 +768,7 @@ bool SMESHGUI_AddQuadraticElementDlg::ClickOnApply()
}
}
SMESH::ElementType anElementType;
SMESH::ElementType anElementType = SMESH::ALL;
long anElemId = -1, nbElemsBefore = 0;
SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();
switch (myGeomType) {
@ -1055,7 +1055,7 @@ void SMESHGUI_AddQuadraticElementDlg::SelectionIntoArgument()
// process groups
if ( !myMesh->_is_nil() && myEntry != aCurrentEntry ) {
SMESH::ElementType anElementType;
SMESH::ElementType anElementType = SMESH::ALL;
switch ( myGeomType ) {
case SMDSEntity_Quad_Edge:
anElementType = SMESH::EDGE; break;
@ -1371,8 +1371,8 @@ void SMESHGUI_AddQuadraticElementDlg::UpdateTable( bool theConersValidity )
for ( int row = 0; row < myTable->rowCount(); row++ )
myTable->item( row, 1 )->setText("");
int* aFirstColIds;
int* aLastColIds;
int* aFirstColIds = 0;
int* aLastColIds = 0;
switch (myGeomType) {
case SMDSEntity_Quad_Edge:

8
src/SMESHGUI/SMESHGUI_ClippingDlg.cxx
View File

@ -766,7 +766,7 @@ bool SMESHGUI_ClippingDlg::AddPlane ( SMESH::TActorList theActorList,
double aDir[2][3] = {{0, 0, 0}, {0, 0, 0}};
static double aCoeff = vtkMath::Pi()/180.0;
int anOrientation;
int anOrientation = 0;
if ( thePlane->PlaneMode == SMESH::Absolute )
anOrientation = thePlane->myAbsoluteOrientation;
else if ( thePlane->PlaneMode == SMESH::Relative )
@ -1436,7 +1436,7 @@ void SMESHGUI_ClippingDlg::SetCurrentPlaneParam()
static double aCoeff = vtkMath::Pi()/180.0;
double aRot[2] = { getRotation1(), getRotation2() };
int anOrient;
int anOrient = 0;
if ( aPlane->PlaneMode == SMESH::Absolute )
anOrient = CBAbsoluteOrientation->currentIndex();
else if ( aPlane->PlaneMode == SMESH::Relative )
@ -1623,8 +1623,8 @@ void SMESHGUI_ClippingDlg::absolutePlaneToRelative ( double theOrigin[3], double
double eps = 0.0001;
int anOrientation = CBRelativeOrientation->currentIndex();
double aDirection[3];
double aRotation1, aRotation2;
double aDirection[3] = { 0.,0.,0. };
double aRotation1 = 0, aRotation2 = 0;
switch( anOrientation ) {
case 0:
aDirection[0] = theDir[0] + eps;

8
src/SMESHGUI/SMESHGUI_ComputeDlg.cxx
View File

@ -943,7 +943,9 @@ void SMESHGUI_BaseComputeOp::computeMesh()
if ( !smSObj ) continue;
SMESH::SMESH_IDSource_var aSubMeshObj =
SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( smSObj );
aListToUpdate.append( TListOf_IDSrc_SObj::value_type( aSubMeshObj, smSObj ));
SMESH_Actor *anActor = SMESH::FindActorByObject( aSubMeshObj );
if ( anActor && anActor->GetVisibility() )
aListToUpdate.append( TListOf_IDSrc_SObj::value_type( aSubMeshObj, smSObj ));
}
// put Groups into list
SMESH::ListOfGroups_var aGroups = myMesh->GetGroups();
@ -959,7 +961,9 @@ void SMESHGUI_BaseComputeOp::computeMesh()
if ( !aGroupSO ) continue;
SMESH::SMESH_IDSource_var aGroupObj =
SMESH::SObjectToInterface<SMESH::SMESH_IDSource>( aGroupSO );
aListToUpdate.append( TListOf_IDSrc_SObj::value_type( aGroupObj, aGroupSO ));
SMESH_Actor *anActor = SMESH::FindActorByObject( aGroupObj );
if ( anActor && anActor->GetVisibility() )
aListToUpdate.append( TListOf_IDSrc_SObj::value_type( aGroupObj, aGroupSO ));
}
// update mesh, sub-mesh and groups, if it's possible

3
src/SMESHGUI/SMESHGUI_DeleteGroupDlg.cxx
View File

@ -37,6 +37,7 @@
#include <SUIT_Session.h>
#include <SUIT_MessageBox.h>
#include <SUIT_ResourceMgr.h>
#include <SUIT_OverrideCursor.h>
#include <SalomeApp_Study.h>
#include <LightApp_Application.h>
@ -205,6 +206,8 @@ bool SMESHGUI_DeleteGroupDlg::onApply()
if (!isValid())
return false;
SUIT_OverrideCursor wc;
myBlockSelection = true;
QList<SMESH::SMESH_GroupBase_var>::iterator anIter;

2
src/SMESHGUI/SMESHGUI_GroupDlg.cxx
View File

@ -936,7 +936,7 @@ bool SMESHGUI_GroupDlg::onApply()
QStringList anEntryList;
SMESH::SMESH_GroupBase_var resultGroup;
bool isCreation, isConversion = false;
bool isCreation = false, isConversion = false;
SUIT_OverrideCursor wc;

2
src/SMESHGUI/SMESHGUI_HypothesesUtils.cxx
View File

@ -378,7 +378,7 @@ namespace SMESH
return false;
if ( algoData->BasicHypos.contains( hypType ))
return true;
if ( algoData->OptionalHypos.contains( hypType)) {
if ( algoData->OptionalHypos.contains( hypType )) {
isAuxiliary = true;
return true;
}

4
src/SMESHGUI/SMESHGUI_MeshInfo.cxx
View File

@ -1227,7 +1227,7 @@ void SMESHGUI_SimpleElemInfo::information( const QList<long>& ids )
int shapeID = pos->shapeID;
if ( shapeID > 0 ) {
QString shapeType;
double u, v;
double u = 0, v = 0;
switch ( pos->shapeType ) {
case GEOM::EDGE:
shapeType = SMESHGUI_ElemInfo::tr( "GEOM_EDGE" );
@ -1751,7 +1751,7 @@ void SMESHGUI_TreeElemInfo::information( const QList<long>& ids )
int shapeID = pos->shapeID;
if ( shapeID > 0 ) {
QString shapeType;
double u, v;
double u = 0, v = 0;
switch ( pos->shapeType ) {
case GEOM::EDGE:
shapeType = SMESHGUI_ElemInfo::tr( "GEOM_EDGE" );

6
src/SMESHGUI/SMESHGUI_SewingDlg.cxx
View File

@ -1308,7 +1308,7 @@ bool SMESHGUI_SewingDlg::ClickOnApply()
SMESH::SMESH_MeshEditor_var aMeshEditor = myMesh->GetMeshEditor();
int aConstructorId = GetConstructorId();
SMESH::SMESH_MeshEditor::Sew_Error anError;
SMESH::SMESH_MeshEditor::Sew_Error anError = SMESH::SMESH_MeshEditor::SEW_OK;
if (aConstructorId == 0)
{
@ -1954,11 +1954,15 @@ void SMESHGUI_SewingDlg::BorderGroupDisplayer::getPartEnds( int p
ids.push_back( aBRD.nodeIDs[ aPART.node1 ]);
ids.push_back( aBRD.nodeIDs[ aPART.nodeLast ]);
if ( aPART.node1 == aPART.nodeLast )
ids.push_back( aBRD.nodeIDs[ aPART.node2 ]);
SMDS_Mesh* mesh = myPartActors[ partIndex ]->GetObject()->GetMesh();
coords.push_back( SMESH_TNodeXYZ( mesh->FindNode( aPART.node1+1 )));
coords.push_back( SMESH_TNodeXYZ( mesh->FindNode( aPART.nodeLast+1 )));
if ( aPART.node1 == aPART.nodeLast )
coords.push_back( SMESH_TNodeXYZ( mesh->FindNode( aPART.node2+1 )));
}
void SMESHGUI_SewingDlg::BorderGroupDisplayer::Update()

77
src/SMESHGUI/SMESHGUI_VTKUtils.cxx
View File

@ -854,7 +854,7 @@ namespace SMESH
bool Update(const Handle(SALOME_InteractiveObject)& theIO, bool theDisplay)
{
MESSAGE("Update");
//MESSAGE("Update");
_PTR(Study) aStudy = GetActiveStudyDocument();
CORBA::Long anId = aStudy->StudyId();
if ( TVisualObjPtr aVisualObj = SMESH::GetVisualObj(anId,theIO->getEntry())) {
@ -867,7 +867,7 @@ namespace SMESH
bool UpdateNulData(const Handle(SALOME_InteractiveObject)& theIO, bool theDisplay)
{
MESSAGE("UpdateNulData");
//MESSAGE("UpdateNulData");
_PTR(Study) aStudy = GetActiveStudyDocument();
CORBA::Long anId = aStudy->StudyId();
if ( TVisualObjPtr aVisualObj = SMESH::GetVisualObj(anId,theIO->getEntry(), true)) {
@ -878,7 +878,8 @@ namespace SMESH
return false;
}
void UpdateSelectionProp( SMESHGUI* theModule ) {
void UpdateSelectionProp( SMESHGUI* theModule )
{
if( !theModule )
return;
@ -905,25 +906,29 @@ namespace SMESH
return;
}
QColor aHiColor = mgr->colorValue( "SMESH", "selection_object_color", Qt::white ),
aSelColor = mgr->colorValue( "SMESH", "selection_element_color", Qt::yellow ),
aPreColor = mgr->colorValue( "SMESH", "highlight_color", Qt::cyan );
QColor
aHiColor = mgr->colorValue( "SMESH", "selection_object_color", Qt::white ),
aSelColor = mgr->colorValue( "SMESH", "selection_element_color", Qt::yellow ),
aPreColor = mgr->colorValue( "SMESH", "highlight_color", Qt::cyan );
int aElem0DSize = mgr->integerValue("SMESH", "elem0d_size", 5);
// int aBallSize = mgr->integerValue("SMESH", "ball_elem_size", 5);
// int aBallSize = mgr->integerValue("SMESH", "ball_elem_size", 5);
int aLineWidth = mgr->integerValue("SMESH", "element_width", 1);
int maxSize = aElem0DSize;
if (aElem0DSize > maxSize) maxSize = aElem0DSize;
if (aLineWidth > maxSize) maxSize = aLineWidth;
// if (aBallSize > maxSize) maxSize = aBallSize;
// if (aBallSize > maxSize) maxSize = aBallSize;
double SP1 = mgr->doubleValue( "SMESH", "selection_precision_node", 0.025 ),
SP2 = mgr->doubleValue( "SMESH", "selection_precision_element", 0.001 ),
SP3 = mgr->doubleValue( "SMESH", "selection_precision_object", 0.025 );
double
SP1 = mgr->doubleValue( "SMESH", "selection_precision_node", 0.025 ),
SP2 = mgr->doubleValue( "SMESH", "selection_precision_element", 0.001 ),
SP3 = mgr->doubleValue( "SMESH", "selection_precision_object", 0.025 );
for ( int i=0, n=views.count(); i<n; i++ ){
for ( int i=0, n=views.count(); i<n; i++ )
{
// update VTK viewer properties
if(SVTK_ViewWindow* aVtkView = GetVtkViewWindow( views[i] )){
if ( SVTK_ViewWindow* aVtkView = GetVtkViewWindow( views[i] ))
{
// mesh element selection
aVtkView->SetSelectionProp(aSelColor.red()/255.,
aSelColor.green()/255.,
@ -940,8 +945,8 @@ namespace SMESH
VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
vtkActorCollection *aCollection = aCopy.GetActors();
aCollection->InitTraversal();
while(vtkActor *anAct = aCollection->GetNextActor()){
if(SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct)){
while ( vtkActor *anAct = aCollection->GetNextActor() ) {
if ( SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct) ) {
anActor->SetHighlightColor(aHiColor.red()/255.,
aHiColor.green()/255.,
aHiColor.blue()/255.);
@ -1076,8 +1081,9 @@ namespace SMESH
//----------------------------------------------------------------------------
void SetPointRepresentation(bool theIsVisible){
if(SVTK_ViewWindow* aViewWindow = GetCurrentVtkView()){
void SetPointRepresentation(bool theIsVisible)
{
if ( SVTK_ViewWindow* aViewWindow = GetCurrentVtkView() ) {
vtkRenderer *aRenderer = aViewWindow->getRenderer();
VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
vtkActorCollection *aCollection = aCopy.GetActors();
@ -1094,8 +1100,9 @@ namespace SMESH
}
void SetPickable(SMESH_Actor* theActor){
if(SVTK_ViewWindow* aWnd = GetCurrentVtkView()){
void SetPickable(SMESH_Actor* theActor)
{
if ( SVTK_ViewWindow* aWnd = GetCurrentVtkView() ) {
int anIsAllPickable = (theActor == NULL);
vtkRenderer *aRenderer = aWnd->getRenderer();
VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
@ -1116,9 +1123,9 @@ namespace SMESH
//----------------------------------------------------------------------------
int GetNameOfSelectedNodes(SVTK_Selector* theSelector,
int GetNameOfSelectedNodes(SVTK_Selector* theSelector,
const Handle(SALOME_InteractiveObject)& theIO,
QString& theName)
QString& theName)
{
theName = "";
TColStd_IndexedMapOfInteger aMapIndex;
@ -1204,7 +1211,8 @@ namespace SMESH
return -1;
}
int GetNameOfSelectedNodes(LightApp_SelectionMgr *theMgr, QString& theName){
int GetNameOfSelectedNodes(LightApp_SelectionMgr *theMgr, QString& theName)
{
theName = "";
SALOME_ListIO selected; theMgr->selectedObjects( selected );
if(selected.Extent() == 1){
@ -1215,9 +1223,9 @@ namespace SMESH
}
int GetNameOfSelectedElements(LightApp_SelectionMgr *theMgr,
int GetNameOfSelectedElements(LightApp_SelectionMgr * theMgr,
const Handle(SALOME_InteractiveObject)& theIO,
QString& theName)
QString& theName)
{
theName = "";
if(theIO->hasEntry()){
@ -1342,13 +1350,13 @@ namespace SMESH
}
double aBoundPoints[8][3] = { {theBounds[0],theBounds[2],theBounds[4]},
{theBounds[1],theBounds[2],theBounds[4]},
{theBounds[0],theBounds[3],theBounds[4]},
{theBounds[1],theBounds[3],theBounds[4]},
{theBounds[0],theBounds[2],theBounds[5]},
{theBounds[1],theBounds[2],theBounds[5]},
{theBounds[0],theBounds[3],theBounds[5]},
{theBounds[1],theBounds[3],theBounds[5]}};
{theBounds[1],theBounds[2],theBounds[4]},
{theBounds[0],theBounds[3],theBounds[4]},
{theBounds[1],theBounds[3],theBounds[4]},
{theBounds[0],theBounds[2],theBounds[5]},
{theBounds[1],theBounds[2],theBounds[5]},
{theBounds[0],theBounds[3],theBounds[5]},
{theBounds[1],theBounds[3],theBounds[5]}};
int aMaxId = 0;
theMaxBoundPrj = vtkMath::Dot(theDirection,aBoundPoints[aMaxId]);
@ -1445,8 +1453,9 @@ namespace SMESH
*/
//================================================================================
void ClearPlot2Viewers( SUIT_ViewWindow* theWindow ) {
if(SVTK_ViewWindow* aViewWindow = GetVtkViewWindow(theWindow)){
void ClearPlot2Viewers( SUIT_ViewWindow* theWindow )
{
if ( SVTK_ViewWindow* aViewWindow = GetVtkViewWindow(theWindow) ) {
vtkRenderer *aRenderer = aViewWindow->getRenderer();
VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
vtkActorCollection *aCollection = aCopy.GetActors();
@ -1460,7 +1469,7 @@ namespace SMESH
}
}
}
#endif
} // end of namespace SMESH

2
src/SMESHGUI/SMESHGUI_XmlHandler.cxx
View File

@ -104,7 +104,7 @@ bool SMESHGUI_XmlHandler::startElement (const QString&, const QString&,
QString aResName = atts.value("resources");
if (aResName != "")
{
MESSAGE("Loading Resources " << aResName.toLatin1().data());
//MESSAGE("Loading Resources " << aResName.toLatin1().data());
SUIT_ResourceMgr* resMgr = SMESHGUI::resourceMgr();
QString lang = resMgr->stringValue( resMgr->langSection(), "language", "en" );
resMgr->loadTranslator( "resources", QString( "%1_msg_%2.qm" ).arg( aResName, lang ) );

5
src/SMESHUtils/SMESH_Block.cxx
View File

@ -930,6 +930,7 @@ void SMESH_Block::refineParametersOnFace( const gp_Pnt& thePoint,
{
// find UV of thePoint on the FACE
Standard_Real U,V;
U=V=0;
const TFace& tface = myFace[ theFaceID - ID_FirstF ];
if ( !tface.Surface() ) return;
@ -1778,7 +1779,7 @@ bool SMESH_Block::FindBlockShapes(const TopoDS_Shell& theShell,
if ( V000.IsNull() ) {
// find vertex 000 - the one with smallest coordinates
double minVal = DBL_MAX, minX, val;
double minVal = DBL_MAX, minX = DBL_MAX, val;
for ( int i = 1; i <= 8; i++ ) {
const TopoDS_Vertex& v = TopoDS::Vertex( vfMap.FindKey( i ));
gp_Pnt P = BRep_Tool::Pnt( v );
@ -1822,7 +1823,7 @@ bool SMESH_Block::FindBlockShapes(const TopoDS_Shell& theShell,
return false;
}
TopTools_ListIteratorOfListOfShape f001It, f000It ( f000List );
int i, j, iFound1, iFound2;
int i, j, iFound1=0, iFound2=0;
for ( j = 0; f000It.More(); f000It.Next(), j++ )
{
if ( NB_FACES_BY_VERTEX == 6 && j % 2 ) continue; // each face encounters twice

89
src/SMESHUtils/SMESH_FreeBorders.cxx
View File

@ -36,6 +36,7 @@
#include <vector>
#include <NCollection_DataMap.hxx>
#include <Precision.hxx>
#include <gp_Pnt.hxx>
using namespace SMESH_MeshAlgos;
@ -62,6 +63,7 @@ namespace
bool HasCloseEdgeWithNode( const BNode* n ) const;
bool IsCloseEdge( const BEdge*, double * u = 0 ) const;
bool operator<(const BNode& other) const { return Node()->GetID() < other.Node()->GetID(); }
double SquareDistance(const BNode& e2) const { return ( e2 - *this ).SquareModulus(); }
};
/*!
* \brief Edge of a free border
@ -133,6 +135,12 @@ namespace
myNext->SetID( id + 1 );
}
}
//================================================================================
/*!
* \brief Checks if a point is closer to this BEdge than tol
*/
//================================================================================
bool IsOut( const gp_XYZ& point, const double tol, double& u ) const
{
gp_XYZ me = *myBNode2 - *myBNode1;
@ -145,6 +153,12 @@ namespace
double dist2 = ( point - proj ).SquareModulus();
return ( dist2 > tol * tol );
}
//================================================================================
/*!
* \brief Checks if two BEdges can be considered as overlapping
*/
//================================================================================
bool IsOverlappingProjection( const BEdge* toE, const double u, bool is1st ) const
{
// is1st shows which end of toE is projected on this at u
@ -160,6 +174,12 @@ namespace
return Abs( u - u2 ) > eps;
return false;
}
//================================================================================
/*!
* \brief Finds all neighbor BEdge's having the same close borders
*/
//================================================================================
bool GetRangeOfSameCloseBorders(BEdge* eRange[2], const std::set< int >& bordIDs)
{
if ( this->myCloseBorders != bordIDs )
@ -221,6 +241,64 @@ namespace
}
}; // class BEdge
//================================================================================
/*!
* \brief Checks if all border parts include the whole closed border, and if so
* returns \c true and choose starting BEdge's with most coincident nodes
*/
//================================================================================
bool chooseStartOfClosedBorders( std::vector< BEdge* >& ranges ) // PAL23078#c21002
{
bool allClosed = true;
for ( size_t iR = 1; iR < ranges.size() && allClosed; iR += 2 )
allClosed = ( ranges[ iR-1 ]->myPrev == ranges[ iR ] );
if ( !allClosed )
return allClosed;
double u, minDiff = Precision::Infinite();
std::vector< BEdge* > start( ranges.size() / 2 );
BEdge* range0 = start[0] = ranges[0];
do
{
double maxDiffU = 0;
double maxDiff = 0;
for ( size_t iR = 3; iR < ranges.size(); iR += 2 )
{
int borderID = ranges[iR]->myBorderID;
if ( BEdge* e = start[0]->myBNode1->GetCloseEdgeOfBorder( borderID, & u ))
{
start[ iR / 2 ] = e;
double diffU = Min( Abs( u ), Abs( 1.-u ));
double diff = e->myBNode1->SquareDistance( *e->myBNode2 ) * diffU * diffU;
maxDiffU = Max( diffU, maxDiffU );
maxDiff = Max( diff, maxDiff );
}
}
if ( maxDiff < minDiff )
{
minDiff = maxDiff;
for ( size_t iR = 1; iR < ranges.size(); iR += 2 )
{
ranges[ iR-1 ] = start[ iR/2 ];
ranges[ iR ] = ranges[ iR-1]->myPrev;
}
}
if ( maxDiffU < 1e-6 )
break;
start[0] = start[0]->myNext;
}
while ( start[0] != range0 );
return allClosed;
}
//================================================================================
/*!
* \brief Tries to include neighbor BEdge's into a border part
*/
//================================================================================
void extendPart( BEdge* & e1, BEdge* & e2, const std::set< int >& bordIDs, int groupID )
{
if (( e1->myPrev == e2 ) ||
@ -268,6 +346,12 @@ namespace
}
}
//================================================================================
/*!
* \brief Connect BEdge's incident at this node
*/
//================================================================================
void BNode::AddLinked( BEdge* e ) const
{
myLinkedEdges.reserve(2);
@ -670,8 +754,9 @@ void SMESH_MeshAlgos::FindCoincidentFreeBorders(SMDS_Mesh& mesh,
if ( ranges.size() > 2 )
{
for ( size_t iR = 1; iR < ranges.size(); iR += 2 )
extendPart( ranges[ iR-1 ], ranges[ iR ], be1st->myCloseBorders, groupID );
if ( !chooseStartOfClosedBorders( ranges ))
for ( size_t iR = 1; iR < ranges.size(); iR += 2 )
extendPart( ranges[ iR-1 ], ranges[ iR ], be1st->myCloseBorders, groupID );
// fill in a group
beRange[0] = ranges[0];

2
src/SMESHUtils/SMESH_MeshAlgos.cxx
View File

@ -1194,7 +1194,7 @@ bool SMESH_MeshAlgos::IsOut( const SMDS_MeshElement* element, const gp_Pnt& poin
dist.back() = dist.front();
// find the closest intersection
int iClosest = -1;
double rClosest, distClosest = 1e100;;
double rClosest = 0, distClosest = 1e100;;
gp_Pnt pClosest;
for ( i = 0; i < nbNodes; ++i )
{

1
src/SMESHUtils/SMESH_TypeDefs.hxx
View File

@ -186,6 +186,7 @@ typedef struct uvPtStruct
uvPtStruct(): node(NULL) {}
inline gp_XY UV() const { return gp_XY( u, v ); }
inline void SetUV( const gp_XY& uv ) { u = uv.X(); v = uv.Y(); }
struct NodeAccessor // accessor to iterate on nodes in UVPtStructVec
{

2
src/SMESH_I/SMESH_2D_Algo_i.cxx
View File

@ -45,7 +45,6 @@ SMESH_2D_Algo_i::SMESH_2D_Algo_i( PortableServer::POA_ptr thePOA )
SMESH_Hypothesis_i( thePOA ),
SMESH_Algo_i( thePOA )
{
MESSAGE( "SMESH_2D_Algo_i::SMESH_2D_Algo_i" );
}
//=============================================================================
@ -58,7 +57,6 @@ SMESH_2D_Algo_i::SMESH_2D_Algo_i( PortableServer::POA_ptr thePOA )
SMESH_2D_Algo_i::~SMESH_2D_Algo_i()
{
MESSAGE( "SMESH_2D_Algo_i::~SMESH_2D_Algo_i" );
}
//================================================================================

2
src/SMESH_I/SMESH_3D_Algo_i.cxx
View File

@ -45,7 +45,6 @@ SMESH_3D_Algo_i::SMESH_3D_Algo_i( PortableServer::POA_ptr thePOA )
SMESH_Hypothesis_i( thePOA ),
SMESH_Algo_i( thePOA )
{
MESSAGE( "SMESH_3D_Algo_i::SMESH_3D_Algo_i" );
}
//=============================================================================
@ -58,7 +57,6 @@ SMESH_3D_Algo_i::SMESH_3D_Algo_i( PortableServer::POA_ptr thePOA )
SMESH_3D_Algo_i::~SMESH_3D_Algo_i()
{
MESSAGE( "SMESH_3D_Algo_i::~SMESH_3D_Algo_i" );
}
//================================================================================

3
src/SMESH_I/SMESH_Algo_i.cxx
View File

@ -48,7 +48,6 @@ SMESH_Algo_i::SMESH_Algo_i( PortableServer::POA_ptr thePOA )
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA )
{
MESSAGE( "SMESH_Algo_i::SMESH_Algo_i" );
}
//=============================================================================
@ -61,7 +60,6 @@ SMESH_Algo_i::SMESH_Algo_i( PortableServer::POA_ptr thePOA )
SMESH_Algo_i::~SMESH_Algo_i()
{
MESSAGE( "SMESH_Algo_i::~SMESH_Algo_i" );
}
//=============================================================================
@ -74,7 +72,6 @@ SMESH_Algo_i::~SMESH_Algo_i()
SMESH::ListOfHypothesisName* SMESH_Algo_i::GetCompatibleHypothesis()
{
MESSAGE( "SMESH_Algo_i::GetCompatibleHypothesis" );
SMESH::ListOfHypothesisName_var listOfHypothesis = new SMESH::ListOfHypothesisName;
const vector<string>& hypList = ( ( ::SMESH_Algo* )myBaseImpl )->GetCompatibleHypothesis();
int nbHyp = hypList.size();

8
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -285,7 +285,6 @@ SMESH_Gen_i::SMESH_Gen_i( CORBA::ORB_ptr orb,
const char* interfaceName )
: Engines_Component_i( orb, poa, contId, instanceName, interfaceName )
{
MESSAGE( "SMESH_Gen_i::SMESH_Gen_i : standard constructor" );
myOrb = CORBA::ORB::_duplicate(orb);
myPoa = PortableServer::POA::_duplicate(poa);
@ -335,8 +334,6 @@ SMESH_Gen_i::SMESH_Gen_i( CORBA::ORB_ptr orb,
SMESH_Gen_i::~SMESH_Gen_i()
{
MESSAGE( "SMESH_Gen_i::~SMESH_Gen_i" );
// delete hypothesis creators
map<string, GenericHypothesisCreator_i*>::iterator itHyp, itHyp2;
for (itHyp = myHypCreatorMap.begin(); itHyp != myHypCreatorMap.end(); itHyp++)
@ -512,7 +509,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::createMesh()
// create a new mesh object servant, store it in a map in study context
SMESH_Mesh_i* meshServant = new SMESH_Mesh_i( GetPOA(), this, GetCurrentStudyID() );
// create a new mesh object
MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
if(MYDEBUG) MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
meshServant->SetImpl( myGen.CreateMesh( GetCurrentStudyID(), myIsEmbeddedMode ));
// activate the CORBA servant of Mesh
@ -571,7 +568,6 @@ void SMESH_Gen_i::SetGeomEngine( GEOM::GEOM_Gen_ptr geomcompo )
void SMESH_Gen_i::SetEmbeddedMode( CORBA::Boolean theMode )
{
myIsEmbeddedMode = theMode;
MESSAGE("myIsEmbeddedMode " << myIsEmbeddedMode);
if ( !myIsEmbeddedMode ) {
//PAL10867: disable signals catching with "noexcepthandler" option
@ -4489,7 +4485,7 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent,
// --> try to find SUB-MESHES containers for each type of submesh
for ( int j = GetSubMeshOnVertexTag(); j <= GetSubMeshOnCompoundTag(); j++ ) {
const char* name_meshgroup;
const char* name_meshgroup = 0;
if ( j == GetSubMeshOnVertexTag() )
name_meshgroup = "SubMeshes On Vertex";
else if ( j == GetSubMeshOnEdgeTag() )

3
src/SMESH_I/SMESH_Gen_i_1.cxx
View File

@ -771,8 +771,7 @@ SALOMEDS::SObject_ptr SMESH_Gen_i::PublishGroup (SALOMEDS::Study_ptr theStudy
SetName( aRootSO, aRootNames[aType] );
// Add new group to corresponding sub-tree
SMESH::array_of_ElementType_var elemTypes = theGroup->GetTypes();
int isEmpty = ( elemTypes->length() == 0 );
int isEmpty = false;
std::string pm[2] = { "ICON_SMESH_TREE_GROUP", "ICON_SMESH_TREE_MESH_WARN" };
if ( SMESH::DownCast< SMESH_GroupOnFilter_i* > ( theGroup ))
{

12
src/SMESH_I/SMESH_Group_i.cxx
View File

@ -72,7 +72,6 @@ SMESH_Group_i::SMESH_Group_i( PortableServer::POA_ptr thePOA,
: SALOME::GenericObj_i( thePOA ),
SMESH_GroupBase_i( thePOA, theMeshServant, theLocalID )
{
//MESSAGE("SMESH_Group_i; this = "<<this );
}
SMESH_GroupOnGeom_i::SMESH_GroupOnGeom_i( PortableServer::POA_ptr thePOA,
@ -81,7 +80,6 @@ SMESH_GroupOnGeom_i::SMESH_GroupOnGeom_i( PortableServer::POA_ptr thePOA,
: SALOME::GenericObj_i( thePOA ),
SMESH_GroupBase_i( thePOA, theMeshServant, theLocalID )
{
//MESSAGE("SMESH_GroupOnGeom_i; this = "<<this );
}
SMESH_GroupOnFilter_i::SMESH_GroupOnFilter_i( PortableServer::POA_ptr thePOA,
@ -90,7 +88,6 @@ SMESH_GroupOnFilter_i::SMESH_GroupOnFilter_i( PortableServer::POA_ptr thePOA,
: SALOME::GenericObj_i( thePOA ),
SMESH_GroupBase_i( thePOA, theMeshServant, theLocalID )
{
//MESSAGE("SMESH_GroupOnGeom_i; this = "<<this );
}
//=============================================================================
@ -176,7 +173,6 @@ char* SMESH_GroupBase_i::GetName()
::SMESH_Group* aGroup = GetSmeshGroup();
if (aGroup)
return CORBA::string_dup (aGroup->GetName());
MESSAGE("get name of a vague group");
return CORBA::string_dup( "NO_NAME" );
}
@ -203,7 +199,6 @@ SMESH::ElementType SMESH_GroupBase_i::GetType()
}
return aType;
}
MESSAGE("get type of a vague group");
return SMESH::ALL;
}
@ -222,7 +217,6 @@ CORBA::Long SMESH_GroupBase_i::Size()
SMESHDS_GroupBase* aGroupDS = GetGroupDS();
if (aGroupDS)
return aGroupDS->Extent();
MESSAGE("get size of a vague group");
return 0;
}
@ -240,7 +234,6 @@ CORBA::Boolean SMESH_GroupBase_i::IsEmpty()
SMESHDS_GroupBase* aGroupDS = GetGroupDS();
if (aGroupDS)
return aGroupDS->IsEmpty();
MESSAGE("checking IsEmpty of a vague group");
return true;
}
@ -280,8 +273,6 @@ void SMESH_Group_i::Clear()
return;
}
Modified(); // notify dependent Filter with FT_BelongToMeshGroup criterion
MESSAGE("attempt to clear a vague group");
}
//=============================================================================
@ -298,7 +289,6 @@ CORBA::Boolean SMESH_GroupBase_i::Contains( CORBA::Long theID )
SMESHDS_GroupBase* aGroupDS = GetGroupDS();
if (aGroupDS)
return aGroupDS->Contains(theID);
MESSAGE("attempt to check contents of a vague group");
return false;
}
@ -631,7 +621,6 @@ SALOMEDS::Color SMESH_GroupBase_i::GetColor()
return aColor;
}
MESSAGE("get color of a group");
return SALOMEDS::Color();
}
@ -889,7 +878,6 @@ SMESH::long_array* SMESH_GroupOnFilter_i::GetListOfID()
if ( 0 < aRes->length() && aRes->length() < 100 ) // for comfortable testing ;)
std::sort( &aRes[0], &aRes[0] + aRes->length() );
}
MESSAGE("get list of IDs of a vague group");
return aRes._retn();
}

10
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -108,7 +108,6 @@ SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
CORBA::Long studyId )
: SALOME::GenericObj_i( thePOA )
{
MESSAGE("SMESH_Mesh_i");
_impl = NULL;
_gen_i = gen_i;
_id = _idGenerator++;
@ -127,8 +126,6 @@ SMESH_Mesh_i::SMESH_Mesh_i( PortableServer::POA_ptr thePOA,
SMESH_Mesh_i::~SMESH_Mesh_i()
{
MESSAGE("~SMESH_Mesh_i");
// destroy groups
map<int, SMESH::SMESH_GroupBase_ptr>::iterator itGr;
for (itGr = _mapGroups.begin(); itGr != _mapGroups.end(); itGr++)
@ -4079,7 +4076,7 @@ SMESH::long_array* SMESH_Mesh_i::GetNodesId()
SMESH::ElementType SMESH_Mesh_i::GetElementType( const CORBA::Long id, const bool iselem )
throw (SALOME::SALOME_Exception)
{
SMESH::ElementType type;
SMESH::ElementType type = SMESH::ALL;
SMESH_TRY;
if ( _preMeshInfo )
@ -4227,7 +4224,7 @@ SMESH::long_array* SMESH_Mesh_i::GetSubMeshNodesId(const CORBA::Long ShapeID,
SMESH::ElementType SMESH_Mesh_i::GetSubMeshElementType(const CORBA::Long ShapeID)
throw (SALOME::SALOME_Exception)
{
SMESH::ElementType type;
SMESH::ElementType type = SMESH::ALL;
SMESH_TRY;
if ( _preMeshInfo )
@ -4265,8 +4262,7 @@ CORBA::LongLong SMESH_Mesh_i::GetMeshPtr()
_preMeshInfo->FullLoadFromFile();
CORBA::LongLong pointeur = CORBA::LongLong(_impl);
if ( MYDEBUG )
MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);
if ( MYDEBUG ) MESSAGE("CORBA::LongLong SMESH_Mesh_i::GetMeshPtr() "<<pointeur);
return pointeur;
}

2
src/StdMeshers/StdMeshers_Cartesian_3D.cxx
View File

@ -3050,7 +3050,7 @@ namespace
_Node* orderNodes [20];
TGeomID orderShapeIDs[20];
size_t nbN = 0;
TGeomID id, *pID;
TGeomID id, *pID = 0;
for ( e = edges.begin(); e != edges.end(); ++e )
{
if (( id = _grid->_shapes.FindIndex( SMESH_MesherHelper::IthVertex( 0, *e ))) &&

13
src/StdMeshers/StdMeshers_CompositeHexa_3D.cxx
View File

@ -382,12 +382,12 @@ namespace
const TopTools_MapOfShape& cornerVV,
TopTools_MapOfShape& internEE)
{
TopTools_IndexedMapOfShape subEE, subFF;
TopTools_IndexedMapOfShape subEE;
TopExp::MapShapes( shape, TopAbs_EDGE, subEE );
TopExp::MapShapes( shape, TopAbs_FACE, subFF );
//TopExp::MapShapes( shape, TopAbs_FACE, subFF );
TopoDS_Vertex VV[2];
TopTools_MapOfShape subChecked/*, ridgeEE*/;
TopTools_MapOfShape subChecked, ridgeEE;
TopTools_MapIteratorOfMapOfShape vIt( cornerVV );
for ( ; vIt.More(); vIt.Next() )
{
@ -401,6 +401,8 @@ namespace
TopoDS_Edge ridgeE = TopoDS::Edge( *riE );
while ( !ridgeE.IsNull() )
{
if ( !ridgeEE.Add( ridgeE ))
break;
TopExp::Vertices( ridgeE, VV[0], VV[1] );
TopoDS_Shape V1 = VV[ V0.IsSame( VV[0] )];
if ( cornerVV.Contains( V1 ) )
@ -451,6 +453,11 @@ namespace
} // loop on ridge EDGEs around a corner VERTEX
} // loop on on corner VERTEXes
if ( subEE.Extent() > ridgeEE.Extent() + internEE.Extent() ) // PAL23269
for ( int i = 1; i < subEE.Extent(); ++i )
if ( !ridgeEE.Contains( subEE(i) ))
internEE.Add( subEE(i) );
return true;
} // getInternalEdges()
} // namespace

18
src/StdMeshers/StdMeshers_FaceSide.cxx
View File

@ -144,7 +144,6 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const TopoDS_Face& theFace,
double p4 = myFirst[i]+(myLast[i]-myFirst[i])/4.;
double d2 = GCPnts_AbscissaPoint::Length( A2dC, myFirst[i], p2 );
double d4 = GCPnts_AbscissaPoint::Length( A2dC, myFirst[i], p4 );
//cout<<"len = "<<len<<" d2 = "<<d2<<" fabs(2*d2/len-1.0) = "<<fabs(2*d2/len-1.0)<<endl;
myIsUniform[i] = !( fabs(2*d2/myEdgeLength[i]-1.0) > 0.01 || fabs(2*d4/d2-1.0) > 0.01 );
Handle(Geom_Curve) C3d = BRep_Tool::Curve(myEdge[i],d2,d4);
myC3dAdaptor[i].Load( C3d, d2,d4 );
@ -232,9 +231,11 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(const StdMeshers_FaceSide* theSide,
//================================================================================
StdMeshers_FaceSide::StdMeshers_FaceSide(UVPtStructVec& theSideNodes,
const TopoDS_Face& theFace)
const TopoDS_Face& theFace,
const TopoDS_Edge& theEdge,
SMESH_Mesh* theMesh)
{
myEdge.resize( 1 );
myEdge.resize( 1, theEdge );
myEdgeID.resize( 1, -1 );
myC2d.resize( 1 );
myC3dAdaptor.resize( 1 );
@ -244,6 +245,17 @@ StdMeshers_FaceSide::StdMeshers_FaceSide(UVPtStructVec& theSideNodes,
myIsUniform.resize( 1, 1 );
myMissingVertexNodes = myIgnoreMediumNodes = false;
myDefaultPnt2d.SetCoord( 1e100, 1e100 );
if ( theMesh ) myProxyMesh.reset( new SMESH_ProxyMesh( *theMesh ));
if ( !theEdge.IsNull() )
{
if ( theMesh ) myEdgeID[0] = theMesh->GetMeshDS()->ShapeToIndex( theEdge );
if ( theFace.IsNull() )
BRep_Tool::Range( theEdge, myFirst[0], myLast[0] );
else
myC2d[0] = BRep_Tool::CurveOnSurface( theEdge, theFace, myFirst[0], myLast[0] );
if ( theEdge.Orientation() == TopAbs_REVERSED )
std::swap( myFirst[0], myLast[0] );
}
myFace = theFace;
myPoints = theSideNodes;

8
src/StdMeshers/StdMeshers_FaceSide.hxx
View File

@ -97,7 +97,9 @@ public:
* \brief Create a side from an UVPtStructVec
*/
StdMeshers_FaceSide(UVPtStructVec& theSideNodes,
const TopoDS_Face& theFace = TopoDS_Face());
const TopoDS_Face& theFace = TopoDS_Face(),
const TopoDS_Edge& theEdge = TopoDS_Edge(),
SMESH_Mesh* theMesh = 0);
// static "consrtuctors"
static StdMeshers_FaceSidePtr New(const TopoDS_Face& Face,
@ -245,6 +247,10 @@ public:
* \brief Return all edges
*/
const std::vector<TopoDS_Edge>& Edges() const { return myEdge; }
/*!
* \brief Return the FACE
*/
const TopoDS_Face& Face() const { return myFace; }
/*!
* \brief Return 1st vertex of the i-th edge (count starts from zero)
*/

2
src/StdMeshers/StdMeshers_Penta_3D.cxx
View File

@ -1367,7 +1367,7 @@ bool StdMeshers_Penta_3D::LoadIJNodes(StdMeshers_IJNodeMap & theIJNodes,
// find the other edges of theFace and orientation of e1
TopoDS_Edge e1, e2, eTop;
bool rev1, CumOri = false;
bool rev1 = false, CumOri = false;
TopExp_Explorer exp( theFace, TopAbs_EDGE );
int nbEdges = 0;
for ( ; exp.More(); exp.Next() ) {

4
src/StdMeshers/StdMeshers_Prism_3D.cxx
View File

@ -1116,7 +1116,7 @@ bool StdMeshers_Prism_3D::compute(const Prism_3D::TPrismTopo& thePrism)
( ! botSM->GetAlgo() ||
! _gen->Compute( *botSM->GetFather(), botSM->GetSubShape(), /*shapeOnly=*/true )))
return error( COMPERR_BAD_INPUT_MESH,
TCom( "No mesher defined to compute the face #")
TCom( "No mesher defined to compute the base face #")
<< shapeID( thePrism.myBottom ));
// Make all side FACEs of thePrism meshed with quads
@ -3155,7 +3155,7 @@ bool StdMeshers_Prism_3D::initPrism(Prism_3D::TPrismTopo& thePrism,
// find vertex 000 - the one with smallest coordinates (for easy DEBUG :-)
TopoDS_Vertex V000;
double minVal = DBL_MAX, minX, val;
double minVal = DBL_MAX, minX = 0, val;
for ( TopExp_Explorer exp( botSM->GetSubShape(), TopAbs_VERTEX );
exp.More(); exp.Next() )
{

54
src/StdMeshers/StdMeshers_Projection_2D.cxx
View File

@ -1147,6 +1147,51 @@ namespace {
return true;
}
//=======================================================================
/*
* Set initial association of VERTEXes for the case of projection
* from a quadrangle FACE to a closed FACE, where opposite src EDGEs
* have different nb of segments
*/
//=======================================================================
void initAssoc4Quad2Closed(const TopoDS_Shape& tgtFace,
SMESH_MesherHelper& tgtHelper,
const TopoDS_Shape& srcFace,
SMESH_Mesh* srcMesh,
TAssocTool::TShapeShapeMap & assocMap)
{
if ( !tgtHelper.HasRealSeam() || srcFace.ShapeType() != TopAbs_FACE )
return; // no seam edge
list< TopoDS_Edge > tgtEdges, srcEdges;
list< int > tgtNbEW, srcNbEW;
int tgtNbW = SMESH_Block::GetOrderedEdges( TopoDS::Face( tgtFace ), tgtEdges, tgtNbEW );
int srcNbW = SMESH_Block::GetOrderedEdges( TopoDS::Face( srcFace ), srcEdges, srcNbEW );
if ( tgtNbW != 1 || srcNbW != 1 ||
tgtNbEW.front() != 4 || srcNbEW.front() != 4 )
return; // not quads
int srcNbSeg[4];
list< TopoDS_Edge >::iterator edgeS = srcEdges.begin(), edgeT = tgtEdges.begin();
for ( int i = 0; edgeS != srcEdges.end(); ++i, ++edgeS )
if ( SMESHDS_SubMesh* sm = srcMesh->GetMeshDS()->MeshElements( *edgeS ))
srcNbSeg[ i ] = sm->NbNodes();
else
return; // not meshed
if ( srcNbSeg[0] == srcNbSeg[2] && srcNbSeg[1] == srcNbSeg[3] )
return; // same nb segments
if ( srcNbSeg[0] != srcNbSeg[2] && srcNbSeg[1] != srcNbSeg[3] )
return; // all different nb segments
edgeS = srcEdges.begin();
if ( srcNbSeg[0] != srcNbSeg[2] )
++edgeS;
TAssocTool::InsertAssociation( tgtHelper.IthVertex( 0,*edgeT ),
tgtHelper.IthVertex( 0,*edgeS ), assocMap );
TAssocTool::InsertAssociation( tgtHelper.IthVertex( 1,*edgeT ),
tgtHelper.IthVertex( 1,*edgeS ), assocMap );
}
} // namespace
@ -1159,7 +1204,6 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
{
_src2tgtNodes.clear();
MESSAGE("Projection_2D Compute");
if ( !_sourceHypo )
return false;
@ -1178,8 +1222,12 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
TopoDS_Face tgtFace = TopoDS::Face( theShape.Oriented(TopAbs_FORWARD));
TopoDS_Shape srcShape = _sourceHypo->GetSourceFace().Oriented(TopAbs_FORWARD);
helper.SetSubShape( tgtFace );
TAssocTool::TShapeShapeMap shape2ShapeMap;
TAssocTool::InitVertexAssociation( _sourceHypo, shape2ShapeMap );
if ( shape2ShapeMap.IsEmpty() )
initAssoc4Quad2Closed( tgtFace, helper, srcShape, srcMesh, shape2ShapeMap );
if ( !TAssocTool::FindSubShapeAssociation( tgtFace, tgtMesh, srcShape, srcMesh,
shape2ShapeMap) ||
!shape2ShapeMap.IsBound( tgtFace ))
@ -1257,7 +1305,7 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
{
// projection in case if the faces are similar in 2D space
projDone = projectBy2DSimilarity( tgtFace, srcFace, tgtWires, srcWires,
shape2ShapeMap, _src2tgtNodes, is1DComputed);
shape2ShapeMap, _src2tgtNodes, is1DComputed );
}
if ( !projDone )
{
@ -1266,8 +1314,6 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
// shape2ShapeMap, _src2tgtNodes, is1DComputed);
}
helper.SetSubShape( tgtFace );
// it will remove mesh built on edges and vertices in failure case
MeshCleaner cleaner( tgtSubMesh );

18
src/StdMeshers/StdMeshers_Quadrangle_2D.cxx
View File

@ -519,7 +519,7 @@ bool StdMeshers_Quadrangle_2D::computeQuadDominant(SMESH_Mesh& aMesh,
// for each node of the down edge find nearest node
// in the first row of the regular grid and link them
for (i = 0; i < stop; i++) {
const SMDS_MeshNode *a, *b, *c, *d;
const SMDS_MeshNode *a, *b, *c=0, *d;
a = uv_e0[i].node;
b = uv_e0[i + 1].node;
gp_Pnt pb (b->X(), b->Y(), b->Z());
@ -533,6 +533,7 @@ bool StdMeshers_Quadrangle_2D::computeQuadDominant(SMESH_Mesh& aMesh,
}
else {
// find in the grid node c, nearest to the b
c = 0;
double mind = RealLast();
for (int k = g; k <= iup; k++) {
@ -734,6 +735,7 @@ bool StdMeshers_Quadrangle_2D::computeQuadDominant(SMESH_Mesh& aMesh,
gp_Pnt pb (b->X(), b->Y(), b->Z());
// find node c in the grid, nearest to the b
c = 0;
int near = g;
if (i == stop - 1) { // up bondary reached
c = quad->uv_grid[nbhoriz*(jup + 1) - 2].node;
@ -2138,7 +2140,7 @@ bool StdMeshers_Quadrangle_2D::computeQuadPref (SMESH_Mesh & aMesh,
npl.Append(uv_el[i].normParam);
}
int dl,dr;
int dl = 0, dr = 0;
if (OldVersion) {
// add some params to right and left after the first param
// insert to right
@ -2380,7 +2382,7 @@ bool StdMeshers_Quadrangle_2D::computeQuadPref (SMESH_Mesh & aMesh,
TColgp_SequenceOfXY UVtmp;
double drparam = npr.Value(nr) - npr.Value(nnn-1);
double dlparam = npl.Value(nnn) - npl.Value(nnn-1);
double y0,y1;
double y0 = 0, y1 = 0;
for (i=1; i<=drl; i++) {
// add existed nodes from right edge
NodesC.SetValue(nb,i+1,uv_er[nnn+i-2].node);
@ -3296,7 +3298,11 @@ bool StdMeshers_Quadrangle_2D::computeReduced (SMESH_Mesh & aMesh,
vector<UVPtStruct> curr_base = uv_eb, next_base;
UVPtStruct nullUVPtStruct; nullUVPtStruct.node = 0;
UVPtStruct nullUVPtStruct;
nullUVPtStruct.node = 0;
nullUVPtStruct.x = nullUVPtStruct.y = nullUVPtStruct.u = nullUVPtStruct.y = 0;
nullUVPtStruct.param = 0;
int curr_base_len = nb;
int next_base_len = 0;
@ -4108,7 +4114,7 @@ bool StdMeshers_Quadrangle_2D::check()
StdMeshers_FaceSidePtr wire = wireVec[0];
// find a right angle VERTEX
int iVertex;
int iVertex = 0;
double maxAngle = -1e100;
for ( int i = 0; i < wire->NbEdges(); ++i )
{
@ -5145,6 +5151,8 @@ void StdMeshers_Quadrangle_2D::updateSideUV( FaceQuadStruct::Side& side,
for ( iS = 0; iS < q->side.size(); ++iS )
if ( side.grid == q->side[ iS ].grid )
break;
if ( iS == q->side.size() )
continue;
bool isOut;
if ( !q->side[ iS ].IsReversed() )
isOut = ( q->side[ iS ].from > iCur || q->side[ iS ].to-1 <= iCur );

135
src/StdMeshers/StdMeshers_Regular_1D.cxx
View File

@ -72,15 +72,15 @@ using namespace StdMeshers;
//=============================================================================
/*!
*
*
*/
//=============================================================================
StdMeshers_Regular_1D::StdMeshers_Regular_1D(int hypId, int studyId,
StdMeshers_Regular_1D::StdMeshers_Regular_1D(int hypId,
int studyId,
SMESH_Gen * gen)
:SMESH_1D_Algo(hypId, studyId, gen)
:SMESH_1D_Algo( hypId, studyId, gen )
{
MESSAGE("StdMeshers_Regular_1D::StdMeshers_Regular_1D");
_name = "Regular_1D";
_shapeType = (1 << TopAbs_EDGE);
_fpHyp = 0;
@ -155,7 +155,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
string hypName = theHyp->GetName();
if (hypName == "LocalLength")
if ( hypName == "LocalLength" )
{
const StdMeshers_LocalLength * hyp =
dynamic_cast <const StdMeshers_LocalLength * >(theHyp);
@ -167,7 +167,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
aStatus = SMESH_Hypothesis::HYP_OK;
}
else if (hypName == "MaxLength")
else if ( hypName == "MaxLength" )
{
const StdMeshers_MaxLength * hyp =
dynamic_cast <const StdMeshers_MaxLength * >(theHyp);
@ -182,7 +182,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
aStatus = SMESH_Hypothesis::HYP_OK;
}
else if (hypName == "NumberOfSegments")
else if ( hypName == "NumberOfSegments" )
{
const StdMeshers_NumberOfSegments * hyp =
dynamic_cast <const StdMeshers_NumberOfSegments * >(theHyp);
@ -217,7 +217,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
aStatus = SMESH_Hypothesis::HYP_OK;
}
else if (hypName == "Arithmetic1D")
else if ( hypName == "Arithmetic1D" )
{
const StdMeshers_Arithmetic1D * hyp =
dynamic_cast <const StdMeshers_Arithmetic1D * >(theHyp);
@ -232,7 +232,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
aStatus = SMESH_Hypothesis::HYP_OK;
}
else if (hypName == "GeometricProgression")
else if ( hypName == "GeometricProgression" )
{
const StdMeshers_Geometric1D * hyp =
dynamic_cast <const StdMeshers_Geometric1D * >(theHyp);
@ -247,7 +247,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
aStatus = SMESH_Hypothesis::HYP_OK;
}
else if (hypName == "FixedPoints1D") {
else if ( hypName == "FixedPoints1D" ) {
_fpHyp = dynamic_cast <const StdMeshers_FixedPoints1D*>(theHyp);
ASSERT(_fpHyp);
_hypType = FIXED_POINTS_1D;
@ -257,7 +257,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
aStatus = SMESH_Hypothesis::HYP_OK;
}
else if (hypName == "StartEndLength")
else if ( hypName == "StartEndLength" )
{
const StdMeshers_StartEndLength * hyp =
dynamic_cast <const StdMeshers_StartEndLength * >(theHyp);
@ -272,7 +272,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
aStatus = SMESH_Hypothesis::HYP_OK;
}
else if (hypName == "Deflection1D")
else if ( hypName == "Deflection1D" )
{
const StdMeshers_Deflection1D * hyp =
dynamic_cast <const StdMeshers_Deflection1D * >(theHyp);
@ -283,7 +283,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
aStatus = SMESH_Hypothesis::HYP_OK;
}
else if (hypName == "AutomaticLength")
else if ( hypName == "AutomaticLength" )
{
StdMeshers_AutomaticLength * hyp = const_cast<StdMeshers_AutomaticLength *>
(dynamic_cast <const StdMeshers_AutomaticLength * >(theHyp));
@ -293,7 +293,7 @@ bool StdMeshers_Regular_1D::CheckHypothesis( SMESH_Mesh& aMesh,
_hypType = MAX_LENGTH;
aStatus = SMESH_Hypothesis::HYP_OK;
}
else if (hypName == "Adaptive1D")
else if ( hypName == "Adaptive1D" )
{
_adaptiveHyp = dynamic_cast < const StdMeshers_Adaptive1D* >(theHyp);
ASSERT(_adaptiveHyp);
@ -351,13 +351,11 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d,
// never do this way
//OSD::SetSignal( true );
if (nbSeg <= 0)
if ( nbSeg <= 0 )
return false;
MESSAGE( "computeParamByFunc" );
int nbPnt = 1 + nbSeg;
vector<double> x(nbPnt, 0.);
vector<double> x( nbPnt, 0. );
if ( !buildDistribution( func, 0.0, 1.0, nbSeg, x, 1E-4 ))
return false;
@ -374,7 +372,7 @@ static bool computeParamByFunc(Adaptor3d_Curve& C3d,
for ( int i = 1; i < nbSeg; i++ )
{
double curvLength = length * (x[i] - x[i-1]) * sign;
double tol = Min( Precision::Confusion(), curvLength / 100. );
double tol = Min( Precision::Confusion(), curvLength / 100. );
GCPnts_AbscissaPoint Discret( tol, C3d, curvLength, prevU );
if ( !Discret.IsDone() )
return false;
@ -686,7 +684,6 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
if ( ! SMESH_Algo::GetSortedNodesOnEdge( theMesh.GetMeshDS(), mainEdge, _quadraticMesh,
mainEdgeParamsOfNodes, SMDSAbs_Edge ))
return error("Bad node parameters on the source edge of Propagation Of Distribution");
vector< double > segLen( mainEdgeParamsOfNodes.size() - 1 );
double totalLen = 0;
BRepAdaptor_Curve mainEdgeCurve( mainEdge );
@ -715,7 +712,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
++nbParams;
}
if ( nbParams != segLen.size()-1 )
return error( SMESH_Comment("Can't divide into ") << segLen.size() << " segements");
return error( SMESH_Comment("Can't divide into ") << segLen.size() << " segments");
compensateError( segLen[ theReverse ? segLen.size()-1 : 0 ],
segLen[ theReverse ? 0 : segLen.size()-1 ],
@ -728,8 +725,8 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
{
case LOCAL_LENGTH:
case MAX_LENGTH:
case NB_SEGMENTS: {
case NB_SEGMENTS:
{
double eltSize = 1;
int nbSegments;
if ( _hypType == MAX_LENGTH )
@ -761,7 +758,7 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
}
if (computed) {
SMESHDS_SubMesh* smds = sm->GetSubMeshDS();
int nb_segments = smds->NbElements();
int nb_segments = smds->NbElements();
if (nbseg - 1 <= nb_segments && nb_segments <= nbseg + 1) {
isFound = true;
nbseg = nb_segments;
@ -893,18 +890,18 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
return true;
}
case ARITHMETIC_1D: {
case ARITHMETIC_1D:
{
// arithmetic progression: SUM(n) = ( an - a1 + q ) * ( a1 + an ) / ( 2 * q ) = theLength
double a1 = _value[ BEG_LENGTH_IND ];
double an = _value[ END_LENGTH_IND ];
if ( 1.01*theLength < a1 + an)
if ( 1.01*theLength < a1 + an )
return error ( SMESH_Comment("Invalid segment lengths (")<<a1<<" and "<<an<<") "<<
"for an edge of length "<<theLength);
double q = ( an - a1 ) / ( 2 *theLength/( a1 + an ) - 1 );
int n = int(fabs(q) > numeric_limits<double>::min() ? ( 1+( an-a1 )/q ) : ( 1+theLength/a1 ));
double q = ( an - a1 ) / ( 2 *theLength/( a1 + an ) - 1 );
int n = int(fabs(q) > numeric_limits<double>::min() ? ( 1+( an-a1 )/q ) : ( 1+theLength/a1 ));
double U1 = theReverse ? l : f;
double Un = theReverse ? f : l;
@ -927,14 +924,14 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
eltSize += q;
}
compensateError( a1, an, U1, Un, theLength, theC3d, theParams );
if (theReverse) theParams.reverse(); // NPAL18025
if ( theReverse ) theParams.reverse(); // NPAL18025
return true;
}
case GEOMETRIC_1D: {
double a1 = _value[ BEG_LENGTH_IND ], an;
case GEOMETRIC_1D:
{
double a1 = _value[ BEG_LENGTH_IND ], an = 0;
double q = _value[ END_LENGTH_IND ];
double U1 = theReverse ? l : f;
@ -977,7 +974,8 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
return true;
}
case FIXED_POINTS_1D: {
case FIXED_POINTS_1D:
{
const std::vector<double>& aPnts = _fpHyp->GetPoints();
const std::vector<int>& nbsegs = _fpHyp->GetNbSegments();
TColStd_SequenceOfReal Params;
@ -986,22 +984,22 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
if( aPnts[i]<0.0001 || aPnts[i]>0.9999 ) continue;
int j=1;
bool IsExist = false;
for(; j<=Params.Length(); j++) {
if( fabs(aPnts[i]-Params.Value(j)) < 1e-4 ) {
for ( ; j <= Params.Length(); j++ ) {
if ( Abs( aPnts[i] - Params.Value(j) ) < 1e-4 ) {
IsExist = true;
break;
}
if( aPnts[i]<Params.Value(j) ) break;
if ( aPnts[i]<Params.Value(j) ) break;
}
if(!IsExist) Params.InsertBefore(j,aPnts[i]);
if ( !IsExist ) Params.InsertBefore( j, aPnts[i] );
}
double par2, par1, lp;
par1 = f;
lp = l;
lp = l;
double sign = 1.0;
if(theReverse) {
if ( theReverse ) {
par1 = l;
lp = f;
lp = f;
sign = -1.0;
}
double eltSize, segmentSize = 0.;
@ -1009,37 +1007,34 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
for ( int i = 0; i < Params.Length(); i++ )
{
int nbseg = ( i > (int)nbsegs.size()-1 ) ? nbsegs[0] : nbsegs[i];
segmentSize = Params.Value(i+1)*theLength - currAbscissa;
segmentSize = Params.Value( i+1 ) * theLength - currAbscissa;
currAbscissa += segmentSize;
GCPnts_AbscissaPoint APnt(theC3d, sign*segmentSize, par1);
if( !APnt.IsDone() )
GCPnts_AbscissaPoint APnt( theC3d, sign*segmentSize, par1 );
if ( !APnt.IsDone() )
return error( "GCPnts_AbscissaPoint failed");
par2 = APnt.Parameter();
par2 = APnt.Parameter();
eltSize = segmentSize/nbseg;
GCPnts_UniformAbscissa Discret(theC3d, eltSize, par1, par2);
if(theReverse)
Discret.Initialize(theC3d, eltSize, par2, par1);
GCPnts_UniformAbscissa Discret( theC3d, eltSize, par1, par2 );
if ( theReverse )
Discret.Initialize( theC3d, eltSize, par2, par1 );
else
Discret.Initialize(theC3d, eltSize, par1, par2);
Discret.Initialize( theC3d, eltSize, par1, par2 );
if ( !Discret.IsDone() )
return error( "GCPnts_UniformAbscissa failed");
int NbPoints = Discret.NbPoints();
list<double> tmpParams;
for(int i=2; i<NbPoints; i++) {
for ( int i = 2; i < NbPoints; i++ ) {
double param = Discret.Parameter(i);
tmpParams.push_back( param );
}
if (theReverse) {
if ( theReverse ) {
compensateError( eltSize, eltSize, par2, par1, segmentSize, theC3d, tmpParams );
tmpParams.reverse();
}
else {
compensateError( eltSize, eltSize, par1, par2, segmentSize, theC3d, tmpParams );
}
list<double>::iterator itP = tmpParams.begin();
for(; itP != tmpParams.end(); itP++) {
theParams.push_back( *(itP) );
}
theParams.splice( theParams.end(), tmpParams );
theParams.push_back( par2 );
par1 = par2;
@ -1049,39 +1044,36 @@ bool StdMeshers_Regular_1D::computeInternalParameters(SMESH_Mesh & theMesh,
segmentSize = theLength - currAbscissa;
eltSize = segmentSize/nbseg;
GCPnts_UniformAbscissa Discret;
if(theReverse)
Discret.Initialize(theC3d, eltSize, par1, lp);
if ( theReverse )
Discret.Initialize( theC3d, eltSize, par1, lp );
else
Discret.Initialize(theC3d, eltSize, lp, par1);
Discret.Initialize( theC3d, eltSize, lp, par1 );
if ( !Discret.IsDone() )
return error( "GCPnts_UniformAbscissa failed");
int NbPoints = Discret.NbPoints();
list<double> tmpParams;
for(int i=2; i<NbPoints; i++) {
for ( int i = 2; i < NbPoints; i++ ) {
double param = Discret.Parameter(i);
tmpParams.push_back( param );
}
if (theReverse) {
if ( theReverse ) {
compensateError( eltSize, eltSize, lp, par1, segmentSize, theC3d, tmpParams );
tmpParams.reverse();
}
else {
compensateError( eltSize, eltSize, par1, lp, segmentSize, theC3d, tmpParams );
}
list<double>::iterator itP = tmpParams.begin();
for(; itP != tmpParams.end(); itP++) {
theParams.push_back( *(itP) );
}
theParams.splice( theParams.end(), tmpParams );
if (theReverse) {
if ( theReverse )
theParams.reverse(); // NPAL18025
}
return true;
}
case DEFLECTION: {
GCPnts_UniformDeflection Discret(theC3d, _value[ DEFLECTION_IND ], f, l, true);
case DEFLECTION:
{
GCPnts_UniformDeflection Discret( theC3d, _value[ DEFLECTION_IND ], f, l, true );
if ( !Discret.IsDone() )
return false;
@ -1241,8 +1233,6 @@ bool StdMeshers_Regular_1D::Compute(SMESH_Mesh & theMesh, const TopoDS_Shape & t
}
else
{
//MESSAGE("************* Degenerated edge! *****************");
// Edge is a degenerated Edge : We put n = 5 points on the edge.
const int NbPoints = 5;
BRep_Tool::Range( E, f, l ); // PAL15185
@ -1345,9 +1335,8 @@ bool StdMeshers_Regular_1D::Evaluate(SMESH_Mesh & theMesh,
}
else {
//MESSAGE("************* Degenerated edge! *****************");
// Edge is a degenerated Edge : We put n = 5 points on the edge.
if(_quadraticMesh) {
if ( _quadraticMesh ) {
aVec[SMDSEntity_Node] = 11;
aVec[SMDSEntity_Quad_Edge] = 6;
}

5238
src/StdMeshers/StdMeshers_ViscousLayers.cxx
View File

File diff suppressed because it is too large Load Diff

59
src/StdMeshers/StdMeshers_ViscousLayers2D.cxx
View File

@ -113,6 +113,7 @@ namespace VISCOUS_2D
//virtual int NbElements() const { return _elements.size()+1; }
virtual int NbNodes() const { return Max( 0, _uvPtStructVec.size()-2 ); }
void SetUVPtStructVec(UVPtStructVec& vec) { _uvPtStructVec.swap( vec ); }
UVPtStructVec& GetUVPtStructVec() { return _uvPtStructVec; }
};
_ProxyMeshOfFace(const SMESH_Mesh& mesh): SMESH_ProxyMesh(mesh) {}
_EdgeSubMesh* GetEdgeSubMesh(int ID) { return (_EdgeSubMesh*) getProxySubMesh(ID); }
@ -299,6 +300,8 @@ namespace VISCOUS_2D
double _D; // _vec1.Crossed( _vec2 )
double _param1, _param2; // intersection param on _seg1 and _seg2
_SegmentIntersection(): _param1(0), _param2(0), _D(0) {}
bool Compute(const _Segment& seg1, const _Segment& seg2, bool seg2IsRay = false )
{
// !!! If seg2IsRay, returns true at any _param2 !!!
@ -515,29 +518,53 @@ SMESH_ProxyMesh::Ptr
StdMeshers_ViscousLayers2D::Compute(SMESH_Mesh& theMesh,
const TopoDS_Face& theFace)
{
SMESH_ProxyMesh::Ptr pm;
using namespace VISCOUS_2D;
vector< const StdMeshers_ViscousLayers2D* > hyps;
vector< TopoDS_Shape > hypShapes;
if ( VISCOUS_2D::findHyps( theMesh, theFace, hyps, hypShapes ))
SMESH_ProxyMesh::Ptr pm = _ProxyMeshHolder::FindProxyMeshOfFace( theFace, theMesh );
if ( !pm )
{
VISCOUS_2D::_ViscousBuilder2D builder( theMesh, theFace, hyps, hypShapes );
pm = builder.Compute();
SMESH_ComputeErrorPtr error = builder.GetError();
if ( error && !error->IsOK() )
theMesh.GetSubMesh( theFace )->GetComputeError() = error;
else if ( !pm )
if ( findHyps( theMesh, theFace, hyps, hypShapes ))
{
VISCOUS_2D::_ViscousBuilder2D builder( theMesh, theFace, hyps, hypShapes );
pm = builder.Compute();
SMESH_ComputeErrorPtr error = builder.GetError();
if ( error && !error->IsOK() )
theMesh.GetSubMesh( theFace )->GetComputeError() = error;
else if ( !pm )
pm.reset( new SMESH_ProxyMesh( theMesh ));
if ( getenv("__ONLY__VL2D__"))
pm.reset();
}
else
{
pm.reset( new SMESH_ProxyMesh( theMesh ));
if ( getenv("__ONLY__VL2D__"))
pm.reset();
}
else
{
pm.reset( new SMESH_ProxyMesh( theMesh ));
}
}
return pm;
}
// --------------------------------------------------------------------------------
void StdMeshers_ViscousLayers2D::SetProxyMeshOfEdge( const StdMeshers_FaceSide& edgeNodes )
{
using namespace VISCOUS_2D;
SMESH_ProxyMesh::Ptr pm =
_ProxyMeshHolder::FindProxyMeshOfFace( edgeNodes.Face(), *edgeNodes.GetMesh() );
if ( !pm ) {
_ProxyMeshOfFace* proxyMeshOfFace = new _ProxyMeshOfFace( *edgeNodes.GetMesh() );
pm.reset( proxyMeshOfFace );
new _ProxyMeshHolder( edgeNodes.Face(), pm );
}
_ProxyMeshOfFace* proxyMeshOfFace = static_cast<_ProxyMeshOfFace*>( pm.get() );
_ProxyMeshOfFace::_EdgeSubMesh* sm = proxyMeshOfFace->GetEdgeSubMesh( edgeNodes.EdgeID(0) );
sm->GetUVPtStructVec() = edgeNodes.GetUVPtStruct();
}
// --------------------------------------------------------------------------------
bool StdMeshers_ViscousLayers2D::HasProxyMesh( const TopoDS_Face& face, SMESH_Mesh& mesh )
{
return VISCOUS_2D::_ProxyMeshHolder::FindProxyMeshOfFace( face, mesh );
}
// --------------------------------------------------------------------------------
SMESH_ComputeErrorPtr
StdMeshers_ViscousLayers2D::CheckHypothesis(SMESH_Mesh& theMesh,
const TopoDS_Shape& theShape,
@ -1794,7 +1821,7 @@ bool _ViscousBuilder2D::shrink()
// x-x-x-x-----x-----x----
// | | | | e1 e2 e3
int isRShrinkedForAdjacent;
int isRShrinkedForAdjacent = 0;
UVPtStructVec nodeDataForAdjacent;
for ( int isR = 0; isR < 2; ++isR )
{

4
src/StdMeshers/StdMeshers_ViscousLayers2D.hxx
View File

@ -27,6 +27,7 @@
#include "StdMeshers_ViscousLayers.hxx"
class TopoDS_Face;
class StdMeshers_FaceSide;
/*!
* \brief Hypothesis defining parameters of viscous layers
@ -72,6 +73,9 @@ public:
static const char* GetHypType() { return "ViscousLayers2D"; }
static void SetProxyMeshOfEdge( const StdMeshers_FaceSide& edgeNodes );
static bool HasProxyMesh( const TopoDS_Face& face, SMESH_Mesh& theMesh );
private:
};

2
src/StdMeshersGUI/StdMeshersGUI_DistrPreview.cxx
View File

@ -293,7 +293,7 @@ void StdMeshersGUI_DistrPreview::update()
int size = graph.length()/2;
double* x = new double[size], *y = new double[size];
double min_x, max_x, min_y, max_y;
double min_x = 0, max_x = 0, min_y = 0, max_y = 0;
for( int i=0; i<size; i++ )
{
x[i] = graph[2*i];

5
src/StdMeshersGUI/StdMeshersGUI_SubShapeSelectorWdg.cxx
View File

@ -418,12 +418,15 @@ void StdMeshersGUI_SubShapeSelectorWdg::onListSelectionChanged()
return;
//mySelectionMgr->clearSelected();
TColStd_MapOfInteger aIndexes;
myPreviewActor->HighlightAll( false );
QList<QListWidgetItem*> selItems = myListWidget->selectedItems();
QListWidgetItem* anItem;
foreach(anItem, selItems)
myPreviewActor->HighlightID( anItem->text().toInt() );
if ( SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( mySMESHGUI ))
aViewWindow->Repaint();
// update remove button
myRemoveButton->setEnabled( selItems.size() > 0 );

3
src/StdMeshers_I/StdMeshers_ViscousLayers_i.cxx
View File

@ -53,7 +53,6 @@ StdMeshers_ViscousLayers_i::StdMeshers_ViscousLayers_i( PortableServer::POA_ptr
: SALOME::GenericObj_i( thePOA ),
SMESH_Hypothesis_i( thePOA )
{
MESSAGE( "StdMeshers_ViscousLayers_i::StdMeshers_ViscousLayers_i" );
myBaseImpl = new ::StdMeshers_ViscousLayers( theGenImpl->GetANewId(),
theStudyId,
theGenImpl );
@ -69,7 +68,6 @@ StdMeshers_ViscousLayers_i::StdMeshers_ViscousLayers_i( PortableServer::POA_ptr
StdMeshers_ViscousLayers_i::~StdMeshers_ViscousLayers_i()
{
MESSAGE( "StdMeshers_ViscousLayers_i::~StdMeshers_ViscousLayers_i" );
}
//================================================================================
@ -265,7 +263,6 @@ void StdMeshers_ViscousLayers_i::SetMethod( ::StdMeshers::VLExtrusionMethod how
::StdMeshers_ViscousLayers* StdMeshers_ViscousLayers_i::GetImpl()
{
MESSAGE( "StdMeshers_ViscousLayers_i::GetImpl" );
return ( ::StdMeshers_ViscousLayers* )myBaseImpl;
}

2
src/StdMeshers_I/StdMeshers_i.cxx
View File

@ -134,8 +134,6 @@ extern "C"
STDMESHERS_I_EXPORT
GenericHypothesisCreator_i* GetHypothesisCreator (const char* aHypName)
{
MESSAGE("Get HypothesisCreator for " << aHypName);
GenericHypothesisCreator_i* aCreator = 0;
// Hypotheses

14
src/Tools/MeshCut/MeshCut_DC.cxx
View File

@ -72,13 +72,13 @@ int main(int argc, char *argv[])
debug = false;
string ficMEDin;
string ficMEDout;
float xNormal;
float yNormal;
float zNormal;
float xm;
float ym;
float zm;
float tolerance;
float xNormal = 0;
float yNormal = 0;
float zNormal = 0;
float xm = 0;
float ym = 0;
float zm = 0;
float tolerance = 0;
try
{
if (argc != 13)

2
src/Tools/MeshCut/MeshCut_Fonctions.cxx
View File

@ -84,7 +84,7 @@ int MESHCUT::positionNoeudPlan(int indiceNoeud)
int MESHCUT::intersectionSegmentPlan(int it4, int na)
{
int ngA, ngB; // Numéros des noeuds extrémités AB
int ngA = -1, ngB = -1; // Numéros des noeuds extrémités AB
float lambda, ps; //, ab; // ab = longueur AB
float A[3], B[3];

18
src/Tools/MeshCut/MeshCut_Maillage.cxx
View File

@ -204,7 +204,7 @@ float Maillage::distanceNoeudMaille(int ngnoeud, int imaille, TYPE_MAILLE tm)
int Maillage::noeudVoisin(int ngnoeud, int imaille, TYPE_MAILLE tm)
{
float x, y, z;
int ngv;
int ngv = -1;
float x0 = XX[ngnoeud - 1];
float y0 = YY[ngnoeud - 1];
float z0 = ZZ[ngnoeud - 1];
@ -557,13 +557,13 @@ void Maillage::inputMED(std::string fichierMED)
ostringstream OSCOORD;
med_int nnoe = 0; // Nbre de noeuds
med_float *coo1; // Table des coordonnées
med_float *coo1 = 0; // Table des coordonnées
// char nomcoo[mdim * MED_SNAME_SIZE + 1]; // Table des noms des coordonnées
// char unicoo[mdim * MED_SNAME_SIZE + 1]; // Table des unités des coordonnées
char *nomnoe;
char *nomnoe = 0;
med_int *numnoe;
med_int *nufano;
med_int *numnoe = 0;
med_int *nufano = 0;
// med_grid_type rep;
// med_bool inonoe, inunoe;
// med_int profil[2] = { 2, 3 };
@ -1133,7 +1133,7 @@ void Maillage::outputMED(std::string fichierMED)
// float x, y, z;
med_int nnoe = nombreNoeudsMaillage; // Nombre de noeuds
med_float *coo; // Table des coordonnées
med_float *coo = 0; // Table des coordonnées
// Noms des coordonnées (variable nomcoo)
char* nomcoo = new char[mdim * MED_SNAME_SIZE + 1];
@ -1169,9 +1169,9 @@ void Maillage::outputMED(std::string fichierMED)
// Tables des noms, numeros, numeros de familles des noeuds
// autant d'elements que de noeuds - les noms ont pout longueur MED_SNAME_SIZE
char *nomnoe;
char *nomnoe = 0;
med_int *numnoe = NULL;
med_int *nufano;
med_int *nufano = NULL;
med_bool inonoe = MED_FALSE;
med_bool inunoe = MED_FALSE;
@ -1580,7 +1580,7 @@ int Maillage::NGLOBAL(TYPE_MAILLE typeMaille, int nlocal)
TYPE_MAILLE Maillage::TYPE(int nglobal)
{
// Attention, les num. globaux commencent à 1, les num. locaux à 0
TYPE_MAILLE resultat;
TYPE_MAILLE resultat = (TYPE_MAILLE)-1;
int cpt = 0;
for (int itm = (int) POI1; itm <= (int) HEXA20; itm++)
{

2
src/Tools/MeshCut/MeshCut_Utils.cxx
View File

@ -534,7 +534,7 @@ int MESHCUT::copieFichier(std::string source, std::string cible)
med_geometry_type MESHCUT::InstanceMGE(TYPE_MAILLE TYPE)
{
med_geometry_type typeBanaliseMED;
med_geometry_type typeBanaliseMED = MED_NONE;
switch (TYPE)
{

3
src/Tools/blocFissure/doc/conf.py.in
View File

@ -83,7 +83,8 @@ pygments_style = 'sphinx'
# The style sheet to use for HTML and HTML Help pages. A file of that name
# must exist either in Sphinx' static/ path, or in one of the custom paths
# given in html_static_path.
html_style = 'default'
#html_style = 'default'
html_theme = 'default'
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".

19
src/Tools/blocFissure/doc/faq.rst Executable file
View File

@ -0,0 +1,19 @@
.. _faq:
#######################
FAQ
#######################
- Does Bloc Fissure works on a 2D mesh ?
No, Bloc Fissure works only for 3D meshes. However, the user can extrude the 2D mesh to a 3D mesh, insert a crack and then extract a surface containing the crack.
- Can I insert a crack in a symmetry plan ?
No, the user must insert the crack without using the symmetry plan passing through the crack lips.
- I can't have Bloc Fissure working, it raises a pure python error, what can I do ?
Bloc Fissure has some error messages for the most commonly encountered misuses. If the program raises a pure python error, it means that this error is rare or has not been encountered by the programmers yet.
Still, either the case can't be treated using Bloc Fissure or the insertion procedure was not fully respected. In the first case, use Zcracks (soon available). In the second case, see the :ref:`tutorial <tutorials>`.

79
src/Tools/blocFissure/doc/gui.rst Executable file
View File

@ -0,0 +1,79 @@
.. _gui:
With GUI
=====================================
To make the use of « Bloc Fissure » easier, a Graphical User Interface (GUI) was developed.
Inputs are similar to those of :ref:`script mode <script>`. GUI is accessible in the SMESH extension *Add a crack in a mesh*
.. figure:: images/BF_GUI_capture.png
:width: 700
:align: center
Windows of the graphical interface
+------------------------------------------------------------------------------------------------------------------+
| GUI parameters |
+======================+===================================+=======================================================+
| **maillageSain** | *[string]* | Relative address of the input structure 3D mesh |
| | ex: mesh/maillage.med | in MED format (base is repertoire de travail) |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **FaceFissure** | *[string]* | Relative address of the input crack geometry |
| | ex: mesh/fissure.brep | in BREP format (base is repertoire de travail) |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **index edges fond | *[list of integers]* | List of edges number which define the crack front |
| fissure** | ex: [1,2] | |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **min** | *[float]* | Float defining the minimum size of elements |
| | ex: 1.00000 | to mesh the crack |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **max** | *[float]* | Float defining the maximum size of elements |
| | ex: 10.0000 | to mesh the crack |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **distance | *[float]* | Length of influence - distance that defines the |
| influence** | ex: 20.0000 | size of the extracted Box around the crack |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **rayon pipe** | *[float]* | Radius of the tore around the front |
| | ex: 5.00000 | |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **longueur mailles** | *[float]* | Length of the segments of the tore along crack front |
| | ex: 5.00000 | |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **couronnes** | *[integer]* | Number of radial segment of the tore |
| | ex: 5 | |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **secteurs** | *[integer]* | Number of sectors of the tore |
| | ex: 16 | |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **arete face | *[float]* | Mesh size of elements for the Box remeshing |
| fissure** | ex: 5.0000 | |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **repertoire de | *[string]* | Absolute address of the directory where files are |
| travail** | ex: /home/A123456 | saved |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **nom résultat** | *[string]* | Name of the resulting mesh |
| | ex: maillage_fissure | |
+----------------------+-----------------------------------+-------------------------------------------------------+
| **mode** | *[choice]* | Verbose mode for Salome messages |
| | ex: verbose | |
+----------------------+-----------------------------------+-------------------------------------------------------+
.. figure:: images/parametres_GUI.png
:width: 350
:align: center
Tore parameters
- **Reset**: clears all the parameters
- **Précédent**: loads the last set of parameters used
- **Recharger**: loads a .dic file containing parameters
- **Sauver**: save a .dic file with the active parameters
- **Cancel**: exit GUI
- **Sauver**: Launch calculation

BIN
src/Tools/blocFissure/doc/images/01_CubeAngle.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
src/Tools/blocFissure/doc/images/01_CubeAngle_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 17 KiB

BIN
src/Tools/blocFissure/doc/images/02_CubeAngle2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 20 KiB

BIN
src/Tools/blocFissure/doc/images/02_CubeAngle2_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 28 KiB

BIN
src/Tools/blocFissure/doc/images/03_cylindre.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 18 KiB

BIN
src/Tools/blocFissure/doc/images/03_cylindre_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 31 KiB

BIN
src/Tools/blocFissure/doc/images/04_cylindre2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 20 KiB

BIN
src/Tools/blocFissure/doc/images/04_cylindre2_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 32 KiB

BIN
src/Tools/blocFissure/doc/images/05_disque.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 33 KiB

BIN
src/Tools/blocFissure/doc/images/05_disque_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 25 KiB

BIN
src/Tools/blocFissure/doc/images/06_ellipse1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
src/Tools/blocFissure/doc/images/06_ellipse1_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 25 KiB

BIN
src/Tools/blocFissure/doc/images/07_ellipse2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 18 KiB

BIN
src/Tools/blocFissure/doc/images/07_ellipse2_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 15 KiB

BIN
src/Tools/blocFissure/doc/images/08_eprouvetteCourbe.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 19 KiB

BIN
src/Tools/blocFissure/doc/images/08_eprouvetteCourbe_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 31 KiB

BIN
src/Tools/blocFissure/doc/images/09_eprouvetteDroite.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 14 KiB

BIN
src/Tools/blocFissure/doc/images/09_eprouvetteDroite_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 32 KiB

BIN
src/Tools/blocFissure/doc/images/10_eprouvetteDroite2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 16 KiB

BIN
src/Tools/blocFissure/doc/images/10_eprouvetteDroite2_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 23 KiB

BIN
src/Tools/blocFissure/doc/images/11_faceGauche.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 37 KiB

BIN
src/Tools/blocFissure/doc/images/11_faceGauche_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 42 KiB

BIN
src/Tools/blocFissure/doc/images/12_faceGauche2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 21 KiB

BIN
src/Tools/blocFissure/doc/images/12_faceGauche2_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 32 KiB

BIN
src/Tools/blocFissure/doc/images/13_vis_1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 45 KiB

BIN
src/Tools/blocFissure/doc/images/13_vis_1_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 71 KiB

BIN
src/Tools/blocFissure/doc/images/BF_GUI_capture.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 44 KiB

BIN
src/Tools/blocFissure/doc/images/Capture_GUI_pipes.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 78 KiB

BIN
src/Tools/blocFissure/doc/images/Capture_GUI_pipes_2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 170 KiB

BIN
src/Tools/blocFissure/doc/images/GUI_BG.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 193 KiB

BIN
src/Tools/blocFissure/doc/images/coude_0.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 18 KiB

Some files were not shown because too many files have changed in this diff Show More