-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2014 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.
+// 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
//
// SMESH SMESH_OctreeNode : Octree with Nodes set
-// inherites global class SMESH_Octree
+// inherites class SMESH_Octree
// File : SMESH_OctreeNode.cxx
// Created : Tue Jan 16 16:00:00 2007
// Author : Nicolas Geimer & Aurelien Motteux (OCC)
* \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 SMESH_Octree::Limit( maxLevel,minBoxSize)),
- myMaxNbNodes(maxNbNodes),
- myNodes(theNodes)
+ :SMESH_Octree( new Limit( maxLevel,minBoxSize,maxNbNodes)),
+ myNodes(theNodes)
{
compute();
}
*/
//================================================================================
-SMESH_OctreeNode::SMESH_OctreeNode (int maxNbNodes):
- SMESH_Octree(), myMaxNbNodes(maxNbNodes)
+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::allocateOctreeChild() const
+SMESH_Octree* SMESH_OctreeNode::newChild() const
{
- return new SMESH_OctreeNode(myMaxNbNodes);
+ return new SMESH_OctreeNode();
}
//======================================
gp_XYZ p1( n1->X(), n1->Y(), n1->Z() );
box->Add(p1);
}
- if ( myNodes.size() <= myMaxNbNodes )
+ if ( myNodes.size() <= getMaxNbNodes() )
myIsLeaf = true;
return box;
const bool SMESH_OctreeNode::isInside (const gp_XYZ& p, const double precision)
{
if (precision <= 0.)
- return !(getBox().IsOut(p));
- Bnd_B3d BoxWithPrecision = getBox();
+ return !(getBox()->IsOut(p));
+ Bnd_B3d BoxWithPrecision = *getBox();
BoxWithPrecision.Enlarge(precision);
return ! BoxWithPrecision.IsOut(p);
}
//================================================
void SMESH_OctreeNode::buildChildrenData()
{
- gp_XYZ min = getBox().CornerMin();
- gp_XYZ max = getBox().CornerMax();
+ gp_XYZ min = getBox()->CornerMin();
+ gp_XYZ max = getBox()->CornerMax();
gp_XYZ mid = (min + max)/2.;
TIDSortedNodeSet::iterator it = myNodes.begin();
for (int i = 0; i < 8; i++)
{
SMESH_OctreeNode* myChild = dynamic_cast<SMESH_OctreeNode*> (myChildren[i]);
- if ( myChild->myNodes.size() <= myMaxNbNodes )
+ if ( myChild->myNodes.size() <= getMaxNbNodes() )
myChild->myIsLeaf = true;
}
}
if (!isLeaf())
{
// 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 );
if ( ((SMESH_OctreeNode*) myChildren[nodeChild])->NodesAround(node, dist2Nodes, precision))
return true;
// if ( dist2Nodes.size() > 1 ) // leave only closest node in dist2Nodes
// dist2Nodes.erase( ++dist2Nodes.begin(), dist2Nodes.end());
- return ( sqrt( minDist) <= precision * 1e-12 );
+ return ( sqrt( minDist) <= precision * ( 1 + 1e-12 ));
}
}
return false;
* \param precision - Precision used
*/
//======================================================================================
-void SMESH_OctreeNode::FindCoincidentNodes (const SMDS_MeshNode * Node,
- TIDSortedNodeSet* SetOfNodes,
+void SMESH_OctreeNode::FindCoincidentNodes (const SMDS_MeshNode * Node,
+ TIDSortedNodeSet* SetOfNodes,
list<const SMDS_MeshNode*>* Result,
- const double precision)
+ const double precision)
{
- gp_XYZ p(Node->X(), Node->Y(), Node->Z());
- bool isInsideBool = isInside(p, precision);
+ gp_Pnt p1 (Node->X(), Node->Y(), Node->Z());
+ bool isInsideBool = isInside( p1.XYZ(), precision );
if (isInsideBool)
{
// I'm only looking in the leaves, since all the nodes are stored there.
if (isLeaf())
{
- gp_Pnt p1 (Node->X(), Node->Y(), Node->Z());
-
- TIDSortedNodeSet myNodesCopy = myNodes;
- TIDSortedNodeSet::iterator it = myNodesCopy.begin();
- double tol2 = precision * precision;
+ TIDSortedNodeSet::iterator it = myNodes.begin();
+ const double tol2 = precision * precision;
bool squareBool;
- while (it != myNodesCopy.end())
+ while (it != myNodes.end())
{
const SMDS_MeshNode* n2 = *it;
+ squareBool = false;
// We're only looking at nodes with a superior Id.
// JFA: Why?
//if (Node->GetID() < n2->GetID())
{
Result->insert(Result->begin(), n2);
SetOfNodes->erase( n2 );
- myNodes.erase( n2 );
+ myNodes.erase( *it++ ); // it++ goes forward and returns it's previous position
}
}
- //myNodesCopy.erase( it );
- //it = myNodesCopy.begin();
- it++;
+ if ( !squareBool )
+ it++;
}
- if (Result->size() > 0)
+ if ( !Result->empty() )
myNodes.erase(Node); // JFA: for bug 0020185
}
else
}
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 pointChild = getChildIndex( toPnt.X(), toPnt.Y(), toPnt.Z(), mid );
if ( nodeChild != pointChild )
SMESH_OctreeNodeIteratorPtr SMESH_OctreeNode::GetChildrenIterator()
{
return SMESH_OctreeNodeIteratorPtr
- ( new SMDS_SetIterator< SMESH_OctreeNode*, SMESH_Octree** >
+ ( new SMDS_SetIterator< SMESH_OctreeNode*, TBaseTree** >
( myChildren, (( isLeaf() || !myChildren ) ? myChildren : &myChildren[ 8 ] )));
}
