Egalware/EgtGeomKernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2d83c860f24be8ab4700b3de6712ca18999b47c9
EgtGeomKernel/Tree.cpp
T
Daniele Bariletti 2d83c860f2 EgtGeomKernel : 
- utilizzo di un binary tree al posto del kd-tree
- implementate le funzioni sul binary tree ( a parte il bilanciamento)
- errori noti : calcolo curvatura per decidere la direzione di split.
2023-05-08 17:02:02 +02:00

756 lines
33 KiB
C++
Raw Blame History

//----------------------------------------------------------------------------
// EgalTech 2023
//----------------------------------------------------------------------------
// File : Tree.cpp Data : 21.04.23 Versione :
// Contenuto : Implementazione della classe Tree.
//
//
//
// Modifiche : 21.04.23 DB Creazione modulo.
//
//
//----------------------------------------------------------------------------
//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include <algorithm>
#include "Tree.h"
#include "SurfBezier.h"
#include "GeoConst.h"
using namespace std ;
//----------------------------------------------------------------------------
Cell::Cell( void)
: m_nId( -1), m_ptPbl( ORIG), m_bProcessed ( false) , m_bSplitVert ( true) , m_nTop ( -2), m_nBottom( -2),
m_nLeft( -2), m_nRight ( -2), m_nParent( -2), m_nDepth( 0), m_nChild1( -2), m_nChild2( -2)
{
Point3d ptTr ( 1, 1) ;
m_ptPtr = ptTr ;
}
//----------------------------------------------------------------------------
Cell::Cell( Point3d ptBL, Point3d ptTR)
: m_nId( -1), m_ptPbl( ptBL), m_ptPtr(ptTR), m_bProcessed ( false) , m_bSplitVert ( true) , m_nTop ( -2),
m_nBottom( -2), m_nLeft( -2), m_nRight ( -2), m_nParent( -2), m_nDepth( 0), m_nChild1( -2), m_nChild2( -2)
{}
//----------------------------------------------------------------------------
Cell::~Cell( void)
{
}
//----------------------------------------------------------------------------
inline bool
Cell::IsSame( Cell cOtherCell)
{
if ( AreSamePointXYApprox( m_ptPbl, cOtherCell.GetBottomLeft()) &&
AreSamePointXYApprox( m_ptPtr, cOtherCell.GetTopRight())) {
return true ;
}
else {
return false ;
}
}
//----------------------------------------------------------------------------
bool
//Cell::IsLeaf ( void) const
Cell::IsLeaf ( void)
{
if( m_nChild1 == -2 && m_nChild2 == -2)
return true ;
else
return false ;
}
//----------------------------------------------------------------------------
Tree::Tree( void)
: m_dLinTol(LIN_TOL_FINE), m_pSrfBz(nullptr), m_nRoot( -1)
{
Point3d ptBl( 0, 0), ptTr ( 1, 1) ;
Cell cRoot( ptBl, ptTr) ;
m_mTree.insert( pair< int, Cell>( m_nRoot, cRoot)) ;
}
//----------------------------------------------------------------------------
Tree::Tree( const SurfBezier* pSrfBz)
: m_dLinTol( LIN_TOL_FINE), m_pSrfBz ( pSrfBz), m_nRoot( -1)
{
// le coordinate delle celle sono nello spazio parametrico
int nDegU, nDegV, nSpanU, nSpanV ;
bool bIsRat, bTrimmed ;
m_pSrfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bIsRat, bTrimmed) ;
Point3d ptTop( nSpanU, nSpanV) ;
Cell cRoot( ORIG, ptTop) ;
m_mTree.insert( pair< int, Cell>( m_nRoot, cRoot)) ;
}
//----------------------------------------------------------------------------
Tree::~Tree( void)
{
}
//----------------------------------------------------------------------------
void Tree::SetSurf( const SurfBezier* pSrfBz)
{
m_pSrfBz = pSrfBz ;
// le coordinate delle celle sono nello spazio parametrico
int nDegU, nDegV, nSpanU, nSpanV ;
bool bIsRat, bTrimmed ;
m_pSrfBz->GetInfo( nDegU, nDegV, nSpanU, nSpanV, bIsRat, bTrimmed) ;
Point3d ptTop( nSpanU, nSpanV) ;
Cell cRoot( ORIG, ptTop) ;
m_mTree.insert( pair< int, Cell>( -1, cRoot)) ;
}
//----------------------------------------------------------------------------
void
Tree::Split( int nId)
{
Cell cChild1, cChild2 ;
cChild1.m_nDepth = m_mTree[nId].m_nDepth + 1 ;
cChild2.m_nDepth = m_mTree[nId].m_nDepth + 1 ;
int nNodes = (int) m_mTree.size() ;
cChild1.m_nId = nNodes - 1 ;
m_mTree[nId].m_nChild1 = nNodes - 1 ;
cChild2.m_nId = nNodes ;
m_mTree[nId].m_nChild2 = nNodes ;
m_mTree.insert( pair<int, Cell>( nNodes - 1, cChild1)) ;
m_mTree.insert( pair<int, Cell>( nNodes, cChild2)) ;
if ( ! m_mTree[nId].IsSplitVert())
{
// la cella figlio 1 è quella sopra
Point3d ptBL( m_mTree[nId].GetBottomLeft().x, ( m_mTree[nId].GetBottomLeft().y + m_mTree[nId].GetTopRight().y) / 2) ;
m_mTree[m_mTree[nId].m_nChild1].SetBottomLeft( ptBL) ;
m_mTree[m_mTree[nId].m_nChild1].SetTopRight( m_mTree[nId].GetTopRight()) ;
m_mTree[m_mTree[nId].m_nChild1].m_nTop = m_mTree[nId].m_nTop ;
m_mTree[m_mTree[nId].m_nChild1].m_nBottom = m_mTree[nId].m_nChild2 ;
m_mTree[m_mTree[nId].m_nChild1].m_nLeft = m_mTree[nId].m_nLeft ;
m_mTree[m_mTree[nId].m_nChild1].m_nRight = m_mTree[nId].m_nRight ;
Point3d ptTR( m_mTree[nId].GetTopRight().x, ( m_mTree[nId].GetTopRight().y + m_mTree[nId].GetBottomLeft().y) / 2) ;
m_mTree[m_mTree[nId].m_nChild2].SetBottomLeft( m_mTree[nId].GetBottomLeft()) ;
m_mTree[m_mTree[nId].m_nChild2].SetTopRight( ptTR) ;
m_mTree[m_mTree[nId].m_nChild2].m_nTop = m_mTree[nId].m_nChild1 ;
m_mTree[m_mTree[nId].m_nChild2].m_nBottom = m_mTree[nId].m_nBottom ;
m_mTree[m_mTree[nId].m_nChild2].m_nLeft = m_mTree[nId].m_nLeft ;
m_mTree[m_mTree[nId].m_nChild2].m_nRight = m_mTree[nId].m_nRight ;
}
else {
// la cella figlio 1 è quella di sinistra
Point3d ptTR( ( m_mTree[nId].GetBottomLeft().x + m_mTree[nId].GetTopRight().x) / 2, m_mTree[nId].GetTopRight().y) ;
m_mTree[m_mTree[nId].m_nChild1].SetBottomLeft( m_mTree[nId].GetBottomLeft()) ;
m_mTree[m_mTree[nId].m_nChild1].SetTopRight( ptTR) ;
m_mTree[m_mTree[nId].m_nChild1].m_nTop = m_mTree[nId].m_nTop ;
m_mTree[m_mTree[nId].m_nChild1].m_nBottom = m_mTree[nId].m_nBottom ;
m_mTree[m_mTree[nId].m_nChild1].m_nLeft = m_mTree[nId].m_nLeft ;
m_mTree[m_mTree[nId].m_nChild1].m_nRight = m_mTree[nId].m_nChild2 ;
Point3d ptBL(( m_mTree[nId].GetBottomLeft().x + m_mTree[nId].GetTopRight().x) / 2, m_mTree[nId].GetBottomLeft().y) ;
m_mTree[m_mTree[nId].m_nChild2].SetBottomLeft( ptBL) ;
m_mTree[m_mTree[nId].m_nChild2].SetTopRight( m_mTree[nId].GetTopRight()) ;
m_mTree[m_mTree[nId].m_nChild2].m_nTop = m_mTree[nId].m_nTop ;
m_mTree[m_mTree[nId].m_nChild2].m_nBottom = m_mTree[nId].m_nBottom ;
m_mTree[m_mTree[nId].m_nChild2].m_nLeft = m_mTree[nId].m_nChild1 ;
m_mTree[m_mTree[nId].m_nChild2].m_nRight = m_mTree[nId].m_nRight ;
}
m_mTree[m_mTree[nId].m_nChild1].SetParent( nId) ;
m_mTree[m_mTree[nId].m_nChild2].SetParent( nId) ;
//m_bProcessed = true ;
}
////----------------------------------------------------------------------------
//bool Tree::BuildTree(void)
//{
// // di default SplitVert è true !
// int ToSplit = -1;
// m_mTree[ToSplit].SetSplitDirVert( true) ;
// Split( ToSplit) ;
// // celle 2 e 3
// ToSplit = m_mTree[-1].m_nChild1 ;
// m_mTree[ToSplit].SetSplitDirVert( false) ;
// Split( ToSplit) ;
// // celle 4 e 5
// ToSplit = m_mTree[ToSplit].m_nChild1 ;
// m_mTree[ToSplit].SetSplitDirVert( true) ;
// Split( ToSplit) ;
// // celle 6 e 7
// ToSplit = m_mTree[ToSplit].m_nChild2 ;
// m_mTree[ToSplit].SetSplitDirVert( false) ;
// Split( ToSplit) ;
// // celle 8 e 9
// ToSplit = m_mTree[ToSplit].m_nChild2 ;
// m_mTree[ToSplit].SetSplitDirVert( true) ;
// Split( ToSplit) ;
// // celle 10 e 11
// ToSplit = m_mTree[ToSplit].m_nChild1 ;
// m_mTree[ToSplit].SetSplitDirVert( false) ;
// Split( ToSplit) ;
// // celle 12 e 13
// ToSplit = m_mTree[ToSplit].m_nParent ;
// ToSplit = m_mTree[ToSplit].m_nChild2 ;
// m_mTree[ToSplit].SetSplitDirVert( true) ;
// Split( ToSplit) ;
// INTVECTOR vTops, vBottoms, vLefts, vRights , vLeaves1, vLeaves2, vLeaves;
// int d1, d2 , H1 ;
// GetTopNeigh( 3, vTops) ;
// GetBottomNeigh( 6, vBottoms) ;
// GetLeftNeigh( 1, vLefts) ;
// GetRightNeigh( 4, vRights ) ;
// d1 = GetHeightLeaves( 7, vLeaves1) ;
// d2 = GetHeightLeaves( 5, vLeaves2) ;
// H1 = GetHeightLeaves( -1, vLeaves) ;
// m_vnLeaves = vLeaves ;
// int i = 0 ;
//
// return true ;
//}
//----------------------------------------------------------------------------
bool Tree::BuildTree( void)
{
// trovo dove splittare la cella e creo i puntatori ai figli
// comincio a suddividere la superficie usando un kd-tree
// approssimo con una bilineare e se l'errore di approssimazione è troppo grande cerco una direzione
// in cui dividere la superficie
double dErr ; // errore calcolato
double dDist; // distanza tra punti selezionati sulla isoparametrica
double dSide ; // lunghezza del lato della eventuale cella figlio
double dSplit = 0.5 ; // effettuo sempre split a metà
//double dSidemin = 0.05 ; // lunghezza minima del lato di una cella
double dSidemin = 0.1 ; // lunghezza minima del lato di una cella
int nSteps = 51 ; // numero di Step mentre scorro lungo un'isoparametrica
double dU, dV , dIter, dIterLoc, dULoc, dVLoc ;
bool bVert ;
Point3d ptBz, ptBl ;
// cerco lo scostamento massimo tra la sup di Bezier e la sua approssimazione bilineare
INTVECTOR vBalanceCheck ;
int nCToSplit = -1 ;
int c = 1 ;
while ( nCToSplit != -2 && m_mTree[nCToSplit].IsProcessed() == false) {
dErr = 0 ;
// verifico se l'approsimazione bilineare è ancora troppo distante dalla superficie reale
// calcolo la bilineare per gli estremi della cella
SurfBezier pSrfBl ;
pSrfBl.Init(1, 1, 1, 1, false) ;
m_pSrfBz->GetPointD1D2( m_mTree[nCToSplit].GetBottomLeft().x, m_mTree[nCToSplit].GetBottomLeft().y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptBz) ;
pSrfBl.SetControlPoint( 0, ptBz) ; // P00
m_pSrfBz->GetPointD1D2( m_mTree[nCToSplit].GetTopRight().x, m_mTree[nCToSplit].GetBottomLeft().y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptBz) ;
pSrfBl.SetControlPoint( 1, ptBz) ; // P01
m_pSrfBz->GetPointD1D2( m_mTree[nCToSplit].GetBottomLeft().x, m_mTree[nCToSplit].GetTopRight().y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptBz) ;
pSrfBl.SetControlPoint( 2, ptBz) ; // P10
m_pSrfBz->GetPointD1D2( m_mTree[nCToSplit].GetTopRight().x, m_mTree[nCToSplit].GetTopRight().y, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptBz) ;
pSrfBl.SetControlPoint( 3, ptBz) ; // P11
// scorro lungo le isoparametriche a questi valori di U e V per trovare dov'è il punto di maggior discostamento
dU = ( m_mTree[nCToSplit].GetTopRight().x + m_mTree[nCToSplit].GetBottomLeft().x) / 2 ;
dV = ( m_mTree[nCToSplit].GetTopRight().y + m_mTree[nCToSplit].GetBottomLeft().y) / 2 ;
dULoc = dU - m_mTree[nCToSplit].GetBottomLeft().x / ( m_mTree[nCToSplit].GetTopRight().x - m_mTree[nCToSplit].GetBottomLeft().x) ;
dVLoc = dV - m_mTree[nCToSplit].GetBottomLeft().y / ( m_mTree[nCToSplit].GetTopRight().y - m_mTree[nCToSplit].GetBottomLeft().y) ;
double dErrUmax, dErrVmax ;
for ( int i = 0 ; i < nSteps ; ++ i){
dIter = double ( i) / double ( nSteps - 1) ;
dIterLoc = ( 1 - dIter) * m_mTree[nCToSplit].GetBottomLeft().y + dIter * m_mTree[nCToSplit].GetTopRight().y ;
if ( ! m_pSrfBz->GetPointD1D2( dU, dIterLoc, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptBz) ||
! pSrfBl.GetPointD1D2( dU, dIter, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptBl)) /// dU è riferito alla Bz totale, quant'è sulla Bl??
return false ;
dDist = Dist( ptBz, ptBl) ;
if ( dDist > dErr) {
dErr = dDist ;
bVert = true ;
dErrVmax = dErr ;
}
dIterLoc = ( 1 - dIter) * m_mTree[nCToSplit].GetBottomLeft().x + dIter * m_mTree[nCToSplit].GetTopRight().x ;
if ( ! m_pSrfBz->GetPointD1D2( dIterLoc, dV, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptBz) ||
! pSrfBl.GetPointD1D2( dIter, dV, ISurfBezier::FROM_MINUS, ISurfBezier::FROM_MINUS, ptBl)) /// dV è riferito alla Bz totale, quant'è sulla Bl??
return false ;
dDist = Dist( ptBz, ptBl) ;
if ( dDist > dErr) {
dErr = dDist ;
bVert = false ;
dErrUmax = dErr ;
}
}
// verifico che la cella sia da splittare e che eventualmente sia abbastanza grande da poterlo fare
if ( bVert)
dSide = m_mTree[nCToSplit].GetTopRight().x - m_mTree[nCToSplit].GetBottomLeft().x ;
else
dSide = m_mTree[nCToSplit].GetTopRight().y - m_mTree[nCToSplit].GetBottomLeft().y ;
if ( dErr > m_dLinTol && dSide >= dSidemin) {
m_mTree[nCToSplit].SetSplitDirVert( bVert) ;
// effettuo lo split
Split( nCToSplit) ;
// qui faccio i check per capire quali celle devo inserire in vBalanceCheck ///////////////////////////////////////////////////////
// procedo con lo split del Child1
nCToSplit = m_mTree[nCToSplit].m_nChild1 ;
}
else {
// sono arrivato ad una cella Leaf, quindi salvo la cella
m_vnLeaves.push_back( nCToSplit) ;
m_mTree[nCToSplit].Processed() ;
// risalgo i parent finché non trovo il primo Child2 da processare
nCToSplit = m_mTree[nCToSplit].m_nParent ;
if ( m_mTree[m_mTree[nCToSplit].m_nChild1].IsProcessed() && m_mTree[m_mTree[nCToSplit].m_nChild2].IsProcessed())
m_mTree[nCToSplit].Processed() ;
while ( m_mTree[m_mTree[nCToSplit].m_nChild2].IsProcessed()) {
if ( m_mTree[nCToSplit].m_nParent != -2 )
nCToSplit = m_mTree[nCToSplit].m_nParent ;
if ( m_mTree[m_mTree[nCToSplit].m_nChild1].IsProcessed() && m_mTree[m_mTree[nCToSplit].m_nChild2].IsProcessed())
m_mTree[nCToSplit].Processed() ;
if ( nCToSplit == m_nRoot && m_mTree[m_mTree[nCToSplit].m_nChild2].IsProcessed() )
break ;
}
nCToSplit = m_mTree[nCToSplit].m_nChild2 ;
}
c ++ ;
}
Balance( vBalanceCheck) ;
return true ;
}
//----------------------------------------------------------------------------
void Tree::Balance( INTVECTOR vCheck)
{
for ( int i : vCheck ) {
}
}
//----------------------------------------------------------------------------
void Tree::GetTopNeigh( int nId, INTVECTOR& vTopNeighs)
{
if ( (int) vTopNeighs.size() == 0) {
if ( m_mTree[nId].m_nTop == -2)
return ;
if ( m_mTree[m_mTree[nId].m_nTop].IsLeaf())
vTopNeighs.push_back( m_mTree[nId].m_nTop) ;
else {
if ( m_mTree[m_mTree[nId].m_nTop].IsSplitVert()) {
// se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima
if ( m_mTree[m_mTree[nId].m_nTop].GetTopRight().x - m_mTree[m_mTree[nId].m_nTop].GetBottomLeft().x <=
m_mTree[nId].GetTopRight().x - m_mTree[nId].GetBottomLeft().x) {
vTopNeighs.push_back( m_mTree[m_mTree[nId].m_nTop].m_nChild1) ;
vTopNeighs.push_back( m_mTree[m_mTree[nId].m_nTop].m_nChild2) ;
}
// altrimenti solo uno dei figli lo sarà
else{
if ( m_mTree[m_mTree[m_mTree[nId].m_nTop].m_nChild1].GetTopRight().x <= m_mTree[nId].GetBottomLeft().x ||
m_mTree[m_mTree[m_mTree[nId].m_nTop].m_nChild1].GetBottomLeft().x >= m_mTree[nId].GetTopRight().x )
vTopNeighs.push_back( m_mTree[m_mTree[nId].m_nTop].m_nChild2) ;
else
vTopNeighs.push_back( m_mTree[m_mTree[nId].m_nTop].m_nChild1) ;
}
}
else {
vTopNeighs.push_back( m_mTree[m_mTree[nId].m_nTop].m_nChild2) ;
}
}
bool bAllLeaves = true ;
for ( int i : vTopNeighs ) {
if ( ! m_mTree[i].IsLeaf())
bAllLeaves = false ;
}
if ( ! bAllLeaves )
// almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child
GetTopNeigh( nId, vTopNeighs) ;
}
else {
for ( int j = 0 ; j != (int) vTopNeighs.size() ; ++ j) {
int i = vTopNeighs[j] ;
if ( m_mTree[i].IsLeaf())
continue;
else {
// se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child
vTopNeighs.erase( remove( vTopNeighs.begin(),vTopNeighs.end(),i)) ;
-- j ;
if ( m_mTree[i].IsSplitVert() ) {
// se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima
if ( m_mTree[i].GetTopRight().x - m_mTree[i].GetBottomLeft().x <=
m_mTree[nId].GetTopRight().x - m_mTree[nId].GetBottomLeft().x) {
vTopNeighs.push_back( m_mTree[i].m_nChild1) ;
vTopNeighs.push_back( m_mTree[i].m_nChild2) ;
}
// altrimenti solo uno dei figli lo sarà
else {
if ( m_mTree[m_mTree[i].m_nChild1].GetTopRight().x <= m_mTree[nId].GetBottomLeft().x ||
m_mTree[m_mTree[i].m_nChild1].GetBottomLeft().x >= m_mTree[nId].GetTopRight().x )
vTopNeighs.push_back( m_mTree[i].m_nChild2) ;
else
vTopNeighs.push_back( m_mTree[i].m_nChild1) ;
}
}
else {
vTopNeighs.push_back( m_mTree[i].m_nChild2) ;
}
}
}
}
vector<Cell> vCells ;
for ( int k : vTopNeighs )
vCells.push_back( m_mTree[k]) ;
sort( vCells.begin(), vCells.end(), Cell::minorX ) ;
vTopNeighs.clear() ;
for ( Cell c : vCells)
vTopNeighs.push_back( c.m_nId) ;
}
//----------------------------------------------------------------------------
void Tree::GetBottomNeigh( int nId, INTVECTOR& vBottomNeighs)
{
if ( (int) vBottomNeighs.size() == 0) {
if ( m_mTree[nId].m_nBottom == -2)
return ;
if ( m_mTree[m_mTree[nId].m_nBottom].IsLeaf())
vBottomNeighs.push_back( m_mTree[nId].m_nBottom) ;
else {
if ( m_mTree[m_mTree[nId].m_nBottom].IsSplitVert()) {
// se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima
if ( m_mTree[m_mTree[nId].m_nBottom].GetTopRight().x - m_mTree[m_mTree[nId].m_nBottom].GetBottomLeft().x <=
m_mTree[nId].GetTopRight().x - m_mTree[nId].GetBottomLeft().x) {
vBottomNeighs.push_back( m_mTree[m_mTree[nId].m_nBottom].m_nChild1) ;
vBottomNeighs.push_back( m_mTree[m_mTree[nId].m_nBottom].m_nChild2) ;
}
// altrimenti solo uno dei figli lo sarà
else{
if ( m_mTree[m_mTree[m_mTree[nId].m_nBottom].m_nChild1].GetTopRight().x <= m_mTree[nId].GetBottomLeft().x ||
m_mTree[m_mTree[m_mTree[nId].m_nBottom].m_nChild1].GetBottomLeft().x >= m_mTree[nId].GetTopRight().x )
vBottomNeighs.push_back( m_mTree[m_mTree[nId].m_nBottom].m_nChild2) ;
else
vBottomNeighs.push_back( m_mTree[m_mTree[nId].m_nBottom].m_nChild1) ;
}
}
else {
vBottomNeighs.push_back( m_mTree[m_mTree[nId].m_nBottom].m_nChild1) ;
}
}
bool bAllLeaves = true ;
for ( int i : vBottomNeighs ) {
if ( ! m_mTree[i].IsLeaf())
bAllLeaves = false ;
}
if ( ! bAllLeaves )
// almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child
GetBottomNeigh( nId, vBottomNeighs) ;
}
else {
for ( int j = 0 ; j != (int) vBottomNeighs.size() ; ++ j) {
int i = vBottomNeighs[j] ;
if ( m_mTree[i].IsLeaf())
continue;
else {
// se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child
vBottomNeighs.erase( remove( vBottomNeighs.begin(),vBottomNeighs.end(),i)) ;
-- j ;
if ( m_mTree[i].IsSplitVert()) {
// se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima
if ( m_mTree[i].GetTopRight().x - m_mTree[i].GetBottomLeft().x <=
m_mTree[nId].GetTopRight().x - m_mTree[nId].GetBottomLeft().x) {
vBottomNeighs.push_back( m_mTree[i].m_nChild1) ;
vBottomNeighs.push_back( m_mTree[i].m_nChild2) ;
}
// altrimenti solo uno dei figli lo sarà
else {
if ( m_mTree[m_mTree[i].m_nChild1].GetTopRight().x <= m_mTree[nId].GetBottomLeft().x ||
m_mTree[m_mTree[i].m_nChild1].GetBottomLeft().x >= m_mTree[nId].GetTopRight().x )
vBottomNeighs.push_back( m_mTree[i].m_nChild2) ;
else
vBottomNeighs.push_back( m_mTree[i].m_nChild1) ;
}
}
else {
vBottomNeighs.push_back( m_mTree[i].m_nChild1) ;
}
}
}
}
vector<Cell> vCells ;
for ( int k : vBottomNeighs )
vCells.push_back( m_mTree[k]) ;
sort( vCells.begin(), vCells.end(), Cell::minorX) ;
vBottomNeighs.clear() ;
for ( Cell c : vCells)
vBottomNeighs.push_back( c.m_nId) ;
}
//----------------------------------------------------------------------------
void Tree::GetLeftNeigh( int nId, INTVECTOR& vLeftNeighs)
{
if ( (int) vLeftNeighs.size() == 0 ) {
if ( m_mTree[nId].m_nLeft == -2)
return ;
if ( m_mTree[m_mTree[nId].m_nLeft].IsLeaf())
vLeftNeighs.push_back( m_mTree[nId].m_nLeft) ;
else {
if ( ! m_mTree[m_mTree[nId].m_nLeft].IsSplitVert()) {
// se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima
if ( m_mTree[m_mTree[nId].m_nLeft].GetTopRight().y - m_mTree[m_mTree[nId].m_nLeft].GetBottomLeft().y <=
m_mTree[nId].GetTopRight().y - m_mTree[nId].GetBottomLeft().y) {
vLeftNeighs.push_back( m_mTree[m_mTree[nId].m_nLeft].m_nChild1) ;
vLeftNeighs.push_back( m_mTree[m_mTree[nId].m_nLeft].m_nChild2) ;
}
// altrimenti solo uno dei figli lo sarà
else{
if ( m_mTree[m_mTree[m_mTree[nId].m_nLeft].m_nChild1].GetTopRight().y <= m_mTree[nId].GetBottomLeft().y ||
m_mTree[m_mTree[m_mTree[nId].m_nLeft].m_nChild1].GetBottomLeft().y >= m_mTree[nId].GetTopRight().y )
vLeftNeighs.push_back( m_mTree[m_mTree[nId].m_nLeft].m_nChild2) ;
else
vLeftNeighs.push_back( m_mTree[m_mTree[nId].m_nLeft].m_nChild1) ;
}
}
else {
vLeftNeighs.push_back( m_mTree[m_mTree[nId].m_nLeft].m_nChild2) ;
}
}
bool bAllLeaves = true ;
for ( int i : vLeftNeighs ) {
if ( ! m_mTree[i].IsLeaf())
bAllLeaves = false ;
}
if ( ! bAllLeaves )
// almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child
GetLeftNeigh( nId, vLeftNeighs) ;
}
else {
for ( int j = 0 ; j != (int) vLeftNeighs.size() ; ++ j) {
int i = vLeftNeighs[j] ;
if ( m_mTree[i].IsLeaf())
continue;
else {
// se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child
vLeftNeighs.erase( remove( vLeftNeighs.begin(),vLeftNeighs.end(),i)) ;
-- j ;
if ( ! m_mTree[i].IsSplitVert()) {
// se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima
if ( m_mTree[i].GetTopRight().y - m_mTree[i].GetBottomLeft().y <=
m_mTree[nId].GetTopRight().y - m_mTree[nId].GetBottomLeft().y) {
vLeftNeighs.push_back( m_mTree[i].m_nChild1) ;
vLeftNeighs.push_back( m_mTree[i].m_nChild2) ;
}
// altrimenti solo uno dei figli lo sarà
else {
if ( m_mTree[m_mTree[i].m_nChild1].GetTopRight().y <= m_mTree[nId].GetBottomLeft().y ||
m_mTree[m_mTree[i].m_nChild1].GetBottomLeft().y >= m_mTree[nId].GetTopRight().y )
vLeftNeighs.push_back( m_mTree[i].m_nChild2) ;
else
vLeftNeighs.push_back( m_mTree[i].m_nChild1) ;
}
}
else {
vLeftNeighs.push_back( m_mTree[i].m_nChild2) ;
}
}
}
}
vector<Cell> vCells ;
for ( int k : vLeftNeighs)
vCells.push_back( m_mTree[k]) ;
sort( vCells.begin(), vCells.end(), Cell::minorY) ;
vLeftNeighs.clear() ;
for ( Cell c : vCells)
vLeftNeighs.push_back( c.m_nId) ;
}
//----------------------------------------------------------------------------
void Tree::GetRightNeigh( int nId, INTVECTOR& vRightNeighs)
{
if ( (int) vRightNeighs.size() == 0) {
if ( m_mTree[nId].m_nRight == -2)
return ;
if ( m_mTree[m_mTree[nId].m_nRight].IsLeaf())
vRightNeighs.push_back( m_mTree[nId].m_nRight) ;
else {
if ( ! m_mTree[m_mTree[nId].m_nRight].IsSplitVert()) {
// se la cella vicina è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima
if ( m_mTree[m_mTree[nId].m_nRight].GetTopRight().y - m_mTree[m_mTree[nId].m_nRight].GetBottomLeft().y <=
m_mTree[nId].GetTopRight().y - m_mTree[nId].GetBottomLeft().y) {
vRightNeighs.push_back( m_mTree[m_mTree[nId].m_nRight].m_nChild1) ;
vRightNeighs.push_back( m_mTree[m_mTree[nId].m_nRight].m_nChild2) ;
}
// altrimenti solo uno dei figli lo sarà
else{
if ( m_mTree[m_mTree[m_mTree[nId].m_nRight].m_nChild1].GetTopRight().y <= m_mTree[nId].GetBottomLeft().y ||
m_mTree[m_mTree[m_mTree[nId].m_nRight].m_nChild1].GetBottomLeft().y >= m_mTree[nId].GetTopRight().y )
vRightNeighs.push_back( m_mTree[m_mTree[nId].m_nRight].m_nChild2) ;
else
vRightNeighs.push_back( m_mTree[m_mTree[nId].m_nRight].m_nChild1) ;
}
}
else {
vRightNeighs.push_back( m_mTree[m_mTree[nId].m_nRight].m_nChild1) ;
}
}
bool bAllLeaves = true ;
for ( int i : vRightNeighs) {
if ( ! m_mTree[i].IsLeaf())
bAllLeaves = false ;
}
if ( ! bAllLeaves )
// almeno una cella tra i vicini trovati non è leaf quindi devo richiamare ricorsivamente questa funzione per trovare i suoi child
GetRightNeigh( nId, vRightNeighs) ;
}
else {
for ( int j = 0 ; j != (int) vRightNeighs.size() ; ++ j) {
int i = vRightNeighs[j] ;
if ( m_mTree[i].IsLeaf())
continue;
else {
// se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child
vRightNeighs.erase( remove( vRightNeighs.begin(),vRightNeighs.end(), i)) ;
-- j ;
if ( ! m_mTree[i].IsSplitVert()) {
// se la cella è più piccola della cella indagata, allora entrambi i figli saranno vicini di quest'ultima
if ( m_mTree[i].GetTopRight().y - m_mTree[i].GetBottomLeft().y <=
m_mTree[nId].GetTopRight().y - m_mTree[nId].GetBottomLeft().y) {
vRightNeighs.push_back( m_mTree[i].m_nChild1) ;
vRightNeighs.push_back( m_mTree[i].m_nChild2) ;
}
// altrimenti solo uno dei figli lo sarà
else {
if ( m_mTree[m_mTree[i].m_nChild1].GetTopRight().y <= m_mTree[nId].GetBottomLeft().y ||
m_mTree[m_mTree[i].m_nChild1].GetBottomLeft().y >= m_mTree[nId].GetTopRight().y )
vRightNeighs.push_back( m_mTree[i].m_nChild2) ;
else
vRightNeighs.push_back( m_mTree[i].m_nChild1) ;
}
}
else {
vRightNeighs.push_back( m_mTree[i].m_nChild1) ;
}
}
}
}
vector<Cell> vCells ;
for ( int k : vRightNeighs)
vCells.push_back( m_mTree[k]) ;
sort( vCells.begin(), vCells.end(), Cell::minorY) ;
vRightNeighs.clear() ;
for ( Cell c : vCells)
vRightNeighs.push_back( c.m_nId) ;
}
//----------------------------------------------------------------------------
int Tree::GetHeightLeaves( int nId, INTVECTOR& vnLeaves, int d)
{
if ( (int) vnLeaves.size() == 0) {
if ( m_mTree[nId].IsLeaf())
return d ;
else {
vnLeaves.push_back( m_mTree[nId].m_nChild1) ;
vnLeaves.push_back( m_mTree[nId].m_nChild2) ;
if ( ! m_mTree[m_mTree[nId].m_nChild1].IsLeaf() || ! m_mTree[m_mTree[nId].m_nChild2].IsLeaf())
// almeno un child non è leaf quindi devo richiamare ricorsivamente questa funzione sui child in questione
d = GetHeightLeaves( nId, vnLeaves, m_mTree[m_mTree[nId].m_nChild1].m_nDepth) ;
}
}
else {
for ( int j = 0 ; j != (int) vnLeaves.size() ; ++ j) {
int i = vnLeaves[j] ;
if ( m_mTree[i].IsLeaf() ) {
continue ;
}
else {
// se la cella non è leaf la tolgo dal vettore delle foglie e aggiungo invece i suoi child
vnLeaves.erase( remove( vnLeaves.begin(),vnLeaves.end(),i)) ;
-- j ;
vnLeaves.push_back( m_mTree[i].m_nChild1) ;
vnLeaves.push_back( m_mTree[i].m_nChild2) ;
d = max ( d, m_mTree[m_mTree[i].m_nChild1].m_nDepth) ;
}
}
return d ;
}
return d - m_mTree[nId].m_nDepth ;
}
//----------------------------------------------------------------------------
int Tree::GetDepth( int nId, int nRef = -2)
{
int c = 0 ;
while ( m_mTree[nId].m_nParent != nRef ) {
nId = m_mTree[nId].m_nParent ;
++ c ;
}
return c ;
}
//----------------------------------------------------------------------------
bool Tree::GetPolygons( POLYLINEVECTOR& vPolygons)
{
if ( m_vPolygons.empty()) {
PNTVECTOR vVertices ;
INTVECTOR vNeigh ;
bool bBottomRight , bTopLeft ;
// scorro lungo tutte le celle leaves ( dell'albero bilanciato) e oltre agli angoli della cella aggiungo alla polyline anche i vertici sui lati
for ( int nId : m_vnLeaves) {
//Point3d ptPbr( m_mTree[nId].GetTopRight().x, m_mTree[nId].GetBottomLeft().y) ;
//Point3d ptPtl( m_mTree[nId].GetBottomLeft().x, m_mTree[nId].GetTopRight().y) ;
vVertices.clear() ;
vNeigh.clear() ;
vVertices.push_back( m_mTree[nId].GetBottomLeft()) ;
GetBottomNeigh( nId, vNeigh) ;
// aggiungo i vertici che sono sul lato bottom, solo se ho più di un vicino bottom
if ( (int) vNeigh.size() != 0 && (int) vNeigh.size() != 1){
for ( int j : vNeigh )
vVertices.push_back( m_mTree[j].GetTopRight()) ;
bBottomRight = true ;
}
else
bBottomRight = false ;
vNeigh.clear() ;
GetRightNeigh ( nId, vNeigh) ;
// aggiungo i vertici che sono sul lato right, solo se ho più di un vicino right
if ( (int) vNeigh.size() != 0 && (int) vNeigh.size() != 1){
for ( int j : vNeigh )
vVertices.push_back( m_mTree[j].GetBottomLeft()) ;
}
// se non l'ho già aggiunto tramite i vicini bottom aggiungo il punto bottom right
else if ( ! bBottomRight ) {
Point3d ptBr( m_mTree[nId].GetTopRight().x, m_mTree[nId].GetBottomLeft().y) ;
vVertices.push_back( ptBr) ;
}
vNeigh.clear() ;
vVertices.push_back( m_mTree[nId].GetTopRight()) ;
GetTopNeigh ( nId, vNeigh) ;
reverse( vNeigh.begin(), vNeigh.end()) ;
// aggiungo i vertici che sono sul lato top, solo se ho più di un vicino top
if ( (int) vNeigh.size() != 0 && (int) vNeigh.size() != 1) {
for ( int j : vNeigh)
vVertices.push_back( m_mTree[j].GetBottomLeft()) ;
bTopLeft = true ;
}
else
bTopLeft = false ;
vNeigh.clear() ;
GetLeftNeigh ( nId, vNeigh) ;
reverse( vNeigh.begin(), vNeigh.end()) ;
// aggiungo i vertici che sono sul lato left, solo se ho più di un vicino left
if ( (int) vNeigh.size() != 0 && (int) vNeigh.size() != 1) {
for ( int j : vNeigh)
vVertices.push_back( m_mTree[j].GetTopRight()) ;
}
// se non l'ho già aggiunto tramite i vicini top aggiungo il punto top left
else if ( ! bTopLeft) {
Point3d ptTl( m_mTree[nId].GetBottomLeft().x, m_mTree[nId].GetTopRight().y) ;
vVertices.push_back( ptTl) ;
}
vNeigh.clear() ;
vVertices.push_back( m_mTree[nId].GetBottomLeft()) ;
double k = 0 ;
m_vPolygons.emplace_back() ;
for ( int i = 0 ; i < (int) vVertices.size() ; ++i ) {
k = double( i) / double( vVertices.size()) ;
m_vPolygons.back().AddUPoint( i, vVertices[i]) ;
}
}
}
// restituisco i poligoni delle celle del tree nello spazio parametrico
vPolygons = m_vPolygons ;
return true ;
}
Reference in New Issue View Git Blame Copy Permalink