SaraP
1660 lines
73 KiB
C++
1660 lines
73 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
/**
|
|
\file
|
|
\brief \ru Дерево габаритных кубов.
|
|
\en Bounding boxes tree. \~
|
|
|
|
*/
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef __MB_CUBE_TREE_H
|
|
#define __MB_CUBE_TREE_H
|
|
|
|
#include <system_cpp_standard.h>
|
|
#include <vector>
|
|
#include <utility>
|
|
#include <iterator>
|
|
#include <algorithm>
|
|
#include <limits>
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
/** \brief \ru Дерево объектов с габаритными кубами.
|
|
\en Tree of objects with bounding boxes. \~
|
|
\details \ru Дерево объектов с габаритными кубами.\n
|
|
Oбъекты дерева должны иметь функции "const Cube & Type::GetCube() const", "double Type::DistanceToCube( const Cube & cube, double eps )".
|
|
\en Tree of objects with bounding boxes.\n
|
|
Tree objects must have functions : "const Cube & Type::GetCube() const", "double Type::DistanceToCube( const Cube & cube, double eps )". \~
|
|
\ingroup Base_Items
|
|
*/
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
class MbCubeTree {
|
|
public:
|
|
typedef std::pair<const Type *,size_t> ItemIndex;
|
|
typedef std::pair<const Type *,const Type *> ItemItem;
|
|
typedef std::vector<ItemIndex> ItemIndexVector;
|
|
typedef std::pair<const Type *,double> ItemDistance;
|
|
typedef std::pair<size_t,double> IndexDistance;
|
|
typedef MbCubeTree<Type,Cube,Point,Vector> TypeTree;
|
|
|
|
/// \ru Тип алгоритма вычисления расстояния от точки до габарита. \en Algorithm type that is used to measure distance between point and bounding box.
|
|
enum DistanceMeasure {
|
|
edm_MaxCoord = 0, ///< \ru Максимальное расстояние вдоль одной из координатных осей. \en Distance maximum along one of coordinate axes.
|
|
edm_CubeCenter, ///< \ru Расстояние до центра габарита объекта. \en Distance to central point of bounding box.
|
|
};
|
|
/// \ru Битовые флаги направлений ветвления. \en Bit flags of branching directions.
|
|
enum BranchingDirections {
|
|
ebd_WasDirX = 0x01, ///< \ru Была попытка ветвления по оси Ox. \en An attempt was made to branch along the Ox axis.
|
|
ebd_WasDirY = 0x02, ///< \ru Была попытка ветвления по оси Oy. \en An attempt was made to branch along the Oy axis.
|
|
ebd_WasDirZ = 0x04, ///< \ru Была попытка ветвления по оси Oz. \en An attempt was made to branch along the Oz axis.
|
|
};
|
|
private:
|
|
/// \ru Координатная ось деления на ветви. \en Selected coordinate axis for branching.
|
|
enum DirectionAxis {
|
|
eda_anyDir = 0, ///< \ru Произвольная координатная ось. \en Arbitrarily coordinate axis.
|
|
eda_axisX = 1, ///< \ru Координатная ось X. \en Coordinate axis X.
|
|
eda_axisY = 2, ///< \ru Координатная ось Y. \en Coordinate axis Y.
|
|
eda_axisZ = 3, ///< \ru Координатная ось Z. \en Coordinate axis Z.
|
|
eda_newDir = 4, ///< \ru Нужен выбор оси в зависимости от битового флага. \en Have to select axis by bit flags of branching.
|
|
};
|
|
|
|
// Selected coordinate axis for branching
|
|
// ^
|
|
// | maximum +-------------+
|
|
// | | upperBranch |
|
|
// | | |
|
|
// | upper +---|-------------|---+
|
|
// | | | | |
|
|
// | midst --------midstBranch-------- or leafObjects for terminal branch content
|
|
// | | | | |
|
|
// | lower +---|-------------|---+
|
|
// | | |
|
|
// | | lowerBranch |
|
|
// | minimum +-------------+
|
|
// |
|
|
|
|
private:
|
|
double midst; ///< \ru Центральное значение по оси direction. \en Central value along "direction" axis.
|
|
double minimum; ///< \ru Минимальное значение по оси direction. \en Minimal value along "direction" axis.
|
|
double maximum; ///< \ru Максимальное значение по оси direction. \en Maximal value along "direction" axis.
|
|
double lower; ///< \ru Размер центральной ветви в сторону увеличения от midst. \en Size of the central branch upward relative to the value of midst.
|
|
double upper; ///< \ru Размер центральной ветви в сторону уменьшения от midst. \en Size of the central branch downward relative to the value of midst.
|
|
DirectionAxis direction; ///< \ru Направление деления на ветви. \en Branching direction.
|
|
DistanceMeasure dmType; ///< \ru Тип расчета расстояния от точки до габарита объекта. \en Distance measurement type between point and bounding box.
|
|
Cube branchCube; ///< \ru Габарит ветви. \en Branch bounding box.
|
|
ItemIndexVector leafObjects; ///< \ru Объекты c габаритами в конечной ветви (листе). \en Objects (with indices in initial array) in terminal branch of tree.
|
|
|
|
TypeTree * midstBranch; ///< \ru Ветвь, элементы которой пересекают центральное значение. \en A branch, whose elements cross the central value.
|
|
TypeTree * lowerBranch; ///< \ru Ветвь, элементы которой меньше центрального значения. \en A branch whose elements are smaller than the central value.
|
|
TypeTree * upperBranch; ///< \ru Ветвь, элементы которой больше центрального значения. \en A branch whose elements are larger than the central value.
|
|
|
|
static size_t treeDepth; ///< \ru Глубина дерева. \en Tree depth.
|
|
static size_t leafMinCount; ///< \ru Минимальное количество элементов в конечной ветви. \en The minimum number of elements in the leaf branch.
|
|
static const double minDoubleValue; ///< \ru Минимальное значение double. \en Min double value.
|
|
static const double maxDoubleValue; ///< \ru Максимальное значение double. \en Max double value.
|
|
static const double defaultEpsilon; ///< \ru Точность по умолчанию. \en Default accuracy.
|
|
|
|
public:
|
|
/**
|
|
\brief \ru Конструктор дерева по объектам.
|
|
\en Tree constructor by objects. \~
|
|
\details \ru Конструктор дерева по объектам. \n
|
|
\en Tree constructor by objects. \n \~
|
|
\param[in] objects - \ru Объекты дерева.
|
|
\en Tree objects. \~
|
|
\param[in] dm - \ru Тип вычисления расстояния от точки до габарита.
|
|
\en Distance measure type between point and bounding box. \~
|
|
*/
|
|
MbCubeTree( std::vector<ItemIndex> & objects, DistanceMeasure dm = edm_MaxCoord );
|
|
/**
|
|
\brief \ru Конструктор дерева по объектам.
|
|
\en Tree constructor by objects. \~
|
|
\details \ru Конструктор дерева по объектам. \n
|
|
\en Tree constructor by objects. \n \~
|
|
\param[in] objects - \ru Объекты дерева.
|
|
\en Tree objects. \~
|
|
\param[in] gabarit - \ru Общий габарит всех объектов дерева, должен быть не пустым.
|
|
\en The total bounding box of all objects in the tree, it must not be empty. \~
|
|
\param[in] dm - \ru Тип вычисления расстояния от точки до габарита.
|
|
\en Distance measure type between point and bounding box. \~
|
|
*/
|
|
MbCubeTree( std::vector<ItemIndex> & objects, const Cube & gabarit, DistanceMeasure dm = edm_MaxCoord );
|
|
/**
|
|
\brief \ru Конструктор пустого дерева.
|
|
\en Constructor of empty tree. \~
|
|
\details \ru Конструктор пустого дерева. \n
|
|
\en Constructor of empty tree. \n \~
|
|
\param[in] dm - \ru Тип вычисления расстояния от точки до габарита.
|
|
\en Distance measure type between point and bounding box. \~
|
|
*/
|
|
MbCubeTree( DistanceMeasure dm = edm_MaxCoord );
|
|
private:
|
|
MbCubeTree( const MbCubeTree & ); // не реализовано / not implemented
|
|
MbCubeTree & operator = ( const MbCubeTree & ); // не реализовано / not implemented
|
|
public:
|
|
/// \ru Деструктор. \en Destuctror.
|
|
~MbCubeTree();
|
|
|
|
public:
|
|
/**
|
|
\brief \ru Инициализация дерева по объектам.
|
|
\en Initialize tree by objects. \~
|
|
\details \ru Инициализация дерева по объектам. \n
|
|
\en Initialize tree by objects. \n \~
|
|
\param[in] objects - \ru Объекты дерева.
|
|
\en Tree objects. \~
|
|
\param[in] gabarit - \ru Общий габарит всех объектов дерева, должен быть не пустым.
|
|
\en The total bounding box of all objects in the tree, it must not be empty. \~
|
|
\param[in] dm - \ru Тип вычисления расстояния от точки до габарита.
|
|
\en Distance measure type between point and bounding box. \~
|
|
*/
|
|
bool InitTree( std::vector<ItemIndex> & objects, const Cube & gabarit, DistanceMeasure dm = edm_MaxCoord );
|
|
/**
|
|
\brief \ru Копировать дерево.
|
|
\en Copy the tree. \~
|
|
\details \ru Копировать дерево. \n
|
|
\en Copy the tree. \n \~
|
|
\param[in] srcTree - \ru Исходное дерево.
|
|
\en Initial tree. \~
|
|
\param[in] copiedObjects - \ru Копии объектов дерева.
|
|
\en Copies of tree objects. \~
|
|
*/
|
|
bool InitTree( const MbCubeTree & srcTree,
|
|
const std::vector<ItemIndex> & srcObjects,
|
|
const std::vector<ItemIndex> & dstObjects );
|
|
/// \ru Очистить дерево. \en Clear the tree.
|
|
void Clear();
|
|
/// \ru Сдвинуть дерево. \en Move the tree.
|
|
void Move( const Vector & );
|
|
|
|
public:
|
|
// функции настроек и состояния дерева / settings and tree state functions
|
|
|
|
/// \ru Получить тип алгоритма вычисления расстояния от точки до габарита. \en Get algorithm type that is used to measure distance between point and bounding box.
|
|
DistanceMeasure GetDistanceMeasure() const { return dmType; }
|
|
|
|
/// \ru Количество объектов в дереве (не хранит, считает обходом дерева). \en Number of objects in the tree (does not store, tree calculates it by traversing tree nodes).
|
|
size_t Count() const;
|
|
|
|
/// \ru Готово ли дерево. \en Whether tree is ready.
|
|
bool IsReady() const;
|
|
|
|
/// \ru Получить глубину дерева (общая переменная). \en Get tree depth (shared variable).
|
|
size_t GetTreeDepth() const { return treeDepth; };
|
|
/// \ru Установить глубину дерева (общая переменная). \en Set tree depth (shared variable).
|
|
void SetTreeDepth( size_t k ) { treeDepth = (std::min)( k, (size_t)64 ); }
|
|
/// \ru Сбросить глубину дерева (общая переменная). \en Reset tree depth (shared variable).
|
|
void ResetTreeDepth() { treeDepth = 64; }
|
|
|
|
/// \ru Получить минимальное количество элементов в конечной ветви (общая переменная). \en Get a minimum number of elements in the leaf branch (shared variable).
|
|
size_t GetLeafMinElementsCount() const { return leafMinCount; }
|
|
/// \ru Установить минимальное количество элементов в конечной ветви (общая переменная). \en Set a minimum number of elements in the leaf branch (shared variable).
|
|
void SetLeafMinElementsCount( size_t k ) { leafMinCount = (std::max)( k, (size_t)1 ); }
|
|
/// \ru Сбросить минимальное количество элементов в конечной ветви (общая переменная). \en Reset the minimum number of elements in the leaf branch (shared variable).
|
|
void ResetLeafMinElementsCount() { leafMinCount = 1; }
|
|
|
|
public:
|
|
// функции работы с деревом объектов / public functions for work with objects tree
|
|
|
|
/// \ru Выдать содержащие точку объекты дерева. \en Get tree objects containing a point.
|
|
void GetContainsObjects ( const Point & pnt, double epsilon,
|
|
std::vector<const Type *> & objects ) const;
|
|
/// \ru Выдать содержащие точку объекты дерева. \en Get tree objects containing a point.
|
|
void GetContainsObjects( const Point & pnt, double epsilon,
|
|
std::vector<size_t> & indices ) const;
|
|
|
|
/// \ru Выдать пересекающиеся с габаритным кубом объекты дерева. \en Get objects of the tree intersecting with the bounding box.
|
|
void GetIntersectObjects( const Cube & gabarit, double epsilon,
|
|
std::vector<const Type *> & objects,
|
|
bool skipOwnself = false ) const;
|
|
/// \ru Выдать пересекающиеся с габаритным кубом объекты дерева. \en Get objects of the tree intersecting with the bounding box.
|
|
void GetIntersectObjects( const Cube & gabarit, double epsilon,
|
|
std::vector<size_t> & indices,
|
|
bool skipOwnself = false ) const;
|
|
|
|
/// \ru Выдать пересекающиеся с отрезком луча кубом объекты дерева. \en Get objects of the tree intersecting with the ray segment.
|
|
void GetIntersectObjects( const Point & rayPnt1, const Point & rayPnt2, double epsilon,
|
|
std::vector<size_t> & indices ) const;
|
|
|
|
/// \ru Найти ближайший к кубу объект дерева. \en Find the nearest tree object to a bounding box.
|
|
void FindNearestObject ( const Cube & gabarit, double & distance,
|
|
const Type *& object,
|
|
double eps = MbCubeTree::defaultEpsilon ) const;
|
|
/// \ru Найти ближайший к кубу объект дерева в виде индекса в исходном массиве. \en Find the nearest tree object to a bounding box (as an index in initial array of objects).
|
|
void FindNearestObject ( const Cube & gabarit, double & distance,
|
|
size_t & index,
|
|
double eps = MbCubeTree::defaultEpsilon ) const;
|
|
/// \ru Найти ближайший к точке объект дерева. \en Find the nearest tree object to a point.
|
|
void FindNearestObject ( const Point & pnt, double & distance,
|
|
const Type *& object,
|
|
double eps = MbCubeTree::defaultEpsilon ) const;
|
|
/// \ru Найти ближайший к точке объект дерева в виде индекса в исходном массиве. \en Find the nearest tree object to a point (as an index in initial array of objects).
|
|
void FindNearestObject ( const Point & pnt, double & distance,
|
|
size_t & index,
|
|
double eps = MbCubeTree::defaultEpsilon ) const;
|
|
|
|
/// \ru Выдать объекты дерева, расположенные к кубу ближе заданного расстояния. \en Get tree objects that are closer to the cube than the specified distance.
|
|
void GetNearestObjects ( const Cube & gabarit, const double distance,
|
|
std::vector<IndexDistance> & itemDistances,
|
|
double eps = MbCubeTree::defaultEpsilon ) const;
|
|
/// \ru Выдать объекты дерева, расположенные к точке ближе заданного расстояния. \en Get tree objects that are closer to the point than the specified distance.
|
|
void GetNearestObjects ( const Point & pnt, const double distance,
|
|
std::vector<ItemDistance> & itemDistances,
|
|
double eps = MbCubeTree::defaultEpsilon ) const;
|
|
/// \ru Выдать индексы объектов дерева, расположенные к точке ближе заданного расстояния. \en Get tree objects indices that are closer to the point than the specified distance.
|
|
void GetNearestObjects ( const Point & pnt, const double distance,
|
|
std::vector<IndexDistance> & indexDistances,
|
|
double eps = MbCubeTree::defaultEpsilon ) const;
|
|
/// \ru Выдать индексы объектов дерева, расположенные к точке ближе заданного расстояния. \en Get tree objects indices that are closer to the point than the specified distance.
|
|
void GetNearestObjects ( const Point & pnt, const double distance,
|
|
std::vector<size_t> & indices,
|
|
double eps = MbCubeTree::defaultEpsilon ) const;
|
|
private:
|
|
// функции инициализация и заполнение ветвей дерева / internal functions for initialization, filling branches
|
|
|
|
/// \ru Копировать дерево. \en Copy the tree.
|
|
bool InitTree( const MbCubeTree & srcTree, const std::vector<ItemItem> & objPair );
|
|
|
|
/// \ru Инициализация дерева по объектам. \en Initialize tree by objects.
|
|
bool InitTree ( std::vector<ItemIndex> & objects, const Cube & gabarit,
|
|
DirectionAxis a, int tier, unsigned char flag );
|
|
/// \ru Заполнение ветвей дерева. \en Fill (set) tree branches.
|
|
void SetBranches( std::vector<ItemIndex> & objects, const Cube & gabarit,
|
|
DirectionAxis a, int tier, unsigned char & flag );
|
|
/// \ru Заполнение конечной ветви дерева. \en Fill terminal tree branch.
|
|
void FillLeaf( std::vector<ItemIndex> & objects, const Cube & gabarit,
|
|
DirectionAxis a );
|
|
|
|
/// \ru Установка битового флага flag в зависимости от направления direction. \en Set direction bit flag.
|
|
void SetFlag( unsigned char & flag );
|
|
/// \ru Получить компонент точки в зависимости от направления direction. \en Get point component by branching direction.
|
|
double GetPointComponent( const Point & pnt ) const;
|
|
/// \ru Получить компонент точки в зависимости от направления direction. \en Get point component by branching direction.
|
|
void GetCubeMinMaxComponents( const Cube & cube, double epsExt, double & wMin, double & wMax ) const;
|
|
/// \ru Измерить расстояние по выбранной в мере. \en Measure distance using selected measure type.
|
|
double GetDistance( const Type & object, const Point & pnt, bool signedDistance ) const;
|
|
|
|
/// \ru Функция сравнения - меньше. \en Compare function "Less".
|
|
static bool LessPairByFirstItem( const ItemItem & e1, const ItemItem & e2 ) { return (e1.first < e2.first) ? true : false; }
|
|
};
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Глубина дерева. \en Tree depth.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
size_t MbCubeTree<Type, Cube, Point, Vector>::treeDepth( 64 );
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Минимальное количество элементов в конечной ветви. \en The minimum number of elements in the leaf branch.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
size_t MbCubeTree<Type, Cube, Point, Vector>::leafMinCount( 1 );
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Минимальное значение double. \en Min double value.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
#ifdef C3D_STANDARD_CXX_11
|
|
const double MbCubeTree<Type, Cube, Point, Vector>::minDoubleValue( (std::numeric_limits<double>::lowest)() );
|
|
#else
|
|
const double MbCubeTree<Type, Cube, Point, Vector>::minDoubleValue( -MB_MAXDOUBLE );
|
|
#endif
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Максимальное значение double. \en Max double value.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
#ifdef C3D_STANDARD_CXX_11
|
|
const double MbCubeTree<Type, Cube, Point, Vector>::maxDoubleValue( (std::numeric_limits<double>::max)() );
|
|
#else
|
|
const double MbCubeTree<Type, Cube, Point, Vector>::maxDoubleValue( MB_MAXDOUBLE );
|
|
#endif
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Точность по умолчанию. \en Default accuracy.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
const double MbCubeTree<Type, Cube, Point, Vector>::defaultEpsilon( 1E-7 );
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Конструктор дерева по объектам. \en Tree constructor by objects.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline MbCubeTree<Type, Cube, Point, Vector>::MbCubeTree( std::vector<ItemIndex> & objects, DistanceMeasure dm )
|
|
: midst ( 0.0 )
|
|
, minimum ( 0.0 )
|
|
, maximum ( 0.0 )
|
|
, lower ( 0.0 )
|
|
, upper ( 0.0 )
|
|
, direction ( eda_anyDir )
|
|
, dmType ( dm )
|
|
, leafObjects( )
|
|
, branchCube ( )
|
|
, midstBranch( nullptr )
|
|
, lowerBranch( nullptr )
|
|
, upperBranch( nullptr )
|
|
{
|
|
size_t cnt = objects.size();
|
|
C3D_ASSERT( Cube::GetDimension() == Point::GetDimension() );
|
|
|
|
if ( cnt > 0 ) { // Инициализация дерева
|
|
Cube gabarit;
|
|
for ( size_t i = 0; i < cnt; ++i ) {
|
|
if ( objects[i].first != nullptr )
|
|
gabarit |= objects[i].first->GetCube();
|
|
}
|
|
branchCube = gabarit;
|
|
InitTree( objects, gabarit, eda_anyDir, 0, 0 );
|
|
ResetLeafMinElementsCount();
|
|
ResetTreeDepth();
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Конструктор дерева по объектам. \en Tree constructor by objects.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline MbCubeTree<Type, Cube, Point, Vector>::MbCubeTree( std::vector<ItemIndex> & objects, const Cube & gabarit, DistanceMeasure dm )
|
|
: midst ( 0.0 )
|
|
, minimum ( 0.0 )
|
|
, maximum ( 0.0 )
|
|
, lower ( 0.0 )
|
|
, upper ( 0.0 )
|
|
, direction ( eda_anyDir )
|
|
, dmType ( dm )
|
|
, leafObjects( )
|
|
, branchCube ( gabarit )
|
|
, midstBranch( nullptr )
|
|
, lowerBranch( nullptr )
|
|
, upperBranch( nullptr )
|
|
{
|
|
C3D_ASSERT( Cube::GetDimension() == Point::GetDimension() );
|
|
InitTree( objects, gabarit, eda_anyDir, 0, 0 );
|
|
ResetLeafMinElementsCount();
|
|
ResetTreeDepth();
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Конструктор дерева. \en Tree constructor.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline MbCubeTree<Type, Cube, Point, Vector>::MbCubeTree( DistanceMeasure dm )
|
|
: midst ( 0.0 )
|
|
, minimum ( 0.0 )
|
|
, maximum ( 0.0 )
|
|
, lower ( 0.0 )
|
|
, upper ( 0.0 )
|
|
, direction ( eda_anyDir )
|
|
, dmType ( dm )
|
|
, leafObjects( )
|
|
, branchCube ( )
|
|
, midstBranch( nullptr )
|
|
, lowerBranch( nullptr )
|
|
, upperBranch( nullptr )
|
|
{
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Очистить дерево. \en Clear the tree.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::Clear()
|
|
{
|
|
delete midstBranch;
|
|
delete lowerBranch;
|
|
delete upperBranch;
|
|
midstBranch = lowerBranch = upperBranch = nullptr;
|
|
midst = minimum = maximum = lower = upper = 0.0;
|
|
direction = eda_anyDir;
|
|
branchCube.SetEmpty();
|
|
leafObjects.clear();
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Деструктор. \en Destructor.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline MbCubeTree<Type, Cube, Point, Vector>::~MbCubeTree()
|
|
{
|
|
delete midstBranch;
|
|
delete lowerBranch;
|
|
delete upperBranch;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Сдвинуть дерево. \en Move the tree.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::Move( const Vector & to )
|
|
{
|
|
if ( to.MaxFactor() > 0.0 ) {
|
|
if ( midstBranch != nullptr )
|
|
midstBranch->Move( to );
|
|
if ( lowerBranch != nullptr )
|
|
lowerBranch->Move( to );
|
|
if ( upperBranch != nullptr )
|
|
upperBranch->Move( to );
|
|
|
|
Point pto;
|
|
pto.Move( to );
|
|
double toValue = GetPointComponent( pto );
|
|
|
|
midst += toValue;
|
|
minimum += toValue;
|
|
maximum += toValue;
|
|
lower += toValue;
|
|
upper += toValue;
|
|
|
|
branchCube.Move( to );
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Копировать дерево. \en Copy the tree.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline bool MbCubeTree<Type, Cube, Point, Vector>::InitTree( const MbCubeTree<Type, Cube, Point, Vector> & srcTree, const std::vector<ItemItem> & itemPairs )
|
|
{
|
|
bool res = true;
|
|
|
|
midst = srcTree.midst;
|
|
minimum = srcTree.minimum;
|
|
maximum = srcTree.maximum;
|
|
lower = srcTree.lower;
|
|
upper = srcTree.upper;
|
|
|
|
direction = srcTree.direction;
|
|
dmType = srcTree.dmType;
|
|
|
|
branchCube = srcTree.branchCube;
|
|
|
|
size_t cnt = srcTree.leafObjects.size();
|
|
leafObjects.resize( cnt );
|
|
|
|
typename std::vector<ItemItem>::const_iterator it;
|
|
ItemItem itemPair( nullptr, nullptr );
|
|
|
|
for ( size_t k = 0; k < cnt && res; ++k ) {
|
|
res = false;
|
|
|
|
leafObjects[k].second = srcTree.leafObjects[k].second;
|
|
|
|
itemPair.first = srcTree.leafObjects[k].first;
|
|
it = std::lower_bound( itemPairs.begin(), itemPairs.end(), itemPair, MbCubeTree<Type, Cube, Point, Vector>::LessPairByFirstItem );
|
|
|
|
if ( it != itemPairs.end() ) {
|
|
if ( !MbCubeTree<Type, Cube, Point, Vector>::LessPairByFirstItem( itemPair, *it ) ) {
|
|
leafObjects[k].first = it->second;
|
|
res = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( res && (srcTree.midstBranch != nullptr) ) {
|
|
C3D_ASSERT( midstBranch == nullptr );
|
|
if ( midstBranch == nullptr )
|
|
midstBranch = new MbCubeTree<Type, Cube, Point, Vector>( srcTree.midstBranch->dmType );
|
|
else
|
|
midstBranch->Clear();
|
|
|
|
res &= midstBranch->InitTree( *srcTree.midstBranch, itemPairs );
|
|
}
|
|
|
|
if ( res && (srcTree.lowerBranch != nullptr) ) {
|
|
C3D_ASSERT( lowerBranch == nullptr );
|
|
if ( lowerBranch == nullptr )
|
|
lowerBranch = new MbCubeTree<Type, Cube, Point, Vector>( srcTree.lowerBranch->dmType );
|
|
else
|
|
lowerBranch->Clear();
|
|
|
|
res &= lowerBranch->InitTree( *srcTree.lowerBranch, itemPairs );
|
|
}
|
|
|
|
if ( res && (srcTree.upperBranch != nullptr) ) {
|
|
C3D_ASSERT( upperBranch == nullptr );
|
|
if ( upperBranch == nullptr )
|
|
upperBranch = new MbCubeTree<Type, Cube, Point, Vector>( srcTree.upperBranch->dmType );
|
|
else
|
|
upperBranch->Clear();
|
|
|
|
res &= upperBranch->InitTree( *srcTree.upperBranch, itemPairs );
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Копировать дерево. \en Copy the tree.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline bool MbCubeTree<Type, Cube, Point, Vector>::InitTree( const MbCubeTree<Type, Cube, Point, Vector> & srcTree,
|
|
const std::vector<ItemIndex> & srcItems,
|
|
const std::vector<ItemIndex> & dstItems )
|
|
{
|
|
bool res = false;
|
|
|
|
Clear();
|
|
|
|
const size_t itemCnt = srcItems.size();
|
|
|
|
if ( (itemCnt > 0) && (itemCnt == dstItems.size()) && srcTree.IsReady() && (srcTree.Count() == itemCnt) ) {
|
|
res = true;
|
|
|
|
std::vector< std::pair<const Type *, const Type *> > itemPairs;
|
|
itemPairs.resize( itemCnt );
|
|
|
|
double eps = defaultEpsilon;
|
|
|
|
size_t k;
|
|
for ( k = 0; k < itemCnt; ++k ) {
|
|
res = false;
|
|
if ( srcItems[k].second == dstItems[k].second ) {
|
|
const Type * srcItem = srcItems[k].first;
|
|
const Type * dstItem = dstItems[k].first;
|
|
if ( (srcItem != dstItem) && (srcItem != nullptr) && (dstItem != nullptr) ) {
|
|
if ( srcItem->IsSame( *dstItem, eps ) ) {
|
|
itemPairs[k].first = srcItem;
|
|
itemPairs[k].second = dstItem;
|
|
res = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if ( res ) {
|
|
res = true;
|
|
if ( itemPairs.size() > 1 ) {
|
|
std::sort( itemPairs.begin(), itemPairs.end() );
|
|
itemPairs.erase( std::unique( itemPairs.begin(), itemPairs.end() ), itemPairs.end() );
|
|
if ( itemPairs.size() != itemCnt )
|
|
res = false;
|
|
}
|
|
}
|
|
if ( res ) {
|
|
res = InitTree( srcTree, itemPairs );
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Инициализация дерева по объектам. \en Initialize tree by objects.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline bool MbCubeTree<Type, Cube, Point, Vector>::InitTree( std::vector<ItemIndex> & objects, const Cube & gabarit, DistanceMeasure dm )
|
|
{
|
|
bool res = false;
|
|
|
|
Clear();
|
|
dmType = dm;
|
|
|
|
size_t cnt = objects.size();
|
|
C3D_ASSERT( Cube::GetDimension() == Point::GetDimension() );
|
|
|
|
if ( cnt > 0 ) { // Инициализация дерева
|
|
res = InitTree( objects, gabarit, eda_anyDir, 0, 0 );
|
|
ResetLeafMinElementsCount();
|
|
ResetTreeDepth();
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Инициализация дерева по объектам. \en Initialize tree by objects.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline bool MbCubeTree<Type, Cube, Point, Vector>::InitTree( std::vector<ItemIndex> & objects, const Cube & gabarit,
|
|
DirectionAxis a, int tier, unsigned char flag )
|
|
{
|
|
bool res = false;
|
|
|
|
size_t iCount = objects.size();
|
|
|
|
if ( iCount > 0 ) { // Инициализация дерева / Initialize tree
|
|
const double eps = defaultEpsilon;
|
|
|
|
const size_t gabDim = gabarit.GetDimension();
|
|
|
|
// slow : memory reallocation
|
|
//std::vector< std::pair<double,double> > gabLimits;
|
|
//std::vector<double> gabLens;
|
|
//gabLimits.reserve( gabDim );
|
|
//gabLens.reserve( gabDim );
|
|
|
|
double gabLens[3];
|
|
C3D_ASSERT( gabDim < 4 );
|
|
|
|
bool validLimits = true;
|
|
{
|
|
double gabMin, gabMax, gabLen;
|
|
for ( size_t i = 0; i < gabDim; ++i ) {
|
|
gabMin = gabarit.GetMin(i);
|
|
gabMax = gabarit.GetMax(i);
|
|
gabLen = gabMax - gabMin;
|
|
|
|
// slow : memory reallocation
|
|
//gabLimits.push_back( std::make_pair( gabMin, gabMax ) );
|
|
//gabLens.push_back( gabLen );
|
|
//gabLimits[i] = std::make_pair( gabMin, gabMax );
|
|
gabLens[i] = gabLen;
|
|
|
|
validLimits &= (gabLen > -eps);
|
|
}
|
|
}
|
|
|
|
if ( validLimits ) {
|
|
res = true;
|
|
|
|
branchCube = gabarit;
|
|
|
|
if ( (tier < treeDepth) && (iCount > leafMinCount) ) {
|
|
// если ось указана, то следующее разделение должно выполниться по другой оси
|
|
switch ( a ) {
|
|
|
|
case eda_axisX : { // разделение на ветви по по наиболее вытянутой оси Y или Z
|
|
if ( gabDim == 3 ) {
|
|
if ( gabLens[1] - eps > gabLens[2] )
|
|
SetBranches( objects, gabarit, eda_axisY, tier, flag );
|
|
else
|
|
SetBranches( objects, gabarit, eda_axisZ, tier, flag );
|
|
}
|
|
else if ( gabDim == 2 ) {
|
|
SetBranches( objects, gabarit, eda_axisY, tier, flag );
|
|
}
|
|
} break;
|
|
|
|
case eda_axisY : { // разделение на ветви по по наиболее вытянутой оси Z или X
|
|
if ( gabDim == 3 ) {
|
|
if ( gabLens[2] - eps > gabLens[0] )
|
|
SetBranches( objects, gabarit, eda_axisZ, tier, flag );
|
|
else
|
|
SetBranches( objects, gabarit, eda_axisX, tier, flag );
|
|
}
|
|
else if ( gabDim == 2 ) {
|
|
SetBranches( objects, gabarit, eda_axisX, tier, flag );
|
|
}
|
|
} break;
|
|
|
|
case eda_axisZ : { // разделение на ветви по по наиболее вытянутой оси X или Y
|
|
if ( gabDim == 3 ) {
|
|
if ( gabLens[0] - eps > gabLens[1] )
|
|
SetBranches( objects, gabarit, eda_axisX, tier, flag );
|
|
else
|
|
SetBranches( objects, gabarit, eda_axisY, tier, flag );
|
|
}
|
|
else {
|
|
C3D_ASSERT_UNCONDITIONAL( false );
|
|
}
|
|
} break;
|
|
|
|
case eda_newDir : { // разделение на ветви по ещё не использованному направлению
|
|
if ( gabDim == 3 ) {
|
|
if ( flag & ebd_WasDirX ) { // попытка разделения по оси X не удалась
|
|
if ( gabLens[1] + eps > gabLens[2] && !(flag & ebd_WasDirY) )
|
|
SetBranches( objects, gabarit, eda_axisY, tier, flag );
|
|
else {
|
|
if ( !(flag & ebd_WasDirZ) )
|
|
SetBranches( objects, gabarit, eda_axisZ, tier, flag );
|
|
else { // исчерпаны все возможности разделения
|
|
FillLeaf( objects, gabarit, eda_axisZ );
|
|
}
|
|
}
|
|
}
|
|
else if ( flag & ebd_WasDirY ) { // попытка разделения по оси Y не удалась
|
|
if ( gabLens[2] - eps > gabLens[0] && !(flag & ebd_WasDirZ) )
|
|
SetBranches( objects, gabarit, eda_axisZ, tier, flag );
|
|
else
|
|
SetBranches( objects, gabarit, eda_axisX, tier, flag );
|
|
}
|
|
else { // попытка разделения по оси Z не удалась
|
|
if ( gabLens[0] + eps > gabLens[1] )
|
|
SetBranches( objects, gabarit, eda_axisX, tier, flag );
|
|
else
|
|
SetBranches( objects, gabarit, eda_axisY, tier, flag );
|
|
}
|
|
}
|
|
else if ( gabDim == 2 ) {
|
|
if ( flag & ebd_WasDirX ) { // попытка разделения по оси X не удалась
|
|
if ( !(flag & ebd_WasDirY) )
|
|
SetBranches( objects, gabarit, eda_axisY, tier, flag );
|
|
else { // исчерпаны все возможности разделения
|
|
FillLeaf( objects, gabarit, eda_axisY );
|
|
}
|
|
}
|
|
else if ( flag & ebd_WasDirY ) { // попытка разделения по оси Y не удалась
|
|
if ( !(flag & ebd_WasDirX) )
|
|
SetBranches( objects, gabarit, eda_axisX, tier, flag );
|
|
else { // исчерпаны все возможности разделения
|
|
FillLeaf( objects, gabarit, eda_axisX );
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
C3D_ASSERT_UNCONDITIONAL( false );
|
|
}
|
|
} break;
|
|
|
|
default : { // разделение на ветви по наиболее вытянутой оси
|
|
if ( gabDim == 3 ) {
|
|
if ( (gabLens[0] + eps > gabLens[1]) && (gabLens[0] + eps > gabLens[2]) )
|
|
SetBranches( objects, gabarit, eda_axisX, tier, flag );
|
|
else if ( gabLens[1] + eps > gabLens[2] )
|
|
SetBranches( objects, gabarit, eda_axisY, tier, flag );
|
|
else
|
|
SetBranches( objects, gabarit, eda_axisZ, tier, flag );
|
|
}
|
|
else if ( gabDim == 2 ) {
|
|
if ( gabLens[0] + eps > gabLens[1] )
|
|
SetBranches( objects, gabarit, eda_axisX, tier, flag );
|
|
else
|
|
SetBranches( objects, gabarit, eda_axisY, tier, flag );
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
else { // один объект или достигнут максимальный уровень вложенности
|
|
if ( (a == eda_anyDir) || (a == eda_newDir) ) {
|
|
if ( gabDim == 3 ) {
|
|
if ( (gabLens[0] + eps > gabLens[1]) && (gabLens[0] + eps > gabLens[2]) )
|
|
a = eda_axisX;
|
|
else if ( gabLens[1] + eps > gabLens[2] )
|
|
a = eda_axisY;
|
|
else
|
|
a = eda_axisZ;
|
|
}
|
|
else if ( gabDim == 2 ) {
|
|
if ( gabLens[0] + eps > gabLens[1] )
|
|
a = eda_axisX;
|
|
else
|
|
a = eda_axisY;
|
|
}
|
|
}
|
|
FillLeaf( objects, gabarit, a );
|
|
}
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// установка ветвей
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::SetBranches( std::vector<ItemIndex> & objects, const Cube & gabarit,
|
|
DirectionAxis a, int tier, unsigned char & flag )
|
|
{
|
|
direction = a;
|
|
const size_t iCount = objects.size();
|
|
double eps = defaultEpsilon;
|
|
|
|
GetCubeMinMaxComponents( gabarit, eps, minimum, maximum );
|
|
|
|
midst = 0.5 * (minimum + maximum); // центральное значение
|
|
lower = midst;
|
|
upper = midst;
|
|
|
|
size_t lowerCount = 0;
|
|
size_t upperCount = 0;
|
|
size_t midstCount = 0;
|
|
|
|
Cube lowerGabarit;
|
|
Cube upperGabarit;
|
|
Cube midstGabarit;
|
|
|
|
for ( size_t i = 0; i < iCount; ++i ) {
|
|
const ItemIndex & obj = objects[i];
|
|
if ( obj.first != nullptr ) {
|
|
const Cube & cube = obj.first->GetCube();
|
|
|
|
double pMin, pMax;
|
|
GetCubeMinMaxComponents( cube, 0.0, pMin, pMax );
|
|
|
|
if ( pMax < midst - eps ) {
|
|
lowerCount++;
|
|
lowerGabarit |= cube;
|
|
}
|
|
else if ( pMin > midst + eps ) {
|
|
upperCount++;
|
|
upperGabarit |= cube;
|
|
}
|
|
else {
|
|
lower = std_min( lower, pMin );
|
|
upper = std_max( upper, pMax );
|
|
midstCount++;
|
|
midstGabarit |= cube;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<ItemIndex> lowerArray;
|
|
std::vector<ItemIndex> upperArray;
|
|
std::vector<ItemIndex> midstArray;
|
|
|
|
lowerArray.reserve( lowerCount );
|
|
upperArray.reserve( upperCount );
|
|
midstArray.reserve( midstCount );
|
|
|
|
// KOMPAS-46058
|
|
//size_t iDelta = std_max( (size_t)1, iCount / 8 );
|
|
//lowerArray.reserve( iDelta );
|
|
//upperArray.reserve( iDelta );
|
|
//midstArray.reserve( iDelta );
|
|
|
|
for ( size_t i = 0; i < iCount; ++i ) {
|
|
const ItemIndex & obj = objects[i];
|
|
if ( obj.first != nullptr ) {
|
|
const Cube & cube = obj.first->GetCube();
|
|
|
|
double pMin, pMax;
|
|
GetCubeMinMaxComponents( cube, 0.0, pMin, pMax );
|
|
|
|
if ( pMax < midst - eps ) { // объект расположен ниже центрального значения
|
|
lowerArray.emplace_back( obj );
|
|
}
|
|
else if ( pMin > midst + eps ) { // объект расположен выше центрального значения
|
|
upperArray.emplace_back( obj );
|
|
}
|
|
else { // объект содержит центральное значение
|
|
lower = std_min( lower, pMin );
|
|
upper = std_max( upper, pMax );
|
|
midstArray.emplace_back( obj );
|
|
}
|
|
}
|
|
}
|
|
|
|
lower -= eps; // верхний размер центральной ветви, расширенный на погрешность
|
|
upper += eps; // нижний размер центральной ветви, расширенный на погрешность
|
|
|
|
lowerCount = lowerArray.size();
|
|
upperCount = upperArray.size();
|
|
midstCount = midstArray.size();
|
|
|
|
if ( (lowerCount > 0) || (upperCount > 0) ) {
|
|
if ( lowerCount > 0 ) { // нижняя ветвь / lower branch
|
|
C3D_ASSERT ( lowerBranch == nullptr );
|
|
if ( lowerBranch == nullptr )
|
|
lowerBranch = new MbCubeTree<Type,Cube,Point,Vector>( dmType );
|
|
lowerBranch->InitTree( lowerArray, lowerGabarit, eda_anyDir, tier+1, 0 );
|
|
lowerArray.clear();
|
|
}
|
|
if ( upperCount > 0 ) { // верхняя ветвь / upper branch
|
|
C3D_ASSERT( upperBranch == nullptr );
|
|
if ( upperBranch == nullptr )
|
|
upperBranch = new MbCubeTree<Type,Cube,Point,Vector>( dmType );
|
|
upperBranch->InitTree( upperArray, upperGabarit, eda_anyDir, tier+1, 0 );
|
|
upperArray.clear();
|
|
}
|
|
if ( midstCount > 0 ) { // центральная ветвь / central branch
|
|
C3D_ASSERT( midstBranch == nullptr );
|
|
if ( midstBranch == nullptr )
|
|
midstBranch = new MbCubeTree<Type,Cube,Point,Vector>( dmType );
|
|
midstBranch->InitTree( midstArray, midstGabarit, direction, tier+1, 0 );
|
|
midstArray.clear();
|
|
}
|
|
}
|
|
else { // попытка разделить на ветви по-другому, ещё не использованному направлению
|
|
bool freeDir = false;
|
|
|
|
const size_t gabDim = gabarit.GetDimension();
|
|
if ( gabDim == 3 ) {
|
|
freeDir = !((flag & ebd_WasDirX) &&
|
|
(flag & ebd_WasDirY) &&
|
|
(flag & ebd_WasDirZ));
|
|
}
|
|
else if ( gabDim == 2 ) {
|
|
freeDir = !((flag & ebd_WasDirX) &&
|
|
(flag & ebd_WasDirY));
|
|
}
|
|
|
|
if ( midstCount > leafMinCount && freeDir ) {
|
|
// установка битового флага flag в зависимости от направления direction
|
|
SetFlag( flag );
|
|
InitTree( midstArray, midstGabarit, eda_newDir, tier, flag );
|
|
midstArray.clear();
|
|
}
|
|
else { // разделение на ветви не произошло ни по одному направлению
|
|
branchCube = gabarit;
|
|
leafObjects = std::move( objects );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// установка битового флага flag в зависимости от направления direction
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::SetFlag( unsigned char & flag )
|
|
{
|
|
if ( direction == eda_axisX )
|
|
flag |= ebd_WasDirX;
|
|
else if ( direction == eda_axisY )
|
|
flag |= ebd_WasDirY;
|
|
else if ( direction == eda_axisZ )
|
|
flag |= ebd_WasDirZ;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Получить компонент точки в зависимости от направления direction. \en Get point component by branching direction.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline double MbCubeTree<Type, Cube, Point, Vector>::GetPointComponent( const Point & pnt ) const
|
|
{
|
|
double w = minDoubleValue;
|
|
|
|
switch ( direction ) {
|
|
case eda_axisX : { w = pnt[0]; } break;
|
|
case eda_axisY : { w = pnt[1]; } break;
|
|
case eda_axisZ : { w = pnt[2]; } break;
|
|
case eda_anyDir : { C3D_ASSERT_UNCONDITIONAL( false ); } break;
|
|
case eda_newDir : { C3D_ASSERT_UNCONDITIONAL( false ); } break;
|
|
default: break;
|
|
}
|
|
return w;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Получить компонент точки в зависимости от направления direction. \en Get point component by branching direction.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::GetCubeMinMaxComponents( const Cube & cube, double eps, double & wMin, double & wMax ) const
|
|
{
|
|
wMin = maxDoubleValue;
|
|
wMax = minDoubleValue;
|
|
|
|
switch ( direction ) {
|
|
case eda_axisX: { wMin = cube.GetMin( 0 ) - eps; wMax = cube.GetMax( 0 ) + eps; } break;
|
|
case eda_axisY: { wMin = cube.GetMin( 1 ) - eps; wMax = cube.GetMax( 1 ) + eps; } break;
|
|
case eda_axisZ: { wMin = cube.GetMin( 2 ) - eps; wMax = cube.GetMax( 2 ) + eps; } break;
|
|
case eda_anyDir: { C3D_ASSERT_UNCONDITIONAL( false ); } break;
|
|
case eda_newDir: { C3D_ASSERT_UNCONDITIONAL( false ); } break;
|
|
default: break;
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Заполнение конечной ветви дерева (установка конечной ветви). \en Fill (set) terminal tree branch.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::FillLeaf( std::vector<ItemIndex> & objects, const Cube & gabarit, DirectionAxis a )
|
|
{
|
|
direction = a;
|
|
const double eps = defaultEpsilon;
|
|
GetCubeMinMaxComponents( gabarit, eps, minimum, maximum );
|
|
|
|
midst = 0.5 * (minimum + maximum); // центральное значение
|
|
lower = minimum;
|
|
upper = maximum;
|
|
|
|
branchCube = gabarit;
|
|
|
|
leafObjects = std::move( objects );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Готово ли дерево. \en Whether tree is ready.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline bool MbCubeTree<Type, Cube, Point, Vector>::IsReady() const
|
|
{
|
|
return ( (midstBranch != nullptr) ||
|
|
(lowerBranch != nullptr) ||
|
|
(upperBranch != nullptr) ||
|
|
(leafObjects.size() > 0) );
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Количество объектов в дереве. \en Number of objects in the tree.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline size_t MbCubeTree<Type, Cube, Point, Vector>::Count() const
|
|
{
|
|
size_t cnt = leafObjects.size();
|
|
|
|
if ( midstBranch != nullptr )
|
|
cnt += midstBranch->Count();
|
|
if ( lowerBranch != nullptr )
|
|
cnt += lowerBranch->Count();
|
|
if ( upperBranch != nullptr )
|
|
cnt += upperBranch->Count();
|
|
|
|
return cnt;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Выдать содержащие точку объекты дерева. \en Get tree objects containing a point.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::GetContainsObjects( const Point & pnt, double epsilon,
|
|
std::vector<const Type *> & items ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double w = GetPointComponent( pnt );
|
|
|
|
if ( (w < (minimum - epsilon)) || ((maximum + epsilon) < w) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (w < (midst + epsilon)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->GetContainsObjects( pnt, epsilon, items );
|
|
}
|
|
if ( ((midst - epsilon) < w) && (upperBranch != nullptr) ) {
|
|
upperBranch->GetContainsObjects( pnt, epsilon, items );
|
|
}
|
|
if ( ((lower - epsilon) < w) && (w < (upper + epsilon)) && (midstBranch != nullptr) ) {
|
|
midstBranch->GetContainsObjects( pnt, epsilon, items );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
size_t iCount = leafObjects.size();
|
|
items.reserve( items.size() + iCount );
|
|
for ( size_t i = 0; i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
if ( obj.first->GetCube().Contains( pnt, epsilon ) )
|
|
items.push_back( obj.first );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Выдать содержащие точку объекты дерева. \en Get tree objects containing a point.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::GetContainsObjects( const Point & pnt, double epsilon,
|
|
std::vector<size_t> & indices ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double w = GetPointComponent( pnt );
|
|
|
|
if ( (w < (minimum - epsilon)) || ((maximum + epsilon) < w) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (w < (midst + epsilon)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->GetContainsObjects( pnt, epsilon, indices );
|
|
}
|
|
if ( ((midst - epsilon) < w) && (upperBranch != nullptr) ) {
|
|
upperBranch->GetContainsObjects( pnt, epsilon, indices );
|
|
}
|
|
if ( ((lower - epsilon) < w) && (w < (upper + epsilon)) && (midstBranch != nullptr) ) {
|
|
midstBranch->GetContainsObjects( pnt, epsilon, indices );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
size_t iCount = leafObjects.size();
|
|
indices.reserve( indices.size() + iCount );
|
|
for ( size_t i = 0; i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
if ( obj.first->GetCube().Contains( pnt, epsilon ) )
|
|
indices.push_back( obj.second );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Выдать пересекающиеся с габаритным кубом объекты дерева. \en Get objects of the tree intersecting with the bounding box.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::GetIntersectObjects( const Cube & gabarit, double epsilon,
|
|
std::vector<const Type *> & items,
|
|
bool skipOwnself ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double wMin, wMax;
|
|
GetCubeMinMaxComponents( gabarit, 0.0, wMin, wMax );
|
|
|
|
if ( (wMax < minimum) || (maximum < wMin) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (wMin < midst) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->GetIntersectObjects( gabarit, epsilon, items, skipOwnself );
|
|
}
|
|
if ( (midst < wMax) && (upperBranch != nullptr) ) {
|
|
upperBranch->GetIntersectObjects( gabarit, epsilon, items, skipOwnself );
|
|
}
|
|
if ( (lower < wMax) && (wMin < upper) && (midstBranch != nullptr) ) {
|
|
midstBranch->GetIntersectObjects( gabarit, epsilon, items, skipOwnself );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
size_t iCount = leafObjects.size();
|
|
items.reserve( items.size() + iCount );
|
|
for ( size_t i = 0; i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
if ( !skipOwnself || (&gabarit != &static_cast<const Cube &>(obj.first->GetCube()) ) ) { // KOMPAS-20871
|
|
if ( obj.first->GetCube().Intersect( gabarit, epsilon ) )
|
|
items.push_back( obj.first );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Выдать пересекающиеся с габаритным кубом объекты дерева. \en Get objects of the tree intersecting with the bounding box.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::GetIntersectObjects( const Cube & gabarit, double epsilon,
|
|
std::vector<size_t> & items,
|
|
bool skipOwnself ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double wMin, wMax;
|
|
GetCubeMinMaxComponents( gabarit, 0.0, wMin, wMax );
|
|
|
|
if ( (wMax < minimum) || (maximum < wMin) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (wMin < midst) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->GetIntersectObjects( gabarit, epsilon, items, skipOwnself );
|
|
}
|
|
if ( (midst < wMax) && (upperBranch != nullptr) ) {
|
|
upperBranch->GetIntersectObjects( gabarit, epsilon, items, skipOwnself );
|
|
}
|
|
if ( (lower < wMax) && (wMin < upper) && (midstBranch != nullptr) ) {
|
|
midstBranch->GetIntersectObjects( gabarit, epsilon, items, skipOwnself );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
size_t iCount = leafObjects.size();
|
|
items.reserve( items.size() + iCount );
|
|
for ( size_t i = 0; i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
if ( !skipOwnself || (&gabarit != &static_cast<const Cube &>(obj.first->GetCube()) ) ) { // KOMPAS-20871
|
|
if ( obj.first->GetCube().Intersect( gabarit, epsilon ) )
|
|
items.push_back( obj.second );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Выдать пересекающиеся с отрезком луча кубом объекты дерева. \en Get objects of the tree intersecting with the ray segment.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::GetIntersectObjects( const Point & rayPnt1, const Point & rayPnt2, double eps,
|
|
std::vector<size_t> & itemIndices ) const
|
|
{
|
|
bool isBranch = (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr);
|
|
|
|
bool isLeaf = !leafObjects.empty();
|
|
|
|
Point segmPnt1( rayPnt1 ), segmPnt2( rayPnt2 );
|
|
double segmLen = segmPnt1.DistanceToPoint( segmPnt2 );
|
|
|
|
C3D_ASSERT( !branchCube.IsEmpty() );
|
|
C3D_ASSERT( !rayPnt1.IsSame( rayPnt2, eps ) );
|
|
|
|
if ( isBranch || isLeaf ) {
|
|
if ( !branchCube.IsEmpty() && !rayPnt1.IsSame( rayPnt2, eps ) ) {
|
|
Vector rayVect( rayPnt1, rayPnt2 );
|
|
{
|
|
double rayLen = rayVect.Length();
|
|
rayVect /= rayLen;
|
|
}
|
|
double minParam = maxDoubleValue;
|
|
double maxParam = minDoubleValue;
|
|
|
|
Point vertPnt;
|
|
Vector vertVect;
|
|
size_t vertCnt = branchCube.GetVerticesCount();
|
|
for ( size_t vertInd = 0; vertInd < vertCnt; ++vertInd ) {
|
|
branchCube.GetVertex( vertInd, vertPnt );
|
|
vertVect.Init( rayPnt1, vertPnt );
|
|
double vt = (rayVect * vertVect);
|
|
if ( vt < minParam )
|
|
minParam = vt;
|
|
if ( vt > maxParam )
|
|
maxParam = vt;
|
|
}
|
|
segmPnt1.Set( rayPnt1, rayVect, minParam );
|
|
segmPnt2.Set( rayPnt1, rayVect, maxParam );
|
|
segmLen = segmPnt1.DistanceToPoint( segmPnt2 );
|
|
}
|
|
}
|
|
|
|
if ( isBranch ) {
|
|
double w1 = minDoubleValue;
|
|
double w2 = minDoubleValue;
|
|
|
|
switch ( direction ) {
|
|
case eda_axisX : { w1 = segmPnt1[0]; w2 = segmPnt2[0]; } break;
|
|
case eda_axisY : { w1 = segmPnt1[1]; w2 = segmPnt2[1]; } break;
|
|
case eda_axisZ : { w1 = segmPnt1[2]; w2 = segmPnt2[2]; } break;
|
|
case eda_anyDir : { C3D_ASSERT_UNCONDITIONAL( false ); } break;
|
|
case eda_newDir : { C3D_ASSERT_UNCONDITIONAL( false ); } break;
|
|
default: break;
|
|
}
|
|
|
|
double wMin = std_min( w1, w2 );
|
|
double wMax = std_max( w1, w2 );
|
|
|
|
if ( (wMax < (minimum - eps)) || ((maximum + eps) < wMin) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (wMin < (midst + eps)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->GetIntersectObjects( segmPnt1, segmPnt2, eps, itemIndices );
|
|
}
|
|
if ( (wMax > (midst - eps)) && (upperBranch != nullptr) ) {
|
|
upperBranch->GetIntersectObjects( segmPnt1, segmPnt2, eps, itemIndices );
|
|
}
|
|
if ( (wMax > (lower - eps)) && (wMin < (upper + eps)) && (midstBranch != nullptr) ) {
|
|
midstBranch->GetIntersectObjects( segmPnt1, segmPnt2, eps, itemIndices );
|
|
}
|
|
}
|
|
else if ( isLeaf ) { // содержимое конечной ветви // terminal branch content
|
|
const Cube segmCube( segmPnt1, segmPnt2, true );
|
|
|
|
Point objPnt, segmPnt;
|
|
segmPnt.Set( segmPnt1, 0.5, segmPnt2, 0.5 );
|
|
|
|
Vector vect1, vect2;
|
|
|
|
size_t iCount = leafObjects.size();
|
|
itemIndices.reserve( itemIndices.size() + iCount );
|
|
for ( size_t i = 0; i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
bool add = false;
|
|
|
|
const Cube & objCube = obj.first->GetCube();
|
|
|
|
if ( objCube.Contains( segmPnt, eps ) )
|
|
add = true;
|
|
else if ( objCube.Intersect( segmCube, eps ) ) {
|
|
add = true;
|
|
|
|
if ( segmLen > eps ) {
|
|
objCube.GetCenter( objPnt );
|
|
double objDist = 0.5 * objCube.GetDiagonal();
|
|
|
|
vect1.Init( segmPnt1, objPnt );
|
|
vect2.Init( segmPnt1, segmPnt2 );
|
|
vect2 /= segmLen;
|
|
vect2 = (vect1 * vect2) * vect2;
|
|
vect1 -= vect2;
|
|
double d = ::sqrt( vect1 * vect1 );
|
|
|
|
if ( d > objDist + eps )
|
|
add = false;
|
|
}
|
|
}
|
|
if ( add )
|
|
itemIndices.push_back( obj.second );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Измерить расстояние по выбранной в мере
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline double MbCubeTree<Type, Cube, Point, Vector>::GetDistance( const Type & object, const Point & pnt, bool signedDistance ) const
|
|
{
|
|
double d = maxDoubleValue;
|
|
|
|
if ( dmType == edm_MaxCoord )
|
|
d = object.GetCube().DistanceToPoint( pnt );
|
|
else if ( dmType == edm_CubeCenter ) {
|
|
Point pnt0;
|
|
object.GetCube().GetCenter( pnt0 );
|
|
d = pnt0.DistanceToPoint( pnt );
|
|
}
|
|
|
|
if ( !signedDistance )
|
|
d = ::fabs(d);
|
|
|
|
return d;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Найти ближайший к кубу объект дерева. \en Find the nearest tree object to a bounding box.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::FindNearestObject( const Cube & gabarit, double & distance, const Type *& item, double eps ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double wMin, wMax;
|
|
GetCubeMinMaxComponents( gabarit, 0.0, wMin, wMax );
|
|
|
|
if ( (wMax < (minimum-distance)) || ((maximum+distance) < wMin) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (wMin < (midst+distance)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->FindNearestObject( gabarit, distance, item, eps );
|
|
}
|
|
if ( ((midst-distance) < wMax) && (upperBranch != nullptr) ) {
|
|
upperBranch->FindNearestObject( gabarit, distance, item, eps );
|
|
}
|
|
if ( ((lower-distance) < wMax) && (wMin < (upper+distance)) && (midstBranch != nullptr) ) {
|
|
midstBranch->FindNearestObject( gabarit, distance, item, eps );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
for ( size_t i = 0, iCount = leafObjects.size(); i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
double d = obj.first->GetCube().DistanceToCube( gabarit, eps );
|
|
if ( distance > d - eps ) {
|
|
item = obj.first;
|
|
distance = d;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Найти ближайший к кубу объект дерева в виде индекса в исходном массиве. \en Find the nearest tree object to a bounding box (as an index in initial array of objects).
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::FindNearestObject( const Cube & gabarit, double & distance, size_t & index, double eps ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double wMin, wMax;
|
|
GetCubeMinMaxComponents( gabarit, 0.0, wMin, wMax );
|
|
|
|
if ( (wMax < (minimum-distance)) || ((maximum+distance) < wMin) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (wMin < (midst+distance)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->FindNearestObject( gabarit, distance, index, eps );
|
|
}
|
|
if ( ((midst-distance) < wMax) && (upperBranch != nullptr) ) {
|
|
upperBranch->FindNearestObject( gabarit, distance, index, eps );
|
|
}
|
|
if ( ((lower-distance) < wMax) && (wMin < (upper+distance)) && (midstBranch != nullptr) ) {
|
|
midstBranch->FindNearestObject( gabarit, distance, index, eps );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
for ( size_t i = 0, iCount = leafObjects.size(); i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
double d = obj.first->GetCube().DistanceToCube( gabarit, eps );
|
|
if ( distance > d - eps ) {
|
|
index = obj.second;
|
|
distance = d;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Выдать объекты дерева, расположенные к кубу ближе заданного расстояния. \en Get tree objects that are closer to the cube than the specified distance.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::GetNearestObjects( const Cube & gabarit, const double distance,
|
|
std::vector<IndexDistance> & itemDistances,
|
|
double eps ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double wMin, wMax;
|
|
GetCubeMinMaxComponents( gabarit, 0.0, wMin, wMax );
|
|
|
|
if ( (wMax < (minimum-distance)) || ((maximum+distance) < wMin) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (wMin < (midst+distance)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->GetNearestObjects( gabarit, distance, itemDistances, eps );
|
|
}
|
|
if ( ((midst-distance) < wMax) && (upperBranch != nullptr) ) {
|
|
upperBranch->GetNearestObjects( gabarit, distance, itemDistances, eps );
|
|
}
|
|
if ( ((lower-distance) < wMax) && (wMin < (upper+distance)) && (midstBranch != nullptr) ) {
|
|
midstBranch->GetNearestObjects( gabarit, distance, itemDistances, eps );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
for ( size_t i = 0, iCount = leafObjects.size(); i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
double d = obj.first->GetCube().DistanceToCube( gabarit, eps );
|
|
if ( distance > d - eps ) {
|
|
IndexDistance itemDistance( obj.second, d );
|
|
itemDistances.push_back( itemDistance );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Найти ближайший к точке объект дерева. \en Find the nearest tree object to a point.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::FindNearestObject( const Point & pnt, double & distance, const Type *& item, double eps ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double w = GetPointComponent( pnt );
|
|
|
|
if ( (w < (minimum-distance)) || ((maximum+distance) < w) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (w < (midst+distance)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->FindNearestObject( pnt, distance, item, eps );
|
|
}
|
|
if ( ((midst-distance) < w) && (upperBranch != nullptr) ) {
|
|
upperBranch->FindNearestObject( pnt, distance, item, eps );
|
|
}
|
|
if ( ((lower-distance) < w) && (w < (upper+distance)) && (midstBranch != nullptr) ) {
|
|
midstBranch->FindNearestObject( pnt, distance, item, eps );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
for ( size_t i = 0, iCount = leafObjects.size(); i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
double d = GetDistance( *obj.first, pnt, false );
|
|
if ( distance > d - eps ) {
|
|
item = obj.first;
|
|
distance = d;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// Выдать ближайший к точке объект дерева
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::FindNearestObject( const Point & pnt, double & distance, size_t & index, double eps ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double w = GetPointComponent( pnt );
|
|
|
|
if ( (w < (minimum-distance)) || ((maximum+distance) < w) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (w < (midst+distance)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->FindNearestObject( pnt, distance, index, eps );
|
|
}
|
|
if ( ((midst-distance) < w) && (upperBranch != nullptr) ) {
|
|
upperBranch->FindNearestObject( pnt, distance, index, eps );
|
|
}
|
|
if ( ((lower-distance) < w) && (w < (upper+distance)) && (midstBranch != nullptr) ) {
|
|
midstBranch->FindNearestObject( pnt, distance, index, eps );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
for ( size_t i = 0, iCount = leafObjects.size(); i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
double d = GetDistance( *obj.first, pnt, false );
|
|
if ( distance > d - eps ) {
|
|
index = obj.second;
|
|
distance = d;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Выдать объекты дерева, расположенные к точке ближе заданного расстояния. \en Get tree objects that are closer to the point than the specified distance.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::GetNearestObjects( const Point & pnt, const double distance,
|
|
std::vector<ItemDistance> & itemDistances,
|
|
double eps ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double w = GetPointComponent( pnt );
|
|
|
|
if ( (w < (minimum-distance)) || ((maximum+distance) < w) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (w < (midst+distance)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->GetNearestObjects( pnt, distance, itemDistances, eps );
|
|
}
|
|
if ( ((midst-distance) < w) && (upperBranch != nullptr) ) {
|
|
upperBranch->GetNearestObjects( pnt, distance, itemDistances, eps );
|
|
}
|
|
if ( ((lower-distance) < w) && (w < (upper+distance)) && (midstBranch != nullptr) ) {
|
|
midstBranch->GetNearestObjects( pnt, distance, itemDistances, eps );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
size_t iCount = leafObjects.size();
|
|
itemDistances.reserve( itemDistances.size() + iCount );
|
|
for ( size_t i = 0; i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
double d = GetDistance( *obj.first, pnt, true );
|
|
if ( distance > d - eps ) {
|
|
ItemDistance itemDistance( obj.first, d );
|
|
itemDistances.push_back( itemDistance );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Выдать индексы объектов дерева, расположенные к точке ближе заданного расстояния. \en Get tree objects indices that are closer to the point than the specified distance.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::GetNearestObjects( const Point & pnt, const double distance,
|
|
std::vector<IndexDistance> & itemDistances,
|
|
double eps ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double w = GetPointComponent( pnt );
|
|
|
|
if ( (w < (minimum-distance)) || ((maximum+distance) < w) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (w < (midst+distance)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->GetNearestObjects( pnt, distance, itemDistances, eps );
|
|
}
|
|
if ( ((midst-distance) < w) && (upperBranch != nullptr) ) {
|
|
upperBranch->GetNearestObjects( pnt, distance, itemDistances, eps );
|
|
}
|
|
if ( ((lower-distance) < w) && (w < (upper+distance)) && (midstBranch != nullptr) ) {
|
|
midstBranch->GetNearestObjects( pnt, distance, itemDistances, eps );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
size_t iCount = leafObjects.size();
|
|
itemDistances.reserve( itemDistances.size() + iCount );
|
|
for ( size_t i = 0; i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
double d = GetDistance( *obj.first, pnt, true );
|
|
if ( distance > d - eps ) {
|
|
IndexDistance itemDistance( obj.second, d );
|
|
itemDistances.push_back( itemDistance );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------
|
|
// \ru Выдать индексы объектов дерева, расположенные к точке ближе заданного расстояния. \en Get tree objects indices that are closer to the point than the specified distance.
|
|
// ---
|
|
template <class Type, class Cube, class Point, class Vector>
|
|
inline void MbCubeTree<Type, Cube, Point, Vector>::GetNearestObjects( const Point & pnt, const double distance,
|
|
std::vector<size_t> & itemIndices,
|
|
double eps ) const
|
|
{
|
|
if ( (lowerBranch != nullptr) || (upperBranch != nullptr) || (midstBranch != nullptr) ) {
|
|
double w = GetPointComponent( pnt );
|
|
|
|
if ( (w < (minimum-distance)) || ((maximum+distance) < w) )
|
|
return; // вне области / out of region
|
|
|
|
if ( (w < (midst+distance)) && (lowerBranch != nullptr) ) {
|
|
lowerBranch->GetNearestObjects( pnt, distance, itemIndices, eps );
|
|
}
|
|
if ( ((midst-distance) < w) && (upperBranch != nullptr) ) {
|
|
upperBranch->GetNearestObjects( pnt, distance, itemIndices, eps );
|
|
}
|
|
if ( ((lower-distance) < w) && (w < (upper+distance)) && (midstBranch != nullptr) ) {
|
|
midstBranch->GetNearestObjects( pnt, distance, itemIndices, eps );
|
|
}
|
|
}
|
|
else { // содержимое конечной ветви // terminal branch content
|
|
size_t iCount = leafObjects.size();
|
|
itemIndices.reserve( itemIndices.size() + iCount );
|
|
for ( size_t i = 0; i < iCount; ++i ) {
|
|
const ItemIndex & obj = leafObjects[i];
|
|
if ( obj.first != nullptr ) {
|
|
double d = GetDistance( *obj.first, pnt, true );
|
|
if ( distance > d - eps ) {
|
|
itemIndices.push_back( obj.second );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#endif
|