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

PR: some more debug

Browse Source
This commit is contained in:
prascle 2010-11-22 16:25:35 +00:00
parent cde2f08074
commit 405a5b87ab
23 changed files with 342 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/OBJECT/SMESH_Object.cxx
View File

@ -186,7 +186,8 @@ vtkIdType SMESH_VisualObjDef::GetElemVTKId( int theObjID )
TMapOfIds::const_iterator i = mySMDS2VTKElems.find(theObjID); TMapOfIds::const_iterator i = mySMDS2VTKElems.find(theObjID);
return i == mySMDS2VTKElems.end() ? -1 : i->second; return i == mySMDS2VTKElems.end() ? -1 : i->second;
} }
return this->GetMesh()->fromSmdsToVtk(theObjID); return this->GetMesh()->FindElement(theObjID)->getVtkId();
//return this->GetMesh()->fromSmdsToVtk(theObjID);
} }
//================================================================================= //=================================================================================
@ -263,6 +264,11 @@ void SMESH_VisualObjDef::buildPrs(bool buildGrid)
else else
{ {
myLocalGrid = false; myLocalGrid = false;
if (!GetMesh()->isCompacted())
{
MESSAGE("*** buildPrs ==> compactMesh!");
GetMesh()->compactMesh();
}
vtkUnstructuredGrid *theGrid = GetMesh()->getGrid(); vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();
myGrid->ShallowCopy(theGrid); myGrid->ShallowCopy(theGrid);
//MESSAGE(myGrid->GetReferenceCount()); //MESSAGE(myGrid->GetReferenceCount());

172
src/SMDS/SMDS_Mesh.cxx
View File

@ -126,7 +126,7 @@ SMDS_Mesh::SMDS_Mesh()
myHasInverseElements(true), myHasInverseElements(true),
myNodeMin(0), myNodeMax(0), myNodeMin(0), myNodeMax(0),
myNodePool(0), myEdgePool(0), myFacePool(0), myVolumePool(0), myNodePool(0), myEdgePool(0), myFacePool(0), myVolumePool(0),
myModified(false), myRemovedNodes(false), myChangedNodes(false), myModified(false), myModifTime(0), myCompactTime(0),
xmin(0), xmax(0), ymin(0), ymax(0), zmin(0), zmax(0) xmin(0), xmax(0), ymin(0), ymax(0), zmin(0), zmax(0)
{ {
myMeshId = _meshList.size(); // --- index of the mesh to push back in the vector myMeshId = _meshList.size(); // --- index of the mesh to push back in the vector
@ -147,7 +147,7 @@ SMDS_Mesh::SMDS_Mesh()
myNodes.clear(); myNodes.clear();
myCells.clear(); myCells.clear();
myCellIdSmdsToVtk.clear(); //myCellIdSmdsToVtk.clear();
myCellIdVtkToSmds.clear(); myCellIdVtkToSmds.clear();
myGrid = SMDS_UnstructuredGrid::New(); myGrid = SMDS_UnstructuredGrid::New();
myGrid->setSMDS_mesh(this); myGrid->setSMDS_mesh(this);
@ -158,6 +158,7 @@ SMDS_Mesh::SMDS_Mesh()
myGrid->SetPoints( points ); myGrid->SetPoints( points );
points->Delete(); points->Delete();
myGrid->BuildLinks(); myGrid->BuildLinks();
this->Modified();
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
@ -1309,15 +1310,74 @@ SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolume
return v; return v;
} }
SMDS_MeshVolume* SMDS_Mesh::AddVolumeFromVtkIds(const std::vector<int>& vtkNodeIds)
{
int ID = myElementIDFactory->GetFreeID();
SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeFromVtkIdsWithID(vtkNodeIds, ID);
if (v == NULL) myElementIDFactory->ReleaseID(ID);
return v;
}
SMDS_MeshVolume* SMDS_Mesh::AddVolumeFromVtkIdsWithID(const std::vector<int>& vtkNodeIds, const int ID)
{
SMDS_VtkVolume *volvtk = myVolumePool->getNew();
volvtk->init(vtkNodeIds, this);
if (!this->registerElement(ID,volvtk))
{
this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
myVolumePool->destroy(volvtk);
return 0;
}
adjustmyCellsCapacity(ID);
myCells[ID] = volvtk;
vtkIdType aVtkType = volvtk->GetVtkType();
switch (aVtkType)
{
case VTK_TETRA:
myInfo.myNbTetras++;
break;
case VTK_PYRAMID:
myInfo.myNbPyramids++;
break;
case VTK_WEDGE:
myInfo.myNbPrisms++;
break;
case VTK_HEXAHEDRON:
myInfo.myNbHexas++;
break;
case VTK_QUADRATIC_TETRA:
myInfo.myNbQuadTetras++;
break;
case VTK_QUADRATIC_PYRAMID:
myInfo.myNbQuadPyramids++;
break;
case VTK_QUADRATIC_WEDGE:
myInfo.myNbQuadPrisms++;
break;
case VTK_QUADRATIC_HEXAHEDRON:
myInfo.myNbQuadHexas++;
break;
#ifdef VTK_HAVE_POLYHEDRON
case VTK_POLYHEDRON:
myInfo.myNbPolyhedrons++;
break;
#endif
default:
myInfo.myNbPolyhedrons++;
break;
}
return volvtk;
}
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
/// Registers element with the given ID, maintains inverse connections /// Registers element with the given ID, maintains inverse connections
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element) bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
{ {
//MESSAGE("registerElement " << ID); //MESSAGE("registerElement " << ID);
if ((ID < myCellIdSmdsToVtk.size()) && myCellIdSmdsToVtk[ID] >= 0) // --- already bound if ((ID >=0) && (ID < myCells.size()) && myCells[ID]) // --- already bound
{ {
MESSAGE(" --------------------------------- already bound "<< ID << " " << myCellIdSmdsToVtk[ID]); MESSAGE(" ------------------ already bound "<< ID << " " << myCells[ID]->getVtkId());
return false; return false;
} }
@ -1330,14 +1390,14 @@ bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
if (vtkId == -1) if (vtkId == -1)
vtkId = myElementIDFactory->SetInVtkGrid(element); vtkId = myElementIDFactory->SetInVtkGrid(element);
if (ID >= myCellIdSmdsToVtk.size()) // --- resize local vector // if (ID >= myCellIdSmdsToVtk.size()) // --- resize local vector
{ // {
MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << ID << " --> " << ID + SMDS_Mesh::chunkSize); // MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << ID << " --> " << ID + SMDS_Mesh::chunkSize);
myCellIdSmdsToVtk.resize(ID + SMDS_Mesh::chunkSize, -1); // fill new elements with -1 // myCellIdSmdsToVtk.resize(ID + SMDS_Mesh::chunkSize, -1); // fill new elements with -1
} // }
//
myCellIdSmdsToVtk[ID] = vtkId; // myCellIdSmdsToVtk[ID] = vtkId;
//MESSAGE("smds:" << ID << " vtk:" << vtkId ); // //MESSAGE("smds:" << ID << " vtk:" << vtkId );
if (vtkId >= myCellIdVtkToSmds.size()) // --- resize local vector if (vtkId >= myCellIdVtkToSmds.size()) // --- resize local vector
{ {
@ -2328,10 +2388,16 @@ SMDS_Mesh::~SMDS_Mesh()
{ {
SMDS_ElemIteratorPtr eIt = elementsIterator(); SMDS_ElemIteratorPtr eIt = elementsIterator();
while ( eIt->more() ) while ( eIt->more() )
myElementIDFactory->ReleaseID(eIt->next()->GetID()); {
const SMDS_MeshElement *elem = eIt->next();
myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
}
SMDS_NodeIteratorPtr itn = nodesIterator(); SMDS_NodeIteratorPtr itn = nodesIterator();
while (itn->more()) while (itn->more())
myNodeIDFactory->ReleaseID(itn->next()->GetID()); {
const SMDS_MeshNode *node = itn->next();
myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
}
} }
// SetOfNodes::Iterator itn(myNodes); // SetOfNodes::Iterator itn(myNodes);
@ -2380,10 +2446,16 @@ void SMDS_Mesh::Clear()
{ {
SMDS_ElemIteratorPtr eIt = elementsIterator(); SMDS_ElemIteratorPtr eIt = elementsIterator();
while ( eIt->more() ) while ( eIt->more() )
myElementIDFactory->ReleaseID(eIt->next()->GetID()); {
const SMDS_MeshElement *elem = eIt->next();
myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
}
SMDS_NodeIteratorPtr itn = nodesIterator(); SMDS_NodeIteratorPtr itn = nodesIterator();
while (itn->more()) while (itn->more())
myNodeIDFactory->ReleaseID(itn->next()->GetID()); {
const SMDS_MeshNode *node = itn->next();
myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
}
} }
else else
{ {
@ -2416,7 +2488,7 @@ void SMDS_Mesh::Clear()
} }
myCells.clear(); myCells.clear();
myCellIdVtkToSmds.clear(); myCellIdVtkToSmds.clear();
myCellIdSmdsToVtk.clear(); //myCellIdSmdsToVtk.clear();
SMDS_NodeIteratorPtr itn = nodesIterator(); SMDS_NodeIteratorPtr itn = nodesIterator();
while (itn->more()) while (itn->more())
@ -2431,8 +2503,6 @@ void SMDS_Mesh::Clear()
(*itc)->Clear(); (*itc)->Clear();
myModified = false; myModified = false;
myRemovedNodes = false;
myChangedNodes = false;
xmin = 0; xmax = 0; xmin = 0; xmax = 0;
ymin = 0; ymax = 0; ymin = 0; ymax = 0;
zmin = 0; zmax = 0; zmin = 0; zmax = 0;
@ -2923,7 +2993,7 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
n->RemoveInverseElement((*it)); n->RemoveInverseElement((*it));
} }
int IdToRemove = (*it)->GetID(); int IdToRemove = (*it)->GetID();
int vtkid = this->fromSmdsToVtk(IdToRemove); int vtkid = (*it)->getVtkId();
//MESSAGE("elem Id to remove " << IdToRemove << " vtkid " << vtkid << //MESSAGE("elem Id to remove " << IdToRemove << " vtkid " << vtkid <<
// " vtktype " << (*it)->GetVtkType() << " type " << (*it)->GetType()); // " vtktype " << (*it)->GetVtkType() << " type " << (*it)->GetType());
switch ((*it)->GetType()) switch ((*it)->GetType())
@ -2939,7 +3009,7 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
myInfo.remove(*it); myInfo.remove(*it);
} }
removedElems.push_back((*it)); removedElems.push_back((*it));
myElementIDFactory->ReleaseID(IdToRemove); myElementIDFactory->ReleaseID(IdToRemove, vtkid);
delete (*it); delete (*it);
break; break;
case SMDSAbs_Edge: case SMDSAbs_Edge:
@ -2949,7 +3019,7 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
myInfo.RemoveEdge(*it); myInfo.RemoveEdge(*it);
} }
removedElems.push_back((*it)); removedElems.push_back((*it));
myElementIDFactory->ReleaseID(IdToRemove); myElementIDFactory->ReleaseID(IdToRemove, vtkid);
if (const SMDS_VtkEdge* vtkElem = dynamic_cast<const SMDS_VtkEdge*>(*it)) if (const SMDS_VtkEdge* vtkElem = dynamic_cast<const SMDS_VtkEdge*>(*it))
myEdgePool->destroy((SMDS_VtkEdge*) vtkElem); myEdgePool->destroy((SMDS_VtkEdge*) vtkElem);
else else
@ -2962,7 +3032,7 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
myInfo.RemoveFace(*it); myInfo.RemoveFace(*it);
} }
removedElems.push_back((*it)); removedElems.push_back((*it));
myElementIDFactory->ReleaseID(IdToRemove); myElementIDFactory->ReleaseID(IdToRemove, vtkid);
if (const SMDS_VtkFace* vtkElem = dynamic_cast<const SMDS_VtkFace*>(*it)) if (const SMDS_VtkFace* vtkElem = dynamic_cast<const SMDS_VtkFace*>(*it))
myFacePool->destroy((SMDS_VtkFace*) vtkElem); myFacePool->destroy((SMDS_VtkFace*) vtkElem);
else else
@ -2975,7 +3045,7 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
myInfo.RemoveVolume(*it); myInfo.RemoveVolume(*it);
} }
removedElems.push_back((*it)); removedElems.push_back((*it));
myElementIDFactory->ReleaseID(IdToRemove); myElementIDFactory->ReleaseID(IdToRemove, vtkid);
if (const SMDS_VtkVolume* vtkElem = dynamic_cast<const SMDS_VtkVolume*>(*it)) if (const SMDS_VtkVolume* vtkElem = dynamic_cast<const SMDS_VtkVolume*>(*it))
myVolumePool->destroy((SMDS_VtkVolume*) vtkElem); myVolumePool->destroy((SMDS_VtkVolume*) vtkElem);
else else
@ -3003,7 +3073,7 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
myNodes[IdToRemove] = 0; myNodes[IdToRemove] = 0;
myInfo.myNbNodes--; myInfo.myNbNodes--;
} }
myNodeIDFactory->ReleaseID((*it)->GetID()); myNodeIDFactory->ReleaseID((*it)->GetID(), (*it)->getVtkId());
removedNodes.push_back((*it)); removedNodes.push_back((*it));
if (const SMDS_MeshNode* vtkElem = dynamic_cast<const SMDS_MeshNode*>(*it)) if (const SMDS_MeshNode* vtkElem = dynamic_cast<const SMDS_MeshNode*>(*it))
myNodePool->destroy((SMDS_MeshNode*) vtkElem); myNodePool->destroy((SMDS_MeshNode*) vtkElem);
@ -3024,6 +3094,7 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem,
void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem) void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
{ {
int elemId = elem->GetID(); int elemId = elem->GetID();
int vtkId = elem->getVtkId();
//MESSAGE("SMDS_Mesh::RemoveFreeElement " << elemId); //MESSAGE("SMDS_Mesh::RemoveFreeElement " << elemId);
SMDSAbs_ElementType aType = elem->GetType(); SMDSAbs_ElementType aType = elem->GetType();
SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem); SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
@ -3036,7 +3107,7 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
myNodes[elemId] = 0; myNodes[elemId] = 0;
myInfo.myNbNodes--; myInfo.myNbNodes--;
myNodePool->destroy(static_cast<SMDS_MeshNode*>(todest)); myNodePool->destroy(static_cast<SMDS_MeshNode*>(todest));
myNodeIDFactory->ReleaseID(elemId); myNodeIDFactory->ReleaseID(elemId, vtkId);
} }
} else { } else {
if (hasConstructionEdges() || hasConstructionFaces()) if (hasConstructionEdges() || hasConstructionFaces())
@ -3044,8 +3115,6 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
return; return;
//MESSAGE("Remove free element " << elemId); //MESSAGE("Remove free element " << elemId);
int vtkid = this->fromSmdsToVtk(elemId);
// Remove element from <InverseElements> of its nodes // Remove element from <InverseElements> of its nodes
SMDS_ElemIteratorPtr itn = elem->nodesIterator(); SMDS_ElemIteratorPtr itn = elem->nodesIterator();
while (itn->more()) { while (itn->more()) {
@ -3079,9 +3148,9 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
default: default:
break; break;
} }
myElementIDFactory->ReleaseID(elemId); myElementIDFactory->ReleaseID(elemId, vtkId);
this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL); this->myGrid->GetCellTypesArray()->SetValue(vtkId, VTK_EMPTY_CELL);
// --- to do: keep vtkid in a list of reusable cells // --- to do: keep vtkid in a list of reusable cells
} }
} }
@ -3980,10 +4049,10 @@ void SMDS_Mesh::updateNodeMinMax()
void SMDS_Mesh::incrementNodesCapacity(int nbNodes) void SMDS_Mesh::incrementNodesCapacity(int nbNodes)
{ {
int val = myCellIdSmdsToVtk.size(); // int val = myCellIdSmdsToVtk.size();
MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << val << " --> " << val + nbNodes); // MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << val << " --> " << val + nbNodes);
myCellIdSmdsToVtk.resize(val + nbNodes, -1); // fill new elements with -1 // myCellIdSmdsToVtk.resize(val + nbNodes, -1); // fill new elements with -1
val = myNodes.size(); int val = myNodes.size();
MESSAGE(" ------------------- resize myNodes " << val << " --> " << val + nbNodes); MESSAGE(" ------------------- resize myNodes " << val << " --> " << val + nbNodes);
myNodes.resize(val +nbNodes, 0); myNodes.resize(val +nbNodes, 0);
} }
@ -4066,13 +4135,6 @@ int SMDS_Mesh::fromVtkToSmds(int vtkid)
throw SALOME_Exception(LOCALIZED ("vtk id out of bounds")); throw SALOME_Exception(LOCALIZED ("vtk id out of bounds"));
} }
int SMDS_Mesh::fromSmdsToVtk(int smdsid)
{
if (smdsid >= 0 && smdsid < myCellIdSmdsToVtk.size())
return myCellIdSmdsToVtk[smdsid];
throw SALOME_Exception(LOCALIZED ("smds id out of bounds"));
}
void SMDS_Mesh::updateBoundingBox() void SMDS_Mesh::updateBoundingBox()
{ {
xmin = 0; xmax = 0; xmin = 0; xmax = 0;
@ -4105,3 +4167,31 @@ double SMDS_Mesh::getMaxDim()
MESSAGE("getMaxDim " << dmax); MESSAGE("getMaxDim " << dmax);
return dmax; return dmax;
} }
//! modification that needs compact structure and redraw
void SMDS_Mesh::Modified()
{
if (this->myModified)
{
this->myModifTime++;
MESSAGE("modified");
myModified = false;
}
}
//! get last modification timeStamp
unsigned long SMDS_Mesh::GetMTime()
{
return this->myModifTime;
}
bool SMDS_Mesh::isCompacted()
{
if (this->myModifTime > this->myCompactTime)
{
MESSAGE(" *** isCompacted " << myCompactTime << " < " << myModifTime);
this->myCompactTime = this->myModifTime;
return false;
}
return true;
}

24
src/SMDS/SMDS_Mesh.hxx
View File

@ -444,6 +444,11 @@ public:
(std::vector<const SMDS_MeshNode*> nodes, (std::vector<const SMDS_MeshNode*> nodes,
std::vector<int> quantities); std::vector<int> quantities);
virtual SMDS_MeshVolume* AddVolumeFromVtkIds(const std::vector<int>& vtkNodeIds);
virtual SMDS_MeshVolume* AddVolumeFromVtkIdsWithID(const std::vector<int>& vtkNodeIds,
const int ID);
virtual void RemoveElement(const SMDS_MeshElement * elem, virtual void RemoveElement(const SMDS_MeshElement * elem,
std::list<const SMDS_MeshElement *>& removedElems, std::list<const SMDS_MeshElement *>& removedElems,
std::list<const SMDS_MeshElement *>& removedNodes, std::list<const SMDS_MeshElement *>& removedNodes,
@ -574,7 +579,6 @@ public:
void updateBoundingBox(); void updateBoundingBox();
double getMaxDim(); double getMaxDim();
int fromVtkToSmds(int vtkid); int fromVtkToSmds(int vtkid);
int fromSmdsToVtk(int smdsid);
void incrementNodesCapacity(int nbNodes); void incrementNodesCapacity(int nbNodes);
void incrementCellsCapacity(int nbCells); void incrementCellsCapacity(int nbCells);
@ -582,6 +586,13 @@ public:
void dumpGrid(string ficdump="dumpGrid"); void dumpGrid(string ficdump="dumpGrid");
static int chunkSize; static int chunkSize;
//! low level modification: add, change or remove node or element
inline void setMyModified() { this->myModified = true; };
void Modified();
unsigned long GetMTime();
bool isCompacted();
protected: protected:
SMDS_Mesh(SMDS_Mesh * parent); SMDS_Mesh(SMDS_Mesh * parent);
@ -652,7 +663,7 @@ protected:
SetOfCells myCells; SetOfCells myCells;
//! for cells only: index = ID for SMDS users, value = ID in vtkUnstructuredGrid //! for cells only: index = ID for SMDS users, value = ID in vtkUnstructuredGrid
std::vector<int> myCellIdSmdsToVtk; //std::vector<int> myCellIdSmdsToVtk;
//! for cells only: index = ID in vtkUnstructuredGrid, value = ID for SMDS users //! for cells only: index = ID in vtkUnstructuredGrid, value = ID for SMDS users
std::vector<int> myCellIdVtkToSmds; std::vector<int> myCellIdVtkToSmds;
@ -663,6 +674,9 @@ protected:
SMDS_MeshElementIDFactory *myElementIDFactory; SMDS_MeshElementIDFactory *myElementIDFactory;
SMDS_MeshInfo myInfo; SMDS_MeshInfo myInfo;
//! use a counter to keep track of modifications
unsigned long myModifTime, myCompactTime;
int myNodeMin; int myNodeMin;
int myNodeMax; int myNodeMax;
@ -670,9 +684,9 @@ protected:
bool myHasConstructionFaces; bool myHasConstructionFaces;
bool myHasInverseElements; bool myHasInverseElements;
bool myModified; // any add remove or change of node or cell //! any add, remove or change of node or cell
bool myRemovedNodes; bool myModified;
bool myChangedNodes;
double xmin; double xmin;
double xmax; double xmax;
double ymin; double ymin;

34
src/SMDS/SMDS_MeshElementIDFactory.cxx
View File

@ -120,7 +120,7 @@ bool SMDS_MeshElementIDFactory::BindID(int ID, SMDS_MeshElement * elem)
//======================================================================= //=======================================================================
SMDS_MeshElement* SMDS_MeshElementIDFactory::MeshElement(int ID) SMDS_MeshElement* SMDS_MeshElementIDFactory::MeshElement(int ID)
{ {
if ((ID<1) || (ID>myMax) || (myMesh->myCellIdSmdsToVtk[ID]<0)) if ((ID<1) || (ID>=myMesh->myCells.size()))
return NULL; return NULL;
const SMDS_MeshElement* elem = GetMesh()->FindElement(ID); const SMDS_MeshElement* elem = GetMesh()->FindElement(ID);
return (SMDS_MeshElement*)(elem); return (SMDS_MeshElement*)(elem);
@ -130,19 +130,19 @@ SMDS_MeshElement* SMDS_MeshElementIDFactory::MeshElement(int ID)
//function : ReleaseID //function : ReleaseID
//purpose : //purpose :
//======================================================================= //=======================================================================
void SMDS_MeshElementIDFactory::ReleaseID(const int ID) void SMDS_MeshElementIDFactory::ReleaseID(int ID, int vtkId)
{ {
if (ID < 1) if (ID < 1) // TODO check case ID == O
{ {
//MESSAGE("~~~~~~~~~~~~~~ SMDS_MeshElementIDFactory::ReleaseID ID = " << ID); MESSAGE("~~~~~~~~~~~~~~ SMDS_MeshElementIDFactory::ReleaseID ID = " << ID);
return; return;
} }
int vtkId = myMesh->myCellIdSmdsToVtk[ID];
//MESSAGE("~~~~~~~~~~~~~~ SMDS_MeshElementIDFactory::ReleaseID smdsId vtkId " << ID << " " << vtkId); //MESSAGE("~~~~~~~~~~~~~~ SMDS_MeshElementIDFactory::ReleaseID smdsId vtkId " << ID << " " << vtkId);
if (ID >=0) if (vtkId >= 0)
{ {
myMesh->myCellIdSmdsToVtk[ID] = -1; assert(vtkId < myMesh->myCellIdVtkToSmds.size());
myMesh->myCellIdVtkToSmds[vtkId] = -1; myMesh->myCellIdVtkToSmds[vtkId] = -1;
myMesh->setMyModified();
} }
SMDS_MeshIDFactory::ReleaseID(ID); SMDS_MeshIDFactory::ReleaseID(ID);
if (ID == myMax) if (ID == myMax)
@ -160,12 +160,17 @@ void SMDS_MeshElementIDFactory::updateMinMax() const
{ {
myMin = IntegerLast(); myMin = IntegerLast();
myMax = 0; myMax = 0;
for (int i=0; i<myMesh->myCellIdSmdsToVtk.size(); i++) for (int i = 0; i < myMesh->myCells.size(); i++)
if (int id=myMesh->myCellIdSmdsToVtk[i] >=0) {
{ if (myMesh->myCells[i])
if (id > myMax) myMax = id; {
if (id < myMin) myMin = id; int id = myMesh->myCells[i]->GetID();
} if (id > myMax)
myMax = id;
if (id < myMin)
myMin = id;
}
}
if (myMin == IntegerLast()) if (myMin == IntegerLast())
myMin = 0; myMin = 0;
} }
@ -182,7 +187,8 @@ SMDS_ElemIteratorPtr SMDS_MeshElementIDFactory::elementsIterator() const
void SMDS_MeshElementIDFactory::Clear() void SMDS_MeshElementIDFactory::Clear()
{ {
myMesh->myCellIdSmdsToVtk.clear(); //myMesh->myCellIdSmdsToVtk.clear();
myMesh->myCellIdVtkToSmds.clear();
myMin = myMax = 0; myMin = myMax = 0;
SMDS_MeshIDFactory::Clear(); SMDS_MeshIDFactory::Clear();
} }

2
src/SMDS/SMDS_MeshElementIDFactory.hxx
View File

@ -45,7 +45,7 @@ public:
bool BindID(int ID, SMDS_MeshElement * elem); bool BindID(int ID, SMDS_MeshElement * elem);
int SetInVtkGrid(SMDS_MeshElement * elem); int SetInVtkGrid(SMDS_MeshElement * elem);
SMDS_MeshElement * MeshElement(int ID); SMDS_MeshElement * MeshElement(int ID);
virtual void ReleaseID(int ID); virtual void ReleaseID(int ID, int vtkId = -1);
SMDS_ElemIteratorPtr elementsIterator() const; SMDS_ElemIteratorPtr elementsIterator() const;
virtual void Clear(); virtual void Clear();
int GetVtkCellType(int SMDSType); int GetVtkCellType(int SMDSType);

3
src/SMDS/SMDS_MeshIDFactory.cxx
View File

@ -62,7 +62,7 @@ int SMDS_MeshIDFactory::GetFreeID()
//function : ReleaseID //function : ReleaseID
//purpose : //purpose :
//======================================================================= //=======================================================================
void SMDS_MeshIDFactory::ReleaseID(const int ID) void SMDS_MeshIDFactory::ReleaseID(int ID, int vtkId)
{ {
if ( ID > 0 ) if ( ID > 0 )
{ {
@ -87,7 +87,6 @@ void SMDS_MeshIDFactory::ReleaseID(const int ID)
} }
} }
} }
myMesh->myModified = true;
} }
void SMDS_MeshIDFactory::Clear() void SMDS_MeshIDFactory::Clear()

2
src/SMDS/SMDS_MeshIDFactory.hxx
View File

@ -38,7 +38,7 @@ class SMDS_EXPORT SMDS_MeshIDFactory:public SMDS_MeshObject
{ {
public: public:
int GetFreeID(); int GetFreeID();
virtual void ReleaseID(int ID); virtual void ReleaseID(int ID, int vtkId = -1);
virtual void Clear(); virtual void Clear();
void SetMesh(SMDS_Mesh *mesh); void SetMesh(SMDS_Mesh *mesh);

3
src/SMDS/SMDS_MeshNode.cxx
View File

@ -295,8 +295,7 @@ void SMDS_MeshNode::setXYZ(double x, double y, double z)
vtkPoints *points = mesh->getGrid()->GetPoints(); vtkPoints *points = mesh->getGrid()->GetPoints();
points->InsertPoint(myVtkID, x, y, z); points->InsertPoint(myVtkID, x, y, z);
mesh->adjustBoundingBox(x, y, z); mesh->adjustBoundingBox(x, y, z);
mesh->myChangedNodes = true; mesh->setMyModified();
mesh->myModified = true;
} }
SMDSAbs_ElementType SMDS_MeshNode::GetType() const SMDSAbs_ElementType SMDS_MeshNode::GetType() const

4
src/SMDS/SMDS_MeshNodeIDFactory.cxx
View File

@ -72,10 +72,10 @@ SMDS_MeshElement* SMDS_MeshNodeIDFactory::MeshElement(int ID)
//function : ReleaseID //function : ReleaseID
//purpose : //purpose :
//======================================================================= //=======================================================================
void SMDS_MeshNodeIDFactory::ReleaseID(const int ID) void SMDS_MeshNodeIDFactory::ReleaseID(const int ID, int vtkId)
{ {
SMDS_MeshIDFactory::ReleaseID(ID); SMDS_MeshIDFactory::ReleaseID(ID);
myMesh->myRemovedNodes = true; myMesh->setMyModified();
if (ID == myMax) if (ID == myMax)
myMax = 0; // --- force updateMinMax myMax = 0; // --- force updateMinMax
if (ID == myMin) if (ID == myMin)

2
src/SMDS/SMDS_MeshNodeIDFactory.hxx
View File

@ -41,7 +41,7 @@ public:
SMDS_MeshNodeIDFactory(); SMDS_MeshNodeIDFactory();
bool BindID(int ID, SMDS_MeshElement * elem); bool BindID(int ID, SMDS_MeshElement * elem);
SMDS_MeshElement * MeshElement(int ID); SMDS_MeshElement * MeshElement(int ID);
virtual void ReleaseID(int ID); virtual void ReleaseID(int ID, int vtkId = -1);
int GetMaxID() const; int GetMaxID() const;
int GetMinID() const; int GetMinID() const;
SMDS_ElemIteratorPtr elementsIterator() const; SMDS_ElemIteratorPtr elementsIterator() const;

2
src/SMDS/SMDS_UnstructuredGrid.hxx
View File

@ -22,7 +22,7 @@
#define VTK_MAXTYPE VTK_QUADRATIC_PYRAMID #define VTK_MAXTYPE VTK_QUADRATIC_PYRAMID
#endif #endif
#define NBMAXNEIGHBORS 10 #define NBMAXNEIGHBORS 100
// allow very huge polyhedrons in tests // allow very huge polyhedrons in tests
#define NBMAXNODESINCELL 5000 #define NBMAXNODESINCELL 5000

3
src/SMDS/SMDS_VtkEdge.cxx
View File

@ -32,12 +32,14 @@ void SMDS_VtkEdge::init(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
if (nodeIds.size() == 3) if (nodeIds.size() == 3)
aType = VTK_QUADRATIC_EDGE; aType = VTK_QUADRATIC_EDGE;
myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]); myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]);
mesh->setMyModified();
//MESSAGE("SMDS_VtkEdge::init myVtkID " << myVtkID); //MESSAGE("SMDS_VtkEdge::init myVtkID " << myVtkID);
} }
bool SMDS_VtkEdge::ChangeNodes(const SMDS_MeshNode * node1, const SMDS_MeshNode * node2) bool SMDS_VtkEdge::ChangeNodes(const SMDS_MeshNode * node1, const SMDS_MeshNode * node2)
{ {
const SMDS_MeshNode* nodes[] = { node1, node2 }; const SMDS_MeshNode* nodes[] = { node1, node2 };
SMDS_Mesh::_meshList[myMeshId]->setMyModified();
return ChangeNodes(nodes, 2); return ChangeNodes(nodes, 2);
} }
@ -56,6 +58,7 @@ bool SMDS_VtkEdge::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
{ {
pts[i] = nodes[i]->getVtkId(); pts[i] = nodes[i]->getVtkId();
} }
SMDS_Mesh::_meshList[myMeshId]->setMyModified();
return true; return true;
} }

3
src/SMDS/SMDS_VtkFace.cxx
View File

@ -47,6 +47,7 @@ void SMDS_VtkFace::init(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
break; break;
} }
myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]); myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]);
mesh->setMyModified();
//MESSAGE("SMDS_VtkFace::init myVtkID " << myVtkID); //MESSAGE("SMDS_VtkFace::init myVtkID " << myVtkID);
} }
@ -56,6 +57,7 @@ void SMDS_VtkFace::initPoly(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
myIdInShape = -1; myIdInShape = -1;
myMeshId = mesh->getMeshId(); myMeshId = mesh->getMeshId();
myVtkID = grid->InsertNextLinkedCell(VTK_POLYGON, nodeIds.size(), &nodeIds[0]); myVtkID = grid->InsertNextLinkedCell(VTK_POLYGON, nodeIds.size(), &nodeIds[0]);
mesh->setMyModified();
} }
bool SMDS_VtkFace::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes) bool SMDS_VtkFace::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
@ -73,6 +75,7 @@ bool SMDS_VtkFace::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
{ {
pts[i] = nodes[i]->getVtkId(); pts[i] = nodes[i]->getVtkId();
} }
SMDS_Mesh::_meshList[myMeshId]->setMyModified();
return true; return true;
} }

3
src/SMDS/SMDS_VtkVolume.cxx
View File

@ -56,6 +56,7 @@ void SMDS_VtkVolume::init(std::vector<vtkIdType> nodeIds, SMDS_Mesh* mesh)
break; break;
} }
myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]); myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]);
mesh->setMyModified();
//MESSAGE("SMDS_VtkVolume::init myVtkID " << myVtkID); //MESSAGE("SMDS_VtkVolume::init myVtkID " << myVtkID);
} }
@ -94,6 +95,7 @@ void SMDS_VtkVolume::initPoly(std::vector<vtkIdType> nodeIds, std::vector<int> n
k += nf; k += nf;
} }
myVtkID = grid->InsertNextLinkedCell(VTK_POLYHEDRON, nbFaces, &ptIds[0]); myVtkID = grid->InsertNextLinkedCell(VTK_POLYHEDRON, nbFaces, &ptIds[0]);
mesh->setMyModified();
} }
#endif #endif
@ -112,6 +114,7 @@ bool SMDS_VtkVolume::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes
{ {
pts[i] = nodes[i]->getVtkId(); pts[i] = nodes[i]->getVtkId();
} }
SMDS_Mesh::_meshList[myMeshId]->setMyModified();
return true; return true;
} }

3
src/SMESH/SMESH_Gen.cxx
View File

@ -159,6 +159,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
else if ( aShapesId ) else if ( aShapesId )
aShapesId->insert( smToCompute->GetId() ); aShapesId->insert( smToCompute->GetId() );
} }
//aMesh.GetMeshDS()->Modified();
return ret; return ret;
} }
else else
@ -277,6 +278,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
SMESHDS_Mesh *myMesh = aMesh.GetMeshDS(); SMESHDS_Mesh *myMesh = aMesh.GetMeshDS();
myMesh->adjustStructure(); myMesh->adjustStructure();
MESSAGE("*** compactMesh after compute");
myMesh->compactMesh(); myMesh->compactMesh();
//myMesh->adjustStructure(); //myMesh->adjustStructure();
list<int> listind = myMesh->SubMeshIndices(); list<int> listind = myMesh->SubMeshIndices();
@ -291,6 +293,7 @@ bool SMESH_Gen::Compute(SMESH_Mesh & aMesh,
MESSAGE("Number of node objects " << SMDS_MeshNode::nbNodes); MESSAGE("Number of node objects " << SMDS_MeshNode::nbNodes);
MESSAGE("Number of cell objects " << SMDS_MeshCell::nbCells); MESSAGE("Number of cell objects " << SMDS_MeshCell::nbCells);
//myMesh->dumpGrid(); //myMesh->dumpGrid();
//aMesh.GetMeshDS()->Modified();
return ret; return ret;
} }

43
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -3290,7 +3290,7 @@ void SMESH_MeshEditor::sweepElement(const SMDS_MeshElement* elem,
const int nbSteps, const int nbSteps,
SMESH_SequenceOfElemPtr& srcElements) SMESH_SequenceOfElemPtr& srcElements)
{ {
MESSAGE("sweepElement " << nbSteps); //MESSAGE("sweepElement " << nbSteps);
SMESHDS_Mesh* aMesh = GetMeshDS(); SMESHDS_Mesh* aMesh = GetMeshDS();
// Loop on elem nodes: // Loop on elem nodes:
@ -7376,7 +7376,11 @@ void SMESH_MeshEditor::MergeNodes (TListOfListOfNodes & theGroupsOfNodes)
// +---+---+ // +---+---+
// 0 7 3 // 0 7 3
isOk = false; isOk = false;
if(nbRepl==2) {
MESSAGE("nbRepl=2: " << iRepl[0] << " " << iRepl[1]);
}
if(nbRepl==3) { if(nbRepl==3) {
MESSAGE("nbRepl=3: " << iRepl[0] << " " << iRepl[1] << " " << iRepl[2]);
nbUniqueNodes = 6; nbUniqueNodes = 6;
if( iRepl[0]==0 && iRepl[1]==1 && iRepl[2]==4 ) { if( iRepl[0]==0 && iRepl[1]==1 && iRepl[2]==4 ) {
uniqueNodes[0] = curNodes[0]; uniqueNodes[0] = curNodes[0];
@ -7451,6 +7455,12 @@ void SMESH_MeshEditor::MergeNodes (TListOfListOfNodes & theGroupsOfNodes)
isOk = true; isOk = true;
} }
} }
if(nbRepl==4) {
MESSAGE("nbRepl=4: " << iRepl[0] << " " << iRepl[1] << " " << iRepl[2] << " " << iRepl[3]);
}
if(nbRepl==5) {
MESSAGE("nbRepl=5: " << iRepl[0] << " " << iRepl[1] << " " << iRepl[2] << " " << iRepl[3] << " " << iRepl[4]);
}
break; break;
} }
//////////////////////////////////// HEXAHEDRON //////////////////////////////////// HEXAHEDRON
@ -7661,17 +7671,18 @@ void SMESH_MeshEditor::MergeNodes (TListOfListOfNodes & theGroupsOfNodes)
} }
} }
else { else {
//MESSAGE("Change regular element or polygon " << elem->GetID()); int elemId = elem->GetID();
//MESSAGE("Change regular element or polygon " << elemId);
SMDSAbs_ElementType etyp = elem->GetType(); SMDSAbs_ElementType etyp = elem->GetType();
uniqueNodes.resize(nbUniqueNodes); uniqueNodes.resize(nbUniqueNodes);
SMDS_MeshElement* newElem = this->AddElement(uniqueNodes, etyp, false); aMesh->RemoveElement(elem);
SMDS_MeshElement* newElem = this->AddElement(uniqueNodes, etyp, false, elemId);
if (newElem) if (newElem)
{ {
myLastCreatedElems.Append(newElem); myLastCreatedElems.Append(newElem);
if ( aShapeId ) if ( aShapeId )
aMesh->SetMeshElementOnShape( newElem, aShapeId ); aMesh->SetMeshElementOnShape( newElem, aShapeId );
} }
aMesh->RemoveElement(elem);
} }
} }
else { else {
@ -8984,6 +8995,8 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
if( !elem || elem->IsQuadratic() ) continue; if( !elem || elem->IsQuadratic() ) continue;
int id = elem->GetID(); int id = elem->GetID();
//MESSAGE("elem " << id);
id = 0; // get a free number for new elements
int nbNodes = elem->NbNodes(); int nbNodes = elem->NbNodes();
vector<const SMDS_MeshNode *> aNds (nbNodes); vector<const SMDS_MeshNode *> aNds (nbNodes);
@ -8993,8 +9006,6 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
} }
SMDSAbs_ElementType aType = elem->GetType(); SMDSAbs_ElementType aType = elem->GetType();
GetMeshDS()->RemoveFreeElement(elem, theSm, notFromGroups);
const SMDS_MeshElement* NewElem = 0; const SMDS_MeshElement* NewElem = 0;
switch( aType ) switch( aType )
@ -9047,8 +9058,11 @@ int SMESH_MeshEditor::convertElemToQuadratic(SMESHDS_SubMesh * theSm,
ReplaceElemInGroups( elem, NewElem, GetMeshDS()); ReplaceElemInGroups( elem, NewElem, GetMeshDS());
if( NewElem ) if( NewElem )
theSm->AddElement( NewElem ); theSm->AddElement( NewElem );
GetMeshDS()->RemoveFreeElement(elem, theSm, notFromGroups);
} }
GetMeshDS()->compactMesh(); // if (!GetMeshDS()->isCompacted())
// GetMeshDS()->compactMesh();
return nbElem; return nbElem;
} }
@ -9176,7 +9190,8 @@ void SMESH_MeshEditor::ConvertToQuadratic(const bool theForce3d)
aHelper.SetSubShape(0); // apply to the whole mesh aHelper.SetSubShape(0); // apply to the whole mesh
aHelper.FixQuadraticElements(); aHelper.FixQuadraticElements();
} }
GetMeshDS()->compactMesh(); if (!GetMeshDS()->isCompacted())
GetMeshDS()->compactMesh();
} }
//======================================================================= //=======================================================================
@ -10433,7 +10448,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
SMDS_MeshElement* anElem = (SMDS_MeshElement*) *elemItr; SMDS_MeshElement* anElem = (SMDS_MeshElement*) *elemItr;
if (!anElem) if (!anElem)
continue; continue;
int vtkId = meshDS->fromSmdsToVtk(anElem->GetID()); int vtkId = anElem->getVtkId();
int neighborsVtkIds[NBMAXNEIGHBORS]; int neighborsVtkIds[NBMAXNEIGHBORS];
int downIds[NBMAXNEIGHBORS]; int downIds[NBMAXNEIGHBORS];
unsigned char downTypes[NBMAXNEIGHBORS]; unsigned char downTypes[NBMAXNEIGHBORS];
@ -10485,7 +10500,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
{ {
double *coords = grid->GetPoint(oldId); double *coords = grid->GetPoint(oldId);
SMDS_MeshNode *newNode = meshDS->AddNode(coords[0], coords[1], coords[2]); SMDS_MeshNode *newNode = meshDS->AddNode(coords[0], coords[1], coords[2]);
int newId = newNode->GetID(); int newId = newNode->getVtkId();
nodeDomains[oldId][idom] = newId; // cloned node for other domains nodeDomains[oldId][idom] = newId; // cloned node for other domains
} }
} }
@ -10531,13 +10546,12 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
MESSAGE("--- problem domain node " << dom2 << " " << oldId); MESSAGE("--- problem domain node " << dom2 << " " << oldId);
localClonedNodeIds[oldId] = newid; localClonedNodeIds[oldId] = newid;
} }
int smdsId = meshDS->fromVtkToSmds(vtkVolId); meshDS->extrudeVolumeFromFace(vtkVolId, localClonedNodeIds);
meshDS->extrudeVolumeFromFace(smdsId, localClonedNodeIds);
} }
} }
// --- iterate on shared faces (volumes to modify, face to extrude) // --- iterate on shared faces (volumes to modify, face to extrude)
// get node id's of the face (id SMDS = id VTK) // get node id's of the face
// replace old nodes by new nodes in volumes, and update inverse connectivity // replace old nodes by new nodes in volumes, and update inverse connectivity
itface = faceDomains.begin(); itface = faceDomains.begin();
@ -10563,8 +10577,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector<TIDSorted
if (nodeDomains[oldId].count(idom)) if (nodeDomains[oldId].count(idom))
localClonedNodeIds[oldId] = nodeDomains[oldId][idom]; localClonedNodeIds[oldId] = nodeDomains[oldId][idom];
} }
int smdsId = meshDS->fromVtkToSmds(vtkVolId); meshDS->ModifyCellNodes(vtkVolId, localClonedNodeIds);
meshDS->ModifyCellNodes(smdsId, localClonedNodeIds);
} }
} }
grid->BuildLinks(); grid->BuildLinks();

22
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -740,6 +740,19 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
const SMDS_PositionPtr Pos1 = n1->GetPosition(); const SMDS_PositionPtr Pos1 = n1->GetPosition();
const SMDS_PositionPtr Pos2 = n2->GetPosition(); const SMDS_PositionPtr Pos2 = n2->GetPosition();
bool onGeom = true;
if ((Pos1->GetTypeOfPosition() != SMDS_TOP_FACE) &&
(Pos1->GetTypeOfPosition() != SMDS_TOP_EDGE))
onGeom = false;
if ((Pos2->GetTypeOfPosition() != SMDS_TOP_FACE) &&
(Pos2->GetTypeOfPosition() != SMDS_TOP_EDGE))
onGeom = false;
TopoDS_Edge E; double u [2];
TopoDS_Face F; gp_XY uv[2];
bool uvOK[2] = { false, false };
if (onGeom) {
if( myShape.IsNull() ) if( myShape.IsNull() )
{ {
if( Pos1->GetTypeOfPosition()==SMDS_TOP_FACE ) { if( Pos1->GetTypeOfPosition()==SMDS_TOP_FACE ) {
@ -757,9 +770,6 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
} }
} }
// get positions of the given nodes on shapes // get positions of the given nodes on shapes
TopoDS_Edge E; double u [2];
TopoDS_Face F; gp_XY uv[2];
bool uvOK[2] = { false, false };
TopAbs_ShapeEnum shapeType = myShape.IsNull() ? TopAbs_SHAPE : myShape.ShapeType(); TopAbs_ShapeEnum shapeType = myShape.IsNull() ? TopAbs_SHAPE : myShape.ShapeType();
if ( faceID>0 || shapeType == TopAbs_FACE) if ( faceID>0 || shapeType == TopAbs_FACE)
{ {
@ -833,11 +843,15 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
} }
} }
} }
} // onGeom
// 3d variant // 3d variant
double x = ( n1->X() + n2->X() )/2.; double x = ( n1->X() + n2->X() )/2.;
double y = ( n1->Y() + n2->Y() )/2.; double y = ( n1->Y() + n2->Y() )/2.;
double z = ( n1->Z() + n2->Z() )/2.; double z = ( n1->Z() + n2->Z() )/2.;
n12 = meshDS->AddNode(x,y,z); n12 = meshDS->AddNode(x,y,z);
if (onGeom) {
if ( !F.IsNull() ) if ( !F.IsNull() )
{ {
gp_XY UV = ( uv[0] + uv[1] ) / 2.; gp_XY UV = ( uv[0] + uv[1] ) / 2.;
@ -854,6 +868,8 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
{ {
meshDS->SetNodeInVolume(n12, myShapeID); meshDS->SetNodeInVolume(n12, myShapeID);
} }
} // onGeom
myTLinkNodeMap.insert( make_pair( link, n12 )); myTLinkNodeMap.insert( make_pair( link, n12 ));
return n12; return n12;
} }

40
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -250,7 +250,8 @@ bool SMESHDS_Mesh::ChangePolyhedronNodes
void SMESHDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID) void SMESHDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
{ {
// TODO not possible yet to have node numbers not starting to O and continuous. // TODO not possible yet to have node numbers not starting to O and continuous.
this->compactMesh(); if (!this->isCompacted())
this->compactMesh();
// SMDS_Mesh::Renumber( isNodes, startID, deltaID ); // SMDS_Mesh::Renumber( isNodes, startID, deltaID );
// myScript->Renumber( isNodes, startID, deltaID ); // myScript->Renumber( isNodes, startID, deltaID );
} }
@ -1891,12 +1892,12 @@ void SMESHDS_Mesh::compactMesh()
// << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() ); // << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
SetOfCells newCells; SetOfCells newCells;
vector<int> newSmdsToVtk; //vector<int> newSmdsToVtk;
vector<int> newVtkToSmds; vector<int> newVtkToSmds;
assert(maxVtkId < newCellSize); assert(maxVtkId < newCellSize);
newCells.resize(newCellSize+1, 0); // 0 not used, SMDS numbers 1..n newCells.resize(newCellSize+1, 0); // 0 not used, SMDS numbers 1..n
newSmdsToVtk.resize(newCellSize+1, -1); //newSmdsToVtk.resize(newCellSize+1, -1);
newVtkToSmds.resize(newCellSize+1, -1); newVtkToSmds.resize(newCellSize+1, -1);
int myCellsSize = myCells.size(); int myCellsSize = myCells.size();
@ -1911,17 +1912,16 @@ void SMESHDS_Mesh::compactMesh()
newCells[newSmdsId]->setId(newSmdsId); newCells[newSmdsId]->setId(newSmdsId);
//MESSAGE("myCells["<< i << "] --> newCells[" << newSmdsId << "]"); //MESSAGE("myCells["<< i << "] --> newCells[" << newSmdsId << "]");
int idvtk = myCells[i]->getVtkId(); int idvtk = myCells[i]->getVtkId();
newSmdsToVtk[newSmdsId] = idvtk; //newSmdsToVtk[newSmdsId] = idvtk;
assert(idvtk < newCellSize); assert(idvtk < newCellSize);
newVtkToSmds[idvtk] = newSmdsId; newVtkToSmds[idvtk] = newSmdsId;
} }
} }
myCells.swap(newCells); myCells.swap(newCells);
myCellIdSmdsToVtk.swap(newSmdsToVtk); //myCellIdSmdsToVtk.swap(newSmdsToVtk);
myCellIdVtkToSmds.swap(newVtkToSmds); myCellIdVtkToSmds.swap(newVtkToSmds);
MESSAGE("myCells.size()=" << myCells.size() MESSAGE("myCells.size()=" << myCells.size()
<< " myCellIdSmdsToVtk.size()=" << myCellIdSmdsToVtk.size()
<< " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() ); << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
this->myElementIDFactory->emptyPool(newSmdsId); this->myElementIDFactory->emptyPool(newSmdsId);
@ -1944,13 +1944,12 @@ void SMESHDS_Mesh::BuildDownWardConnectivity(bool withEdges)
/*! change some nodes in cell without modifying type or internal connectivity. /*! change some nodes in cell without modifying type or internal connectivity.
* Nodes inverse connectivity is maintained up to date. * Nodes inverse connectivity is maintained up to date.
* @param smdsVolId smds id of the cell. * @param vtkVolId vtk id of the cell.
* @param localClonedNodeIds map old node id to new node id. * @param localClonedNodeIds map old node id to new node id.
* @return ok if success. * @return ok if success.
*/ */
bool SMESHDS_Mesh::ModifyCellNodes(int smdsVolId, std::map<int,int> localClonedNodeIds) bool SMESHDS_Mesh::ModifyCellNodes(int vtkVolId, std::map<int,int> localClonedNodeIds)
{ {
int vtkVolId = this->fromSmdsToVtk(smdsVolId);
myGrid->ModifyCellNodes(vtkVolId, localClonedNodeIds); myGrid->ModifyCellNodes(vtkVolId, localClonedNodeIds);
return true; return true;
} }
@ -1961,29 +1960,20 @@ bool SMESHDS_Mesh::ModifyCellNodes(int smdsVolId, std::map<int,int> localClonedN
* @param localClonedNodeIds map old node id to new node id. The old nodes define the face in the volume. * @param localClonedNodeIds map old node id to new node id. The old nodes define the face in the volume.
* @return ok if success. * @return ok if success.
*/ */
bool SMESHDS_Mesh::extrudeVolumeFromFace(int smdsVolId, std::map<int,int> localClonedNodeIds) bool SMESHDS_Mesh::extrudeVolumeFromFace(int vtkVolId, std::map<int,int>& localClonedNodeIds)
{ {
int vtkVolId = this->fromSmdsToVtk(smdsVolId); //MESSAGE("extrudeVolumeFromFace " << vtkVolId);
//MESSAGE(smdsVolId << " " << vtkVolId);
vector<int> orderedNodes; vector<int> orderedNodes;
orderedNodes.clear(); orderedNodes.clear();
map<int, int>::iterator it = localClonedNodeIds.begin(); map<int, int>::const_iterator it = localClonedNodeIds.begin();
for (; it != localClonedNodeIds.end(); ++it) for (; it != localClonedNodeIds.end(); ++it)
orderedNodes.push_back(it->first); orderedNodes.push_back(it->first);
int nbNodes = myGrid->getOrderedNodesOfFace(vtkVolId, orderedNodes); int nbNodes = myGrid->getOrderedNodesOfFace(vtkVolId, orderedNodes);
if (nbNodes == 3) for (int i=0; i<nbNodes; i++)
{ orderedNodes.push_back(localClonedNodeIds[orderedNodes[i]]);
int newVtkVolId =myElementIDFactory->GetFreeID(); SMDS_MeshVolume *vol = this->AddVolumeFromVtkIds(orderedNodes);
SMDS_MeshVolume *vol = this->AddVolumeWithID(orderedNodes[0],
orderedNodes[1],
orderedNodes[2],
localClonedNodeIds[orderedNodes[0]],
localClonedNodeIds[orderedNodes[1]],
localClonedNodeIds[orderedNodes[2]],
newVtkVolId);
}
// TODO update subshape list of elements and nodes // TODO update subshape list of elements and nodes
return true; return vol;
} }

2
src/SMESHDS/SMESHDS_Mesh.hxx
View File

@ -399,7 +399,7 @@ public:
std::vector<const SMDS_MeshNode*> nodes, std::vector<const SMDS_MeshNode*> nodes,
std::vector<int> quantities); std::vector<int> quantities);
bool ModifyCellNodes(int smdsVolId, std::map<int,int> localClonedNodeIds); bool ModifyCellNodes(int smdsVolId, std::map<int,int> localClonedNodeIds);
bool extrudeVolumeFromFace(int smdsVolId, std::map<int,int> localClonedNodeIds); bool extrudeVolumeFromFace(int vtkVolId, std::map<int,int>& localClonedNodeIds);
void Renumber (const bool isNodes, const int startID=1, const int deltaID=1); void Renumber (const bool isNodes, const int startID=1, const int deltaID=1);
void SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Shell & S); void SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Shell & S);

6
src/SMESHDS/SMESHDS_SubMesh.cxx
View File

@ -90,7 +90,7 @@ bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME, bool isElemDele
myUnusedIdElements++; myUnusedIdElements++;
return true; return true;
} }
MESSAGE("Try to remove an already deleted element from a submesh "); //MESSAGE("Try to remove an already deleted element from a submesh ");
return false; return false;
} }
MESSAGE("Try to remove an element from a complex submesh "); MESSAGE("Try to remove an element from a complex submesh ");
@ -118,7 +118,7 @@ void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
node->setIdInShape(myNodes.size()); node->setIdInShape(myNodes.size());
myNodes.push_back(N); myNodes.push_back(N);
} }
MESSAGE("try to add node in a complex submesh " << N->GetID()); //MESSAGE("try to add node in a complex submesh " << N->GetID());
} }
//======================================================================= //=======================================================================
@ -144,7 +144,7 @@ bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N, bool isNodeDeleted)
myUnusedIdNodes++; myUnusedIdNodes++;
return true; return true;
} }
MESSAGE("Try to remove an already deleted node from a submesh"); //MESSAGE("Try to remove an already deleted node from a submesh");
return false; return false;
} }
MESSAGE("Try to remove a node from a complex submesh"); MESSAGE("Try to remove a node from a complex submesh");

13
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -903,6 +903,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromUNV( const char* theFileName
// Dump creation of groups // Dump creation of groups
aServant->GetGroups(); aServant->GetGroups();
aServant->GetImpl().GetMeshDS()->Modified();
return aMesh._retn(); return aMesh._retn();
} }
@ -976,6 +977,7 @@ SMESH::mesh_array* SMESH_Gen_i::CreateMeshesFromMED( const char* theFileName,
theStatus = status1; theStatus = status1;
aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh ); aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh );
meshServant->GetImpl().GetMeshDS()->Modified();
} }
aStudyBuilder->CommitCommand(); aStudyBuilder->CommitCommand();
} }
@ -1022,6 +1024,7 @@ SMESH::SMESH_Mesh_ptr SMESH_Gen_i::CreateMeshesFromSTL( const char* theFileName
SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() ); SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
ASSERT( aServant ); ASSERT( aServant );
aServant->ImportSTLFile( theFileName ); aServant->ImportSTLFile( theFileName );
aServant->GetImpl().GetMeshDS()->Modified();
return aMesh._retn(); return aMesh._retn();
} }
@ -1435,7 +1438,9 @@ CORBA::Boolean SMESH_Gen_i::Compute( SMESH::SMESH_Mesh_ptr theMesh,
myLocShape = SMESH_Mesh::PseudoShape(); myLocShape = SMESH_Mesh::PseudoShape();
// call implementation compute // call implementation compute
::SMESH_Mesh& myLocMesh = meshServant->GetImpl(); ::SMESH_Mesh& myLocMesh = meshServant->GetImpl();
return myGen.Compute( myLocMesh, myLocShape); bool ret = myGen.Compute( myLocMesh, myLocShape);
myLocMesh.GetMeshDS()->Modified();
return ret;
} }
} }
catch ( std::bad_alloc ) { catch ( std::bad_alloc ) {
@ -1924,11 +1929,12 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::mesh_array& theMeshesArray,
// create mesh // create mesh
SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh(); SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh();
SMESHDS_Mesh* aNewMeshDS = 0;
if ( !aNewMesh->_is_nil() ) { if ( !aNewMesh->_is_nil() ) {
SMESH_Mesh_i* aNewImpl = dynamic_cast<SMESH_Mesh_i*>( GetServant( aNewMesh ).in() ); SMESH_Mesh_i* aNewImpl = dynamic_cast<SMESH_Mesh_i*>( GetServant( aNewMesh ).in() );
if ( aNewImpl ) { if ( aNewImpl ) {
::SMESH_Mesh& aLocMesh = aNewImpl->GetImpl(); ::SMESH_Mesh& aLocMesh = aNewImpl->GetImpl();
SMESHDS_Mesh* aNewMeshDS = aLocMesh.GetMeshDS(); aNewMeshDS = aLocMesh.GetMeshDS();
TGroupsMap aGroupsMap; TGroupsMap aGroupsMap;
TListOfNewGroups aListOfNewGroups; TListOfNewGroups aListOfNewGroups;
@ -2204,7 +2210,8 @@ SMESH_Gen_i::ConcatenateCommon(const SMESH::mesh_array& theMeshesArray,
SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr); SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
aPixmap->SetPixMap("ICON_SMESH_TREE_MESH"); aPixmap->SetPixMap("ICON_SMESH_TREE_MESH");
} }
if (aNewMeshDS)
aNewMeshDS->Modified();
return aNewMesh._retn(); return aNewMesh._retn();
} }

85
src/SMESH_I/SMESH_MeshEditor_i.cxx
View File

@ -313,11 +313,12 @@ SMESH_MeshEditor_i::RemoveElements(const SMESH::long_array & IDsOfElements)
// Update Python script // Update Python script
TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )"; TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
// Remove Elements
bool ret = anEditor.Remove( IdList, false );
myMesh->GetMeshDS()->Modified();
if ( IDsOfElements.length() ) if ( IDsOfElements.length() )
myMesh->SetIsModified( true ); // issue 0020693 myMesh->SetIsModified( true ); // issue 0020693
return ret;
// Remove Elements
return anEditor.Remove( IdList, false );
} }
//============================================================================= //=============================================================================
@ -338,10 +339,11 @@ CORBA::Boolean SMESH_MeshEditor_i::RemoveNodes(const SMESH::long_array & IDsOfNo
// Update Python script // Update Python script
TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )"; TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
bool ret = anEditor.Remove( IdList, true );
myMesh->GetMeshDS()->Modified();
if ( IDsOfNodes.length() ) if ( IDsOfNodes.length() )
myMesh->SetIsModified( true ); // issue 0020693 myMesh->SetIsModified( true ); // issue 0020693
return ret;
return anEditor.Remove( IdList, true );
} }
//============================================================================= //=============================================================================
@ -361,8 +363,8 @@ CORBA::Long SMESH_MeshEditor_i::AddNode(CORBA::Double x,
TPythonDump() << "nodeID = " << this << ".AddNode( " TPythonDump() << "nodeID = " << this << ".AddNode( "
<< x << ", " << y << ", " << z << " )"; << x << ", " << y << ", " << z << " )";
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693 myMesh->SetIsModified( true ); // issue 0020693
return N->GetID(); return N->GetID();
} }
@ -381,6 +383,7 @@ CORBA::Long SMESH_MeshEditor_i::Add0DElement(CORBA::Long IDOfNode)
// Update Python script // Update Python script
TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )"; TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693 myMesh->SetIsModified( true ); // issue 0020693
if (elem) if (elem)
@ -423,6 +426,7 @@ CORBA::Long SMESH_MeshEditor_i::AddEdge(const SMESH::long_array & IDsOfNodes)
<<n1<<", "<<n2<<", "<<n12<<" ])"; <<n1<<", "<<n2<<", "<<n12<<" ])";
} }
myMesh->GetMeshDS()->Modified();
if(elem) if(elem)
return myMesh->SetIsModified( true ), elem->GetID(); return myMesh->SetIsModified( true ), elem->GetID();
@ -471,6 +475,7 @@ CORBA::Long SMESH_MeshEditor_i::AddFace(const SMESH::long_array & IDsOfNodes)
// Update Python script // Update Python script
TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )"; TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
myMesh->GetMeshDS()->Modified();
if(elem) if(elem)
return myMesh->SetIsModified( true ), elem->GetID(); return myMesh->SetIsModified( true ), elem->GetID();
@ -496,6 +501,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolygonalFace (const SMESH::long_array & IDsO
// Update Python script // Update Python script
TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )"; TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
myMesh->GetMeshDS()->Modified();
return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0; return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
} }
@ -539,6 +545,7 @@ CORBA::Long SMESH_MeshEditor_i::AddVolume(const SMESH::long_array & IDsOfNodes)
// Update Python script // Update Python script
TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )"; TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
myMesh->GetMeshDS()->Modified();
if(elem) if(elem)
return myMesh->SetIsModified( true ), elem->GetID(); return myMesh->SetIsModified( true ), elem->GetID();
@ -574,6 +581,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolume (const SMESH::long_array & I
// Update Python script // Update Python script
TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( " TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
<< IDsOfNodes << ", " << Quantities << " )"; << IDsOfNodes << ", " << Quantities << " )";
myMesh->GetMeshDS()->Modified();
return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0; return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
} }
@ -606,6 +614,7 @@ CORBA::Long SMESH_MeshEditor_i::AddPolyhedralVolumeByFaces (const SMESH::long_ar
// Update Python script // Update Python script
TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( " TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
<< IdsOfFaces << " )"; << IdsOfFaces << " )";
myMesh->GetMeshDS()->Modified();
return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0; return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
} }
@ -726,7 +735,6 @@ void SMESH_MeshEditor_i::SetNodeOnFace(CORBA::Long NodeID, CORBA::Long FaceID,
} }
mesh->SetNodeOnFace( node, FaceID, u, v ); mesh->SetNodeOnFace( node, FaceID, u, v );
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
} }
@ -817,10 +825,12 @@ CORBA::Boolean SMESH_MeshEditor_i::InverseDiag(CORBA::Long NodeID1,
TPythonDump() << "isDone = " << this << ".InverseDiag( " TPythonDump() << "isDone = " << this << ".InverseDiag( "
<< NodeID1 << ", " << NodeID2 << " )"; << NodeID1 << ", " << NodeID2 << " )";
myMesh->SetIsModified( true );
::SMESH_MeshEditor aMeshEditor( myMesh ); ::SMESH_MeshEditor aMeshEditor( myMesh );
return aMeshEditor.InverseDiag ( n1, n2 ); int ret = aMeshEditor.InverseDiag ( n1, n2 );
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return ret;
} }
//============================================================================= //=============================================================================
@ -847,6 +857,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DeleteDiag(CORBA::Long NodeID1,
bool stat = aMeshEditor.DeleteDiag ( n1, n2 ); bool stat = aMeshEditor.DeleteDiag ( n1, n2 );
myMesh->GetMeshDS()->Modified();
if ( stat ) if ( stat )
myMesh->SetIsModified( true ); // issue 0020693 myMesh->SetIsModified( true ); // issue 0020693
@ -876,6 +887,7 @@ CORBA::Boolean SMESH_MeshEditor_i::Reorient(const SMESH::long_array & IDsOfEleme
// Update Python script // Update Python script
TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )"; TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
myMesh->GetMeshDS()->Modified();
if ( IDsOfElements.length() ) if ( IDsOfElements.length() )
myMesh->SetIsModified( true ); // issue 0020693 myMesh->SetIsModified( true ); // issue 0020693
@ -962,6 +974,7 @@ CORBA::Boolean SMESH_MeshEditor_i::TriToQuad (const SMESH::long_array & IDsOfE
::SMESH_MeshEditor anEditor( myMesh ); ::SMESH_MeshEditor anEditor( myMesh );
bool stat = anEditor.TriToQuad( faces, aCrit, MaxAngle ); bool stat = anEditor.TriToQuad( faces, aCrit, MaxAngle );
myMesh->GetMeshDS()->Modified();
if ( stat ) if ( stat )
myMesh->SetIsModified( true ); // issue 0020693 myMesh->SetIsModified( true ); // issue 0020693
@ -1025,6 +1038,7 @@ CORBA::Boolean SMESH_MeshEditor_i::QuadToTri (const SMESH::long_array & IDsOfE
::SMESH_MeshEditor anEditor( myMesh ); ::SMESH_MeshEditor anEditor( myMesh );
CORBA::Boolean stat = anEditor.QuadToTri( faces, aCrit ); CORBA::Boolean stat = anEditor.QuadToTri( faces, aCrit );
myMesh->GetMeshDS()->Modified();
if ( stat ) if ( stat )
myMesh->SetIsModified( true ); // issue 0020693 myMesh->SetIsModified( true ); // issue 0020693
@ -1079,6 +1093,7 @@ CORBA::Boolean SMESH_MeshEditor_i::SplitQuad (const SMESH::long_array & IDsOfEle
::SMESH_MeshEditor anEditor( myMesh ); ::SMESH_MeshEditor anEditor( myMesh );
CORBA::Boolean stat = anEditor.QuadToTri( faces, Diag13 ); CORBA::Boolean stat = anEditor.QuadToTri( faces, Diag13 );
myMesh->GetMeshDS()->Modified();
if ( stat ) if ( stat )
myMesh->SetIsModified( true ); // issue 0020693 myMesh->SetIsModified( true ); // issue 0020693
@ -1155,6 +1170,7 @@ void SMESH_MeshEditor_i::SplitVolumesIntoTetra (SMESH::SMESH_IDSource_ptr elems,
::SMESH_MeshEditor anEditor (myMesh); ::SMESH_MeshEditor anEditor (myMesh);
anEditor.SplitVolumesIntoTetra( elemSet, int( methodFlags )); anEditor.SplitVolumesIntoTetra( elemSet, int( methodFlags ));
myMesh->GetMeshDS()->Modified();
storeResult(anEditor); storeResult(anEditor);
@ -1269,6 +1285,7 @@ SMESH_MeshEditor_i::smooth(const SMESH::long_array & IDsOfElements,
anEditor.Smooth(elements, fixedNodes, method, anEditor.Smooth(elements, fixedNodes, method,
MaxNbOfIterations, MaxAspectRatio, IsParametric ); MaxNbOfIterations, MaxAspectRatio, IsParametric );
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693 myMesh->SetIsModified( true ); // issue 0020693
storeResult(anEditor); storeResult(anEditor);
@ -1408,6 +1425,7 @@ SMESH_MeshEditor_i::rotationSweep(const SMESH::long_array & theIDsOfElements,
anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians, anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians,
theNbOfSteps, theTolerance, theMakeGroups, makeWalls); theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
storeResult(anEditor); storeResult(anEditor);
myMesh->GetMeshDS()->Modified();
// myMesh->SetIsModified( true ); -- it does not influence Compute() // myMesh->SetIsModified( true ); -- it does not influence Compute()
@ -1686,6 +1704,7 @@ SMESH_MeshEditor_i::extrusionSweep(const SMESH::long_array & theIDsOfElements,
::SMESH_MeshEditor::PGroupIDs groupIds = ::SMESH_MeshEditor::PGroupIDs groupIds =
anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory, theMakeGroups); anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
myMesh->GetMeshDS()->Modified();
storeResult(anEditor); storeResult(anEditor);
return theMakeGroups ? getGroups(groupIds.get()) : 0; return theMakeGroups ? getGroups(groupIds.get()) : 0;
@ -2024,6 +2043,7 @@ SMESH_MeshEditor_i::extrusionAlongPath(const SMESH::long_array & theIDsOfEleme
anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart, anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
theHasAngles, angles, false, theHasAngles, angles, false,
theHasRefPoint, refPnt, theMakeGroups ); theHasRefPoint, refPnt, theMakeGroups );
myMesh->GetMeshDS()->Modified();
storeResult(anEditor); storeResult(anEditor);
theError = convExtrError( error ); theError = convExtrError( error );
@ -2090,6 +2110,7 @@ SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements
error = anEditor.ExtrusionAlongTrack( elements, &(aMeshImp->GetImpl()), aNodeStart, error = anEditor.ExtrusionAlongTrack( elements, &(aMeshImp->GetImpl()), aNodeStart,
HasAngles, angles, LinearVariation, HasAngles, angles, LinearVariation,
HasRefPoint, refPnt, MakeGroups ); HasRefPoint, refPnt, MakeGroups );
myMesh->GetMeshDS()->Modified();
} }
else { else {
SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast<SMESH_subMesh_i*>( Path ); SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast<SMESH_subMesh_i*>( Path );
@ -2108,6 +2129,7 @@ SMESH_MeshEditor_i::extrusionAlongPathX(const SMESH::long_array & IDsOfElements
error = anEditor.ExtrusionAlongTrack( elements, aSubMesh, aNodeStart, error = anEditor.ExtrusionAlongTrack( elements, aSubMesh, aNodeStart,
HasAngles, angles, LinearVariation, HasAngles, angles, LinearVariation,
HasRefPoint, refPnt, MakeGroups ); HasRefPoint, refPnt, MakeGroups );
myMesh->GetMeshDS()->Modified();
} }
else { else {
SMESH_Group_i* aGroupImp = SMESH::DownCast<SMESH_Group_i*>( Path ); SMESH_Group_i* aGroupImp = SMESH::DownCast<SMESH_Group_i*>( Path );
@ -2766,7 +2788,10 @@ SMESH_MeshEditor_i::mirror(const SMESH::long_array & theIDsOfElements,
if(theCopy) if(theCopy)
storeResult(anEditor); storeResult(anEditor);
else else
myMesh->SetIsModified( true ); {
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
}
return theMakeGroups ? getGroups(groupIds.get()) : 0; return theMakeGroups ? getGroups(groupIds.get()) : 0;
} }
@ -2975,7 +3000,10 @@ SMESH_MeshEditor_i::translate(const SMESH::long_array & theIDsOfElements,
if(theCopy) if(theCopy)
storeResult(anEditor); storeResult(anEditor);
else else
myMesh->SetIsModified( true ); {
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
}
return theMakeGroups ? getGroups(groupIds.get()) : 0; return theMakeGroups ? getGroups(groupIds.get()) : 0;
} }
@ -3183,7 +3211,10 @@ SMESH_MeshEditor_i::rotate(const SMESH::long_array & theIDsOfElements,
if(theCopy) if(theCopy)
storeResult(anEditor); storeResult(anEditor);
else else
myMesh->SetIsModified( true ); {
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
}
return theMakeGroups ? getGroups(groupIds.get()) : 0; return theMakeGroups ? getGroups(groupIds.get()) : 0;
} }
@ -3406,8 +3437,10 @@ SMESH_MeshEditor_i::scale(const SMESH::long_array & theIDsOfElements,
if(theCopy) if(theCopy)
storeResult(anEditor); storeResult(anEditor);
else else
myMesh->SetIsModified( true ); {
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
}
return theMakeGroups ? getGroups(groupIds.get()) : 0; return theMakeGroups ? getGroups(groupIds.get()) : 0;
} }
@ -3633,7 +3666,7 @@ void SMESH_MeshEditor_i::MergeNodes (const SMESH::array_of_long_array& GroupsOfN
anEditor.MergeNodes( aListOfListOfNodes ); anEditor.MergeNodes( aListOfListOfNodes );
aTPythonDump << "])"; aTPythonDump << "])";
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
} }
@ -3715,7 +3748,7 @@ void SMESH_MeshEditor_i::MergeElements(const SMESH::array_of_long_array& GroupsO
::SMESH_MeshEditor anEditor( myMesh ); ::SMESH_MeshEditor anEditor( myMesh );
anEditor.MergeElements(aListOfListOfElementsID); anEditor.MergeElements(aListOfListOfElementsID);
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
aTPythonDump << "] )"; aTPythonDump << "] )";
@ -3764,7 +3797,7 @@ CORBA::Boolean SMESH_MeshEditor_i::MoveNode(CORBA::Long NodeID,
// Update Python script // Update Python script
TPythonDump() << "isDone = " << this << ".MoveNode( " TPythonDump() << "isDone = " << this << ".MoveNode( "
<< NodeID << ", " << x << ", " << y << ", " << z << " )"; << NodeID << ", " << x << ", " << y << ", " << z << " )";
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
return true; return true;
@ -3862,6 +3895,7 @@ CORBA::Long SMESH_MeshEditor_i::MoveClosestNodeToPoint(CORBA::Double x,
<< ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z << ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z
<< ", " << nodeID << " )"; << ", " << nodeID << " )";
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
} }
@ -4007,6 +4041,7 @@ SMESH_MeshEditor_i::SewFreeBorders(CORBA::Long FirstNodeID1,
storeResult(anEditor); storeResult(anEditor);
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
return error; return error;
@ -4064,6 +4099,7 @@ SMESH_MeshEditor_i::SewConformFreeBorders(CORBA::Long FirstNodeID1,
storeResult(anEditor); storeResult(anEditor);
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
return error; return error;
@ -4126,6 +4162,7 @@ SMESH_MeshEditor_i::SewBorderToSide(CORBA::Long FirstNodeIDOnFreeBorder,
storeResult(anEditor); storeResult(anEditor);
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
return error; return error;
@ -4183,6 +4220,7 @@ SMESH_MeshEditor_i::SewSideElements(const SMESH::long_array& IDsOfSide1Elements,
storeResult(anEditor); storeResult(anEditor);
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
return error; return error;
@ -4221,6 +4259,7 @@ CORBA::Boolean SMESH_MeshEditor_i::ChangeElemNodes(CORBA::Long ide,
bool res = GetMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 ); bool res = GetMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
myMesh->GetMeshDS()->Modified();
if ( res ) if ( res )
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
@ -4372,6 +4411,7 @@ void SMESH_MeshEditor_i::ConvertToQuadratic(CORBA::Boolean theForce3d)
::SMESH_MeshEditor anEditor( myMesh ); ::SMESH_MeshEditor anEditor( myMesh );
anEditor.ConvertToQuadratic(theForce3d); anEditor.ConvertToQuadratic(theForce3d);
TPythonDump() << this << ".ConvertToQuadratic( " << theForce3d << " )"; TPythonDump() << this << ".ConvertToQuadratic( " << theForce3d << " )";
myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
} }
@ -4385,6 +4425,7 @@ CORBA::Boolean SMESH_MeshEditor_i::ConvertFromQuadratic()
::SMESH_MeshEditor anEditor( myMesh ); ::SMESH_MeshEditor anEditor( myMesh );
CORBA::Boolean isDone = anEditor.ConvertFromQuadratic(); CORBA::Boolean isDone = anEditor.ConvertFromQuadratic();
TPythonDump() << this << ".ConvertFromQuadratic()"; TPythonDump() << this << ".ConvertFromQuadratic()";
myMesh->GetMeshDS()->Modified();
if ( isDone ) if ( isDone )
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
return isDone; return isDone;
@ -4449,6 +4490,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodes( const SMESH::long_array& theNode
bool aResult = aMeshEditor.DoubleNodes( aListOfNodes, aListOfElems ); bool aResult = aMeshEditor.DoubleNodes( aListOfNodes, aListOfElems );
myMesh->GetMeshDS()->Modified();
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
if ( aResult ) if ( aResult )
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
@ -4563,6 +4605,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeGroups(
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult ) if ( aResult )
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
@ -4601,6 +4644,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElem( const SMESH::long_array& theE
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult ) if ( aResult )
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
@ -4644,6 +4688,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemInRegion
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult ) if ( aResult )
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
@ -4698,6 +4743,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroup(SMESH::SMESH_GroupBase_pt
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult ) if ( aResult )
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
@ -4743,6 +4789,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroupInRegion(
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult ) if ( aResult )
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
@ -4800,6 +4847,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodeElemGroups(const SMESH::ListOfGroup
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult ) if ( aResult )
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
@ -4842,6 +4890,7 @@ SMESH_MeshEditor_i::DoubleNodeElemGroupsInRegion(const SMESH::ListOfGroups& theE
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
myMesh->GetMeshDS()->Modified();
if ( aResult ) if ( aResult )
myMesh->SetIsModified( true ); myMesh->SetIsModified( true );
@ -4866,6 +4915,7 @@ CORBA::Boolean SMESH_MeshEditor_i::Make2DMeshFrom3D()
::SMESH_MeshEditor aMeshEditor( myMesh ); ::SMESH_MeshEditor aMeshEditor( myMesh );
bool aResult = aMeshEditor.Make2DMeshFrom3D(); bool aResult = aMeshEditor.Make2DMeshFrom3D();
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
myMesh->GetMeshDS()->Modified();
TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()"; TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()";
return aResult; return aResult;
@ -4912,6 +4962,7 @@ CORBA::Boolean SMESH_MeshEditor_i::DoubleNodesOnGroupBoundaries( const SMESH::Li
bool aResult = aMeshEditor.DoubleNodesOnGroupBoundaries( domains, createJointElems ); bool aResult = aMeshEditor.DoubleNodesOnGroupBoundaries( domains, createJointElems );
storeResult( aMeshEditor) ; storeResult( aMeshEditor) ;
myMesh->GetMeshDS()->Modified();
// Update Python script // Update Python script
TPythonDump() << "isDone = " << this << ".DoubleNodesOnGroupBoundaries( " << &theDomains TPythonDump() << "isDone = " << this << ".DoubleNodesOnGroupBoundaries( " << &theDomains

2
src/SMESH_I/SMESH_Pattern_i.cxx
View File

@ -215,7 +215,6 @@ SMESH::point_array* SMESH_Pattern_i::ApplyToFace(GEOM::GEOM_Object_ptr theFace,
(*xyzIt)->Coord( p.x, p.y, p.z ); (*xyzIt)->Coord( p.x, p.y, p.z );
} }
} }
// Update Python script // Update Python script
TPythonDump() << "pattern.ApplyToFace( " << theFace << ", " TPythonDump() << "pattern.ApplyToFace( " << theFace << ", "
<< theVertexOnKeyPoint1 << ", " << theReverse << " )"; << theVertexOnKeyPoint1 << ", " << theReverse << " )";
@ -388,6 +387,7 @@ CORBA::Boolean SMESH_Pattern_i::MakeMesh (SMESH::SMESH_Mesh_ptr theMesh,
addErrorCode( "MakeMesh" ); addErrorCode( "MakeMesh" );
return myPattern.MakeMesh( aMesh, CreatePolygons, CreatePolyedrs ); return myPattern.MakeMesh( aMesh, CreatePolygons, CreatePolyedrs );
aMesh->GetMeshDS()->Modified();
} }
//======================================================================= //=======================================================================