// SMESH SMESH_OctreeNode : Octree with Nodes set // inherites global class SMESH_Octree // // Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public // License as published by the Free Software Foundation; either // version 2.1 of the License. // // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public // License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // // // // File : SMESH_OctreeNode.cxx // Created : Tue Jan 16 16:00:00 2007 // Author : Nicolas Geimer & Aurélien Motteux (OCC) // Module : SMESH #include "SMESH_OctreeNode.hxx" #include #include using namespace std; //=============================================================== /*! * \brief Constructor : Build all the Octree using Compute() * \param theNodes - Set of nodes, the Octree is built from this nodes * \param maxLevel - Maximum level for the leaves * \param maxNbNodes - Maximum number of nodes, a leaf can contain * \param minBoxSize - Minimal size of the Octree Box */ //================================================================ SMESH_OctreeNode::SMESH_OctreeNode (set theNodes, const int maxLevel, const int maxNbNodes , const double minBoxSize ) :SMESH_Octree(maxLevel,minBoxSize), myMaxNbNodes(maxNbNodes), myNodes(theNodes) { // We need to compute the first bounding box via a special method computeBoxForFather(); myNbNodes = myNodes.size(); myIsLeaf = (myLevel == myMaxLevel)||(myNbNodes<=myMaxNbNodes)||(myMinBoxSize>=maxSize(myBox)); // All the children (Boxes and Data) are computed in Compute() Compute(); } //================================================================================== /*! * \brief Construct an empty SMESH_OctreeNode used by SMESH_Octree::buildChildren() */ //================================================================================== SMESH_Octree* SMESH_OctreeNode::allocateOctreeChild() { SMESH_OctreeNode * theOctree = new SMESH_OctreeNode(); theOctree->myFather = this; theOctree->myLevel = myLevel + 1; theOctree->myMaxLevel = myMaxLevel; theOctree->myMaxNbNodes = myMaxNbNodes; theOctree->myMinBoxSize = myMinBoxSize; theOctree->myNbNodes = 0; return theOctree; } //====================================== /*! * \brief Compute the first bounding box * * We take the max/min coord of the nodes */ //====================================== void SMESH_OctreeNode::computeBoxForFather() { set::iterator it=myNodes.begin(); for( ;it!=myNodes.end();it++){ const SMDS_MeshNode* n1 = *it; gp_XYZ p1( n1->X(), n1->Y(), n1->Z() ); myBox->Add(p1); } } //==================================================================================== /*! * \brief Tell if Octree is a leaf or not (has to be implemented in inherited classes) * \retval - True if the Octree is a leaf */ //==================================================================================== const bool SMESH_OctreeNode::isLeaf() { return myIsLeaf; } //==================================================================================== /*! * \brief Tells us if Node is inside the current box with the precision "precision" * \param Node - Node * \param precision - The box is enlarged with this precision * \retval bool - True if Node is in the box within precision */ //==================================================================================== const bool SMESH_OctreeNode::isInside(const SMDS_MeshNode * Node, const double precision ) { double X=Node->X(); double Y=Node->Y(); double Z=Node->Z(); bool Out = 1 ; if (precision<=0.) return !(myBox->IsOut(gp_XYZ(X,Y,Z))); Bnd_B3d * BoxWithPrecision = new Bnd_B3d(); getBox(BoxWithPrecision); BoxWithPrecision->Enlarge(precision); Out=BoxWithPrecision->IsOut(gp_XYZ(X,Y,Z)); delete BoxWithPrecision; return !(Out); } //================================================ /*! * \brief Set the data of the children * Shares the father's data with each of his child */ //================================================ void SMESH_OctreeNode::buildChildrenData() { gp_XYZ min = myBox->CornerMin(); gp_XYZ max = myBox->CornerMax(); gp_XYZ mid = (min + max)/2.; set::iterator it=myNodes.begin(); int ChildBoxNum; while( it!=myNodes.end()) { const SMDS_MeshNode* n1 = *it; ChildBoxNum= (n1->X()>mid.X()) + (n1->Y()>mid.Y())*2 + (n1->Z()>mid.Z())*4; SMESH_OctreeNode* myChild = dynamic_cast (myChildren[ChildBoxNum]); myChild->myNodes.insert(myChild->myNodes.end(),n1); myNodes.erase( it ); it=myNodes.begin(); } for (int i = 0; i<8; i++) { SMESH_OctreeNode* myChild = dynamic_cast (myChildren[i]); myChild->myNbNodes = (myChild->myNodes).size(); myChild->myIsLeaf = (myChild->myLevel == myMaxLevel)||(myChild->myNbNodes<=myMaxNbNodes)||(myMinBoxSize>=maxSize(myChild->myBox)); } } //=================================================================== /*! * \brief Return in Result a list of Nodes potentials to be near Node * \param Node - Node * \param precision - precision used * \param Result - list of Nodes potentials to be near Node */ //==================================================================== void SMESH_OctreeNode::NodesAround( const SMDS_MeshNode * Node, list* Result, const double precision) { if (isInside(Node,precision)) { if (myIsLeaf) { Result->insert( Result->end(), myNodes.begin(), myNodes.end() ); } else { for(int i=0;i<8;i++) { SMESH_OctreeNode* myChild = dynamic_cast (myChildren[i]); myChild->NodesAround( Node, Result, precision); } } } } //============================= /*! * \brief Return in theGroupsOfNodes a list of group of nodes close to each other within theTolerance * Search for all the nodes in nodes * Static Method : no need to create an SMESH_OctreeNode * \param nodes - set of nodes we look at, modified during research * \param theGroupsOfNodes - list of nodes closed to each other returned * \param theTolerance - Precision used, default value is 0.00001 * \param maxLevel - Maximum level for SMESH_OctreeNode constructed, default value is -1 (Infinite) * \param maxNbNodes - maximum Nodes in a Leaf of the SMESH_OctreeNode constructed, default value is 5 */ //============================= void SMESH_OctreeNode::FindCoincidentNodes ( set nodes, list< list< const SMDS_MeshNode*> >* theGroupsOfNodes, const double theTolerance, const int maxLevel, const int maxNbNodes) { SMESH_OctreeNode* theOctreeNode = new SMESH_OctreeNode(nodes, maxLevel, maxNbNodes, theTolerance); theOctreeNode->FindCoincidentNodes (&nodes, theTolerance, theGroupsOfNodes); delete theOctreeNode; } //============================= /*! * \brief Return in theGroupsOfNodes a list of group of nodes close to each other within theTolerance * Search for all the nodes in nodes * \param nodes - set of nodes we look at, modified during research * \param theTolerance - Precision used * \param theGroupsOfNodes - list of nodes closed to each other returned */ //============================= void SMESH_OctreeNode::FindCoincidentNodes ( set* nodes, const double theTolerance, list< list< const SMDS_MeshNode*> >* theGroupsOfNodes) { set::iterator it1 = nodes->begin(); list::iterator it2; while (it1 != nodes->end()) { const SMDS_MeshNode * n1 = *it1; list ListofCoincidentNodes;// Initialize the lists via a declaration, it's enough list * groupPtr = 0; // Searching for Nodes around n1 and put them in ListofCoincidentNodes FindCoincidentNodes(n1, nodes, &ListofCoincidentNodes, theTolerance); // We build a list {n1 + his neigbours} and add this list in theGroupsOfNodes for (it2=ListofCoincidentNodes.begin();it2 != ListofCoincidentNodes.end(); it2++) { const SMDS_MeshNode* n2 = *it2; if ( !groupPtr ) { theGroupsOfNodes->push_back( list() ); groupPtr = & theGroupsOfNodes->back(); groupPtr->push_back( n1 ); } if(groupPtr->front()>n2) groupPtr->push_front( n2 ); else groupPtr->push_back( n2 ); } if(groupPtr != 0) groupPtr->sort(); nodes->erase(it1); it1=nodes->begin(); } } //====================================================================================== /*! * \brief Return a list of nodes closed to Node and remove it from SetOfNodes * \param Node - We're searching the nodes next to him. * \param SetOfNodes - set of nodes in which we erase the found nodes * \param Result - list of nodes closed to Node * \param precision - Precision used */ //====================================================================================== void SMESH_OctreeNode::FindCoincidentNodes( const SMDS_MeshNode * Node, set* SetOfNodes, list* Result, const double precision) { bool isInsideBool = isInside(Node,precision); if (isInsideBool) { // I'm only looking in the leaves, since all the nodes are stored there. if (myIsLeaf) { gp_Pnt p1( Node->X(), Node->Y(), Node->Z() ); set myNodesCopy = myNodes; set::iterator it = myNodesCopy.begin(); double tol2 = precision * precision; bool squareBool; while (it != myNodesCopy.end()) { const SMDS_MeshNode* n2 = *it; // We're only looking at nodes with a superior Id. if(Node->GetID() < n2->GetID()) { gp_Pnt p2( n2->X(), n2->Y(), n2->Z() ); // Distance optimized computation squareBool = (p1.SquareDistance( p2 ) <= tol2); // If n2 inside the SquareDistance, we add it in Result and remove it from SetOfNodes and myNodes if(squareBool) { Result->insert(Result->begin(), n2); SetOfNodes->erase( n2 ); myNodes.erase( n2 ); } } myNodesCopy.erase( it ); it = myNodesCopy.begin(); } } else { // If I'm not a leaf, I'm going to see my children ! for(int i = 0; i < 8; i++) { SMESH_OctreeNode* myChild = dynamic_cast (myChildren[i]); myChild->FindCoincidentNodes(Node, SetOfNodes, Result, precision); } } } }