ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2025-03-15 23:41:27 +05:00
Code Issues Packages Projects Releases Wiki Activity

0021543: EDF 1978 SMESH: Viscous layer for 2D meshes

Browse Source 
Derive SMESH_Octree from a template SMESH_Tree
This commit is contained in:
eap 2012-10-15 14:30:14 +00:00
parent 8ab8fbfb50
commit cf56ad7e8d
4 changed files with 68 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

158
src/SMESHUtils/SMESH_Octree.cxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// SMESH SMESH_Octree : global Octree implementation // SMESH SMESH_Octree : Octree implementation
// File : SMESH_Octree.cxx // File : SMESH_Octree.cxx
// Created : Tue Jan 16 16:00:00 2007 // Created : Tue Jan 16 16:00:00 2007
// Author : Nicolas Geimer & Aurélien Motteux(OCC) // Author : Nicolas Geimer & Aurélien Motteux(OCC)
@ -35,136 +35,28 @@
*/ */
//=========================================================================== //===========================================================================
SMESH_Octree::SMESH_Octree (SMESH_Octree::Limit* limit): SMESH_Octree::SMESH_Octree (SMESH_TreeLimit* limit): TBaseTree( limit )
myChildren(NULL),
myFather(NULL),
myIsLeaf( false ),
myLimit( limit ),
myLevel(0),
myBox(NULL)
{ {
} }
//================================================================================
/*!
* \brief Compute the Octree
*/
//================================================================================
void SMESH_Octree::compute()
{
if ( myLevel==0 )
{
myBox = buildRootBox();
if ( myLimit->myMinBoxSize > 0. && maxSize() <= myLimit->myMinBoxSize )
myIsLeaf = true;
else
buildChildren();
}
}
//======================================
/*!
* \brief SMESH_Octree Destructor
*/
//======================================
SMESH_Octree::~SMESH_Octree ()
{
if(myChildren != NULL)
{
if(!isLeaf())
{
for(int i = 0; i<8; i++)
delete myChildren[i];
delete[] myChildren;
myChildren = 0;
}
}
if ( myBox )
delete myBox;
myBox = 0;
if ( level() == 0 )
delete myLimit;
myLimit = 0;
}
//================================================================= //=================================================================
/*! /*!
* \brief Build the 8 children boxes and call buildChildrenData() * \brief Allocate a bndbox according to childIndex. childIndex is zero based
*/ */
//================================================================= //=================================================================
void SMESH_Octree::buildChildren() Bnd_B3d* SMESH_Octree::newChildBox(int childIndex) const
{ {
if ( isLeaf() ) return; gp_XYZ min = getBox()->CornerMin();
gp_XYZ max = getBox()->CornerMax();
myChildren = new SMESH_Octree*[8];
gp_XYZ min = myBox->CornerMin();
gp_XYZ max = myBox->CornerMax();
gp_XYZ HSize = (max - min)/2.; gp_XYZ HSize = (max - min)/2.;
gp_XYZ mid = min + HSize;
gp_XYZ childHsize = HSize/2.; gp_XYZ childHsize = HSize/2.;
// get the whole model size gp_XYZ minChild( min.X() + childIndex%2 * HSize.X(),
double rootSize = 0; min.Y() + (childIndex%4)/2 * HSize.Y(),
{ min.Z() + ( childIndex>=4 ) * HSize.Z());
SMESH_Octree* root = this;
while ( root->myLevel > 0 )
root = root->myFather;
rootSize = root->maxSize();
}
Standard_Real XminChild, YminChild, ZminChild;
gp_XYZ minChild;
for (int i = 0; i < 8; i++)
{
// We build the eight boxes, we need 2 points to do that:
// Min and Mid
// In binary, we can write i from 0 to 7
// For instance :
// 5 is 101, it corresponds here in coordinates to ZYX
// If coordinate is 0 in Y-> box from Ymin to Ymid
// If coordinate is 1 in Y-> box from Ymid to Ymax
// Same scheme for X and Z
// I need the minChild to build the Bnd_B3d box.
XminChild = (i%2==0)?min.X():mid.X(); return new Bnd_B3d(minChild+childHsize,childHsize);
YminChild = ((i%4)/2==0)?min.Y():mid.Y();
ZminChild = (i<4)?min.Z():mid.Z();
minChild.SetCoord(XminChild, YminChild, ZminChild);
// The child is of the same type than its father (For instance, a SMESH_OctreeNode)
// We allocate the memory we need for the child
myChildren[i] = allocateOctreeChild();
// and we assign to him its box.
myChildren[i]->myFather = this;
myChildren[i]->myLimit = myLimit;
myChildren[i]->myLevel = myLevel + 1;
myChildren[i]->myBox = new Bnd_B3d(minChild+childHsize,childHsize);
myChildren[i]->myBox->Enlarge( rootSize * 1e-10 );
if ( myLimit->myMinBoxSize > 0. && myChildren[i]->maxSize() <= myLimit->myMinBoxSize )
myChildren[i]->myIsLeaf = true;
}
// After building the 8 boxes, we put the data into the children.
buildChildrenData();
//After we pass to the next level of the Octree
for (int i = 0; i<8; i++)
myChildren[i]->buildChildren();
}
//================================================================================
/*!
* \brief Tell if Octree is a leaf or not
* An inheriting class can influence it via myIsLeaf protected field
*/
//================================================================================
bool SMESH_Octree::isLeaf() const
{
return myIsLeaf || ((myLimit->myMaxLevel > 0) ? (level() >= myLimit->myMaxLevel) : false );
} }
//=========================================================================== //===========================================================================
@ -175,37 +67,13 @@ bool SMESH_Octree::isLeaf() const
double SMESH_Octree::maxSize() const double SMESH_Octree::maxSize() const
{ {
if ( myBox && !myBox->IsVoid() ) if ( getBox() && !getBox()->IsVoid() )
{ {
gp_XYZ min = myBox->CornerMin(); gp_XYZ min = getBox()->CornerMin();
gp_XYZ max = myBox->CornerMax(); gp_XYZ max = getBox()->CornerMax();
gp_XYZ Size = (max - min); gp_XYZ Size = (max - min);
double returnVal = (Size.X()>Size.Y())?Size.X():Size.Y(); double returnVal = (Size.X()>Size.Y())?Size.X():Size.Y();
return (returnVal>Size.Z())?returnVal:Size.Z(); return (returnVal>Size.Z())?returnVal:Size.Z();
} }
return 0.; return 0.;
} }
//================================================================================
/*!
* \brief Return height of the tree, full or from this level to topest leaf
*/
//================================================================================
int SMESH_Octree::getHeight(const bool full) const
{
if ( full && myFather )
return myFather->getHeight( true );
if ( isLeaf() )
return 1;
int heigth = 0;
for (int i = 0; i<8; i++)
{
int h = myChildren[i]->getHeight( false );
if ( h > heigth )
heigth = h;
}
return heigth + 1;
}

85
src/SMESHUtils/SMESH_Octree.hxx
View File

@ -20,7 +20,7 @@
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
// //
// SMESH SMESH_Octree : global Octree implementation // SMESH SMESH_Octree : Octree implementation
// File : SMESH_Octree.hxx // File : SMESH_Octree.hxx
// Created : Tue Jan 16 16:00:00 2007 // Created : Tue Jan 16 16:00:00 2007
// Author : Nicolas Geimer & Aurélien Motteux (OCC) // Author : Nicolas Geimer & Aurélien Motteux (OCC)
@ -30,45 +30,25 @@
#define _SMESH_OCTREE_HXX_ #define _SMESH_OCTREE_HXX_
#include "SMESH_Utils.hxx" #include "SMESH_Utils.hxx"
#include "SMESH_Tree.hxx"
#include <Bnd_B3d.hxx> #include <Bnd_B3d.hxx>
class SMESHUtils_EXPORT SMESH_Octree { //================================================================================
/*!
* \brief 3D tree of anything.
* Methods to implement in a descendant are:
* - Bnd_B3d* buildRootBox(); // box of the whole tree
* - descendant* newChild() const; // a new child instance
* - void buildChildrenData(); // Fill in data of the children
*/
class SMESHUtils_EXPORT SMESH_Octree : public SMESH_Tree< Bnd_B3d, 8 >
{
public: public:
typedef SMESH_Tree< Bnd_B3d, 8> TBaseTree;
// Data limiting the tree height
struct Limit {
// MaxLevel of the Octree
int myMaxLevel;
// Minimal size of the Box
double myMinBoxSize;
// Default:
// maxLevel-> 8^8 = 16777216 terminal trees
// minSize -> box size not checked
Limit(int maxLevel=8, double minSize=0.):myMaxLevel(maxLevel),myMinBoxSize(minSize) {}
virtual ~Limit() {} // it can be inherited
};
// Constructor. limit must be provided at tree root construction. // Constructor. limit must be provided at tree root construction.
// limit will be deleted by SMESH_Octree // limit will be deleted by SMESH_Octree
SMESH_Octree (Limit* limit=0); SMESH_Octree (SMESH_TreeLimit* limit=0);
// Destructor
virtual ~SMESH_Octree ();
// Compute the Octree. Must be called by constructor of inheriting class
void compute();
// Tell if Octree is a leaf or not.
// An inheriting class can influence it via myIsLeaf protected field
bool isLeaf() const;
// Return its level
int level() const { return myLevel; }
// Get box to the 3d Bounding Box of the Octree
const Bnd_B3d& getBox() const { return *myBox; }
// Compute the bigger dimension of my box // Compute the bigger dimension of my box
double maxSize() const; double maxSize() const;
@ -76,49 +56,16 @@ public:
// Return index of a child the given point is in // Return index of a child the given point is in
inline int getChildIndex(double x, double y, double z, const gp_XYZ& boxMiddle)const; inline int getChildIndex(double x, double y, double z, const gp_XYZ& boxMiddle)const;
// Return height of the tree, full or from this level to topest leaf
int getHeight(const bool full=true) const;
protected: protected:
// Return box of the whole tree
virtual Bnd_B3d* buildRootBox() = 0;
// Constructor for children // Allocate a bndbox according to childIndex. childIndex is zero based
virtual SMESH_Octree* allocateOctreeChild() const = 0; virtual Bnd_B3d* newChildBox(int childIndex) const;
// Build the data in the 8 children
virtual void buildChildrenData() = 0;
// members
// Array of 8 Octree children
SMESH_Octree** myChildren;
// Point the father, set to NULL for the level 0
SMESH_Octree* myFather;
// Tell us if the Octree is a leaf or not
bool myIsLeaf;
// Tree limit
const Limit* myLimit;
private:
// Build the 8 children boxes recursively
void buildChildren();
// Level of the Octree
int myLevel;
Bnd_B3d* myBox;
}; };
//================================================================================ //================================================================================
/*! /*!
* \brief Return index of a child the given point is in * \brief Return index of a child the given point is in
*/ */
//================================================================================
inline int SMESH_Octree::getChildIndex(double x, double y, double z, const gp_XYZ& mid) const inline int SMESH_Octree::getChildIndex(double x, double y, double z, const gp_XYZ& mid) const
{ {
return (x > mid.X()) + ( y > mid.Y())*2 + (z > mid.Z())*4; return (x > mid.X()) + ( y > mid.Y())*2 + (z > mid.Z())*4;

42
src/SMESHUtils/SMESH_OctreeNode.cxx
View File

@ -21,7 +21,7 @@
// //
// SMESH SMESH_OctreeNode : Octree with Nodes set // SMESH SMESH_OctreeNode : Octree with Nodes set
// inherites global class SMESH_Octree // inherites class SMESH_Octree
// File : SMESH_OctreeNode.cxx // File : SMESH_OctreeNode.cxx
// Created : Tue Jan 16 16:00:00 2007 // Created : Tue Jan 16 16:00:00 2007
// Author : Nicolas Geimer & Aurelien Motteux (OCC) // Author : Nicolas Geimer & Aurelien Motteux (OCC)
@ -43,10 +43,10 @@ using namespace std;
* \param minBoxSize - Minimal size of the Octree Box * \param minBoxSize - Minimal size of the Octree Box
*/ */
//================================================================ //================================================================
SMESH_OctreeNode::SMESH_OctreeNode (const TIDSortedNodeSet & theNodes, const int maxLevel, SMESH_OctreeNode::SMESH_OctreeNode (const TIDSortedNodeSet & theNodes, const int maxLevel,
const int maxNbNodes , const double minBoxSize ) const int maxNbNodes , const double minBoxSize )
:SMESH_Octree( new SMESH_Octree::Limit( maxLevel,minBoxSize)), :SMESH_Octree( new Limit( maxLevel,minBoxSize,maxNbNodes)),
myMaxNbNodes(maxNbNodes),
myNodes(theNodes) myNodes(theNodes)
{ {
compute(); compute();
@ -58,20 +58,30 @@ SMESH_OctreeNode::SMESH_OctreeNode (const TIDSortedNodeSet & theNodes, const int
*/ */
//================================================================================ //================================================================================
SMESH_OctreeNode::SMESH_OctreeNode (int maxNbNodes): SMESH_OctreeNode::SMESH_OctreeNode ():SMESH_Octree()
SMESH_Octree(), myMaxNbNodes(maxNbNodes)
{ {
} }
//================================================================================
/*!
* \brief Return max number of nodes in a tree leaf
*/
//================================================================================
int SMESH_OctreeNode::getMaxNbNodes() const
{
return ((Limit*)myLimit)->myMaxNbNodes;
}
//================================================================================== //==================================================================================
/*! /*!
* \brief Construct an empty SMESH_OctreeNode used by SMESH_Octree::buildChildren() * \brief Construct an empty SMESH_OctreeNode used by SMESH_Octree::buildChildren()
*/ */
//================================================================================== //==================================================================================
SMESH_Octree* SMESH_OctreeNode::allocateOctreeChild() const SMESH_Octree* SMESH_OctreeNode::newChild() const
{ {
return new SMESH_OctreeNode(myMaxNbNodes); return new SMESH_OctreeNode();
} }
//====================================== //======================================
@ -91,7 +101,7 @@ Bnd_B3d* SMESH_OctreeNode::buildRootBox()
gp_XYZ p1( n1->X(), n1->Y(), n1->Z() ); gp_XYZ p1( n1->X(), n1->Y(), n1->Z() );
box->Add(p1); box->Add(p1);
} }
if ( myNodes.size() <= myMaxNbNodes ) if ( myNodes.size() <= getMaxNbNodes() )
myIsLeaf = true; myIsLeaf = true;
return box; return box;
@ -109,8 +119,8 @@ Bnd_B3d* SMESH_OctreeNode::buildRootBox()
const bool SMESH_OctreeNode::isInside (const gp_XYZ& p, const double precision) const bool SMESH_OctreeNode::isInside (const gp_XYZ& p, const double precision)
{ {
if (precision <= 0.) if (precision <= 0.)
return !(getBox().IsOut(p)); return !(getBox()->IsOut(p));
Bnd_B3d BoxWithPrecision = getBox(); Bnd_B3d BoxWithPrecision = *getBox();
BoxWithPrecision.Enlarge(precision); BoxWithPrecision.Enlarge(precision);
return ! BoxWithPrecision.IsOut(p); return ! BoxWithPrecision.IsOut(p);
} }
@ -123,8 +133,8 @@ const bool SMESH_OctreeNode::isInside (const gp_XYZ& p, const double precision)
//================================================ //================================================
void SMESH_OctreeNode::buildChildrenData() void SMESH_OctreeNode::buildChildrenData()
{ {
gp_XYZ min = getBox().CornerMin(); gp_XYZ min = getBox()->CornerMin();
gp_XYZ max = getBox().CornerMax(); gp_XYZ max = getBox()->CornerMax();
gp_XYZ mid = (min + max)/2.; gp_XYZ mid = (min + max)/2.;
TIDSortedNodeSet::iterator it = myNodes.begin(); TIDSortedNodeSet::iterator it = myNodes.begin();
@ -140,7 +150,7 @@ void SMESH_OctreeNode::buildChildrenData()
for (int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
{ {
SMESH_OctreeNode* myChild = dynamic_cast<SMESH_OctreeNode*> (myChildren[i]); SMESH_OctreeNode* myChild = dynamic_cast<SMESH_OctreeNode*> (myChildren[i]);
if ( myChild->myNodes.size() <= myMaxNbNodes ) if ( myChild->myNodes.size() <= getMaxNbNodes() )
myChild->myIsLeaf = true; myChild->myIsLeaf = true;
} }
} }
@ -200,7 +210,7 @@ bool SMESH_OctreeNode::NodesAround(const gp_XYZ &node,
if (!isLeaf()) if (!isLeaf())
{ {
// first check a child containing node // first check a child containing node
gp_XYZ mid = (getBox().CornerMin() + getBox().CornerMax()) / 2.; gp_XYZ mid = (getBox()->CornerMin() + getBox()->CornerMax()) / 2.;
int nodeChild = getChildIndex( node.X(), node.Y(), node.Z(), mid ); int nodeChild = getChildIndex( node.X(), node.Y(), node.Z(), mid );
if ( ((SMESH_OctreeNode*) myChildren[nodeChild])->NodesAround(node, dist2Nodes, precision)) if ( ((SMESH_OctreeNode*) myChildren[nodeChild])->NodesAround(node, dist2Nodes, precision))
return true; return true;
@ -401,7 +411,7 @@ void SMESH_OctreeNode::UpdateByMoveNode( const SMDS_MeshNode* node, const gp_Pnt
} }
else if ( myChildren ) else if ( myChildren )
{ {
gp_XYZ mid = (getBox().CornerMin() + getBox().CornerMax()) / 2.; gp_XYZ mid = (getBox()->CornerMin() + getBox()->CornerMax()) / 2.;
int nodeChild = getChildIndex( node->X(), node->Y(), node->Z(), mid ); int nodeChild = getChildIndex( node->X(), node->Y(), node->Z(), mid );
int pointChild = getChildIndex( toPnt.X(), toPnt.Y(), toPnt.Z(), mid ); int pointChild = getChildIndex( toPnt.X(), toPnt.Y(), toPnt.Z(), mid );
if ( nodeChild != pointChild ) if ( nodeChild != pointChild )
@ -420,7 +430,7 @@ void SMESH_OctreeNode::UpdateByMoveNode( const SMDS_MeshNode* node, const gp_Pnt
SMESH_OctreeNodeIteratorPtr SMESH_OctreeNode::GetChildrenIterator() SMESH_OctreeNodeIteratorPtr SMESH_OctreeNode::GetChildrenIterator()
{ {
return SMESH_OctreeNodeIteratorPtr return SMESH_OctreeNodeIteratorPtr
( new SMDS_SetIterator< SMESH_OctreeNode*, SMESH_Octree** > ( new SMDS_SetIterator< SMESH_OctreeNode*, TBaseTree** >
( myChildren, (( isLeaf() || !myChildren ) ? myChildren : &myChildren[ 8 ] ))); ( myChildren, (( isLeaf() || !myChildren ) ? myChildren : &myChildren[ 8 ] )));
} }

16
src/SMESHUtils/SMESH_OctreeNode.hxx
View File

@ -109,7 +109,16 @@ public:
protected: protected:
SMESH_OctreeNode (int maxNbNodes ); struct Limit : public SMESH_TreeLimit
{
int myMaxNbNodes;
Limit(int maxLevel, double minSize, int maxNbNodes)
:SMESH_TreeLimit(maxLevel, minSize), myMaxNbNodes(maxNbNodes) {}
};
int getMaxNbNodes() const;
SMESH_OctreeNode();
// Compute the bounding box of the whole set of nodes myNodes // Compute the bounding box of the whole set of nodes myNodes
virtual Bnd_B3d* buildRootBox(); virtual Bnd_B3d* buildRootBox();
@ -118,7 +127,7 @@ protected:
virtual void buildChildrenData(); virtual void buildChildrenData();
// Construct an empty SMESH_OctreeNode used by SMESH_Octree::buildChildren() // Construct an empty SMESH_OctreeNode used by SMESH_Octree::buildChildren()
virtual SMESH_Octree* allocateOctreeChild() const; virtual SMESH_Octree* newChild() const;
// Return in result a list of nodes closed to Node and remove it from SetOfNodes // Return in result a list of nodes closed to Node and remove it from SetOfNodes
void FindCoincidentNodes( const SMDS_MeshNode * Node, void FindCoincidentNodes( const SMDS_MeshNode * Node,
@ -126,9 +135,6 @@ protected:
std::list<const SMDS_MeshNode*>* Result, std::list<const SMDS_MeshNode*>* Result,
const double precision); const double precision);
// The max number of nodes a leaf box can contain
int myMaxNbNodes;
// The set of nodes inside the box of the Octree (Empty if Octree is not a leaf) // The set of nodes inside the box of the Octree (Empty if Octree is not a leaf)
TIDSortedNodeSet myNodes; TIDSortedNodeSet myNodes;