TMapOfIds::const_iterator i = mySMDS2VTKElems.find(theObjID);
return i == mySMDS2VTKElems.end() ? -1 : i->second;
}
- return this->GetMesh()->fromSmdsToVtk(theObjID);
+ return this->GetMesh()->FindElement(theObjID)->getVtkId();
+ //return this->GetMesh()->fromSmdsToVtk(theObjID);
}
//=================================================================================
else
{
myLocalGrid = false;
+ if (!GetMesh()->isCompacted())
+ {
+ MESSAGE("*** buildPrs ==> compactMesh!");
+ GetMesh()->compactMesh();
+ }
vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();
myGrid->ShallowCopy(theGrid);
//MESSAGE(myGrid->GetReferenceCount());
myHasInverseElements(true),
myNodeMin(0), myNodeMax(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)
{
myMeshId = _meshList.size(); // --- index of the mesh to push back in the vector
myNodes.clear();
myCells.clear();
- myCellIdSmdsToVtk.clear();
+ //myCellIdSmdsToVtk.clear();
myCellIdVtkToSmds.clear();
myGrid = SMDS_UnstructuredGrid::New();
myGrid->setSMDS_mesh(this);
myGrid->SetPoints( points );
points->Delete();
myGrid->BuildLinks();
+ this->Modified();
}
///////////////////////////////////////////////////////////////////////////////
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
///////////////////////////////////////////////////////////////////////////////
bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
{
//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;
}
if (vtkId == -1)
vtkId = myElementIDFactory->SetInVtkGrid(element);
- if (ID >= myCellIdSmdsToVtk.size()) // --- resize local vector
- {
- MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << ID << " --> " << ID + SMDS_Mesh::chunkSize);
- myCellIdSmdsToVtk.resize(ID + SMDS_Mesh::chunkSize, -1); // fill new elements with -1
- }
-
- myCellIdSmdsToVtk[ID] = vtkId;
- //MESSAGE("smds:" << ID << " vtk:" << vtkId );
+// if (ID >= myCellIdSmdsToVtk.size()) // --- resize local vector
+// {
+// MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << ID << " --> " << ID + SMDS_Mesh::chunkSize);
+// myCellIdSmdsToVtk.resize(ID + SMDS_Mesh::chunkSize, -1); // fill new elements with -1
+// }
+//
+// myCellIdSmdsToVtk[ID] = vtkId;
+// //MESSAGE("smds:" << ID << " vtk:" << vtkId );
if (vtkId >= myCellIdVtkToSmds.size()) // --- resize local vector
{
{
SMDS_ElemIteratorPtr eIt = elementsIterator();
while ( eIt->more() )
- myElementIDFactory->ReleaseID(eIt->next()->GetID());
+ {
+ const SMDS_MeshElement *elem = eIt->next();
+ myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
+ }
SMDS_NodeIteratorPtr itn = nodesIterator();
while (itn->more())
- myNodeIDFactory->ReleaseID(itn->next()->GetID());
+ {
+ const SMDS_MeshNode *node = itn->next();
+ myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
+ }
}
// SetOfNodes::Iterator itn(myNodes);
{
SMDS_ElemIteratorPtr eIt = elementsIterator();
while ( eIt->more() )
- myElementIDFactory->ReleaseID(eIt->next()->GetID());
+ {
+ const SMDS_MeshElement *elem = eIt->next();
+ myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
+ }
SMDS_NodeIteratorPtr itn = nodesIterator();
while (itn->more())
- myNodeIDFactory->ReleaseID(itn->next()->GetID());
+ {
+ const SMDS_MeshNode *node = itn->next();
+ myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
+ }
}
else
{
}
myCells.clear();
myCellIdVtkToSmds.clear();
- myCellIdSmdsToVtk.clear();
+ //myCellIdSmdsToVtk.clear();
SMDS_NodeIteratorPtr itn = nodesIterator();
while (itn->more())
(*itc)->Clear();
myModified = false;
- myRemovedNodes = false;
- myChangedNodes = false;
xmin = 0; xmax = 0;
ymin = 0; ymax = 0;
zmin = 0; zmax = 0;
n->RemoveInverseElement((*it));
}
int IdToRemove = (*it)->GetID();
- int vtkid = this->fromSmdsToVtk(IdToRemove);
+ int vtkid = (*it)->getVtkId();
//MESSAGE("elem Id to remove " << IdToRemove << " vtkid " << vtkid <<
// " vtktype " << (*it)->GetVtkType() << " type " << (*it)->GetType());
switch ((*it)->GetType())
myInfo.remove(*it);
}
removedElems.push_back((*it));
- myElementIDFactory->ReleaseID(IdToRemove);
+ myElementIDFactory->ReleaseID(IdToRemove, vtkid);
delete (*it);
break;
case SMDSAbs_Edge:
myInfo.RemoveEdge(*it);
}
removedElems.push_back((*it));
- myElementIDFactory->ReleaseID(IdToRemove);
+ myElementIDFactory->ReleaseID(IdToRemove, vtkid);
if (const SMDS_VtkEdge* vtkElem = dynamic_cast<const SMDS_VtkEdge*>(*it))
myEdgePool->destroy((SMDS_VtkEdge*) vtkElem);
else
myInfo.RemoveFace(*it);
}
removedElems.push_back((*it));
- myElementIDFactory->ReleaseID(IdToRemove);
+ myElementIDFactory->ReleaseID(IdToRemove, vtkid);
if (const SMDS_VtkFace* vtkElem = dynamic_cast<const SMDS_VtkFace*>(*it))
myFacePool->destroy((SMDS_VtkFace*) vtkElem);
else
myInfo.RemoveVolume(*it);
}
removedElems.push_back((*it));
- myElementIDFactory->ReleaseID(IdToRemove);
+ myElementIDFactory->ReleaseID(IdToRemove, vtkid);
if (const SMDS_VtkVolume* vtkElem = dynamic_cast<const SMDS_VtkVolume*>(*it))
myVolumePool->destroy((SMDS_VtkVolume*) vtkElem);
else
myNodes[IdToRemove] = 0;
myInfo.myNbNodes--;
}
- myNodeIDFactory->ReleaseID((*it)->GetID());
+ myNodeIDFactory->ReleaseID((*it)->GetID(), (*it)->getVtkId());
removedNodes.push_back((*it));
if (const SMDS_MeshNode* vtkElem = dynamic_cast<const SMDS_MeshNode*>(*it))
myNodePool->destroy((SMDS_MeshNode*) vtkElem);
void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
{
int elemId = elem->GetID();
+ int vtkId = elem->getVtkId();
//MESSAGE("SMDS_Mesh::RemoveFreeElement " << elemId);
SMDSAbs_ElementType aType = elem->GetType();
SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
myNodes[elemId] = 0;
myInfo.myNbNodes--;
myNodePool->destroy(static_cast<SMDS_MeshNode*>(todest));
- myNodeIDFactory->ReleaseID(elemId);
+ myNodeIDFactory->ReleaseID(elemId, vtkId);
}
} else {
if (hasConstructionEdges() || hasConstructionFaces())
return;
//MESSAGE("Remove free element " << elemId);
- int vtkid = this->fromSmdsToVtk(elemId);
-
// Remove element from <InverseElements> of its nodes
SMDS_ElemIteratorPtr itn = elem->nodesIterator();
while (itn->more()) {
default:
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
}
}
void SMDS_Mesh::incrementNodesCapacity(int nbNodes)
{
- int val = myCellIdSmdsToVtk.size();
- MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << val << " --> " << val + nbNodes);
- myCellIdSmdsToVtk.resize(val + nbNodes, -1); // fill new elements with -1
- val = myNodes.size();
+// int val = myCellIdSmdsToVtk.size();
+// 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);
}
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()
{
xmin = 0; xmax = 0;
MESSAGE("getMaxDim " << 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;
+}
(std::vector<const SMDS_MeshNode*> nodes,
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,
std::list<const SMDS_MeshElement *>& removedElems,
std::list<const SMDS_MeshElement *>& removedNodes,
void updateBoundingBox();
double getMaxDim();
int fromVtkToSmds(int vtkid);
- int fromSmdsToVtk(int smdsid);
void incrementNodesCapacity(int nbNodes);
void incrementCellsCapacity(int nbCells);
void dumpGrid(string ficdump="dumpGrid");
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:
SMDS_Mesh(SMDS_Mesh * parent);
SetOfCells myCells;
//! 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
std::vector<int> myCellIdVtkToSmds;
SMDS_MeshElementIDFactory *myElementIDFactory;
SMDS_MeshInfo myInfo;
+ //! use a counter to keep track of modifications
+ unsigned long myModifTime, myCompactTime;
+
int myNodeMin;
int myNodeMax;
bool myHasConstructionFaces;
bool myHasInverseElements;
- bool myModified; // any add remove or change of node or cell
- bool myRemovedNodes;
- bool myChangedNodes;
+ //! any add, remove or change of node or cell
+ bool myModified;
+
double xmin;
double xmax;
double ymin;
//=======================================================================
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;
const SMDS_MeshElement* elem = GetMesh()->FindElement(ID);
return (SMDS_MeshElement*)(elem);
//function : ReleaseID
//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;
}
- int vtkId = myMesh->myCellIdSmdsToVtk[ID];
//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->setMyModified();
}
SMDS_MeshIDFactory::ReleaseID(ID);
if (ID == myMax)
{
myMin = IntegerLast();
myMax = 0;
- for (int i=0; i<myMesh->myCellIdSmdsToVtk.size(); i++)
- if (int id=myMesh->myCellIdSmdsToVtk[i] >=0)
- {
- if (id > myMax) myMax = id;
- if (id < myMin) myMin = id;
- }
+ for (int i = 0; i < myMesh->myCells.size(); i++)
+ {
+ if (myMesh->myCells[i])
+ {
+ int id = myMesh->myCells[i]->GetID();
+ if (id > myMax)
+ myMax = id;
+ if (id < myMin)
+ myMin = id;
+ }
+ }
if (myMin == IntegerLast())
myMin = 0;
}
void SMDS_MeshElementIDFactory::Clear()
{
- myMesh->myCellIdSmdsToVtk.clear();
+ //myMesh->myCellIdSmdsToVtk.clear();
+ myMesh->myCellIdVtkToSmds.clear();
myMin = myMax = 0;
SMDS_MeshIDFactory::Clear();
}
bool BindID(int ID, SMDS_MeshElement * elem);
int SetInVtkGrid(SMDS_MeshElement * elem);
SMDS_MeshElement * MeshElement(int ID);
- virtual void ReleaseID(int ID);
+ virtual void ReleaseID(int ID, int vtkId = -1);
SMDS_ElemIteratorPtr elementsIterator() const;
virtual void Clear();
int GetVtkCellType(int SMDSType);
//function : ReleaseID
//purpose :
//=======================================================================
-void SMDS_MeshIDFactory::ReleaseID(const int ID)
+void SMDS_MeshIDFactory::ReleaseID(int ID, int vtkId)
{
if ( ID > 0 )
{
}
}
}
- myMesh->myModified = true;
}
void SMDS_MeshIDFactory::Clear()
{
public:
int GetFreeID();
- virtual void ReleaseID(int ID);
+ virtual void ReleaseID(int ID, int vtkId = -1);
virtual void Clear();
void SetMesh(SMDS_Mesh *mesh);
vtkPoints *points = mesh->getGrid()->GetPoints();
points->InsertPoint(myVtkID, x, y, z);
mesh->adjustBoundingBox(x, y, z);
- mesh->myChangedNodes = true;
- mesh->myModified = true;
+ mesh->setMyModified();
}
SMDSAbs_ElementType SMDS_MeshNode::GetType() const
//function : ReleaseID
//purpose :
//=======================================================================
-void SMDS_MeshNodeIDFactory::ReleaseID(const int ID)
+void SMDS_MeshNodeIDFactory::ReleaseID(const int ID, int vtkId)
{
SMDS_MeshIDFactory::ReleaseID(ID);
- myMesh->myRemovedNodes = true;
+ myMesh->setMyModified();
if (ID == myMax)
myMax = 0; // --- force updateMinMax
if (ID == myMin)
SMDS_MeshNodeIDFactory();
bool BindID(int ID, SMDS_MeshElement * elem);
SMDS_MeshElement * MeshElement(int ID);
- virtual void ReleaseID(int ID);
+ virtual void ReleaseID(int ID, int vtkId = -1);
int GetMaxID() const;
int GetMinID() const;
SMDS_ElemIteratorPtr elementsIterator() const;
#define VTK_MAXTYPE VTK_QUADRATIC_PYRAMID
#endif
-#define NBMAXNEIGHBORS 10
+#define NBMAXNEIGHBORS 100
// allow very huge polyhedrons in tests
#define NBMAXNODESINCELL 5000
if (nodeIds.size() == 3)
aType = VTK_QUADRATIC_EDGE;
myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]);
+ mesh->setMyModified();
//MESSAGE("SMDS_VtkEdge::init myVtkID " << myVtkID);
}
bool SMDS_VtkEdge::ChangeNodes(const SMDS_MeshNode * node1, const SMDS_MeshNode * node2)
{
const SMDS_MeshNode* nodes[] = { node1, node2 };
+ SMDS_Mesh::_meshList[myMeshId]->setMyModified();
return ChangeNodes(nodes, 2);
}
{
pts[i] = nodes[i]->getVtkId();
}
+ SMDS_Mesh::_meshList[myMeshId]->setMyModified();
return true;
}
break;
}
myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]);
+ mesh->setMyModified();
//MESSAGE("SMDS_VtkFace::init myVtkID " << myVtkID);
}
myIdInShape = -1;
myMeshId = mesh->getMeshId();
myVtkID = grid->InsertNextLinkedCell(VTK_POLYGON, nodeIds.size(), &nodeIds[0]);
+ mesh->setMyModified();
}
bool SMDS_VtkFace::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes)
{
pts[i] = nodes[i]->getVtkId();
}
+ SMDS_Mesh::_meshList[myMeshId]->setMyModified();
return true;
}
break;
}
myVtkID = grid->InsertNextLinkedCell(aType, nodeIds.size(), &nodeIds[0]);
+ mesh->setMyModified();
//MESSAGE("SMDS_VtkVolume::init myVtkID " << myVtkID);
}
k += nf;
}
myVtkID = grid->InsertNextLinkedCell(VTK_POLYHEDRON, nbFaces, &ptIds[0]);
+ mesh->setMyModified();
}
#endif
{
pts[i] = nodes[i]->getVtkId();
}
+ SMDS_Mesh::_meshList[myMeshId]->setMyModified();
return true;
}
else if ( aShapesId )
aShapesId->insert( smToCompute->GetId() );
}
+ //aMesh.GetMeshDS()->Modified();
return ret;
}
else
SMESHDS_Mesh *myMesh = aMesh.GetMeshDS();
myMesh->adjustStructure();
+ MESSAGE("*** compactMesh after compute");
myMesh->compactMesh();
//myMesh->adjustStructure();
list<int> listind = myMesh->SubMeshIndices();
MESSAGE("Number of node objects " << SMDS_MeshNode::nbNodes);
MESSAGE("Number of cell objects " << SMDS_MeshCell::nbCells);
//myMesh->dumpGrid();
+ //aMesh.GetMeshDS()->Modified();
return ret;
}
const int nbSteps,
SMESH_SequenceOfElemPtr& srcElements)
{
- MESSAGE("sweepElement " << nbSteps);
+ //MESSAGE("sweepElement " << nbSteps);
SMESHDS_Mesh* aMesh = GetMeshDS();
// Loop on elem nodes:
// +---+---+
// 0 7 3
isOk = false;
+ if(nbRepl==2) {
+ MESSAGE("nbRepl=2: " << iRepl[0] << " " << iRepl[1]);
+ }
if(nbRepl==3) {
+ MESSAGE("nbRepl=3: " << iRepl[0] << " " << iRepl[1] << " " << iRepl[2]);
nbUniqueNodes = 6;
if( iRepl[0]==0 && iRepl[1]==1 && iRepl[2]==4 ) {
uniqueNodes[0] = curNodes[0];
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;
}
//////////////////////////////////// HEXAHEDRON
}
}
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();
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)
{
myLastCreatedElems.Append(newElem);
if ( aShapeId )
aMesh->SetMeshElementOnShape( newElem, aShapeId );
}
- aMesh->RemoveElement(elem);
}
}
else {
if( !elem || elem->IsQuadratic() ) continue;
int id = elem->GetID();
+ //MESSAGE("elem " << id);
+ id = 0; // get a free number for new elements
int nbNodes = elem->NbNodes();
vector<const SMDS_MeshNode *> aNds (nbNodes);
}
SMDSAbs_ElementType aType = elem->GetType();
- GetMeshDS()->RemoveFreeElement(elem, theSm, notFromGroups);
-
const SMDS_MeshElement* NewElem = 0;
switch( aType )
ReplaceElemInGroups( elem, NewElem, GetMeshDS());
if( NewElem )
theSm->AddElement( NewElem );
+
+ GetMeshDS()->RemoveFreeElement(elem, theSm, notFromGroups);
}
- GetMeshDS()->compactMesh();
+// if (!GetMeshDS()->isCompacted())
+// GetMeshDS()->compactMesh();
return nbElem;
}
aHelper.SetSubShape(0); // apply to the whole mesh
aHelper.FixQuadraticElements();
}
- GetMeshDS()->compactMesh();
+ if (!GetMeshDS()->isCompacted())
+ GetMeshDS()->compactMesh();
}
//=======================================================================
SMDS_MeshElement* anElem = (SMDS_MeshElement*) *elemItr;
if (!anElem)
continue;
- int vtkId = meshDS->fromSmdsToVtk(anElem->GetID());
+ int vtkId = anElem->getVtkId();
int neighborsVtkIds[NBMAXNEIGHBORS];
int downIds[NBMAXNEIGHBORS];
unsigned char downTypes[NBMAXNEIGHBORS];
{
double *coords = grid->GetPoint(oldId);
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
}
}
MESSAGE("--- problem domain node " << dom2 << " " << oldId);
localClonedNodeIds[oldId] = newid;
}
- int smdsId = meshDS->fromVtkToSmds(vtkVolId);
- meshDS->extrudeVolumeFromFace(smdsId, localClonedNodeIds);
+ meshDS->extrudeVolumeFromFace(vtkVolId, localClonedNodeIds);
}
}
// --- 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
itface = faceDomains.begin();
if (nodeDomains[oldId].count(idom))
localClonedNodeIds[oldId] = nodeDomains[oldId][idom];
}
- int smdsId = meshDS->fromVtkToSmds(vtkVolId);
- meshDS->ModifyCellNodes(smdsId, localClonedNodeIds);
+ meshDS->ModifyCellNodes(vtkVolId, localClonedNodeIds);
}
}
grid->BuildLinks();
const SMDS_PositionPtr Pos1 = n1->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( Pos1->GetTypeOfPosition()==SMDS_TOP_FACE ) {
}
}
// 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();
if ( faceID>0 || shapeType == TopAbs_FACE)
{
}
}
}
+ } // onGeom
+
// 3d variant
double x = ( n1->X() + n2->X() )/2.;
double y = ( n1->Y() + n2->Y() )/2.;
double z = ( n1->Z() + n2->Z() )/2.;
n12 = meshDS->AddNode(x,y,z);
+
+ if (onGeom) {
if ( !F.IsNull() )
{
gp_XY UV = ( uv[0] + uv[1] ) / 2.;
{
meshDS->SetNodeInVolume(n12, myShapeID);
}
+ } // onGeom
+
myTLinkNodeMap.insert( make_pair( link, n12 ));
return n12;
}
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.
- this->compactMesh();
+ if (!this->isCompacted())
+ this->compactMesh();
// SMDS_Mesh::Renumber( isNodes, startID, deltaID );
// myScript->Renumber( isNodes, startID, deltaID );
}
// << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
SetOfCells newCells;
- vector<int> newSmdsToVtk;
+ //vector<int> newSmdsToVtk;
vector<int> newVtkToSmds;
assert(maxVtkId < newCellSize);
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);
int myCellsSize = myCells.size();
newCells[newSmdsId]->setId(newSmdsId);
//MESSAGE("myCells["<< i << "] --> newCells[" << newSmdsId << "]");
int idvtk = myCells[i]->getVtkId();
- newSmdsToVtk[newSmdsId] = idvtk;
+ //newSmdsToVtk[newSmdsId] = idvtk;
assert(idvtk < newCellSize);
newVtkToSmds[idvtk] = newSmdsId;
}
}
myCells.swap(newCells);
- myCellIdSmdsToVtk.swap(newSmdsToVtk);
+ //myCellIdSmdsToVtk.swap(newSmdsToVtk);
myCellIdVtkToSmds.swap(newVtkToSmds);
MESSAGE("myCells.size()=" << myCells.size()
- << " myCellIdSmdsToVtk.size()=" << myCellIdSmdsToVtk.size()
<< " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
this->myElementIDFactory->emptyPool(newSmdsId);
/*! change some nodes in cell without modifying type or internal connectivity.
* 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.
* @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);
return true;
}
* @param localClonedNodeIds map old node id to new node id. The old nodes define the face in the volume.
* @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(smdsVolId << " " << vtkVolId);
+ //MESSAGE("extrudeVolumeFromFace " << vtkVolId);
vector<int> orderedNodes;
orderedNodes.clear();
- map<int, int>::iterator it = localClonedNodeIds.begin();
+ map<int, int>::const_iterator it = localClonedNodeIds.begin();
for (; it != localClonedNodeIds.end(); ++it)
orderedNodes.push_back(it->first);
int nbNodes = myGrid->getOrderedNodesOfFace(vtkVolId, orderedNodes);
- if (nbNodes == 3)
- {
- int newVtkVolId =myElementIDFactory->GetFreeID();
- SMDS_MeshVolume *vol = this->AddVolumeWithID(orderedNodes[0],
- orderedNodes[1],
- orderedNodes[2],
- localClonedNodeIds[orderedNodes[0]],
- localClonedNodeIds[orderedNodes[1]],
- localClonedNodeIds[orderedNodes[2]],
- newVtkVolId);
- }
+ for (int i=0; i<nbNodes; i++)
+ orderedNodes.push_back(localClonedNodeIds[orderedNodes[i]]);
+ SMDS_MeshVolume *vol = this->AddVolumeFromVtkIds(orderedNodes);
// TODO update subshape list of elements and nodes
- return true;
+ return vol;
}
std::vector<const SMDS_MeshNode*> nodes,
std::vector<int> quantities);
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 SetNodeInVolume(SMDS_MeshNode * aNode, const TopoDS_Shell & S);
myUnusedIdElements++;
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;
}
MESSAGE("Try to remove an element from a complex submesh ");
node->setIdInShape(myNodes.size());
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());
}
//=======================================================================
myUnusedIdNodes++;
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;
}
MESSAGE("Try to remove a node from a complex submesh");
// Dump creation of groups
aServant->GetGroups();
+ aServant->GetImpl().GetMeshDS()->Modified();
return aMesh._retn();
}
theStatus = status1;
aResult[i++] = SMESH::SMESH_Mesh::_duplicate( mesh );
+ meshServant->GetImpl().GetMeshDS()->Modified();
}
aStudyBuilder->CommitCommand();
}
SMESH_Mesh_i* aServant = dynamic_cast<SMESH_Mesh_i*>( GetServant( aMesh ).in() );
ASSERT( aServant );
aServant->ImportSTLFile( theFileName );
+ aServant->GetImpl().GetMeshDS()->Modified();
return aMesh._retn();
}
myLocShape = SMESH_Mesh::PseudoShape();
// call implementation compute
::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 ) {
// create mesh
SMESH::SMESH_Mesh_var aNewMesh = CreateEmptyMesh();
+ SMESHDS_Mesh* aNewMeshDS = 0;
if ( !aNewMesh->_is_nil() ) {
SMESH_Mesh_i* aNewImpl = dynamic_cast<SMESH_Mesh_i*>( GetServant( aNewMesh ).in() );
if ( aNewImpl ) {
::SMESH_Mesh& aLocMesh = aNewImpl->GetImpl();
- SMESHDS_Mesh* aNewMeshDS = aLocMesh.GetMeshDS();
+ aNewMeshDS = aLocMesh.GetMeshDS();
TGroupsMap aGroupsMap;
TListOfNewGroups aListOfNewGroups;
SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
aPixmap->SetPixMap("ICON_SMESH_TREE_MESH");
}
-
+ if (aNewMeshDS)
+ aNewMeshDS->Modified();
return aNewMesh._retn();
}
// Update Python script
TPythonDump() << "isDone = " << this << ".RemoveElements( " << IDsOfElements << " )";
+ // Remove Elements
+ bool ret = anEditor.Remove( IdList, false );
+ myMesh->GetMeshDS()->Modified();
if ( IDsOfElements.length() )
myMesh->SetIsModified( true ); // issue 0020693
-
- // Remove Elements
- return anEditor.Remove( IdList, false );
+ return ret;
}
//=============================================================================
// Update Python script
TPythonDump() << "isDone = " << this << ".RemoveNodes( " << IDsOfNodes << " )";
+ bool ret = anEditor.Remove( IdList, true );
+ myMesh->GetMeshDS()->Modified();
if ( IDsOfNodes.length() )
myMesh->SetIsModified( true ); // issue 0020693
-
- return anEditor.Remove( IdList, true );
+ return ret;
}
//=============================================================================
TPythonDump() << "nodeID = " << this << ".AddNode( "
<< x << ", " << y << ", " << z << " )";
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693
-
return N->GetID();
}
// Update Python script
TPythonDump() << "elem0d = " << this << ".Add0DElement( " << IDOfNode <<" )";
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693
if (elem)
<<n1<<", "<<n2<<", "<<n12<<" ])";
}
+ myMesh->GetMeshDS()->Modified();
if(elem)
return myMesh->SetIsModified( true ), elem->GetID();
// Update Python script
TPythonDump() << "faceID = " << this << ".AddFace( " << IDsOfNodes << " )";
+ myMesh->GetMeshDS()->Modified();
if(elem)
return myMesh->SetIsModified( true ), elem->GetID();
// Update Python script
TPythonDump() <<"faceID = "<<this<<".AddPolygonalFace( "<<IDsOfNodes<<" )";
+ myMesh->GetMeshDS()->Modified();
return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
}
// Update Python script
TPythonDump() << "volID = " << this << ".AddVolume( " << IDsOfNodes << " )";
+ myMesh->GetMeshDS()->Modified();
if(elem)
return myMesh->SetIsModified( true ), elem->GetID();
// Update Python script
TPythonDump() << "volID = " << this << ".AddPolyhedralVolume( "
<< IDsOfNodes << ", " << Quantities << " )";
+ myMesh->GetMeshDS()->Modified();
return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
}
// Update Python script
TPythonDump() << "volID = " << this << ".AddPolyhedralVolumeByFaces( "
<< IdsOfFaces << " )";
+ myMesh->GetMeshDS()->Modified();
return elem ? ( myMesh->SetIsModified( true ), elem->GetID()) : 0;
}
}
mesh->SetNodeOnFace( node, FaceID, u, v );
-
myMesh->SetIsModified( true );
}
TPythonDump() << "isDone = " << this << ".InverseDiag( "
<< NodeID1 << ", " << NodeID2 << " )";
- myMesh->SetIsModified( true );
::SMESH_MeshEditor aMeshEditor( myMesh );
- return aMeshEditor.InverseDiag ( n1, n2 );
+ int ret = aMeshEditor.InverseDiag ( n1, n2 );
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ return ret;
}
//=============================================================================
bool stat = aMeshEditor.DeleteDiag ( n1, n2 );
+ myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
// Update Python script
TPythonDump() << "isDone = " << this << ".Reorient( " << IDsOfElements << " )";
+ myMesh->GetMeshDS()->Modified();
if ( IDsOfElements.length() )
myMesh->SetIsModified( true ); // issue 0020693
::SMESH_MeshEditor anEditor( myMesh );
bool stat = anEditor.TriToQuad( faces, aCrit, MaxAngle );
+ myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
::SMESH_MeshEditor anEditor( myMesh );
CORBA::Boolean stat = anEditor.QuadToTri( faces, aCrit );
+ myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
::SMESH_MeshEditor anEditor( myMesh );
CORBA::Boolean stat = anEditor.QuadToTri( faces, Diag13 );
+ myMesh->GetMeshDS()->Modified();
if ( stat )
myMesh->SetIsModified( true ); // issue 0020693
::SMESH_MeshEditor anEditor (myMesh);
anEditor.SplitVolumesIntoTetra( elemSet, int( methodFlags ));
+ myMesh->GetMeshDS()->Modified();
storeResult(anEditor);
anEditor.Smooth(elements, fixedNodes, method,
MaxNbOfIterations, MaxAspectRatio, IsParametric );
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true ); // issue 0020693
storeResult(anEditor);
anEditor.RotationSweep (*workElements, Ax1, theAngleInRadians,
theNbOfSteps, theTolerance, theMakeGroups, makeWalls);
storeResult(anEditor);
+ myMesh->GetMeshDS()->Modified();
// myMesh->SetIsModified( true ); -- it does not influence Compute()
::SMESH_MeshEditor::PGroupIDs groupIds =
anEditor.ExtrusionSweep (elements, stepVec, theNbOfSteps, aHystory, theMakeGroups);
+ myMesh->GetMeshDS()->Modified();
storeResult(anEditor);
return theMakeGroups ? getGroups(groupIds.get()) : 0;
anEditor.ExtrusionAlongTrack( elements, aSubMesh, nodeStart,
theHasAngles, angles, false,
theHasRefPoint, refPnt, theMakeGroups );
+ myMesh->GetMeshDS()->Modified();
storeResult(anEditor);
theError = convExtrError( error );
error = anEditor.ExtrusionAlongTrack( elements, &(aMeshImp->GetImpl()), aNodeStart,
HasAngles, angles, LinearVariation,
HasRefPoint, refPnt, MakeGroups );
+ myMesh->GetMeshDS()->Modified();
}
else {
SMESH_subMesh_i* aSubMeshImp = SMESH::DownCast<SMESH_subMesh_i*>( Path );
error = anEditor.ExtrusionAlongTrack( elements, aSubMesh, aNodeStart,
HasAngles, angles, LinearVariation,
HasRefPoint, refPnt, MakeGroups );
+ myMesh->GetMeshDS()->Modified();
}
else {
SMESH_Group_i* aGroupImp = SMESH::DownCast<SMESH_Group_i*>( Path );
if(theCopy)
storeResult(anEditor);
else
- myMesh->SetIsModified( true );
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
if(theCopy)
storeResult(anEditor);
else
- myMesh->SetIsModified( true );
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
if(theCopy)
storeResult(anEditor);
else
- myMesh->SetIsModified( true );
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
if(theCopy)
storeResult(anEditor);
else
- myMesh->SetIsModified( true );
-
+ {
+ myMesh->GetMeshDS()->Modified();
+ myMesh->SetIsModified( true );
+ }
return theMakeGroups ? getGroups(groupIds.get()) : 0;
}
anEditor.MergeNodes( aListOfListOfNodes );
aTPythonDump << "])";
-
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
}
::SMESH_MeshEditor anEditor( myMesh );
anEditor.MergeElements(aListOfListOfElementsID);
-
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
aTPythonDump << "] )";
// Update Python script
TPythonDump() << "isDone = " << this << ".MoveNode( "
<< NodeID << ", " << x << ", " << y << ", " << z << " )";
-
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return true;
<< ".MoveClosestNodeToPoint( "<< x << ", " << y << ", " << z
<< ", " << nodeID << " )";
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
}
storeResult(anEditor);
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return error;
storeResult(anEditor);
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return error;
storeResult(anEditor);
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return error;
storeResult(anEditor);
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
return error;
bool res = GetMeshDS()->ChangeElementNodes( elem, & aNodes[0], nbn1+1 );
+ myMesh->GetMeshDS()->Modified();
if ( res )
myMesh->SetIsModified( true );
::SMESH_MeshEditor anEditor( myMesh );
anEditor.ConvertToQuadratic(theForce3d);
TPythonDump() << this << ".ConvertToQuadratic( " << theForce3d << " )";
+ myMesh->GetMeshDS()->Modified();
myMesh->SetIsModified( true );
}
::SMESH_MeshEditor anEditor( myMesh );
CORBA::Boolean isDone = anEditor.ConvertFromQuadratic();
TPythonDump() << this << ".ConvertFromQuadratic()";
+ myMesh->GetMeshDS()->Modified();
if ( isDone )
myMesh->SetIsModified( true );
return isDone;
bool aResult = aMeshEditor.DoubleNodes( aListOfNodes, aListOfElems );
+ myMesh->GetMeshDS()->Modified();
storeResult( aMeshEditor) ;
if ( aResult )
myMesh->SetIsModified( true );
storeResult( aMeshEditor) ;
+ myMesh->GetMeshDS()->Modified();
if ( aResult )
myMesh->SetIsModified( true );
storeResult( aMeshEditor) ;
+ myMesh->GetMeshDS()->Modified();
if ( aResult )
myMesh->SetIsModified( true );
storeResult( aMeshEditor) ;
+ myMesh->GetMeshDS()->Modified();
if ( aResult )
myMesh->SetIsModified( true );
storeResult( aMeshEditor) ;
+ myMesh->GetMeshDS()->Modified();
if ( aResult )
myMesh->SetIsModified( true );
storeResult( aMeshEditor) ;
+ myMesh->GetMeshDS()->Modified();
if ( aResult )
myMesh->SetIsModified( true );
storeResult( aMeshEditor) ;
+ myMesh->GetMeshDS()->Modified();
if ( aResult )
myMesh->SetIsModified( true );
storeResult( aMeshEditor) ;
+ myMesh->GetMeshDS()->Modified();
if ( aResult )
myMesh->SetIsModified( true );
::SMESH_MeshEditor aMeshEditor( myMesh );
bool aResult = aMeshEditor.Make2DMeshFrom3D();
storeResult( aMeshEditor) ;
+ myMesh->GetMeshDS()->Modified();
TPythonDump() << "isDone = " << this << ".Make2DMeshFrom3D()";
return aResult;
bool aResult = aMeshEditor.DoubleNodesOnGroupBoundaries( domains, createJointElems );
storeResult( aMeshEditor) ;
+ myMesh->GetMeshDS()->Modified();
// Update Python script
TPythonDump() << "isDone = " << this << ".DoubleNodesOnGroupBoundaries( " << &theDomains
(*xyzIt)->Coord( p.x, p.y, p.z );
}
}
-
// Update Python script
TPythonDump() << "pattern.ApplyToFace( " << theFace << ", "
<< theVertexOnKeyPoint1 << ", " << theReverse << " )";
addErrorCode( "MakeMesh" );
return myPattern.MakeMesh( aMesh, CreatePolygons, CreatePolyedrs );
+ aMesh->GetMeshDS()->Modified();
}
//=======================================================================
