Data Structures | Public Types | Public Member Functions | Data Fields | Static Public Attributes | Protected Member Functions | Protected Attributes

DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey > Class Template Reference

Model of CImageContainer implementing the association key<->Value using a hash tree. This class provides a built-in iterator. More...

#include <ImageContainerByHashTree.h>

Collaboration diagram for DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >:
Collaboration graph
[legend]

Data Structures

struct  DefaultDrawStyle
class  Iterator
class  Node
struct  POW
struct  POW< X, 1 >

Public Types

typedef THashKey HashKey
typedef TValueType ValueType
typedef TDomain Domain
typedef Domain::Point Point
typedef Domain::Vector Vector

Public Member Functions

 BOOST_CONCEPT_ASSERT ((CValueType< TValueType >))
 BOOST_CONCEPT_ASSERT ((CDomain< TDomain >))
 ImageContainerByHashTree (const unsigned int hashKeySize, const unsigned int depth, const ValueType defaultValue)
 ImageContainerByHashTree (const unsigned int hashKeySize, const Point &p1, const Point &p2, const ValueType defaultValue)
 ImageContainerByHashTree (const ImageContainerByHashTree< Domain, ValueType > &toCopy)
ValueType get (const HashKey key) const
ValueType operator() (const HashKey key) const
ValueType operator() (const Point &aPoint) const
ValueType get (const Point &aPoint) const
ValueType upwardGet (const HashKey key) const
ValueType reverseGet (const HashKey key) const
void setValue (const HashKey key, const ValueType object)
void setValue (const Point &aPoint, const ValueType object)
unsigned int getSpanSize () const
unsigned int getDepth () const
bool isKeyValid (HashKey key) const
bool checkIntegrity (HashKey key=ROOT_KEY, bool leafAbove=false) const
HashKey getKey (const Point &aPoint) const
unsigned int getKeyDepth (HashKey key) const
int * getCoordinatesFromKey (HashKey key) const
void save (std::ostream &out)
void load (std::istream &in)
void printState (std::ostream &out, bool displayKeys=false) const
void printTree (HashKey key, std::ostream &out, bool displayKeys) const
void printInternalState (std::ostream &out, unsigned int nbBits=0) const
void printInfo (std::ostream &out) const
unsigned int getNbEmptyLists () const
double getAverageCollisions () const
unsigned int getMaxCollisions () const
unsigned int getNbNodes (unsigned int intermediateKey) const
unsigned int getNbNodes () const
Iterator begin ()
Iterator end ()
void selfDisplay (std::ostream &out)
bool isValid () const
DrawableWithDGtalBoarddefaultStyle () const
std::string styleName () const
template<typename Colormap >
void selfDraw (DGtalBoard &board, const ValueType &minValue, const ValueType &maxValue) const

Data Fields

int myDebugCounter

Static Public Attributes

static const
TDomain::Space::Dimension 
dim = TDomain::staticDimension
static const
TDomain::Space::Dimension 
staticDimension = TDomain::staticDimension
static const unsigned int NbChildrenPerNode = POW<2, staticDimension>::VALUE
static const HashKey ROOT_KEY = static_cast<HashKey>(1)

Protected Member Functions

template<typename C >
void recursiveDraw (HashKey key, const double p1[2], const double len, LibBoard::Board &board, const C &cmap) const
HashKey getIntermediateKey (const HashKey key) const
NodeaddNode (const ValueType object, const HashKey key)
NodegetNode (const HashKey key) const
bool removeNode (HashKey key)
void recursiveRemoveNode (HashKey key, unsigned int nbRecursions)
void setDepth (unsigned int depth)
ValueType blendChildren (HashKey key) const

Protected Attributes

Node ** myData
unsigned int myKeySize
unsigned int myArraySize
unsigned int myTreeDepth
unsigned int mySpanSize
Point myOrigin
HashKey myDepthMask
HashKey myPreComputedIntermediateMask
Morton< HashKey, PointmyMorton

Detailed Description

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
class DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >

Model of CImageContainer implementing the association key<->Value using a hash tree. This class provides a built-in iterator.

Description of template class 'ImageContainerByHashTree'

Todo:
doc here

The ImageContainerByHashTree relies on a tree model implemented using a hash table based on Morton Codes. A Morton hash key is obatained from coordinates by interleaving the binary representations of the coordinate values. This means the coordinates have to be of integer type for the morton code to be valid.

The data can be accessed using keys, coordinates or Iterators provided by the container.

The parent of a given key can be found by simply shifting to the left the key's bits by it's dimension. exemples: for an octree (N = 3) the parent key of the key 1110100001 is 1110100. for a quadtree (N = 2) the parent key of the key 10010111 is 100101.

It is then easy to determine, for a N-Dimmensionnal container, all the children keys of a given key, by concatenating any combination of N bits at the right side of the key (least important bits). exemple: for a quadtree (N = 2) 1010100, 1010101, 1010110 and 1010111 are the children of 10101.

In order to disgard any ambiguous case, we need to make the assertion that the root of the hash is at key 1. Else we would have to deal with the problem of the key 00000..0 which would have one of it's children equal to 0 and so on... This means that we need to set the key's N*maxDepth bit to 1 after interleaving the corrdinates bit for key generation.

Note that not any combination of bits is valid. We saw the exemple of the key 0, and there are other cases of invalidity. For a key to be valid, the last set bit (most important set bit) must be at a position of the form k*N with N the Dimmension of the Domain and k a positive integer. exemples: for an octree(N = 3) 1, 1000, 1010111 are valid keys, whereas 0, 10, 11101 are not !

Warning ! For performances this container's access method never check for a key's validity. Trying to access an invalid key may destroy the validity off the tree's structure and/or get the program stuck into an infinite loop.

The method isKeyValid(..) is provided to verify the validity of a key. Note that using this security strongly affects performances.


Member Typedef Documentation

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
typedef TDomain DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::Domain
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
typedef THashKey DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::HashKey
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
typedef Domain::Point DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::Point
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
typedef TValueType DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::ValueType
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
typedef Domain::Vector DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::Vector

Constructor & Destructor Documentation

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::ImageContainerByHashTree ( const unsigned int  hashKeySize,
const unsigned int  depth,
const ValueType  defaultValue 
)

The constructor.

Parameters:
hashKeySize Number of bit of the hash key. This parameter is important as it influences the amount of collisions in the hash table. A value K creates an array of length 2^K with potential unused cells so a compromise between speed and memory usage is to be done here.
depth Determines the maximum depth of the tree and thus qthe "size" of the image. Each span then extends from 0 to 2^depth.
defaultValue In order for the tree to be valid it needs a default value at the root (key = 1)
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::ImageContainerByHashTree ( const unsigned int  hashKeySize,
const Point p1,
const Point p2,
const ValueType  defaultValue 
)
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::ImageContainerByHashTree ( const ImageContainerByHashTree< Domain, ValueType > &  toCopy  ) 

Member Function Documentation

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
Node* DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::addNode ( const ValueType  object,
const HashKey  key 
) [inline, protected]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
Iterator DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::begin (  )  [inline]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
ValueType DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::blendChildren ( HashKey  key  )  const [protected]

Recursively get the value of all the leafs below and blend it to get the value of a parent node. This is called in the get() method when it has been determined that the leafs are deeper than the requested key.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::BOOST_CONCEPT_ASSERT ( (CDomain< TDomain >)   ) 
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::BOOST_CONCEPT_ASSERT ( (CValueType< TValueType >)   ) 
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
bool DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::checkIntegrity ( HashKey  key = ROOT_KEY,
bool  leafAbove = false 
) const

Checks recursively that the sub-tree starting with key is valid. A tree is valid if there's one (and only one) leaf for each position at maximal depth.

Referenced by DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::isValid(), and test_setVal().

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
DrawableWithDGtalBoard* DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::defaultStyle (  )  const

Default drawing style object.

Returns:
the dyn. alloc. default style for this object.
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
Iterator DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::end (  )  [inline]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
ValueType DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::get ( const Point aPoint  )  const

Returns the value at a given coordinate using upwardGet().

Parameters:
aPoint The point.
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
ValueType DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::get ( const HashKey  key  )  const

Returns the value corresponding to a key.

This is the generic method working with any valid key. For efficiency no check is performed on the key so be careful when calling this method. If the leafs are deeper than the requested key, this method will recursively browse through the children nodes and compute a average of each child's value using blendChildren(..) which is very slow. Thus performances are much better when accessing a leaf from a deeper key (needs no blending).

Parameters:
key the haskkey
Returns:
the value type

Referenced by main(), and test_get().

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
double DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getAverageCollisions (  )  const

Returns The average number of collisions in the hash table, without counting the empty places.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
int* DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getCoordinatesFromKey ( HashKey  key  )  const
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getDepth (  )  const [inline]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
HashKey DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getIntermediateKey ( const HashKey  key  )  const [inline, protected]

This is part of the hash function. It is called whenever a key is accessed. The mask used to compute the result is precomputed in the constructor for efficiency.

Referenced by DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::addNode(), and DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getNode().

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
HashKey DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getKey ( const Point aPoint  )  const
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getKeyDepth ( HashKey  key  )  const
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getMaxCollisions (  )  const

Returns the highest number of collisions in the hash table.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getNbEmptyLists (  )  const

Returns the number of empty places in the hash table.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getNbNodes ( unsigned int  intermediateKey  )  const

Returns the number of elements for a givent key of the hash table.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getNbNodes (  )  const

Returns the total amount of elements in the container.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
Node* DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getNode ( const HashKey  key  )  const [inline, protected]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::getSpanSize (  )  const [inline]

Returns the size of a dimension (the container represents a line, a square, a cube, etc. depending on the dimmension so no need for distinctions between width, height, ect.)

References DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::mySpanSize.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
bool DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::isKeyValid ( HashKey  key  )  const

Returns true if the key is valid. A key is valid if the the most important bit that is equal to 1 is at a position of the type dim*k with dim the dimmension of the container (template parameter) and k a strictly positive integer.

Referenced by test_get(), and test_setVal().

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
bool DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::isValid (  )  const [inline]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::load ( std::istream &  in  ) 

Load the container from a stream.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
ValueType DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::operator() ( const HashKey  key  )  const

Returns the value at a given key.

Parameters:
key the hash key used as an index.
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
ValueType DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::operator() ( const Point aPoint  )  const

Returns the value at a given point.

Parameters:
aPoint The point.
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::printInfo ( std::ostream &  out  )  const

Prints informations about the state of the container without displaying the data:

  • Nunber of elements in the tree.
  • Amount of unused disk space due to blanks in the hash table.
  • The dimmension.
  • The number of bits of the HashKey.
  • The size of the image.
  • The average and the maximum amount of collisions.
  • The total memory usage.
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::printInternalState ( std::ostream &  out,
unsigned int  nbBits = 0 
) const

Prints the state of the container in a way that displays the hash table and every node as it is stored in memory instead of the usual tree representation.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::printState ( std::ostream &  out,
bool  displayKeys = false 
) const

Prints in the state of the container as a tree. (Calls printTree)

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::printTree ( HashKey  key,
std::ostream &  out,
bool  displayKeys 
) const

Prints the sub-tree starting with the node corresponding to key.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
template<typename C >
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::recursiveDraw ( HashKey  key,
const double  p1[2],
const double  len,
LibBoard::Board board,
const C &  cmap 
) const [protected]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::recursiveRemoveNode ( HashKey  key,
unsigned int  nbRecursions 
) [protected]

Recusrively calls RemoveNode on the key and its children.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
bool DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::removeNode ( HashKey  key  )  [protected]

Remove the node corresponding to a key. Returns false if the node doesn't exist.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
ValueType DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::reverseGet ( const HashKey  key  )  const

A attempt to do the same thing as get(HashKey) but looking for deeper leafs in the first place instead of doing this in the second place. It hasn't show better results so far.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::save ( std::ostream &  out  ) 

Save the container into a stream.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::selfDisplay ( std::ostream &  out  ) 
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
template<typename Colormap >
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::selfDraw ( DGtalBoard board,
const ValueType minValue,
const ValueType maxValue 
) const

Draw the object on a LibBoard board.

Parameters:
board the output board where the object is drawn.
minValue the minimum value contained in the image (used in the colormap settings)
maxValue the maximum value contained in the image (used in the colormap settings)
Template Parameters:
Coloramp any models of CColormap.
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::setDepth ( unsigned int  depth  )  [protected]

Set the (maximum) depth of the tree and precompute a mask used for some calculations. The depth of the tree must be known because accessing the data from coordinates depends on it.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::setValue ( const HashKey  key,
const ValueType  object 
)

Sets the value of an element in the container, creating it if necessary. In order to keep the tree's coherence this method may add and remove several other nodes in the tree so performances strongly depend on wether or not and how much the tree's structure needs to be modified. For efficiency no check is performed on the key

Referenced by test_get(), and test_setVal().

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
void DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::setValue ( const Point aPoint,
const ValueType  object 
)

Sets the value of an element in the container, creating it if necessary. In order to keep the tree's coherence this method may add and remove several other nodes in the tree so performances strongly depend on wether or not and how much the tree's structure needs to be modified. For efficiency no check is performed on the coordinates

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
std::string DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::styleName (  )  const
Returns:
the style name used for drawing this object.
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
ValueType DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::upwardGet ( const HashKey  key  )  const

Returns the value corresponding to a key making the assomption that the key is at same depth or deeper than the leaf we are looking for.


Field Documentation

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
const TDomain::Space::Dimension DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::dim = TDomain::staticDimension [static]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::myArraySize [protected]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
Node** DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::myData [protected]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::myDebugCounter
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
HashKey DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::myDepthMask [protected]

Precoputed masks to avoid recalculating it all the time

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::myKeySize [protected]

The size of the intermediate hashkey. The bigger the less collisions, but at the same time the more chances to have unused memory allocated.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
Morton<HashKey, Point> DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::myMorton [protected]

The morton code computer.

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
Point DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::myOrigin [protected]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
HashKey DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::myPreComputedIntermediateMask [protected]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::mySpanSize [protected]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::myTreeDepth [protected]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
const unsigned int DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::NbChildrenPerNode = POW<2, staticDimension>::VALUE [static]
template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
const HashKey DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::ROOT_KEY = static_cast<HashKey>(1) [static]

Referenced by test_get(), and test_setVal().

template<typename TDomain, typename TValueType, typename THashKey = typename DGtal::uint64_t>
const TDomain::Space::Dimension DGtal::experimental::ImageContainerByHashTree< TDomain, TValueType, THashKey >::staticDimension = TDomain::staticDimension [static]

The documentation for this class was generated from the following file: