mirror of
https://git.salome-platform.org/gitpub/modules/smesh.git
synced 2025-03-11 07:54:33 +05:00
481 lines
17 KiB
C++
481 lines
17 KiB
C++
// Copyright (C) 2007-2020 CEA/DEN, EDF R&D, OPEN CASCADE
|
|
//
|
|
// Copyright (C) 2003-2007 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, or (at your option) any later version.
|
|
//
|
|
// 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
|
|
//
|
|
|
|
// SMESH SMESH_OctreeNode : Octree with Nodes set
|
|
// inherites class SMESH_Octree
|
|
// File : SMESH_OctreeNode.cxx
|
|
// Created : Tue Jan 16 16:00:00 2007
|
|
// Author : Nicolas Geimer & Aurelien Motteux (OCC)
|
|
// Module : SMESH
|
|
//
|
|
#include "SMESH_OctreeNode.hxx"
|
|
|
|
#include "SMDS_SetIterator.hxx"
|
|
#include "SMESH_MeshAlgos.hxx"
|
|
#include "SMESH_TypeDefs.hxx"
|
|
|
|
#include <gp_Pnt.hxx>
|
|
|
|
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 (const TIDSortedNodeSet & theNodes, const int maxLevel,
|
|
const int maxNbNodes , const double minBoxSize )
|
|
:SMESH_Octree( new Limit( maxLevel,minBoxSize,maxNbNodes)),
|
|
myNodes( theNodes.begin(), theNodes.end() )
|
|
{
|
|
compute();
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Constructor used to allocate a child
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH_OctreeNode::SMESH_OctreeNode ():SMESH_Octree()
|
|
{
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \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()
|
|
*/
|
|
//==================================================================================
|
|
|
|
SMESH_Octree* SMESH_OctreeNode::newChild() const
|
|
{
|
|
return new SMESH_OctreeNode();
|
|
}
|
|
|
|
//======================================
|
|
/*!
|
|
* \brief Compute the first bounding box
|
|
*
|
|
* We take the max/min coord of the nodes
|
|
*/
|
|
//======================================
|
|
|
|
Bnd_B3d* SMESH_OctreeNode::buildRootBox()
|
|
{
|
|
Bnd_B3d* box = new Bnd_B3d;
|
|
for ( size_t i = 0; i < myNodes.size(); ++i )
|
|
box->Add( SMESH_NodeXYZ( myNodes[ i ]));
|
|
|
|
if ((int) myNodes.size() <= getMaxNbNodes() )
|
|
myIsLeaf = true;
|
|
|
|
return box;
|
|
}
|
|
|
|
//====================================================================================
|
|
/*!
|
|
* \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
|
|
*/
|
|
//====================================================================================
|
|
|
|
bool SMESH_OctreeNode::isInside ( const gp_XYZ& p, const double precision )
|
|
{
|
|
if ( precision <= 0.)
|
|
return !( getBox()->IsOut(p) );
|
|
|
|
Bnd_B3d BoxWithPrecision = *getBox();
|
|
BoxWithPrecision.Enlarge( precision );
|
|
return ! BoxWithPrecision.IsOut(p);
|
|
}
|
|
|
|
//================================================
|
|
/*!
|
|
* \brief Set the data of the children
|
|
* Shares the father's data with each of his child
|
|
*/
|
|
//================================================
|
|
|
|
void SMESH_OctreeNode::buildChildrenData()
|
|
{
|
|
gp_XYZ min = getBox()->CornerMin();
|
|
gp_XYZ max = getBox()->CornerMax();
|
|
gp_XYZ mid = (min + max)/2.;
|
|
|
|
for ( int i = 0; i < 8; i++ )
|
|
{
|
|
SMESH_OctreeNode* myChild = static_cast<SMESH_OctreeNode*>( myChildren[ i ]);
|
|
myChild->myNodes.reserve( myNodes.size() / 8 );
|
|
}
|
|
|
|
for ( size_t i = 0; i < myNodes.size(); ++i )
|
|
{
|
|
SMESH_NodeXYZ n = myNodes[ i ];
|
|
int ChildBoxNum = getChildIndex( n.X(), n.Y(), n.Z(), mid );
|
|
SMESH_OctreeNode* myChild = static_cast<SMESH_OctreeNode*>( myChildren[ ChildBoxNum ]);
|
|
myChild->myNodes.push_back( myNodes[ i ]);
|
|
}
|
|
SMESHUtils::FreeVector( myNodes );
|
|
|
|
for ( int i = 0; i < 8; i++ )
|
|
{
|
|
SMESH_OctreeNode* myChild = static_cast<SMESH_OctreeNode*>( myChildren[ i ]);
|
|
if ((int) myChild->myNodes.size() <= getMaxNbNodes() )
|
|
{
|
|
myChild->myIsLeaf = true;
|
|
if ( myChild->myNodes.empty() )
|
|
SMESHUtils::FreeVector( myChild->myNodes );
|
|
}
|
|
}
|
|
}
|
|
|
|
//===================================================================
|
|
/*!
|
|
* \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::AllNodesAround (const SMDS_MeshNode * Node,
|
|
std::vector<const SMDS_MeshNode*>* Result,
|
|
const double precision)
|
|
{
|
|
SMESH_NodeXYZ p = Node;
|
|
if ( isInside( p, precision ))
|
|
{
|
|
if ( isLeaf() )
|
|
{
|
|
Result->insert( Result->end(), myNodes.begin(), myNodes.end() );
|
|
}
|
|
else
|
|
{
|
|
for ( int i = 0; i < 8; i++ )
|
|
{
|
|
SMESH_OctreeNode* myChild = static_cast<SMESH_OctreeNode*> (myChildren[i]);
|
|
myChild->AllNodesAround( Node, Result, precision );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Return in dist2Nodes nodes mapped to their square distance from Node
|
|
* Tries to find a closest node.
|
|
* \param node - node to find nodes closest to
|
|
* \param dist2Nodes - map of found nodes and their distances
|
|
* \param precision - radius of a sphere to check nodes inside
|
|
* \retval bool - true if an exact overlapping found !!!
|
|
*/
|
|
//================================================================================
|
|
|
|
bool SMESH_OctreeNode::NodesAround(const gp_XYZ & node,
|
|
map<double, const SMDS_MeshNode*>& dist2Nodes,
|
|
double precision)
|
|
{
|
|
if ( !dist2Nodes.empty() )
|
|
precision = min ( precision, sqrt( dist2Nodes.begin()->first ));
|
|
else if ( precision == 0. )
|
|
precision = maxSize() / 2;
|
|
|
|
if ( isInside( node, precision ))
|
|
{
|
|
if ( !isLeaf() )
|
|
{
|
|
// first check a child containing node
|
|
gp_XYZ mid = (getBox()->CornerMin() + getBox()->CornerMax()) / 2.;
|
|
int nodeChild = getChildIndex( node.X(), node.Y(), node.Z(), mid );
|
|
if ( ((SMESH_OctreeNode*) myChildren[nodeChild])->NodesAround(node, dist2Nodes, precision))
|
|
return true;
|
|
|
|
for (int i = 0; i < 8; i++)
|
|
if ( i != nodeChild )
|
|
if (((SMESH_OctreeNode*) myChildren[i])->NodesAround(node, dist2Nodes, precision))
|
|
return true;
|
|
}
|
|
else if ( NbNodes() > 0 )
|
|
{
|
|
double minDist = precision * precision;
|
|
for ( size_t i = 0; i < myNodes.size(); ++i )
|
|
{
|
|
SMESH_NodeXYZ p2 = myNodes[ i ];
|
|
double dist2 = ( node - p2 ).SquareModulus();
|
|
if ( dist2 < minDist )
|
|
dist2Nodes.insert( std::make_pair( minDist = dist2, myNodes[ i ] ));
|
|
}
|
|
// if ( dist2Nodes.size() > 1 ) // leave only closest node in dist2Nodes
|
|
// dist2Nodes.erase( ++dist2Nodes.begin(), dist2Nodes.end());
|
|
|
|
// true if an exact overlapping found
|
|
return ( sqrt( minDist ) <= precision * 1e-12 );
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Return a list of nodes close to a point
|
|
* \param [in] point - point
|
|
* \param [out] nodes - found nodes
|
|
* \param [in] precision - allowed distance from \a point
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_OctreeNode::NodesAround(const gp_XYZ& point,
|
|
std::vector<const SMDS_MeshNode*>& nodes,
|
|
double precision)
|
|
{
|
|
if ( isInside( point, precision ))
|
|
{
|
|
if ( isLeaf() && NbNodes() )
|
|
{
|
|
double minDist2 = precision * precision;
|
|
for ( size_t i = 0; i < myNodes.size(); ++i )
|
|
{
|
|
SMESH_NodeXYZ p2 = myNodes[ i ];
|
|
double dist2 = ( point - p2 ).SquareModulus();
|
|
if ( dist2 <= minDist2 )
|
|
nodes.push_back( myNodes[ i ] );
|
|
}
|
|
}
|
|
else if ( myChildren )
|
|
{
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
SMESH_OctreeNode* myChild = static_cast<SMESH_OctreeNode*>( myChildren[ i ]);
|
|
myChild->NodesAround( point, nodes, precision );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//=============================
|
|
/*!
|
|
* \brief Return in theGroupsOfNodes a list of group of nodes close to each other within theTolerance
|
|
* Search for all the nodes in theSetOfNodes
|
|
* Static Method : no need to create an SMESH_OctreeNode
|
|
* \param theSetOfNodes - 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 (TIDSortedNodeSet& theSetOfNodes,
|
|
TListOfNodeLists* theGroupsOfNodes,
|
|
const double theTolerance,
|
|
const int maxLevel,
|
|
const int maxNbNodes)
|
|
{
|
|
// VSR 14/10/2011: limit max number of the levels in order to avoid endless recursion
|
|
const int MAX_LEVEL = 10;
|
|
SMESH_OctreeNode theOctreeNode(theSetOfNodes,
|
|
maxLevel < 0 ? MAX_LEVEL : maxLevel,
|
|
maxNbNodes,
|
|
theTolerance);
|
|
theOctreeNode.FindCoincidentNodes (&theSetOfNodes, theTolerance, theGroupsOfNodes);
|
|
}
|
|
|
|
//=============================
|
|
/*!
|
|
* \brief Return in theGroupsOfNodes a list of group of nodes close to each other within theTolerance
|
|
* Search for all the nodes in theSetOfNodes
|
|
* \note The Octree itself is also modified by this method
|
|
* \param theSetOfNodes - 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 ( TIDSortedNodeSet* theSetOfNodes,
|
|
const double theTolerance,
|
|
TListOfNodeLists* theGroupsOfNodes )
|
|
{
|
|
// un-mark all nodes; we mark nodes added to theGroupsOfNodes
|
|
SMESH_MeshAlgos::MarkElems( SMESHUtils::elemSetIterator( *theSetOfNodes ), false );
|
|
|
|
vector<const SMDS_MeshNode*> coincidentNodes;
|
|
TIDCompare idLess;
|
|
|
|
TIDSortedNodeSet::iterator it1 = theSetOfNodes->begin();
|
|
for ( ; it1 != theSetOfNodes->end(); ++it1 )
|
|
{
|
|
const SMDS_MeshNode * n1 = *it1;
|
|
if ( n1->isMarked() )
|
|
continue;
|
|
n1->setIsMarked( true );
|
|
|
|
// Searching for Nodes around n1 and put them in coincidentNodes.
|
|
// Found nodes are also erased from theSetOfNodes
|
|
coincidentNodes.clear();
|
|
findCoincidentNodes( n1, theSetOfNodes, &coincidentNodes, theTolerance );
|
|
|
|
if ( !coincidentNodes.empty() )
|
|
{
|
|
// We build a list {n1 + his neighbors} and add this list in theGroupsOfNodes
|
|
std::sort( coincidentNodes.begin(), coincidentNodes.end(), idLess );
|
|
list<const SMDS_MeshNode*> newGroup;
|
|
newGroup.push_back( n1 );
|
|
newGroup.insert( newGroup.end(), coincidentNodes.begin(), coincidentNodes.end() );
|
|
|
|
theGroupsOfNodes->emplace_back( newGroup );
|
|
}
|
|
}
|
|
}
|
|
|
|
//======================================================================================
|
|
/*!
|
|
* \brief Return a list of nodes closed to Node and remove it from SetOfNodes
|
|
* \note The Octree itself is also modified by this method
|
|
* \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,
|
|
TIDSortedNodeSet* SetOfNodes,
|
|
std::vector<const SMDS_MeshNode*>* Result,
|
|
const double precision)
|
|
{
|
|
SMESH_NodeXYZ p1 = Node;
|
|
|
|
if ( isInside( p1, precision ))
|
|
{
|
|
// I'm only looking in the leaves, since all the nodes are stored there.
|
|
if ( isLeaf() )
|
|
{
|
|
const double tol2 = precision * precision;
|
|
|
|
for ( size_t i = 0; i < myNodes.size(); ++i )
|
|
{
|
|
if ( myNodes[ i ]->isMarked() ) // coincident node already found
|
|
continue;
|
|
|
|
//if ( Node != myNodes[ i ]) // JFA: for bug 0020185
|
|
{
|
|
// If n2 inside the SquareDistance, we add it in Result
|
|
bool coincide = ( p1.SquareDistance( myNodes[ i ]) <= tol2 );
|
|
if ( coincide )
|
|
{
|
|
Result->push_back ( myNodes[ i ]);
|
|
myNodes[ i ]->setIsMarked( true );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If I'm not a leaf, I'm going to see my children !
|
|
for ( int i = 0; i < 8; i++ )
|
|
{
|
|
SMESH_OctreeNode* myChild = static_cast<SMESH_OctreeNode*> (myChildren[i]);
|
|
myChild->findCoincidentNodes( Node, SetOfNodes, Result, precision );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Update data according to node movement
|
|
*/
|
|
//================================================================================
|
|
|
|
void SMESH_OctreeNode::UpdateByMoveNode( const SMDS_MeshNode* node, const gp_Pnt& toPnt )
|
|
{
|
|
if ( isLeaf() )
|
|
{
|
|
std::vector< const SMDS_MeshNode* >::iterator pNode =
|
|
std::find( myNodes.begin(), myNodes.end(), node );
|
|
|
|
bool nodeInMe = ( pNode != myNodes.end() );
|
|
bool pointInMe = isInside( toPnt.Coord(), 1e-10 );
|
|
|
|
if ( pointInMe != nodeInMe )
|
|
{
|
|
if ( pointInMe )
|
|
myNodes.push_back( node );
|
|
else
|
|
myNodes.erase( pNode );
|
|
}
|
|
}
|
|
else if ( myChildren )
|
|
{
|
|
gp_XYZ mid = (getBox()->CornerMin() + getBox()->CornerMax()) / 2.;
|
|
int nodeChild = getChildIndex( node->X(), node->Y(), node->Z(), mid );
|
|
int pointChild = getChildIndex( toPnt.X(), toPnt.Y(), toPnt.Z(), mid );
|
|
if ( nodeChild != pointChild )
|
|
{
|
|
((SMESH_OctreeNode*) myChildren[ nodeChild ])->UpdateByMoveNode( node, toPnt );
|
|
((SMESH_OctreeNode*) myChildren[ pointChild ])->UpdateByMoveNode( node, toPnt );
|
|
}
|
|
}
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Return iterator over children
|
|
*/
|
|
//================================================================================
|
|
|
|
SMESH_OctreeNodeIteratorPtr SMESH_OctreeNode::GetChildrenIterator()
|
|
{
|
|
return SMESH_OctreeNodeIteratorPtr
|
|
( new SMDS_SetIterator< SMESH_OctreeNode*, TBaseTree** >
|
|
( myChildren, (( isLeaf() || !myChildren ) ? myChildren : &myChildren[ 8 ] )));
|
|
}
|
|
|
|
//================================================================================
|
|
/*!
|
|
* \brief Return nodes iterator
|
|
*/
|
|
//================================================================================
|
|
|
|
SMDS_NodeIteratorPtr SMESH_OctreeNode::GetNodeIterator()
|
|
{
|
|
return boost::make_shared< SMDS_NodeVectorIterator >( myNodes.begin(), myNodes.end());
|
|
}
|