1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
|
/*
Copyright (c) 2006, Michael Kazhdan and Matthew Bolitho
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer. Redistributions in binary form must reproduce
the above copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the distribution.
Neither the name of the Johns Hopkins University nor the names of its contributors
may be used to endorse or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
*/
#ifndef REGULAR_TREE_NODE_INCLUDED
#define REGULAR_TREE_NODE_INCLUDED
#include <functional>
#include "Allocator.h"
#include "BinaryNode.h"
#include "Window.h"
template< unsigned int Dim , class NodeData , class DepthAndOffsetType >
struct RegularTreeNode
{
private:
DepthAndOffsetType _depth , _offset[Dim];
template< typename Initializer >
bool _initChildren ( Allocator< RegularTreeNode >* nodeAllocator , Initializer &initializer );
template< typename Initializer >
bool _initChildren_s( Allocator< RegularTreeNode >* nodeAllocator , Initializer &initializer );
public:
RegularTreeNode* parent;
RegularTreeNode* children;
NodeData nodeData;
RegularTreeNode( void );
static RegularTreeNode* NewBrood( Allocator< RegularTreeNode >* nodeAllocator )
{
auto initializer = []( RegularTreeNode & ){};
return NewBrood( nodeAllocator , initializer );
}
template< typename Initializer >
RegularTreeNode( Initializer &initializer );
template< typename Initializer >
static RegularTreeNode* NewBrood( Allocator< RegularTreeNode >* nodeAllocator , Initializer &initializer );
template< bool ThreadSafe >
bool initChildren( Allocator< RegularTreeNode >* nodeAllocator )
{
auto initializer = []( RegularTreeNode & ){};
return initChildren( nodeAllocator , initializer );
}
template< bool ThreadSafe , typename Initializer >
bool initChildren( Allocator< RegularTreeNode >* nodeAllocator , Initializer &initializer )
{
return ThreadSafe ? _initChildren_s( nodeAllocator , initializer ) : _initChildren( nodeAllocator , initializer );
}
void cleanChildren( bool deleteChildren );
static void ResetDepthAndOffset( RegularTreeNode* root , int d , int off[Dim] );
~RegularTreeNode( void );
// The merge functor takes two objects of type NodeData and returns an object of type NodeData
// [NOTE] We are assuming that the merge functor is symmetric, f(a,b) = f(b,a), and implicity satisfies f(a) = a
template< class MergeFunctor >
void merge( RegularTreeNode* node , MergeFunctor& f );
void depthAndOffset( int& depth , int offset[Dim] ) const;
void centerIndex( int index[Dim] ) const;
int depth( void ) const;
template< class Real > void centerAndWidth( Point< Real , Dim >& center , Real& width ) const;
template< class Real > void startAndWidth( Point< Real , Dim >& start , Real& width ) const;
template< class Real > bool isInside( Point< Real , Dim > p ) const;
size_t leaves( void ) const;
size_t maxDepthLeaves( int maxDepth ) const;
size_t nodes( void ) const;
int maxDepth( void ) const;
const RegularTreeNode* root( void ) const;
const RegularTreeNode* nextLeaf( const RegularTreeNode* currentLeaf=NULL ) const;
RegularTreeNode* nextLeaf( RegularTreeNode* currentLeaf=NULL );
// This lambda takes a RegularTreeNode* as an argument and returns true if we do not need to traverse the tree beyond the specified node.
template< typename NodeTerminationLambda >
const RegularTreeNode* nextNode( NodeTerminationLambda &ntl , const RegularTreeNode* currentNode ) const;
template< typename NodeTerminationLambda >
RegularTreeNode* nextNode( NodeTerminationLambda &ntl , RegularTreeNode* currentNode );
const RegularTreeNode* nextNode( const RegularTreeNode* currentNode=NULL ) const;
RegularTreeNode* nextNode( RegularTreeNode* currentNode=NULL );
const RegularTreeNode* nextBranch( const RegularTreeNode* current ) const;
RegularTreeNode* nextBranch( RegularTreeNode* current );
const RegularTreeNode* prevBranch( const RegularTreeNode* current ) const;
RegularTreeNode* prevBranch( RegularTreeNode* current );
void setFullDepth( int maxDepth , Allocator< RegularTreeNode >* nodeAllocator )
{
auto initializer = []( RegularTreeNode & ){};
return setFulDepth( nodeAllocator , initializer );
}
template< typename Initializer >
void setFullDepth( int maxDepth , Allocator< RegularTreeNode >* nodeAllocator , Initializer &initializer );
void printLeaves( void ) const;
void printRange( void ) const;
template< class Real > static int ChildIndex( const Point< Real , Dim >& center , const Point< Real , Dim > &p );
bool write( const char* fileName ) const;
bool write( FILE* fp ) const;
bool read( const char* fileName , Allocator< RegularTreeNode >* nodeAllocator )
{
auto initializer = []( RegularTreeNode & ){};
return read( fileName , nodeAllocator , initializer );
}
bool read( FILE* fp , Allocator< RegularTreeNode >* nodeAllocator )
{
auto initializer = []( RegularTreeNode & ){};
return read( fp , nodeAllocator , initializer );
}
template< typename Initializer >
bool read( const char* fileName , Allocator< RegularTreeNode >* nodeAllocator , Initializer &initializer );
template< typename Initializer >
bool read( FILE* fp , Allocator< RegularTreeNode >* nodeAllocator , Initializer &initializer );
template< typename Pack > struct Neighbors{};
template< unsigned int ... Widths >
struct Neighbors< UIntPack< Widths ... > >
{
typedef StaticWindow< RegularTreeNode* , UIntPack< Widths ... > > Window;
Window neighbors;
Neighbors( void );
void clear( void );
};
template< typename Pack > struct ConstNeighbors{};
template< unsigned int ... Widths >
struct ConstNeighbors< UIntPack< Widths ... > >
{
typedef StaticWindow< const RegularTreeNode* , UIntPack< Widths ... > > Window;
Window neighbors;
ConstNeighbors( void );
void clear( void );
};
template< typename LeftPack , typename RightPack > struct NeighborKey{};
template< unsigned int ... LeftRadii , unsigned int ... RightRadii >
struct NeighborKey< UIntPack< LeftRadii ... > , UIntPack< RightRadii ... > >
{
protected:
static_assert( sizeof...(LeftRadii)==sizeof...(RightRadii) , "[ERROR] Left and right radii dimensions don't match" );
static const unsigned int CenterIndex = WindowIndex< UIntPack< ( LeftRadii + RightRadii + 1 ) ... > , UIntPack< LeftRadii ... > >::Index;
int _depth;
template< bool CreateNodes , bool ThreadSafe , typename NodeInitializer , unsigned int ... _PLeftRadii , unsigned int ... _PRightRadii , unsigned int ... _CLeftRadii , unsigned int ... _CRightRadii >
static unsigned int _NeighborsLoop( UIntPack< _PLeftRadii ... > , UIntPack< _PRightRadii ... > , UIntPack< _CLeftRadii ... > , UIntPack< _CRightRadii ... > , ConstWindowSlice< RegularTreeNode* , UIntPack< ( _PLeftRadii+_PRightRadii+1 ) ... > > pNeighbors , WindowSlice< RegularTreeNode* , UIntPack< ( _CLeftRadii+_CRightRadii+1 ) ... > > cNeighbors , int cIdx , Allocator< RegularTreeNode >* nodeAllocator , NodeInitializer &initializer );
template< bool CreateNodes , bool ThreadSafe , typename NodeInitializer , unsigned int ... _PLeftRadii , unsigned int ... _PRightRadii , unsigned int ... _CLeftRadii , unsigned int ... _CRightRadii >
static unsigned int _NeighborsLoop( UIntPack< _PLeftRadii ... > , UIntPack< _PRightRadii ... > , UIntPack< _CLeftRadii ... > , UIntPack< _CRightRadii ... > , WindowSlice< RegularTreeNode* , UIntPack< ( _PLeftRadii+_PRightRadii+1 ) ... > > pNeighbors , WindowSlice< RegularTreeNode* , UIntPack< ( _CLeftRadii+_CRightRadii+1 ) ... > > cNeighbors , int cIdx , Allocator< RegularTreeNode >* nodeAllocator , NodeInitializer &initializer );
template< bool CreateNodes , bool ThreadSafe , typename NodeInitializer , typename PLeft , typename PRight , typename CLeft , typename CRight > struct _Run{};
template< bool CreateNodes , bool ThreadSafe , typename NodeInitializer , unsigned int _PLeftRadius , unsigned int ... _PLeftRadii , unsigned int _PRightRadius , unsigned int ... _PRightRadii , unsigned int _CLeftRadius , unsigned int ... _CLeftRadii , unsigned int _CRightRadius , unsigned int ... _CRightRadii >
struct _Run< CreateNodes , ThreadSafe , NodeInitializer , UIntPack< _PLeftRadius , _PLeftRadii ... > , UIntPack< _PRightRadius , _PRightRadii ... > , UIntPack< _CLeftRadius , _CLeftRadii ... > , UIntPack< _CRightRadius , _CRightRadii ... > >
{
static unsigned int Run( ConstWindowSlice< RegularTreeNode* , UIntPack< _PLeftRadius+_PRightRadius+1 , ( _PLeftRadii+_PRightRadii+1 ) ... > > pNeighbors , WindowSlice< RegularTreeNode* , UIntPack< _CLeftRadius+_CRightRadius+1 , ( _CLeftRadii+_CRightRadii+1 ) ... > > cNeighbors , int* c , int cornerIndex , Allocator< RegularTreeNode >* nodeAllocator , NodeInitializer &initializer );
};
template< bool CreateNodes , bool ThreadSafe , typename NodeInitializer , unsigned int _PLeftRadius , unsigned int _PRightRadius , unsigned int _CLeftRadius , unsigned int _CRightRadius >
struct _Run< CreateNodes , ThreadSafe , NodeInitializer , UIntPack< _PLeftRadius > , UIntPack< _PRightRadius > , UIntPack< _CLeftRadius > , UIntPack< _CRightRadius > >
{
static unsigned int Run( ConstWindowSlice< RegularTreeNode* , UIntPack< _PLeftRadius+_PRightRadius+1 > > pNeighbors , WindowSlice< RegularTreeNode* , UIntPack< _CLeftRadius+_CRightRadius+1 > > cNeighbors , int* c , int cornerIndex , Allocator< RegularTreeNode >* nodeAllocator , NodeInitializer &initializer );
};
public:
typedef Neighbors< UIntPack< ( LeftRadii + RightRadii + 1 ) ... > > NeighborType;
NeighborType* neighbors;
NeighborKey( void );
NeighborKey( const NeighborKey& key );
~NeighborKey( void );
int depth( void ) const { return _depth; }
void set( int depth );
template< bool CreateNodes , bool ThreadSafe >
typename RegularTreeNode< Dim , NodeData , DepthAndOffsetType >::template Neighbors< UIntPack< ( LeftRadii + RightRadii + 1 ) ... > >& getNeighbors( RegularTreeNode* node , Allocator< RegularTreeNode >* nodeAllocator )
{
auto initializer = []( RegularTreeNode & ){};
return getNeighbors( node , nodeAllocator , initializer );
}
template< bool CreateNodes , bool ThreadSafe , typename NodeInitializer >
typename RegularTreeNode< Dim , NodeData , DepthAndOffsetType >::template Neighbors< UIntPack< ( LeftRadii + RightRadii + 1 ) ... > >& getNeighbors( RegularTreeNode* node , Allocator< RegularTreeNode >* nodeAllocator , NodeInitializer &nodeInitializer );
NeighborType& getNeighbors( const RegularTreeNode* node )
{
auto initializer = []( RegularTreeNode & ){};
return getNeighbors< false , false >( (RegularTreeNode*)node , NULL , initializer );
}
template< bool CreateNodes , bool ThreadSafe , unsigned int ... _LeftRadii , unsigned int ... _RightRadii >
void getNeighbors( UIntPack< _LeftRadii ... > , UIntPack< _RightRadii ... > , RegularTreeNode* node , Neighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& neighbors , Allocator< RegularTreeNode >* nodeAllocator )
{
auto initializer = []( RegularTreeNode & ){};
return getNeighbors( UIntPack< _LeftRadii ... >() , UIntPack< _RightRadii ... >() , node , neighbors , nodeAllocator , initializer );
}
template< bool CreateNodes , bool ThreadSafe , typename NodeInitializer , unsigned int ... _LeftRadii , unsigned int ... _RightRadii >
void getNeighbors( UIntPack< _LeftRadii ... > , UIntPack< _RightRadii ... > , RegularTreeNode* node , Neighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& neighbors , Allocator< RegularTreeNode >* nodeAllocator , NodeInitializer &initializer );
template< unsigned int ... _LeftRadii , unsigned int ... _RightRadii >
void getNeighbors( UIntPack< _LeftRadii ... > , UIntPack< _RightRadii ... > , const RegularTreeNode* node , Neighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& neighbors )
{
auto initializer = []( RegularTreeNode & ){};
return getNeighbors< false , false >( UIntPack< _LeftRadii ... >() , UIntPack< _RightRadii ... >() , (RegularTreeNode*)node , NULL , initializer );
}
template< bool CreateNodes , bool ThreadSafe , unsigned int ... _LeftRadii , unsigned int ... _RightRadii >
void getNeighbors( UIntPack< _LeftRadii ... > , UIntPack< _RightRadii ... > , RegularTreeNode* node , Neighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& pNeighbors , Neighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& neighbors , Allocator< RegularTreeNode >* nodeAllocator )
{
auto initializer = []( RegularTreeNode & ){};
return getNeighbors( UIntPack< _LeftRadii ... >() , UIntPack< _RightRadii ... >() , node , pNeighbors , neighbors , nodeAllocator , initializer );
}
template< bool CreateNodes , bool ThreadSafe , typename NodeInitializer , unsigned int ... _LeftRadii , unsigned int ... _RightRadii >
void getNeighbors( UIntPack< _LeftRadii ... > , UIntPack< _RightRadii ... > , RegularTreeNode* node , Neighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& pNeighbors , Neighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& neighbors , Allocator< RegularTreeNode >* nodeAllocator , NodeInitializer &initializer );
template< unsigned int ... _LeftRadii , unsigned int ... _RightRadii >
void getNeighbors( UIntPack< _LeftRadii ... > , UIntPack< _RightRadii ... > , const RegularTreeNode* node , Neighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& pNeighbors , Neighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& neighbors )
{
auto initializer = []( RegularTreeNode & ){};
return getNeighbors< false , false >( UIntPack< _LeftRadii ... >() , UIntPack< _RightRadii ... >() , (RegularTreeNode*)node , NULL , initializer );
}
template< bool CreateNodes , bool ThreadSafe >
unsigned int getChildNeighbors( int cIdx , int d , NeighborType& childNeighbors , Allocator< RegularTreeNode >* nodeAllocator ) const
{
auto initializer = []( RegularTreeNode & ){};
return getChildNeighbors( cIdx , d , childNeighbors , nodeAllocator , initializer );
}
template< bool CreateNodes , bool ThreadSafe , typename NodeInitializer >
unsigned int getChildNeighbors( int cIdx , int d , NeighborType& childNeighbors , Allocator< RegularTreeNode >* nodeAllocator , NodeInitializer &initializer ) const;
unsigned int getChildNeighbors( int cIdx , int d , NeighborType& childNeighbors ) const
{
auto initializer = []( RegularTreeNode & ){};
return getChildNeighbors< false , false >( cIdx , d , childNeighbors , NULL , initializer );
}
template< bool CreateNodes , bool ThreadSafe , class Real >
unsigned int getChildNeighbors( Point< Real , Dim > p , int d , NeighborType& childNeighbors , Allocator< RegularTreeNode >* nodeAllocator ) const
{
auto initializer = []( RegularTreeNode & ){};
return getChildNeighbors( p , d , childNeighbors , nodeAllocator , initializer );
}
template< bool CreateNodes , bool ThreadSafe , typename NodeInitializer , class Real >
unsigned int getChildNeighbors( Point< Real , Dim > p , int d , NeighborType& childNeighbors , Allocator< RegularTreeNode >* nodeAllocator , NodeInitializer &initializer ) const;
template< class Real >
unsigned int getChildNeighbors( Point< Real , Dim > p , int d , NeighborType& childNeighbors ) const
{
auto initializer = []( RegularTreeNode & ){};
return getChildNeighbors< false , false , Real >( p , d , childNeighbors , NULL , initializer );
}
};
template< typename LeftPack , typename RightPack > struct ConstNeighborKey{};
template< unsigned int ... LeftRadii , unsigned int ... RightRadii >
struct ConstNeighborKey< UIntPack< LeftRadii ... > , UIntPack< RightRadii ... > >
{
protected:
static_assert( sizeof...(LeftRadii)==sizeof...(RightRadii) , "[ERROR] Left and right radii dimensions don't match" );
static const unsigned int CenterIndex = WindowIndex< UIntPack< ( LeftRadii + RightRadii + 1 ) ... > , UIntPack< LeftRadii ... > >::Index;
int _depth;
template< unsigned int ... _PLeftRadii , unsigned int ... _PRightRadii , unsigned int ... _CLeftRadii , unsigned int ... _CRightRadii >
static unsigned int _NeighborsLoop( UIntPack< _PLeftRadii ... > , UIntPack< _PRightRadii ... > , UIntPack< _CLeftRadii ... > , UIntPack< _CRightRadii ... > , ConstWindowSlice< const RegularTreeNode* , UIntPack< ( _PLeftRadii+_PRightRadii+1 ) ... > > pNeighbors , WindowSlice< const RegularTreeNode* , UIntPack< ( _CLeftRadii+_CRightRadii+1 ) ... > > cNeighbors , int cIdx );
template< unsigned int ... _PLeftRadii , unsigned int ... _PRightRadii , unsigned int ... _CLeftRadii , unsigned int ... _CRightRadii >
static unsigned int _NeighborsLoop( UIntPack< _PLeftRadii ... > , UIntPack< _PRightRadii ... > , UIntPack< _CLeftRadii ... > , UIntPack< _CRightRadii ... > , WindowSlice< const RegularTreeNode* , UIntPack< ( _PLeftRadii+_PRightRadii+1 ) ... > > pNeighbors , WindowSlice< const RegularTreeNode* , UIntPack< ( _CLeftRadii+_CRightRadii+1 ) ... > > cNeighbors , int cIdx );
template< typename PLeft , typename PRight , typename CLeft , typename CRight > struct _Run{};
template< unsigned int _PLeftRadius , unsigned int ... _PLeftRadii , unsigned int _PRightRadius , unsigned int ... _PRightRadii , unsigned int _CLeftRadius , unsigned int ... _CLeftRadii , unsigned int _CRightRadius , unsigned int ... _CRightRadii >
struct _Run< UIntPack< _PLeftRadius , _PLeftRadii ... > , UIntPack< _PRightRadius , _PRightRadii ... > , UIntPack< _CLeftRadius , _CLeftRadii ... > , UIntPack< _CRightRadius , _CRightRadii ... > >
{
static unsigned int Run( ConstWindowSlice< const RegularTreeNode* , UIntPack< _PLeftRadius + _PRightRadius + 1 , ( _PLeftRadii+_PRightRadii+1 ) ... > > pNeighbors , WindowSlice< const RegularTreeNode* , UIntPack< _CLeftRadius + _CRightRadius + 1 , ( _CLeftRadii+_CRightRadii+1 ) ... > > cNeighbors , int* c , int cornerIndex );
};
template< unsigned int _PLeftRadius , unsigned int _PRightRadius , unsigned int _CLeftRadius , unsigned int _CRightRadius >
struct _Run< UIntPack< _PLeftRadius > , UIntPack< _PRightRadius > , UIntPack< _CLeftRadius > , UIntPack< _CRightRadius > >
{
static unsigned int Run( ConstWindowSlice< const RegularTreeNode* , UIntPack< _PLeftRadius+_PRightRadius+1 > > pNeighbors , WindowSlice< const RegularTreeNode* , UIntPack< _CLeftRadius+_CRightRadius+1 > > cNeighbors , int* c , int cornerIndex );
};
public:
typedef ConstNeighbors< UIntPack< ( LeftRadii + RightRadii + 1 ) ... > > NeighborType;
NeighborType* neighbors;
ConstNeighborKey( void );
ConstNeighborKey( const ConstNeighborKey& key );
~ConstNeighborKey( void );
ConstNeighborKey& operator = ( const ConstNeighborKey& key );
int depth( void ) const { return _depth; }
void set( int depth );
typename RegularTreeNode< Dim , NodeData , DepthAndOffsetType >::template ConstNeighbors< UIntPack< ( LeftRadii + RightRadii + 1 ) ... > >& getNeighbors( const RegularTreeNode* node );
template< unsigned int ... _LeftRadii , unsigned int ... _RightRadii >
void getNeighbors( UIntPack< _LeftRadii ... > , UIntPack< _RightRadii ... > , const RegularTreeNode* node , ConstNeighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& neighbors );
template< unsigned int ... _LeftRadii , unsigned int ... _RightRadii >
void getNeighbors( UIntPack< _LeftRadii ... > , UIntPack< _RightRadii ... > , const RegularTreeNode* node , ConstNeighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& pNeighbors , ConstNeighbors< UIntPack< ( _LeftRadii + _RightRadii + 1 ) ... > >& neighbors );
unsigned int getChildNeighbors( int cIdx , int d , NeighborType& childNeighbors ) const;
template< class Real >
unsigned int getChildNeighbors( Point< Real , Dim > p , int d , ConstNeighbors< UIntPack< ( LeftRadii + RightRadii + 1 ) ... > >& childNeighbors ) const;
};
int width( int maxDepth ) const;
};
#include "RegularTree.inl"
#endif // REGULAR_TREE_NODE_INCLUDED
|
