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: debug in progress, still about 30 bugs

Browse Source
This commit is contained in:
prascle 2010-11-15 15:09:53 +00:00
parent 7eead70477
commit cde2f08074
36 changed files with 341 additions and 331 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
doc/salome/tui/doxyfile.in
View File

@ -239,7 +239,7 @@ CLASS_DIAGRAMS = YES
HIDE_UNDOC_RELATIONS = NO HIDE_UNDOC_RELATIONS = NO
HAVE_DOT = YES HAVE_DOT = YES
CLASS_GRAPH = YES CLASS_GRAPH = YES
COLLABORATION_GRAPH = YES COLLABORATION_GRAPH = NO
GROUP_GRAPHS = YES GROUP_GRAPHS = YES
UML_LOOK = NO UML_LOOK = NO
TEMPLATE_RELATIONS = YES TEMPLATE_RELATIONS = YES

17
src/SMDS/SMDS_EdgePosition.cxx
View File

@ -36,22 +36,9 @@ using namespace std;
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_EdgePosition::SMDS_EdgePosition(const int aEdgeId, SMDS_EdgePosition::SMDS_EdgePosition(const double aUParam): myUParameter(aUParam)
const double aUParam):SMDS_Position(aEdgeId), myUParameter(aUParam)
{ {
//MESSAGE("********************************* SMDS_EdgePosition "<< aEdgeId << " " << myUParameter); //MESSAGE("********************************* SMDS_EdgePosition " << myUParameter);
}
//=======================================================================
//function : Coords
//purpose :
//=======================================================================
const double *SMDS_EdgePosition::Coords() const
{
static double origin[]={0,0,0};
MESSAGE("SMDS_EdgePosition::Coords not implemented");
return origin;
} }
/** /**

3
src/SMDS/SMDS_EdgePosition.hxx
View File

@ -35,8 +35,7 @@ class SMDS_EXPORT SMDS_EdgePosition:public SMDS_Position
{ {
public: public:
SMDS_EdgePosition(const int aEdgeId=0, const double aUParam=0); SMDS_EdgePosition(const double aUParam=0);
const virtual double * Coords() const;
SMDS_TypeOfPosition GetTypeOfPosition() const; SMDS_TypeOfPosition GetTypeOfPosition() const;
void SetUParameter(double aUparam); void SetUParameter(double aUparam);
double GetUParameter() const; double GetUParameter() const;

17
src/SMDS/SMDS_FacePosition.cxx
View File

@ -36,26 +36,13 @@ using namespace std;
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_FacePosition::SMDS_FacePosition(const int aEdgeId, SMDS_FacePosition::SMDS_FacePosition(const double aUParam,
const double aUParam,
const double aVParam) const double aVParam)
:SMDS_Position(aEdgeId), : myUParameter(aUParam),myVParameter(aVParam)
myUParameter(aUParam),myVParameter(aVParam)
{ {
//MESSAGE("******************************************************** SMDS_FacePosition"); //MESSAGE("******************************************************** SMDS_FacePosition");
} }
//=======================================================================
//function : Coords
//purpose :
//=======================================================================
const double *SMDS_FacePosition::Coords() const
{
static double origin[]={0,0,0};
MESSAGE("SMDS_EdgePosition::Coords not implemented");
return origin;
}
/** /**
*/ */
SMDS_TypeOfPosition SMDS_FacePosition::GetTypeOfPosition() const SMDS_TypeOfPosition SMDS_FacePosition::GetTypeOfPosition() const

4
src/SMDS/SMDS_FacePosition.hxx
View File

@ -35,9 +35,7 @@ class SMDS_EXPORT SMDS_FacePosition:public SMDS_Position
{ {
public: public:
SMDS_FacePosition(int aFaceId=0, double aUParam=0, SMDS_FacePosition(double aUParam=0, double aVParam=0);
double aVParam=0);
const virtual double * Coords() const;
SMDS_TypeOfPosition GetTypeOfPosition() const; SMDS_TypeOfPosition GetTypeOfPosition() const;
void SetUParameter(double aUparam); void SetUParameter(double aUparam);
void SetVParameter(double aVparam); void SetVParameter(double aVparam);

48
src/SMDS/SMDS_Mesh.cxx
View File

@ -125,7 +125,9 @@ SMDS_Mesh::SMDS_Mesh()
myHasConstructionEdges(false), myHasConstructionFaces(false), myHasConstructionEdges(false), myHasConstructionFaces(false),
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),
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
MESSAGE("myMeshId=" << myMeshId); MESSAGE("myMeshId=" << myMeshId);
@ -215,7 +217,7 @@ SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID)
} }
myNodeIDFactory->adjustMaxId(ID); myNodeIDFactory->adjustMaxId(ID);
SMDS_MeshNode * node = myNodePool->getNew(); SMDS_MeshNode * node = myNodePool->getNew();
node->init(ID, myMeshId, -1, x, y, z); node->init(ID, myMeshId, 0, x, y, z);
if (ID >= myNodes.size()) if (ID >= myNodes.size())
{ {
myNodes.resize(ID+SMDS_Mesh::chunkSize, 0); myNodes.resize(ID+SMDS_Mesh::chunkSize, 0);
@ -224,6 +226,8 @@ SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID)
myNodes[ID] = node; myNodes[ID] = node;
myNodeIDFactory->BindID(ID,node); myNodeIDFactory->BindID(ID,node);
myInfo.myNbNodes++; myInfo.myNbNodes++;
myModified = true;
this->adjustBoundingBox(x, y, z);
return node; return node;
}else }else
return NULL; return NULL;
@ -2426,6 +2430,13 @@ void SMDS_Mesh::Clear()
while(itc!=myChildren.end()) while(itc!=myChildren.end())
(*itc)->Clear(); (*itc)->Clear();
myModified = false;
myRemovedNodes = false;
myChangedNodes = false;
xmin = 0; xmax = 0;
ymin = 0; ymax = 0;
zmin = 0; zmax = 0;
myInfo.Clear(); myInfo.Clear();
myGrid->Initialize(); myGrid->Initialize();
@ -4061,3 +4072,36 @@ int SMDS_Mesh::fromSmdsToVtk(int smdsid)
return myCellIdSmdsToVtk[smdsid]; return myCellIdSmdsToVtk[smdsid];
throw SALOME_Exception(LOCALIZED ("smds id out of bounds")); throw SALOME_Exception(LOCALIZED ("smds id out of bounds"));
} }
void SMDS_Mesh::updateBoundingBox()
{
xmin = 0; xmax = 0;
ymin = 0; ymax = 0;
zmin = 0; zmax = 0;
vtkPoints *points = myGrid->GetPoints();
int myNodesSize = this->myNodes.size();
for (int i = 0; i < myNodesSize; i++)
{
if (SMDS_MeshNode *n = myNodes[i])
{
double coords[3];
points->GetPoint(n->myVtkID, coords);
if (coords[0] < xmin) xmin = coords[0];
else if (coords[0] > xmax) xmax = coords[0];
if (coords[1] < ymin) ymin = coords[1];
else if (coords[1] > ymax) ymax = coords[1];
if (coords[2] < zmin) zmin = coords[2];
else if (coords[2] > zmax) zmax = coords[2];
}
}
}
double SMDS_Mesh::getMaxDim()
{
double dmax = 1.e-3;
if ((xmax - xmin) > dmax) dmax = xmax -xmin;
if ((ymax - ymin) > dmax) dmax = ymax -ymin;
if ((zmax - zmin) > dmax) dmax = zmax -zmin;
MESSAGE("getMaxDim " << dmax);
return dmax;
}

25
src/SMDS/SMDS_Mesh.hxx
View File

@ -57,8 +57,11 @@
class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject{ class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject{
public: public:
friend class SMDS_MeshIDFactory;
friend class SMDS_MeshNodeIDFactory;
friend class SMDS_MeshElementIDFactory; friend class SMDS_MeshElementIDFactory;
friend class SMDS_MeshVolumeVtkNodes; friend class SMDS_MeshVolumeVtkNodes;
friend class SMDS_MeshNode;
SMDS_Mesh(); SMDS_Mesh();
@ -568,6 +571,8 @@ public:
typedef std::vector<SMDS_MeshCell *> SetOfCells; typedef std::vector<SMDS_MeshCell *> SetOfCells;
void updateNodeMinMax(); void updateNodeMinMax();
void updateBoundingBox();
double getMaxDim();
int fromVtkToSmds(int vtkid); int fromVtkToSmds(int vtkid);
int fromSmdsToVtk(int smdsid); int fromSmdsToVtk(int smdsid);
@ -614,6 +619,16 @@ protected:
myCells.resize(ID+SMDS_Mesh::chunkSize,0); myCells.resize(ID+SMDS_Mesh::chunkSize,0);
}; };
inline void adjustBoundingBox(double x, double y, double z)
{
if (x > xmax) xmax = x;
else if (x < xmin) xmin = x;
if (y > ymax) ymax = y;
else if (y < ymin) ymin = y;
if (z > zmax) zmax = z;
else if (z < zmin) zmin = z;
};
// Fields PRIVATE // Fields PRIVATE
//! index of this SMDS_mesh in the static vector<SMDS_Mesh*> _meshList //! index of this SMDS_mesh in the static vector<SMDS_Mesh*> _meshList
@ -654,6 +669,16 @@ protected:
bool myHasConstructionEdges; bool myHasConstructionEdges;
bool myHasConstructionFaces; bool myHasConstructionFaces;
bool myHasInverseElements; bool myHasInverseElements;
bool myModified; // any add remove or change of node or cell
bool myRemovedNodes;
bool myChangedNodes;
double xmin;
double xmax;
double ymin;
double ymax;
double zmin;
double zmax;
}; };

2
src/SMDS/SMDS_MeshElement.cxx
View File

@ -35,7 +35,7 @@
using namespace std; using namespace std;
SMDS_MeshElement::SMDS_MeshElement(int ID):myID(ID), myMeshId(-1), myShapeId(-1), myIdInShape(-1) SMDS_MeshElement::SMDS_MeshElement(int ID):myID(ID), myMeshId(-1), myShapeId(0), myIdInShape(-1)
{ {
} }

29
src/SMDS/SMDS_MeshElement.hxx
View File

@ -92,6 +92,8 @@ public:
friend SMDS_EXPORT bool SMDS_MeshElementIDFactory::BindID(int ID,SMDS_MeshElement* elem); friend SMDS_EXPORT bool SMDS_MeshElementIDFactory::BindID(int ID,SMDS_MeshElement* elem);
friend class SMDS_Mesh; friend class SMDS_Mesh;
friend class SMESHDS_Mesh; friend class SMESHDS_Mesh;
friend class SMESHDS_SubMesh;
friend class SMDS_MeshElementIDFactory;
// =========================== // ===========================
// Access to nodes by index // Access to nodes by index
@ -137,41 +139,28 @@ public:
*/ */
int GetNodeIndex( const SMDS_MeshNode* node ) const; int GetNodeIndex( const SMDS_MeshNode* node ) const;
//inline int getId() const {return myID; };
inline ShortType getMeshId() const {return myMeshId; }; inline ShortType getMeshId() const {return myMeshId; };
inline ShortType getshapeId() const {return myShapeId; }; inline ShortType getshapeId() const {return myShapeId; };
inline void setShapeId(ShortType shapeId) {myShapeId = shapeId; };
inline int getIdInShape() const { return myIdInShape; }; inline int getIdInShape() const { return myIdInShape; };
inline void setIdInShape(int id) { myIdInShape = id; }; inline int getVtkId() const { return myVtkID; };
inline void setVtkId(int vtkId)
{
myVtkID = vtkId;
}
inline int getVtkId() const
{
return myVtkID;
}
protected: protected:
inline void setId(int id) {myID = id; }; inline void setId(int id) {myID = id; };
inline void setShapeId(ShortType shapeId) {myShapeId = shapeId; };
inline void setIdInShape(int id) { myIdInShape = id; };
inline void setVtkId(int vtkId) { myVtkID = vtkId; };
SMDS_MeshElement(int ID=-1); SMDS_MeshElement(int ID=-1);
SMDS_MeshElement(int id, ShortType meshId, ShortType shapeId=-1); SMDS_MeshElement(int id, ShortType meshId, ShortType shapeId = 0);
virtual void Print(std::ostream & OS) const; virtual void Print(std::ostream & OS) const;
//! Element index in vector SMDS_Mesh::myNodes or SMDS_Mesh::myCells //! Element index in vector SMDS_Mesh::myNodes or SMDS_Mesh::myCells
int myID; int myID;
//! index in vtkUnstructuredGrid
// index in vtkUnstructuredGrid
int myVtkID; int myVtkID;
//! SMDS_Mesh identification in SMESH //! SMDS_Mesh identification in SMESH
ShortType myMeshId; ShortType myMeshId;
//! SubShape and SubMesh identification in SMESHDS
//! SubShape and SubMesh identification in SMESHDS (not in use?)
ShortType myShapeId; ShortType myShapeId;
//! Element index in SMESHDS_SubMesh vector //! Element index in SMESHDS_SubMesh vector
int myIdInShape; int myIdInShape;
}; };

1
src/SMDS/SMDS_MeshIDFactory.cxx
View File

@ -87,6 +87,7 @@ void SMDS_MeshIDFactory::ReleaseID(const int ID)
} }
} }
} }
myMesh->myModified = true;
} }
void SMDS_MeshIDFactory::Clear() void SMDS_MeshIDFactory::Clear()

9
src/SMDS/SMDS_MeshNode.cxx
View File

@ -49,7 +49,7 @@ int SMDS_MeshNode::nbNodes =0;
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_MeshNode::SMDS_MeshNode() : SMDS_MeshNode::SMDS_MeshNode() :
SMDS_MeshElement(-1, -1, -1), SMDS_MeshElement(-1, -1, 0),
myPosition(SMDS_SpacePosition::originSpacePosition()) myPosition(SMDS_SpacePosition::originSpacePosition())
{ {
nbNodes++; nbNodes++;
@ -265,7 +265,6 @@ int SMDS_MeshNode::NbNodes() const
return 1; return 1;
} }
double* SMDS_MeshNode::getCoord() const double* SMDS_MeshNode::getCoord() const
{ {
return SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetPoint(myVtkID); return SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetPoint(myVtkID);
@ -292,8 +291,12 @@ double SMDS_MeshNode::Z() const
//* resize the vtkPoints structure every SMDS_Mesh::chunkSize points //* resize the vtkPoints structure every SMDS_Mesh::chunkSize points
void SMDS_MeshNode::setXYZ(double x, double y, double z) void SMDS_MeshNode::setXYZ(double x, double y, double z)
{ {
vtkPoints *points = SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetPoints(); SMDS_Mesh *mesh = SMDS_Mesh::_meshList[myMeshId];
vtkPoints *points = mesh->getGrid()->GetPoints();
points->InsertPoint(myVtkID, x, y, z); points->InsertPoint(myVtkID, x, y, z);
mesh->adjustBoundingBox(x, y, z);
mesh->myChangedNodes = true;
mesh->myModified = true;
} }
SMDSAbs_ElementType SMDS_MeshNode::GetType() const SMDSAbs_ElementType SMDS_MeshNode::GetType() const

8
src/SMDS/SMDS_MeshNode.hxx
View File

@ -41,7 +41,6 @@ public:
friend class SMDS_Mesh; friend class SMDS_Mesh;
friend class ObjectPool<SMDS_MeshNode>; friend class ObjectPool<SMDS_MeshNode>;
double* getCoord() const;
void Print(std::ostream & OS) const; void Print(std::ostream & OS) const;
double X() const; double X() const;
double Y() const; double Y() const;
@ -63,12 +62,6 @@ public:
bool emptyInverseElements(); bool emptyInverseElements();
void setXYZ(double x, double y, double z); void setXYZ(double x, double y, double z);
/*!
* \brief Return node by its index
* \param ind - node index
* \retval const SMDS_MeshNode* - the node
*/
//virtual const SMDS_MeshNode* GetNode(const int) const { return this; }
static int nbNodes; static int nbNodes;
protected: protected:
@ -77,6 +70,7 @@ protected:
virtual ~SMDS_MeshNode(); virtual ~SMDS_MeshNode();
void init(int id, int meshId, int shapeId = -1, double x=0, double y=0, double z=0); void init(int id, int meshId, int shapeId = -1, double x=0, double y=0, double z=0);
inline void setVtkId(int vtkId) { myVtkID = vtkId; }; inline void setVtkId(int vtkId) { myVtkID = vtkId; };
double* getCoord() const;
SMDS_ElemIteratorPtr SMDS_ElemIteratorPtr
elementsIterator(SMDSAbs_ElementType type) const; elementsIterator(SMDSAbs_ElementType type) const;

1
src/SMDS/SMDS_MeshNodeIDFactory.cxx
View File

@ -75,6 +75,7 @@ SMDS_MeshElement* SMDS_MeshNodeIDFactory::MeshElement(int ID)
void SMDS_MeshNodeIDFactory::ReleaseID(const int ID) void SMDS_MeshNodeIDFactory::ReleaseID(const int ID)
{ {
SMDS_MeshIDFactory::ReleaseID(ID); SMDS_MeshIDFactory::ReleaseID(ID);
myMesh->myRemovedNodes = true;
if (ID == myMax) if (ID == myMax)
myMax = 0; // --- force updateMinMax myMax = 0; // --- force updateMinMax
if (ID == myMin) if (ID == myMin)

26
src/SMDS/SMDS_Position.cxx
View File

@ -33,31 +33,9 @@
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_Position::SMDS_Position(int aShapeId) :myShapeId(aShapeId) SMDS_Position::SMDS_Position()
{ {
//MESSAGE("########################## SMDS_Position " << myShapeId); //MESSAGE("########################## SMDS_Position ");
}
//=======================================================================
//function : SetShapeId
//purpose :
//=======================================================================
void SMDS_Position::SetShapeId(int aShapeId)
{
//MESSAGE("############################## SetShapeId "<< aShapeId);
myShapeId = aShapeId;
}
//=======================================================================
//function : GetShapeId
//purpose :
//=======================================================================
int SMDS_Position::GetShapeId() const
{
//MESSAGE("################################# GetShapeId " << myShapeId);
return myShapeId;
} }
//======================================================================= //=======================================================================

8
src/SMDS/SMDS_Position.hxx
View File

@ -40,18 +40,12 @@ class SMDS_EXPORT SMDS_Position
{ {
public: public:
const virtual double * Coords() const = 0;
virtual SMDS_TypeOfPosition GetTypeOfPosition() const = 0; virtual SMDS_TypeOfPosition GetTypeOfPosition() const = 0;
virtual int GetDim() const; virtual int GetDim() const;
void SetShapeId(int aShapeId);
int GetShapeId() const;
virtual ~SMDS_Position() {} virtual ~SMDS_Position() {}
protected: protected:
SMDS_Position(int aShapeId); SMDS_Position();
private:
int myShapeId;
}; };

9
src/SMDS/SMDS_SpacePosition.cxx
View File

@ -30,17 +30,10 @@
SMDS_SpacePosition* SMDS_SpacePosition::_originPosition = new SMDS_SpacePosition(); SMDS_SpacePosition* SMDS_SpacePosition::_originPosition = new SMDS_SpacePosition();
SMDS_SpacePosition::SMDS_SpacePosition(double x, double y, double z): SMDS_SpacePosition::SMDS_SpacePosition(double x, double y, double z)
SMDS_Position(0)
{ {
} }
const double* SMDS_SpacePosition::Coords() const
{
static double origin[]={0,0,0};
return origin;
}
SMDS_TypeOfPosition SMDS_SpacePosition::GetTypeOfPosition() const SMDS_TypeOfPosition SMDS_SpacePosition::GetTypeOfPosition() const
{ {
return SMDS_TOP_3DSPACE; return SMDS_TOP_3DSPACE;

1
src/SMDS/SMDS_SpacePosition.hxx
View File

@ -36,7 +36,6 @@ class SMDS_EXPORT SMDS_SpacePosition:public SMDS_Position
public: public:
SMDS_SpacePosition(double x=0, double y=0, double z=0); SMDS_SpacePosition(double x=0, double y=0, double z=0);
const virtual double * Coords() const;
virtual inline SMDS_TypeOfPosition GetTypeOfPosition() const; virtual inline SMDS_TypeOfPosition GetTypeOfPosition() const;
static SMDS_PositionPtr originSpacePosition(); static SMDS_PositionPtr originSpacePosition();
private: private:

16
src/SMDS/SMDS_VertexPosition.cxx
View File

@ -36,25 +36,11 @@ using namespace std;
//purpose : //purpose :
//======================================================================= //=======================================================================
SMDS_VertexPosition:: SMDS_VertexPosition(const int aVertexId) SMDS_VertexPosition:: SMDS_VertexPosition()
:SMDS_Position(aVertexId)
{ {
//MESSAGE("*********************************************** SMDS_VertexPosition " << aVertexId); //MESSAGE("*********************************************** SMDS_VertexPosition " << aVertexId);
} }
//=======================================================================
//function : Coords
//purpose :
//=======================================================================
const double *SMDS_VertexPosition::Coords() const
{
const static double origin[]={0,0,0};
//MESSAGE("######################### SMDS_VertexPosition::Coords not implemented");
return origin;
}
SMDS_TypeOfPosition SMDS_VertexPosition::GetTypeOfPosition() const SMDS_TypeOfPosition SMDS_VertexPosition::GetTypeOfPosition() const
{ {
//MESSAGE("################################################# GetTypeOfPosition"); //MESSAGE("################################################# GetTypeOfPosition");

3
src/SMDS/SMDS_VertexPosition.hxx
View File

@ -36,8 +36,7 @@ class SMDS_EXPORT SMDS_VertexPosition:public SMDS_Position
public: public:
SMDS_TypeOfPosition GetTypeOfPosition() const; SMDS_TypeOfPosition GetTypeOfPosition() const;
SMDS_VertexPosition(int aVertexId=0); SMDS_VertexPosition();
const double *Coords() const;
}; };
#endif #endif

1
src/SMDS/SMDS_VtkEdge.cxx
View File

@ -65,6 +65,7 @@ bool SMDS_VtkEdge::IsMediumNode(const SMDS_MeshNode* node) const
vtkIdType npts = 0; vtkIdType npts = 0;
vtkIdType* pts = 0; vtkIdType* pts = 0;
grid->GetCellPoints(myVtkID, npts, pts); grid->GetCellPoints(myVtkID, npts, pts);
//MESSAGE("IsMediumNode " << npts << " " << (node->getVtkId() == pts[npts-1]));
return ((npts == 3) && (node->getVtkId() == pts[2])); return ((npts == 3) && (node->getVtkId() == pts[2]));
} }

2
src/SMDS/SMDS_VtkFace.cxx
View File

@ -165,6 +165,7 @@ bool SMDS_VtkFace::IsMediumNode(const SMDS_MeshNode* node) const
rankFirstMedium = 4; // medium nodes are of rank 4,5,6,7 rankFirstMedium = 4; // medium nodes are of rank 4,5,6,7
break; break;
default: default:
//MESSAGE("wrong element type " << aVtkType);
return false; return false;
} }
vtkIdType npts = 0; vtkIdType npts = 0;
@ -175,6 +176,7 @@ bool SMDS_VtkFace::IsMediumNode(const SMDS_MeshNode* node) const
{ {
if (pts[rank] == nodeId) if (pts[rank] == nodeId)
{ {
//MESSAGE("rank " << rank << " is medium node " << (rank < rankFirstMedium));
if (rank < rankFirstMedium) if (rank < rankFirstMedium)
return false; return false;
else else

15
src/SMDS/SMDS_VtkVolume.cxx
View File

@ -75,13 +75,14 @@ void SMDS_VtkVolume::initPoly(std::vector<vtkIdType> nodeIds, std::vector<int> n
{ {
int nf = nbNodesPerFace[i]; int nf = nbNodesPerFace[i];
ptIds.push_back(nf); ptIds.push_back(nf);
double a[3]; // double a[3];
double b[3]; // double b[3];
double c[3]; // double c[3];
grid->GetPoints()->GetPoint(nodeIds[k], a); // grid->GetPoints()->GetPoint(nodeIds[k], a);
grid->GetPoints()->GetPoint(nodeIds[k + 1], b); // grid->GetPoints()->GetPoint(nodeIds[k + 1], b);
grid->GetPoints()->GetPoint(nodeIds[k + 2], c); // grid->GetPoints()->GetPoint(nodeIds[k + 2], c);
bool isFaceForward = this->isForward(a, b, c, center); // bool isFaceForward = this->isForward(a, b, c, center);
bool isFaceForward = true;
//MESSAGE("isFaceForward " << i << " " << isFaceForward); //MESSAGE("isFaceForward " << i << " " << isFaceForward);
vtkIdType *facePts = &nodeIds[k]; vtkIdType *facePts = &nodeIds[k];
if (isFaceForward) if (isFaceForward)

2
src/SMESH/SMESH_Algo.cxx
View File

@ -258,7 +258,7 @@ bool SMESH_Algo::IsReversedSubMesh (const TopoDS_Face& theFace,
fPos = dynamic_cast< const SMDS_FacePosition* >( pos ); fPos = dynamic_cast< const SMDS_FacePosition* >( pos );
} }
else if ( pos->GetTypeOfPosition() == SMDS_TOP_VERTEX ) { else if ( pos->GetTypeOfPosition() == SMDS_TOP_VERTEX ) {
vID = pos->GetShapeId(); vID = node->getshapeId();
} }
} }
if ( fPos || ( !normalOK && vID )) { if ( fPos || ( !normalOK && vID )) {

35
src/SMESH/SMESH_MeshEditor.cxx
View File

@ -278,7 +278,7 @@ bool SMESH_MeshEditor::Remove (const list< int >& theIDs,
if ( isNodes ) { if ( isNodes ) {
const SMDS_MeshNode* node = cast2Node( elem ); const SMDS_MeshNode* node = cast2Node( elem );
if ( node->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX ) if ( node->GetPosition()->GetTypeOfPosition() == SMDS_TOP_VERTEX )
if ( int aShapeID = node->GetPosition()->GetShapeId() ) if ( int aShapeID = node->getshapeId() )
if ( SMESH_subMesh * sm = GetMesh()->GetSubMeshContaining( aShapeID ) ) if ( SMESH_subMesh * sm = GetMesh()->GetSubMeshContaining( aShapeID ) )
smmap.insert( sm ); smmap.insert( sm );
} }
@ -331,22 +331,21 @@ int SMESH_MeshEditor::FindShape (const SMDS_MeshElement * theElem)
if ( aMesh->ShapeToMesh().IsNull() ) if ( aMesh->ShapeToMesh().IsNull() )
return 0; return 0;
if ( theElem->GetType() == SMDSAbs_Node ) { if ( theElem->GetType() == SMDSAbs_Node )
const SMDS_PositionPtr& aPosition = {
static_cast<const SMDS_MeshNode*>( theElem )->GetPosition(); int aShapeID = theElem->getshapeId();
if ( aPosition ) if (aShapeID <= 0)
return aPosition->GetShapeId(); return 0;
else else
return 0; return aShapeID;
} }
TopoDS_Shape aShape; // the shape a node is on TopoDS_Shape aShape; // the shape a node is on
SMDS_ElemIteratorPtr nodeIt = theElem->nodesIterator(); SMDS_ElemIteratorPtr nodeIt = theElem->nodesIterator();
while ( nodeIt->more() ) { while ( nodeIt->more() ) {
const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( nodeIt->next() ); const SMDS_MeshNode* node = static_cast<const SMDS_MeshNode*>( nodeIt->next() );
const SMDS_PositionPtr& aPosition = node->GetPosition(); int aShapeID = node->getshapeId();
if ( aPosition ) { if (aShapeID > 0) {
int aShapeID = aPosition->GetShapeId();
SMESHDS_SubMesh * sm = aMesh->MeshElements( aShapeID ); SMESHDS_SubMesh * sm = aMesh->MeshElements( aShapeID );
if ( sm ) { if ( sm ) {
if ( sm->Contains( theElem )) if ( sm->Contains( theElem ))
@ -2920,7 +2919,7 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet & theElems,
break; break;
} }
case SMDS_TOP_EDGE: { case SMDS_TOP_EDGE: {
TopoDS_Shape S = aMesh->IndexToShape( pos->GetShapeId() ); TopoDS_Shape S = aMesh->IndexToShape( node->getshapeId() );
Handle(Geom2d_Curve) pcurve; Handle(Geom2d_Curve) pcurve;
if ( !S.IsNull() && S.ShapeType() == TopAbs_EDGE ) if ( !S.IsNull() && S.ShapeType() == TopAbs_EDGE )
pcurve = BRep_Tool::CurveOnSurface( TopoDS::Edge( S ), face, f,l ); pcurve = BRep_Tool::CurveOnSurface( TopoDS::Edge( S ), face, f,l );
@ -2931,7 +2930,7 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet & theElems,
break; break;
} }
case SMDS_TOP_VERTEX: { case SMDS_TOP_VERTEX: {
TopoDS_Shape S = aMesh->IndexToShape( pos->GetShapeId() ); TopoDS_Shape S = aMesh->IndexToShape( node->getshapeId() );
if ( !S.IsNull() && S.ShapeType() == TopAbs_VERTEX ) if ( !S.IsNull() && S.ShapeType() == TopAbs_VERTEX )
uv = BRep_Tool::Parameters( TopoDS::Vertex( S ), face ).XY(); uv = BRep_Tool::Parameters( TopoDS::Vertex( S ), face ).XY();
break; break;
@ -3194,7 +3193,7 @@ void SMESH_MeshEditor::Smooth (TIDSortedElemSet & theElems,
if ( node_uv != uvMap.end() ) { if ( node_uv != uvMap.end() ) {
gp_XY* uv = node_uv->second; gp_XY* uv = node_uv->second;
node->SetPosition node->SetPosition
( SMDS_PositionPtr( new SMDS_FacePosition( *fId, uv->X(), uv->Y() ))); ( SMDS_PositionPtr( new SMDS_FacePosition( uv->X(), uv->Y() )));
} }
} }
@ -3291,6 +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);
SMESHDS_Mesh* aMesh = GetMeshDS(); SMESHDS_Mesh* aMesh = GetMeshDS();
// Loop on elem nodes: // Loop on elem nodes:
@ -4287,6 +4287,7 @@ SMESH_MeshEditor::ExtrusionSweep (TIDSortedElemSet & theElems,
const int theFlags, const int theFlags,
const double theTolerance) const double theTolerance)
{ {
MESSAGE("ExtrusionSweep " << theMakeGroups << " " << theFlags << " " << theTolerance);
myLastCreatedElems.Clear(); myLastCreatedElems.Clear();
myLastCreatedNodes.Clear(); myLastCreatedNodes.Clear();
@ -9230,9 +9231,9 @@ int SMESH_MeshEditor::removeQuadElem(SMESHDS_SubMesh * theSm,
for ( ; nIt != mediumNodes.end(); ++nIt ) { for ( ; nIt != mediumNodes.end(); ++nIt ) {
const SMDS_MeshNode* n = *nIt; const SMDS_MeshNode* n = *nIt;
if ( n->NbInverseElements() == 0 ) { if ( n->NbInverseElements() == 0 ) {
if ( n->GetPosition()->GetShapeId() != theShapeID ) if ( n->getshapeId() != theShapeID )
meshDS->RemoveFreeNode( n, meshDS->MeshElements meshDS->RemoveFreeNode( n, meshDS->MeshElements
( n->GetPosition()->GetShapeId() )); ( n->getshapeId() ));
else else
meshDS->RemoveFreeNode( n, theSm ); meshDS->RemoveFreeNode( n, theSm );
} }

40
src/SMESH/SMESH_MesherHelper.cxx
View File

@ -286,7 +286,7 @@ bool SMESH_MesherHelper::IsMedium(const SMDS_MeshNode* node,
TopoDS_Shape SMESH_MesherHelper::GetSubShapeByNode(const SMDS_MeshNode* node, TopoDS_Shape SMESH_MesherHelper::GetSubShapeByNode(const SMDS_MeshNode* node,
SMESHDS_Mesh* meshDS) SMESHDS_Mesh* meshDS)
{ {
int shapeID = node->GetPosition()->GetShapeId(); int shapeID = node->getshapeId();
if ( 0 < shapeID && shapeID <= meshDS->MaxShapeIndex() ) if ( 0 < shapeID && shapeID <= meshDS->MaxShapeIndex() )
return meshDS->IndexToShape( shapeID ); return meshDS->IndexToShape( shapeID );
else else
@ -365,7 +365,7 @@ gp_XY SMESH_MesherHelper::GetNodeUV(const TopoDS_Face& F,
// edge and retrieve value from this pcurve // edge and retrieve value from this pcurve
const SMDS_EdgePosition* epos = const SMDS_EdgePosition* epos =
static_cast<const SMDS_EdgePosition*>(n->GetPosition()); static_cast<const SMDS_EdgePosition*>(n->GetPosition());
int edgeID = Pos->GetShapeId(); int edgeID = n->getshapeId();
TopoDS_Edge E = TopoDS::Edge(GetMeshDS()->IndexToShape(edgeID)); TopoDS_Edge E = TopoDS::Edge(GetMeshDS()->IndexToShape(edgeID));
double f, l, u = epos->GetUParameter(); double f, l, u = epos->GetUParameter();
Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l); Handle(Geom2d_Curve) C2d = BRep_Tool::CurveOnSurface(E, F, f, l);
@ -400,7 +400,7 @@ gp_XY SMESH_MesherHelper::GetNodeUV(const TopoDS_Face& F,
} }
else if(Pos->GetTypeOfPosition()==SMDS_TOP_VERTEX) else if(Pos->GetTypeOfPosition()==SMDS_TOP_VERTEX)
{ {
if ( int vertexID = n->GetPosition()->GetShapeId() ) { if ( int vertexID = n->getshapeId() ) {
const TopoDS_Vertex& V = TopoDS::Vertex(GetMeshDS()->IndexToShape(vertexID)); const TopoDS_Vertex& V = TopoDS::Vertex(GetMeshDS()->IndexToShape(vertexID));
try { try {
uv = BRep_Tool::Parameters( V, F ); uv = BRep_Tool::Parameters( V, F );
@ -470,8 +470,11 @@ bool SMESH_MesherHelper::CheckNodeUV(const TopoDS_Face& F,
const double tol, const double tol,
const bool force) const const bool force) const
{ {
if ( force || !myOkNodePosShapes.count( n->GetPosition()->GetShapeId() )) if ( force || !myOkNodePosShapes.count( n->getshapeId() ))
{ {
double toldis = tol;
double tolmin = 1.e-7*myMesh->GetMeshDS()->getMaxDim(); // nodes coordinates are stored in float format
if (toldis < tolmin) toldis = tolmin;
// check that uv is correct // check that uv is correct
TopLoc_Location loc; TopLoc_Location loc;
Handle(Geom_Surface) surface = BRep_Tool::Surface( F,loc ); Handle(Geom_Surface) surface = BRep_Tool::Surface( F,loc );
@ -479,7 +482,7 @@ bool SMESH_MesherHelper::CheckNodeUV(const TopoDS_Face& F,
if ( !loc.IsIdentity() ) nodePnt.Transform( loc.Transformation().Inverted() ); if ( !loc.IsIdentity() ) nodePnt.Transform( loc.Transformation().Inverted() );
if ( Precision::IsInfinite( uv.X() ) || if ( Precision::IsInfinite( uv.X() ) ||
Precision::IsInfinite( uv.Y() ) || Precision::IsInfinite( uv.Y() ) ||
nodePnt.Distance( surface->Value( uv.X(), uv.Y() )) > tol ) nodePnt.Distance( surface->Value( uv.X(), uv.Y() )) > toldis )
{ {
// uv incorrect, project the node to surface // uv incorrect, project the node to surface
GeomAPI_ProjectPointOnSurf& projector = GetProjector( F, loc, tol ); GeomAPI_ProjectPointOnSurf& projector = GetProjector( F, loc, tol );
@ -491,7 +494,7 @@ bool SMESH_MesherHelper::CheckNodeUV(const TopoDS_Face& F,
} }
Quantity_Parameter U,V; Quantity_Parameter U,V;
projector.LowerDistanceParameters(U,V); projector.LowerDistanceParameters(U,V);
if ( nodePnt.Distance( surface->Value( U, V )) > tol ) if ( nodePnt.Distance( surface->Value( U, V )) > toldis )
{ {
MESSAGE( "SMESH_MesherHelper::CheckNodeUV(), invalid projection" ); MESSAGE( "SMESH_MesherHelper::CheckNodeUV(), invalid projection" );
return false; return false;
@ -500,7 +503,7 @@ bool SMESH_MesherHelper::CheckNodeUV(const TopoDS_Face& F,
} }
else if ( uv.Modulus() > numeric_limits<double>::min() ) else if ( uv.Modulus() > numeric_limits<double>::min() )
{ {
((SMESH_MesherHelper*) this)->myOkNodePosShapes.insert( n->GetPosition()->GetShapeId() ); ((SMESH_MesherHelper*) this)->myOkNodePosShapes.insert( n->getshapeId() );
} }
} }
return true; return true;
@ -619,7 +622,7 @@ double SMESH_MesherHelper::GetNodeU(const TopoDS_Edge& E,
else else
{ {
SMESHDS_Mesh * meshDS = GetMeshDS(); SMESHDS_Mesh * meshDS = GetMeshDS();
int vertexID = pos->GetShapeId(); int vertexID = n->getshapeId();
const TopoDS_Vertex& V = TopoDS::Vertex(meshDS->IndexToShape(vertexID)); const TopoDS_Vertex& V = TopoDS::Vertex(meshDS->IndexToShape(vertexID));
param = BRep_Tool::Parameter( V, E ); param = BRep_Tool::Parameter( V, E );
} }
@ -630,7 +633,7 @@ double SMESH_MesherHelper::GetNodeU(const TopoDS_Edge& E,
double f,l; BRep_Tool::Range( E, f,l ); double f,l; BRep_Tool::Range( E, f,l );
bool force = ( param < f-tol || param > l+tol ); bool force = ( param < f-tol || param > l+tol );
if ( !force && pos->GetTypeOfPosition()==SMDS_TOP_EDGE ) if ( !force && pos->GetTypeOfPosition()==SMDS_TOP_EDGE )
force = ( GetMeshDS()->ShapeToIndex( E ) != pos->GetShapeId() ); force = ( GetMeshDS()->ShapeToIndex( E ) != n->getshapeId() );
*check = CheckNodeU( E, n, param, tol, force ); *check = CheckNodeU( E, n, param, tol, force );
} }
@ -649,10 +652,11 @@ bool SMESH_MesherHelper::CheckNodeU(const TopoDS_Edge& E,
const double tol, const double tol,
const bool force) const const bool force) const
{ {
if ( force || !myOkNodePosShapes.count( n->GetPosition()->GetShapeId() )) if ( force || !myOkNodePosShapes.count( n->getshapeId() ))
{ {
double toldis = tol; double toldis = tol;
// TODO if (toldis < 5.e-5) toldis = 5.e-5; // nodes coordinates are stored in float format double tolmin = 1.e-7*myMesh->GetMeshDS()->getMaxDim(); // nodes coordinates are stored in float format
if (toldis < tolmin) toldis = tolmin;
// check that u is correct // check that u is correct
TopLoc_Location loc; double f,l; TopLoc_Location loc; double f,l;
Handle(Geom_Curve) curve = BRep_Tool::Curve( E,loc,f,l ); Handle(Geom_Curve) curve = BRep_Tool::Curve( E,loc,f,l );
@ -688,7 +692,7 @@ bool SMESH_MesherHelper::CheckNodeU(const TopoDS_Edge& E,
} }
else if ( fabs( u ) > numeric_limits<double>::min() ) else if ( fabs( u ) > numeric_limits<double>::min() )
{ {
((SMESH_MesherHelper*) this)->myOkNodePosShapes.insert( n->GetPosition()->GetShapeId() ); ((SMESH_MesherHelper*) this)->myOkNodePosShapes.insert( n->getshapeId() );
} }
if (( u < f-tol || u > l+tol ) && force ) if (( u < f-tol || u > l+tol ) && force )
{ {
@ -739,17 +743,17 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
if( myShape.IsNull() ) if( myShape.IsNull() )
{ {
if( Pos1->GetTypeOfPosition()==SMDS_TOP_FACE ) { if( Pos1->GetTypeOfPosition()==SMDS_TOP_FACE ) {
faceID = Pos1->GetShapeId(); faceID = n1->getshapeId();
} }
else if( Pos2->GetTypeOfPosition()==SMDS_TOP_FACE ) { else if( Pos2->GetTypeOfPosition()==SMDS_TOP_FACE ) {
faceID = Pos2->GetShapeId(); faceID = n2->getshapeId();
} }
if( Pos1->GetTypeOfPosition()==SMDS_TOP_EDGE ) { if( Pos1->GetTypeOfPosition()==SMDS_TOP_EDGE ) {
edgeID = Pos1->GetShapeId(); edgeID = n1->getshapeId();
} }
if( Pos2->GetTypeOfPosition()==SMDS_TOP_EDGE ) { if( Pos2->GetTypeOfPosition()==SMDS_TOP_EDGE ) {
edgeID = Pos2->GetShapeId(); edgeID = n2->getshapeId();
} }
} }
// get positions of the given nodes on shapes // get positions of the given nodes on shapes
@ -787,10 +791,10 @@ const SMDS_MeshNode* SMESH_MesherHelper::GetMediumNode(const SMDS_MeshNode* n1,
{ {
if ( uvOK[0] && uvOK[1] ) if ( uvOK[0] && uvOK[1] )
{ {
if ( IsDegenShape( Pos1->GetShapeId() )) if ( IsDegenShape( n1->getshapeId() ))
if ( myParIndex & U_periodic ) uv[0].SetCoord( 1, uv[1].Coord( 1 )); if ( myParIndex & U_periodic ) uv[0].SetCoord( 1, uv[1].Coord( 1 ));
else uv[0].SetCoord( 2, uv[1].Coord( 2 )); else uv[0].SetCoord( 2, uv[1].Coord( 2 ));
else if ( IsDegenShape( Pos2->GetShapeId() )) else if ( IsDegenShape( n2->getshapeId() ))
if ( myParIndex & U_periodic ) uv[1].SetCoord( 1, uv[0].Coord( 1 )); if ( myParIndex & U_periodic ) uv[1].SetCoord( 1, uv[0].Coord( 1 ));
else uv[1].SetCoord( 2, uv[0].Coord( 2 )); else uv[1].SetCoord( 2, uv[0].Coord( 2 ));

9
src/SMESH/SMESH_Pattern.cxx
View File

@ -463,8 +463,7 @@ template <class TFaceIterator> bool areNodesBound( TFaceIterator & faceItr )
while ( nIt->more() ) while ( nIt->more() )
{ {
const SMDS_MeshNode* node = smdsNode( nIt->next() ); const SMDS_MeshNode* node = smdsNode( nIt->next() );
SMDS_PositionPtr pos = node->GetPosition(); if (node->getshapeId() <0) {
if ( !pos || !pos->GetShapeId() ) {
return false; return false;
} }
} }
@ -877,7 +876,7 @@ bool SMESH_Pattern::Load (SMESH_Mesh* theMesh,
const SMDS_MeshNode* node = smdsNode( nIt->next() ); const SMDS_MeshNode* node = smdsNode( nIt->next() );
iPoint = nodePointIDMap[ node ]; // point index of interest iPoint = nodePointIDMap[ node ]; // point index of interest
// for a node on a seam edge there are two points // for a node on a seam edge there are two points
if ( helper.IsRealSeam( node->GetPosition()->GetShapeId() ) && if ( helper.IsRealSeam( node->getshapeId() ) &&
( n_id = closeNodePointIDMap.find( node )) != not_found ) ( n_id = closeNodePointIDMap.find( node )) != not_found )
{ {
TPoint & p1 = myPoints[ iPoint ]; TPoint & p1 = myPoints[ iPoint ];
@ -888,7 +887,7 @@ bool SMESH_Pattern::Load (SMESH_Mesh* theMesh,
// find node not on a seam edge // find node not on a seam edge
while ( nIt2->more() && !notSeamNode ) { while ( nIt2->more() && !notSeamNode ) {
const SMDS_MeshNode* n = smdsNode( nIt2->next() ); const SMDS_MeshNode* n = smdsNode( nIt2->next() );
if ( !helper.IsSeamShape( n->GetPosition()->GetShapeId() )) if ( !helper.IsSeamShape( n->getshapeId() ))
notSeamNode = n; notSeamNode = n;
} }
gp_Pnt2d uv = helper.GetNodeUV( theFace, node, notSeamNode ); gp_Pnt2d uv = helper.GetNodeUV( theFace, node, notSeamNode );
@ -4114,7 +4113,7 @@ void SMESH_Pattern::createElements(SMESH_Mesh* theMes
SMDS_ElemIteratorPtr noIt = elem->nodesIterator(); SMDS_ElemIteratorPtr noIt = elem->nodesIterator();
while ( noIt->more() ) { while ( noIt->more() ) {
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>(smdsNode( noIt->next() )); SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>(smdsNode( noIt->next() ));
if (!node->GetPosition()->GetShapeId() && if (!node->getshapeId() &&
shellNodes.find( node ) == shellNodes.end() ) { shellNodes.find( node ) == shellNodes.end() ) {
if ( S.ShapeType() == TopAbs_FACE ) if ( S.ShapeType() == TopAbs_FACE )
aMeshDS->SetNodeOnFace( node, shapeID ); aMeshDS->SetNodeOnFace( node, shapeID );

69
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -87,7 +87,7 @@ void SMESHDS_Mesh::ShapeToMesh(const TopoDS_Shape & S)
if ( !i_sub->second->IsComplexSubmesh() ) { if ( !i_sub->second->IsComplexSubmesh() ) {
SMDS_NodeIteratorPtr nIt = i_sub->second->GetNodes(); SMDS_NodeIteratorPtr nIt = i_sub->second->GetNodes();
while ( nIt->more() ) while ( nIt->more() )
nIt->next()->GetPosition()->SetShapeId( 0 ); i_sub->second->RemoveNode(nIt->next(), false);
} }
} }
// - sub-meshes // - sub-meshes
@ -729,7 +729,7 @@ void SMESHDS_Mesh::RemoveNode(const SMDS_MeshNode * n)
{ {
SMESHDS_SubMesh* subMesh=0; SMESHDS_SubMesh* subMesh=0;
map<int,SMESHDS_SubMesh*>::iterator SubIt = map<int,SMESHDS_SubMesh*>::iterator SubIt =
myShapeIndexToSubMesh.find( n->GetPosition()->GetShapeId() ); myShapeIndexToSubMesh.find( n->getshapeId() );
if ( SubIt != myShapeIndexToSubMesh.end() ) if ( SubIt != myShapeIndexToSubMesh.end() )
subMesh = SubIt->second; subMesh = SubIt->second;
else else
@ -919,7 +919,7 @@ SMESHDS_SubMesh* SMESHDS_Mesh::getSubmesh( const int Index )
if ( Index != myCurSubID ) { if ( Index != myCurSubID ) {
map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index ); map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
if ( it == myShapeIndexToSubMesh.end() ) if ( it == myShapeIndexToSubMesh.end() )
it = myShapeIndexToSubMesh.insert( make_pair(Index, new SMESHDS_SubMesh() )).first; it = myShapeIndexToSubMesh.insert( make_pair(Index, new SMESHDS_SubMesh(this, Index) )).first;
myCurSubMesh = it->second; myCurSubMesh = it->second;
myCurSubID = Index; myCurSubID = Index;
myCurSubShape.Nullify(); // myCurSubShape no more corresponds to submesh myCurSubShape.Nullify(); // myCurSubShape no more corresponds to submesh
@ -947,22 +947,6 @@ bool SMESHDS_Mesh::add(const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh )
return false; return false;
} }
namespace {
//================================================================================
/*!
* \brief Creates a node position in volume
*/
//================================================================================
inline SMDS_PositionPtr volumePosition(int volId)
{
SMDS_SpacePosition* pos = new SMDS_SpacePosition();
pos->SetShapeId( volId );
return SMDS_PositionPtr(pos);
}
}
//======================================================================= //=======================================================================
//function : SetNodeOnVolume //function : SetNodeOnVolume
//purpose : //purpose :
@ -971,8 +955,9 @@ void SMESHDS_Mesh::SetNodeInVolume(SMDS_MeshNode * aNode,
const TopoDS_Shell & S) const TopoDS_Shell & S)
{ {
if ( add( aNode, getSubmesh(S) )) if ( add( aNode, getSubmesh(S) ))
aNode->SetPosition ( volumePosition( myCurSubID )); aNode->SetPosition ( SMDS_SpacePosition::originSpacePosition() );
} }
//======================================================================= //=======================================================================
//function : SetNodeOnVolume //function : SetNodeOnVolume
//purpose : //purpose :
@ -981,7 +966,7 @@ void SMESHDS_Mesh::SetNodeInVolume(SMDS_MeshNode * aNode,
const TopoDS_Solid & S) const TopoDS_Solid & S)
{ {
if ( add( aNode, getSubmesh(S) )) if ( add( aNode, getSubmesh(S) ))
aNode->SetPosition ( volumePosition( myCurSubID )); aNode->SetPosition ( SMDS_SpacePosition::originSpacePosition() );
} }
//======================================================================= //=======================================================================
@ -994,7 +979,7 @@ void SMESHDS_Mesh::SetNodeOnFace(SMDS_MeshNode * aNode,
double v) double v)
{ {
if ( add( aNode, getSubmesh(S) )) if ( add( aNode, getSubmesh(S) ))
aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition(myCurSubID, u, v))); aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
} }
//======================================================================= //=======================================================================
@ -1006,7 +991,7 @@ void SMESHDS_Mesh::SetNodeOnEdge(SMDS_MeshNode * aNode,
double u) double u)
{ {
if ( add( aNode, getSubmesh(S) )) if ( add( aNode, getSubmesh(S) ))
aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(myCurSubID, u))); aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
} }
//======================================================================= //=======================================================================
@ -1017,7 +1002,7 @@ void SMESHDS_Mesh::SetNodeOnVertex(SMDS_MeshNode * aNode,
const TopoDS_Vertex & S) const TopoDS_Vertex & S)
{ {
if ( add( aNode, getSubmesh(S) )) if ( add( aNode, getSubmesh(S) ))
aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition(myCurSubID))); aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
} }
//======================================================================= //=======================================================================
@ -1026,12 +1011,13 @@ void SMESHDS_Mesh::SetNodeOnVertex(SMDS_MeshNode * aNode,
//======================================================================= //=======================================================================
void SMESHDS_Mesh::UnSetNodeOnShape(const SMDS_MeshNode* aNode) void SMESHDS_Mesh::UnSetNodeOnShape(const SMDS_MeshNode* aNode)
{ {
if ( aNode && aNode->GetPosition() ) { int shapeId = aNode->getshapeId();
map<int,SMESHDS_SubMesh*>::iterator it = if (shapeId >= 0)
myShapeIndexToSubMesh.find( aNode->GetPosition()->GetShapeId() ); {
if ( it != myShapeIndexToSubMesh.end() ) map<int, SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find(shapeId);
it->second->RemoveNode( aNode, /*deleted=*/false ); if (it != myShapeIndexToSubMesh.end())
} it->second->RemoveNode(aNode, /*deleted=*/false);
}
} }
//======================================================================= //=======================================================================
@ -1193,7 +1179,7 @@ SMESHDS_SubMesh * SMESHDS_Mesh::NewSubMesh(int Index)
TShapeIndexToSubMesh::iterator anIter = myShapeIndexToSubMesh.find(Index); TShapeIndexToSubMesh::iterator anIter = myShapeIndexToSubMesh.find(Index);
if (anIter == myShapeIndexToSubMesh.end()) if (anIter == myShapeIndexToSubMesh.end())
{ {
SM = new SMESHDS_SubMesh(); SM = new SMESHDS_SubMesh(this, Index);
myShapeIndexToSubMesh[Index]=SM; myShapeIndexToSubMesh[Index]=SM;
} }
else else
@ -1274,8 +1260,9 @@ int SMESHDS_Mesh::ShapeToIndex(const TopoDS_Shape & S) const
//======================================================================= //=======================================================================
void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode, int Index) void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode, int Index)
{ {
//add(aNode, getSubmesh(Index));
if ( add( aNode, getSubmesh( Index ))) if ( add( aNode, getSubmesh( Index )))
((SMDS_MeshNode*) aNode)->SetPosition( volumePosition( Index )); ((SMDS_MeshNode*) aNode)->SetPosition( SMDS_SpacePosition::originSpacePosition());
} }
//======================================================================= //=======================================================================
@ -1286,7 +1273,7 @@ void SMESHDS_Mesh::SetNodeOnFace(SMDS_MeshNode* aNode, int Index, double u, doub
{ {
//Set Position on Node //Set Position on Node
if ( add( aNode, getSubmesh( Index ))) if ( add( aNode, getSubmesh( Index )))
aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition(Index, u, v))); aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
} }
//======================================================================= //=======================================================================
@ -1299,7 +1286,7 @@ void SMESHDS_Mesh::SetNodeOnEdge(SMDS_MeshNode* aNode,
{ {
//Set Position on Node //Set Position on Node
if ( add( aNode, getSubmesh( Index ))) if ( add( aNode, getSubmesh( Index )))
aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(Index, u))); aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
} }
//======================================================================= //=======================================================================
@ -1310,7 +1297,7 @@ void SMESHDS_Mesh::SetNodeOnVertex(SMDS_MeshNode* aNode, int Index)
{ {
//Set Position on Node //Set Position on Node
if ( add( aNode, getSubmesh( Index ))) if ( add( aNode, getSubmesh( Index )))
aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition(Index))); aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
} }
//======================================================================= //=======================================================================
@ -1940,13 +1927,13 @@ void SMESHDS_Mesh::compactMesh()
this->myScript->SetModified(true); // notify GUI client for buildPrs when update this->myScript->SetModified(true); // notify GUI client for buildPrs when update
// ---TODO: myNodes, myElements in submeshes // --- compact list myNodes and myElements in submeshes
// map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.begin(); map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.begin();
// for(; it != myShapeIndexToSubMesh.end(); ++it) for(; it != myShapeIndexToSubMesh.end(); ++it)
// { {
// (*it).second->compactList(idNodesOldToNew, newNodeSize, idCellsOldToNew, newCellSize); (*it).second->compactList();
// } }
} }

2
src/SMESHDS/SMESHDS_Mesh.hxx
View File

@ -453,7 +453,7 @@ private:
//Update or build submesh //Update or build submesh
std::map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index ); std::map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
if ( it == myShapeIndexToSubMesh.end() ) if ( it == myShapeIndexToSubMesh.end() )
it = myShapeIndexToSubMesh.insert( std::make_pair(Index, new SMESHDS_SubMesh() )).first; it = myShapeIndexToSubMesh.insert( std::make_pair(Index, new SMESHDS_SubMesh(this, Index) )).first;
it->second->AddNode( aNode ); // add aNode to submesh it->second->AddNode( aNode ); // add aNode to submesh
} }

195
src/SMESHDS/SMESHDS_SubMesh.cxx
View File

@ -27,6 +27,7 @@
// $Header: // $Header:
// //
#include "SMESHDS_SubMesh.hxx" #include "SMESHDS_SubMesh.hxx"
#include "SMESHDS_Mesh.hxx"
#include "utilities.h" #include "utilities.h"
#include "SMDS_SetIterator.hxx" #include "SMDS_SetIterator.hxx"
@ -35,10 +36,12 @@
using namespace std; using namespace std;
SMESHDS_SubMesh::SMESHDS_SubMesh() SMESHDS_SubMesh::SMESHDS_SubMesh(SMESHDS_Mesh *parent, int index)
{ {
myParent = parent;
myElements.clear(); myElements.clear();
myNodes.clear(); myNodes.clear();
myIndex = index;
myUnusedIdNodes = 0; myUnusedIdNodes = 0;
myUnusedIdElements = 0; myUnusedIdElements = 0;
} }
@ -59,6 +62,7 @@ void SMESHDS_SubMesh::AddElement(const SMDS_MeshElement * ME)
throw SALOME_Exception(LOCALIZED("add element in subshape already belonging to a subshape")); throw SALOME_Exception(LOCALIZED("add element in subshape already belonging to a subshape"));
} }
SMDS_MeshElement* elem = (SMDS_MeshElement*) (ME); SMDS_MeshElement* elem = (SMDS_MeshElement*) (ME);
elem->setShapeId(myIndex);
elem->setIdInShape(myElements.size()); elem->setIdInShape(myElements.size());
myElements.push_back(ME); myElements.push_back(ME);
} }
@ -70,30 +74,26 @@ void SMESHDS_SubMesh::AddElement(const SMDS_MeshElement * ME)
//======================================================================= //=======================================================================
bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME, bool isElemDeleted) bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME, bool isElemDeleted)
{ {
// MESSAGE("--------------------------------------> RemoveElement " << isElemDeleted); // MESSAGE("--------------------------------------> RemoveElement " << isElemDeleted);
// if ( !IsComplexSubmesh() && NbElements() ) { if (!IsComplexSubmesh())
{
if (!isElemDeleted) // alive element has valid ID and can be found if (!isElemDeleted) // alive element has valid ID and can be found
{ {
int idInSubShape = ME->getIdInShape(); int idInSubShape = ME->getIdInShape();
//MESSAGE("SMESHDS_SubMesh::RemoveElement " << idInSubShape << " " << ME->GetID() << " " << myUnusedIdElements); //MESSAGE("SMESHDS_SubMesh::RemoveElement " << idInSubShape << " " << ME->GetID() << " " << myUnusedIdElements);
assert(idInSubShape >= 0); assert(idInSubShape >= 0);
assert(idInSubShape < myElements.size()); assert(idInSubShape < myElements.size());
myElements[idInSubShape] = 0; // this vector entry is no more used SMDS_MeshElement* elem = (SMDS_MeshElement*) (ME);
myUnusedIdElements++; elem->setShapeId(0);
return true; elem->setIdInShape(-1);
} myElements[idInSubShape] = 0; // this vector entry is no more used
myUnusedIdElements++;
return true;
// --- strange ? }
// TElemSet::iterator e = myElements.begin(), eEnd = myElements.end(); MESSAGE("Try to remove an already deleted element from a submesh ");
// for ( ; e != eEnd; ++e ) return false;
// if ( ME == *e ) { }
// myElements.erase( e ); MESSAGE("Try to remove an element from a complex submesh ");
// return true;
// }
// }
return false; return false;
} }
@ -106,11 +106,19 @@ void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
if ( !IsComplexSubmesh() ) if ( !IsComplexSubmesh() )
{ {
int idInSubShape = N->getIdInShape(); int idInSubShape = N->getIdInShape();
assert(idInSubShape == -1); int shapeId = N->getshapeId();
if ((shapeId > 0) && (idInSubShape >= 0))
{
MESSAGE("========== AddNode already belonging to other subShape " << N->GetID());
// OK for vertex nodes
//this->getParent()->UnSetNodeOnShape(N);
}
SMDS_MeshNode* node = (SMDS_MeshNode*)(N); SMDS_MeshNode* node = (SMDS_MeshNode*)(N);
node->setShapeId(myIndex);
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());
} }
//======================================================================= //=======================================================================
@ -120,28 +128,26 @@ void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N, bool isNodeDeleted) bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N, bool isNodeDeleted)
{ {
// if ( !IsComplexSubmesh() && NbNodes() ) { if (!IsComplexSubmesh())
{
if (!isNodeDeleted) // alive node has valid ID and can be found if (!isNodeDeleted) // alive node has valid ID and can be found
{ {
int idInSubShape = N->getIdInShape(); int idInSubShape = N->getIdInShape();
//MESSAGE("SMESHDS_SubMesh::RemoveNode " << idInSubShape << " " << N->GetID()); int shapeId = N->getshapeId();
assert(idInSubShape >= 0); MESSAGE("SMESHDS_SubMesh::RemoveNode " << shapeId << " " << idInSubShape << " " << N->GetID());
assert(idInSubShape < myNodes.size()); //assert(idInSubShape >= 0);
myNodes[idInSubShape] = 0; // this vector entry is no more used //assert(idInSubShape < myNodes.size());
myUnusedIdNodes++; SMDS_MeshNode* node = (SMDS_MeshNode*) (N);
return true; node->setShapeId(0);
} node->setIdInShape(-1);
myNodes[idInSubShape] = 0; // this vector entry is no more used
// --- strange ? myUnusedIdNodes++;
// TElemSet::iterator e = myNodes.begin(), eEnd = myNodes.end(); return true;
// for ( ; e != eEnd; ++e ) }
// if ( N == *e ) { MESSAGE("Try to remove an already deleted node from a submesh");
// myNodes.erase( e ); return false;
// return true; }
// } MESSAGE("Try to remove a node from a complex submesh");
// }
return false; return false;
} }
@ -151,6 +157,7 @@ bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N, bool isNodeDeleted)
//======================================================================= //=======================================================================
int SMESHDS_SubMesh::NbElements() const int SMESHDS_SubMesh::NbElements() const
{ {
//MESSAGE(this << " NbElements " << IsComplexSubmesh() << " " << myElements.size() - myUnusedIdElements);
if ( !IsComplexSubmesh() ) if ( !IsComplexSubmesh() )
return myElements.size() - myUnusedIdElements; return myElements.size() - myUnusedIdElements;
@ -169,8 +176,9 @@ int SMESHDS_SubMesh::NbElements() const
int SMESHDS_SubMesh::NbNodes() const int SMESHDS_SubMesh::NbNodes() const
{ {
if ( !IsComplexSubmesh() ) //MESSAGE(this << " NbNodes " << IsComplexSubmesh() << " " << myNodes.size() - myUnusedIdNodes);
return myNodes.size() - myUnusedIdNodes; if ( !IsComplexSubmesh() )
return myNodes.size() - myUnusedIdNodes;
int nbElems = 0; int nbElems = 0;
set<const SMESHDS_SubMesh*>::const_iterator it = mySubMeshes.begin(); set<const SMESHDS_SubMesh*>::const_iterator it = mySubMeshes.begin();
@ -192,41 +200,28 @@ template <class ELEM, typename TSET> class MySetIterator : public SMDS_Iterator<
protected: protected:
typename TSET::const_iterator _it, _end; typename TSET::const_iterator _it, _end;
TSET _table; TSET _table;
// int _ind;
public: public:
MySetIterator(const TSET& table) MySetIterator(const TSET& table)
// : _it(table.begin()), _end(table.end())
{ {
// MESSAGE("table.size()="<< table.size()); _table = table;
_table = table; _it = _table.begin();
_it = _table.begin(); _end = _table.end();
_end = _table.end(); while ((_it != _end) && (*_it == 0))
// for (int i=0; i< _table.size(); i++) _it++;
// if (_table[i]) { MESSAGE("_table["<< i << "]="<< _table[i]);}
// else
// { MESSAGE("_table["<< i << "]=NULL"); }
// _ind = 0;
} }
virtual bool more() virtual bool more()
{ {
while((_it != _end) && (*_it == 0)) while ((_it != _end) && (*_it == 0))
{
_it++; _it++;
// _ind++;
}
// MESSAGE("more _ind=" << _ind);
return (_it != _end); return (_it != _end);
} }
virtual ELEM next() virtual ELEM next()
{ {
ELEM e=*_it; ELEM e = *_it;
// if (e) { MESSAGE("next _ind=" << _ind << " *_it=" << *_it);} _it++;
// else { MESSAGE("next _ind=" << _ind << " *_it=NULL");} return e;
// _ind++;
_it++;
return e;
} }
}; };
@ -327,31 +322,33 @@ bool SMESHDS_SubMesh::Contains(const SMDS_MeshElement * ME) const
{ {
// DO NOT TRY TO FIND A REMOVED ELEMENT !! // DO NOT TRY TO FIND A REMOVED ELEMENT !!
//if ( IsComplexSubmesh() || !ME ) //if ( IsComplexSubmesh() || !ME )
if (!ME ) if (!ME)
return false; return false;
if ( IsComplexSubmesh() ) if (IsComplexSubmesh())
{ {
set<const SMESHDS_SubMesh*>::const_iterator aSubIt = mySubMeshes.begin(); set<const SMESHDS_SubMesh*>::const_iterator aSubIt = mySubMeshes.begin();
for ( ; aSubIt != mySubMeshes.end(); aSubIt++ ) for (; aSubIt != mySubMeshes.end(); aSubIt++)
if ( (*aSubIt)->Contains( ME )) if ((*aSubIt)->Contains(ME))
return true; return true;
return false; return false;
} }
if ( ME->GetType() == SMDSAbs_Node ) if (ME->GetType() == SMDSAbs_Node)
{ {
int idInShape = ME->getIdInShape(); int idInShape = ME->getIdInShape();
if ((idInShape >= 0) && (idInShape < myNodes.size())) if ((idInShape >= 0) && (idInShape < myNodes.size()))
if (myNodes[idInShape] == ME) return true; if (myNodes[idInShape] == ME)
return true;
} }
else else
{ {
int idInShape = ME->getIdInShape(); int idInShape = ME->getIdInShape();
if ((idInShape >= 0) && (idInShape < myElements.size())) if ((idInShape >= 0) && (idInShape < myElements.size()))
if (myElements[idInShape] == ME) return true; if (myElements[idInShape] == ME)
return true;
} }
return false; return false;
} }
//======================================================================= //=======================================================================
@ -407,6 +404,8 @@ void SMESHDS_SubMesh::Clear()
{ {
myElements.clear(); myElements.clear();
myNodes.clear(); myNodes.clear();
myUnusedIdNodes = 0;
myUnusedIdElements = 0;
SMESHDS_SubMeshIteratorPtr sub = GetSubMeshIterator(); SMESHDS_SubMeshIteratorPtr sub = GetSubMeshIterator();
while ( sub->more() ) { while ( sub->more() ) {
if ( SMESHDS_SubMesh* sm = (SMESHDS_SubMesh*) sub->next()) if ( SMESHDS_SubMesh* sm = (SMESHDS_SubMesh*) sub->next())
@ -425,5 +424,29 @@ int SMESHDS_SubMesh::getSize()
void SMESHDS_SubMesh::compactList() void SMESHDS_SubMesh::compactList()
{ {
// todo : compact vector of nodes and elements MESSAGE("compactList old: nodes " << myNodes.size() << " elements " << myElements.size());
std::vector<const SMDS_MeshElement*> newElems;
newElems.clear();
for (int i = 0; i < myElements.size(); i++)
if (myElements[i])
{
SMDS_MeshElement* elem = (SMDS_MeshElement*)myElements[i];
elem->setIdInShape(newElems.size());
newElems.push_back(elem);
}
myElements.swap(newElems);
myUnusedIdElements = 0;
std::vector<const SMDS_MeshNode*> newNodes;
newNodes.clear();
for (int i = 0; i < myNodes.size(); i++)
if (myNodes[i])
{
SMDS_MeshNode* node = (SMDS_MeshNode*)myNodes[i];
node->setIdInShape(newNodes.size());
newNodes.push_back(node);
}
myNodes.swap(newNodes);
myUnusedIdNodes = 0;
//MESSAGE("compactList new: nodes " << myNodes.size() << " elements " << myElements.size());
} }

9
src/SMESHDS/SMESHDS_SubMesh.hxx
View File

@ -37,10 +37,12 @@ class SMESHDS_SubMesh;
typedef SMDS_Iterator<const SMESHDS_SubMesh*> SMESHDS_SubMeshIterator; typedef SMDS_Iterator<const SMESHDS_SubMesh*> SMESHDS_SubMeshIterator;
typedef boost::shared_ptr< SMESHDS_SubMeshIterator > SMESHDS_SubMeshIteratorPtr; typedef boost::shared_ptr< SMESHDS_SubMeshIterator > SMESHDS_SubMeshIteratorPtr;
class SMESHDS_Mesh;
class SMESHDS_EXPORT SMESHDS_SubMesh class SMESHDS_EXPORT SMESHDS_SubMesh
{ {
public: public:
SMESHDS_SubMesh(); SMESHDS_SubMesh(SMESHDS_Mesh *parent, int index);
bool IsComplexSubmesh() const { return !mySubMeshes.empty(); } bool IsComplexSubmesh() const { return !mySubMeshes.empty(); }
@ -69,13 +71,16 @@ class SMESHDS_EXPORT SMESHDS_SubMesh
int getSize(); int getSize();
void compactList(); void compactList();
private: inline SMESHDS_Mesh *getParent() {return myParent; };
private:
SMESHDS_Mesh * myParent;
std::vector<const SMDS_MeshElement*> myElements; std::vector<const SMDS_MeshElement*> myElements;
std::vector<const SMDS_MeshNode*> myNodes; std::vector<const SMDS_MeshNode*> myNodes;
int myUnusedIdNodes; int myUnusedIdNodes;
int myUnusedIdElements; int myUnusedIdElements;
int myIndex;
std::set<const SMESHDS_SubMesh*> mySubMeshes; std::set<const SMESHDS_SubMesh*> mySubMeshes;
}; };

1
src/SMESH_I/SMESH_Gen_i.cxx
View File

@ -4004,7 +4004,6 @@ bool SMESH_Gen_i::Load( SALOMEDS::SComponent_ptr theComponent,
// add // add
if ( isNode ) { if ( isNode ) {
SMDS_PositionPtr pos = aPositionCreator.MakePosition( smType[ smID ]); SMDS_PositionPtr pos = aPositionCreator.MakePosition( smType[ smID ]);
pos->SetShapeId( smID );
SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( static_cast<const SMDS_MeshNode*>( elem )); SMDS_MeshNode* node = const_cast<SMDS_MeshNode*>( static_cast<const SMDS_MeshNode*>( elem ));
node->SetPosition( pos ); node->SetPosition( pos );
sm->AddNode( node ); sm->AddNode( node );

8
src/SMESH_I/SMESH_Mesh_i.cxx
View File

@ -2985,7 +2985,7 @@ SMESH::NodePosition* SMESH_Mesh_i::GetNodePosition(CORBA::Long NodeID)
{ {
if ( SMDS_PositionPtr pos = aNode->GetPosition() ) if ( SMDS_PositionPtr pos = aNode->GetPosition() )
{ {
aNodePosition->shapeID = pos->GetShapeId(); aNodePosition->shapeID = aNode->getshapeId();
switch ( pos->GetTypeOfPosition() ) { switch ( pos->GetTypeOfPosition() ) {
case SMDS_TOP_EDGE: case SMDS_TOP_EDGE:
aNodePosition->shapeType = GEOM::EDGE; aNodePosition->shapeType = GEOM::EDGE;
@ -3033,11 +3033,7 @@ CORBA::Long SMESH_Mesh_i::GetShapeID(const CORBA::Long id)
// try to find node // try to find node
const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id); const SMDS_MeshNode* aNode = aSMESHDS_Mesh->FindNode(id);
if(aNode) { if(aNode) {
SMDS_PositionPtr pos = aNode->GetPosition(); return aNode->getshapeId();
if(!pos)
return -1;
else
return pos->GetShapeId();
} }
return -1; return -1;

6
src/StdMeshers/StdMeshers_MEFISTO_2D.cxx
View File

@ -613,9 +613,9 @@ bool StdMeshers_MEFISTO_2D::LoadPoints(TWireVector & wires,
case SMDS_TOP_EDGE: case SMDS_TOP_EDGE:
// In order to detect degenerated faces easily, we replace // In order to detect degenerated faces easily, we replace
// nodes on a degenerated edge by node on the vertex of that edge // nodes on a degenerated edge by node on the vertex of that edge
if ( myTool->IsDegenShape( uvPt->node->GetPosition()->GetShapeId() )) if ( myTool->IsDegenShape( uvPt->node->getshapeId() ))
{ {
int edgeID = uvPt->node->GetPosition()->GetShapeId(); int edgeID = uvPt->node->getshapeId();
SMESH_subMesh* edgeSM = myTool->GetMesh()->GetSubMeshContaining( edgeID ); SMESH_subMesh* edgeSM = myTool->GetMesh()->GetSubMeshContaining( edgeID );
SMESH_subMeshIteratorPtr smIt = edgeSM->getDependsOnIterator( /*includeSelf=*/0, SMESH_subMeshIteratorPtr smIt = edgeSM->getDependsOnIterator( /*includeSelf=*/0,
/*complexShapeFirst=*/0); /*complexShapeFirst=*/0);
@ -640,7 +640,7 @@ bool StdMeshers_MEFISTO_2D::LoadPoints(TWireVector & wires,
int m = *mIt; int m = *mIt;
if ( iW && !VWMap.IsEmpty()) { // except outer wire if ( iW && !VWMap.IsEmpty()) { // except outer wire
// avoid passing same uv point for a vertex common to 2 wires // avoid passing same uv point for a vertex common to 2 wires
int vID = mefistoToDS[m]->GetPosition()->GetShapeId(); int vID = mefistoToDS[m]->getshapeId();
TopoDS_Vertex V = TopoDS::Vertex( myTool->GetMeshDS()->IndexToShape( vID )); TopoDS_Vertex V = TopoDS::Vertex( myTool->GetMeshDS()->IndexToShape( vID ));
if ( fixCommonVertexUV( uvslf[m], V, F, VWMap, *myTool->GetMesh(), if ( fixCommonVertexUV( uvslf[m], V, F, VWMap, *myTool->GetMesh(),
scalex, scaley, _quadraticMesh )) { scalex, scaley, _quadraticMesh )) {

15
src/StdMeshers/StdMeshers_Prism_3D.cxx
View File

@ -478,7 +478,7 @@ bool StdMeshers_Prism_3D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape& theSh
if ( !myBlock.ComputeParameters( topCoords, topParams, ID_TOP_FACE, topParams )) if ( !myBlock.ComputeParameters( topCoords, topParams, ID_TOP_FACE, topParams ))
return error(TCom("Can't compute normalized parameters ") return error(TCom("Can't compute normalized parameters ")
<< "for node " << column.back()->GetID() << "for node " << column.back()->GetID()
<< " on the face #"<< column.back()->GetPosition()->GetShapeId() ); << " on the face #"<< column.back()->getshapeId() );
} }
// vertical loop // vertical loop
@ -806,6 +806,8 @@ bool StdMeshers_Prism_3D::assocOrProjBottom2Top()
botSMDS->NbElements() != topSMDS->NbElements() || botSMDS->NbElements() != topSMDS->NbElements() ||
botSMDS->NbNodes() != topSMDS->NbNodes()) botSMDS->NbNodes() != topSMDS->NbNodes())
{ {
MESSAGE("nb elem bot " << botSMDS->NbElements() << " top " << topSMDS->NbElements());
MESSAGE("nb node bot " << botSMDS->NbNodes() << " top " << topSMDS->NbNodes());
if ( myBlock.HasNotQuadElemOnTop() ) if ( myBlock.HasNotQuadElemOnTop() )
return error(TCom("Mesh on faces #") << botSM->GetId() return error(TCom("Mesh on faces #") << botSM->GetId()
<<" and #"<< topSM->GetId() << " seems different" ); <<" and #"<< topSM->GetId() << " seems different" );
@ -1208,6 +1210,7 @@ bool StdMeshers_PrismAsBlock::Init(SMESH_MesherHelper* helper,
} }
myNotQuadOnTop = ( nbNotQuadMeshed > 1 ); myNotQuadOnTop = ( nbNotQuadMeshed > 1 );
MESSAGE("myNotQuadOnTop " << myNotQuadOnTop << " nbNotQuadMeshed " << nbNotQuadMeshed);
// ---------------------------------------------------------- // ----------------------------------------------------------
@ -1364,11 +1367,11 @@ bool StdMeshers_PrismAsBlock::Init(SMESH_MesherHelper* helper,
// columns for vertices // columns for vertices
// 1 // 1
const SMDS_MeshNode* n0 = faceColumns.begin()->second.front(); const SMDS_MeshNode* n0 = faceColumns.begin()->second.front();
id = n0->GetPosition()->GetShapeId(); id = n0->getshapeId();
myShapeIndex2ColumnMap[ id ] = make_pair( & faceColumns, isForward ); myShapeIndex2ColumnMap[ id ] = make_pair( & faceColumns, isForward );
// 2 // 2
const SMDS_MeshNode* n1 = faceColumns.rbegin()->second.front(); const SMDS_MeshNode* n1 = faceColumns.rbegin()->second.front();
id = n1->GetPosition()->GetShapeId(); id = n1->getshapeId();
myShapeIndex2ColumnMap[ id ] = make_pair( & faceColumns, isForward ); myShapeIndex2ColumnMap[ id ] = make_pair( & faceColumns, isForward );
// SHOWYXZ("\np1 F "<<iE, gpXYZ(faceColumns.begin()->second.front() )); // SHOWYXZ("\np1 F "<<iE, gpXYZ(faceColumns.begin()->second.front() ));
// SHOWYXZ("p2 F "<<iE, gpXYZ(faceColumns.rbegin()->second.front() )); // SHOWYXZ("p2 F "<<iE, gpXYZ(faceColumns.rbegin()->second.front() ));
@ -1578,11 +1581,11 @@ bool StdMeshers_PrismAsBlock::Init(SMESH_MesherHelper* helper,
// columns for vertices // columns for vertices
const SMDS_MeshNode* n0 = cols->begin()->second.front(); const SMDS_MeshNode* n0 = cols->begin()->second.front();
id = n0->GetPosition()->GetShapeId(); id = n0->getshapeId();
myShapeIndex2ColumnMap[ id ] = make_pair( cols, isForward ); myShapeIndex2ColumnMap[ id ] = make_pair( cols, isForward );
const SMDS_MeshNode* n1 = cols->rbegin()->second.front(); const SMDS_MeshNode* n1 = cols->rbegin()->second.front();
id = n1->GetPosition()->GetShapeId(); id = n1->getshapeId();
myShapeIndex2ColumnMap[ id ] = make_pair( cols, !isForward ); myShapeIndex2ColumnMap[ id ] = make_pair( cols, !isForward );
} }
} }
@ -1609,7 +1612,7 @@ bool StdMeshers_PrismAsBlock::Init(SMESH_MesherHelper* helper,
const TNodeColumn* StdMeshers_PrismAsBlock::GetNodeColumn(const SMDS_MeshNode* node) const const TNodeColumn* StdMeshers_PrismAsBlock::GetNodeColumn(const SMDS_MeshNode* node) const
{ {
int sID = node->GetPosition()->GetShapeId(); int sID = node->getshapeId();
map<int, pair< TParam2ColumnMap*, bool > >::const_iterator col_frw = map<int, pair< TParam2ColumnMap*, bool > >::const_iterator col_frw =
myShapeIndex2ColumnMap.find( sID ); myShapeIndex2ColumnMap.find( sID );

2
src/StdMeshers/StdMeshers_ProjectionUtils.cxx
View File

@ -1645,7 +1645,7 @@ FindMatchingNodesOnFaces( const TopoDS_Face& face1,
const SMDS_MeshElement* f = ( iF ? f2 : f1 ); const SMDS_MeshElement* f = ( iF ? f2 : f1 );
for ( int i = 0; !notSeamNode[ iF ] && i < f->NbNodes(); ++i ) { for ( int i = 0; !notSeamNode[ iF ] && i < f->NbNodes(); ++i ) {
const SMDS_MeshNode* node = f->GetNode( i ); const SMDS_MeshNode* node = f->GetNode( i );
if ( !helper->IsSeamShape( node->GetPosition()->GetShapeId() )) if ( !helper->IsSeamShape( node->getshapeId() ))
notSeamNode[ iF ] = node; notSeamNode[ iF ] = node;
} }
} }

32
src/StdMeshers/StdMeshers_Projection_2D.cxx
View File

@ -375,7 +375,7 @@ namespace {
const TAssocTool::TShapeShapeMap& shape2ShapeMap) const TAssocTool::TShapeShapeMap& shape2ShapeMap)
{ {
MESSAGE("projectPartner"); MESSAGE("projectPartner");
const double tol = 1e-6; const double tol = 1.e-7*srcMesh->GetMeshDS()->getMaxDim();
gp_Trsf trsf; // transformation to get location of target nodes from source ones gp_Trsf trsf; // transformation to get location of target nodes from source ones
if ( tgtFace.IsPartner( srcFace )) if ( tgtFace.IsPartner( srcFace ))
@ -407,13 +407,13 @@ namespace {
{ {
case 0: pOK = true; break; case 0: pOK = true; break;
case 1: pOK = ( srcPP[0].SquareDistance( p ) > tol ); break; case 1: pOK = ( srcPP[0].SquareDistance( p ) > 10*tol ); break;
case 2: case 2:
{ {
gp_Vec p0p1( srcPP[0], srcPP[1] ), p0p( srcPP[0], p ); gp_Vec p0p1( srcPP[0], srcPP[1] ), p0p( srcPP[0], p );
pOK = !p0p1.IsParallel( p0p, tol ); // pOK = !p0p1.IsParallel( p0p, tol );
// TODO angle pOK = !p0p1.IsParallel( p0p, 3.14/6 ); pOK = !p0p1.IsParallel( p0p, 3.14/20 ); // angle min 18 degrees
break; break;
} }
} }
@ -436,6 +436,7 @@ namespace {
{ {
double srcDist = srcPP[0].Distance( p ); double srcDist = srcPP[0].Distance( p );
double eTol = BRep_Tool::Tolerance( TopoDS::Edge( tgtShape )); double eTol = BRep_Tool::Tolerance( TopoDS::Edge( tgtShape ));
if (eTol < tol) eTol = tol;
SMDS_NodeIteratorPtr nItT = tgtSmds->GetNodes(); SMDS_NodeIteratorPtr nItT = tgtSmds->GetNodes();
while ( nItT->more() && !pOK ) while ( nItT->more() && !pOK )
{ {
@ -492,7 +493,7 @@ namespace {
if ( !tgtEdge.IsPartner( srcEdge.Current() )) if ( !tgtEdge.IsPartner( srcEdge.Current() ))
{ {
// check that transormation is OK by three nodes // check that transformation is OK by three nodes
gp_Pnt p0S = SMESH_MeshEditor::TNodeXYZ( (srcNodes.begin()) ->second); gp_Pnt p0S = SMESH_MeshEditor::TNodeXYZ( (srcNodes.begin()) ->second);
gp_Pnt p1S = SMESH_MeshEditor::TNodeXYZ( (srcNodes.rbegin()) ->second); gp_Pnt p1S = SMESH_MeshEditor::TNodeXYZ( (srcNodes.rbegin()) ->second);
gp_Pnt p2S = SMESH_MeshEditor::TNodeXYZ( (++srcNodes.begin())->second); gp_Pnt p2S = SMESH_MeshEditor::TNodeXYZ( (++srcNodes.begin())->second);
@ -501,7 +502,7 @@ namespace {
gp_Pnt p1T = SMESH_MeshEditor::TNodeXYZ( (tgtNodes.rbegin()) ->second); gp_Pnt p1T = SMESH_MeshEditor::TNodeXYZ( (tgtNodes.rbegin()) ->second);
gp_Pnt p2T = SMESH_MeshEditor::TNodeXYZ( (++tgtNodes.begin())->second); gp_Pnt p2T = SMESH_MeshEditor::TNodeXYZ( (++tgtNodes.begin())->second);
// transform source points, they must coinside with target ones // transform source points, they must coincide with target ones
if ( p0T.SquareDistance( p0S.Transformed( trsf )) > tol || if ( p0T.SquareDistance( p0S.Transformed( trsf )) > tol ||
p1T.SquareDistance( p1S.Transformed( trsf )) > tol || p1T.SquareDistance( p1S.Transformed( trsf )) > tol ||
p2T.SquareDistance( p2S.Transformed( trsf )) > tol ) p2T.SquareDistance( p2S.Transformed( trsf )) > tol )
@ -524,6 +525,7 @@ namespace {
// prepare the helper adding quadratic elements if necessary // prepare the helper adding quadratic elements if necessary
SMESH_MesherHelper helper( *tgtMesh ); SMESH_MesherHelper helper( *tgtMesh );
helper.SetSubShape( tgtFace );
helper.IsQuadraticSubMesh( tgtFace ); helper.IsQuadraticSubMesh( tgtFace );
helper.SetElementsOnShape( true ); helper.SetElementsOnShape( true );
@ -540,6 +542,8 @@ namespace {
while ( nodeIt->more() ) // loop on nodes of the source element while ( nodeIt->more() ) // loop on nodes of the source element
{ {
const SMDS_MeshNode* srcNode = (const SMDS_MeshNode*) nodeIt->next(); const SMDS_MeshNode* srcNode = (const SMDS_MeshNode*) nodeIt->next();
if (elem->IsMediumNode(srcNode))
continue;
srcN_tgtN = src2tgtNodes.insert( make_pair( srcNode, nullNode )).first; srcN_tgtN = src2tgtNodes.insert( make_pair( srcNode, nullNode )).first;
if ( srcN_tgtN->second == nullNode ) if ( srcN_tgtN->second == nullNode )
{ {
@ -551,10 +555,18 @@ namespace {
tgtFaceNodes.push_back( srcN_tgtN->second ); tgtFaceNodes.push_back( srcN_tgtN->second );
} }
// create a new face (with reversed orientation) // create a new face (with reversed orientation)
if ( tgtFaceNodes.size() == 3 ) //MESSAGE("tgtFaceNodes.size() " << tgtFaceNodes.size());
helper.AddFace( tgtFaceNodes[0],tgtFaceNodes[2],tgtFaceNodes[1]); switch (tgtFaceNodes.size())
else {
helper.AddFace( tgtFaceNodes[0],tgtFaceNodes[3],tgtFaceNodes[2],tgtFaceNodes[1]); case 3:
case 6:
helper.AddFace(tgtFaceNodes[0], tgtFaceNodes[2], tgtFaceNodes[1]);
break;
case 4:
case 8:
helper.AddFace(tgtFaceNodes[0], tgtFaceNodes[3], tgtFaceNodes[2], tgtFaceNodes[1]);
break;
}
} }
return true; return true;
} }