A sparse 3D grid of point-based data. More...

#include <PointHashGrid.h>

Classes
class	BoxIterator

class	CellIterator

class	Entry

class	Iterator

class	SphereIterator

Public Member Functions
void	getCellCoord (const Point3 &pos, Point3int32 &cellCoord) const
	Compute the grid cell index of a real position. This is used extensively internally by PointHashGrid. It is useful to calling code to determine when an object is about to move between cells. More...

	PointHashGrid (float radiusHint, const MemoryManager::Ref &m=MemoryManager::create())

float	radiusHint () const

void	clear (float radiusHint)

void	clearAndSetRadiusHint (float radiusHint)

	PointHashGrid (const Array< Value > &init, float radiusHint=-1.0f, const MemoryManager::Ref &m=MemoryManager::create())

int	size () const

const AABox &	conservativeBoxBounds () const

void	debugPrintStatistics () const

void	insert (const Value &v)

void	insert (const Array< Value > &v)

bool	remove (const Value &v, bool shrinkIfNecessary=true)

void	remove (const Array< Value > &v, bool shrink=true)

Iterator	begin () const

const Iterator &	end () const

BoxIterator	beginBoxIntersection (const AABox &box, bool exact=true) const

const BoxIterator &	endBoxIntersection () const

SphereIterator	begin (const Sphere &sphere) const

SphereIterator G3D_DEPRECATED	beginSphereIntersection (const Sphere &sphere) const

const SphereIterator &	endSphereIntersection () const

void	getIntersectingMembers (const Sphere &sphere, Array< Value > &result) const

CellIterator	beginCells () const

const CellIterator &	endCells () const

bool	contains (const Value &v) const

void	deleteAll ()

void	clearAndSetMemoryManager (const MemoryManager::Ref &m)

void	clear (bool shrink=true)

int	debugGetDeepestBucketSize () const

float	debugGetAverageBucketSize () const

Protected Member Functions
void	initOffsetArray ()

Private Types
typedef SmallArray< Entry, expectedCellSize >	Cell

typedef Table< Point3int32, Cell >	CellTable

Private Member Functions
	PointHashGrid (const ThisType &)

PointHashGrid &	operator= (const ThisType &)

bool	find (const Value &v, Point3int32 &foundCellCoord, Cell *&foundCell, int &index)

Private Attributes
Vector3int32	m_offsetArray [3 3 3]

int	m_epoch

float	m_cellWidth

float	m_invCellWidth

AABox	m_bounds

int	m_size

CellTable	m_data

MemoryManager::Ref	m_memoryManager

Detailed Description

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>
class G3D::PointHashGrid< Value, PosFunc, EqualsFunc >

A sparse 3D grid of point-based data.

The space cost for n elements is O(n). For data with approximately uniform density (with respect to the radius hint), the time cost of searching for neighbors is O(1).

You can move members of the data set by first removing them and then adding them with a new location.

Template argument PosFunc must provide a static getPosition method and EqualsFunc must provide a static equals method, as described below. You can either write classes that support these yourself, provide template specializations of G3D::PositionTrait and G3D::EqualsTrait, or rely on the default template specializations, which already exist for common G3D classes like G3D::Point3. For example:

class PosFunc {
public:
 static void getPosition(const Data& d, Vector3& pos) {
 pos = d.location;
 }
};
class EqualsFunc {
public:
 static bool equals(const Data& p, const Data& q) {
 return p == q;
 }
};
PointHashGrid<Data, Data::PosFunc, Data::EqualsFunc> grid;

If the Value class defines operator==, then the Equalsfunc is optional, so you can just write:

PointHashGrid<Data, Data::PosFunc> grid;

The simplest way to define these is often to make them both methods of the parameter class itself, e.g.,

 class Data {
 public:
 Point3 location;
 ...
 bool operator==(const Data& other) const {
 return (location == other.location) && ...;
 }
 static void getPosition(const Data& p, Vector3& pos) {
 pos = p.location;
 } 
};
typedef PointHashGrid<Data, Data> DataGrid;

Member Typedef Documentation

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

typedef SmallArray<Entry, expectedCellSize> G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::Cell

private

One cell of the grid.

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

typedef Table<Point3int32, Cell > G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::CellTable

private

Constructor & Destructor Documentation

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::PointHashGrid ( const ThisType & )

private

Intentionally unimplemented: prevent copy construction.

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::PointHashGrid	(	float	radiusHint,
		const MemoryManager::Ref &	m = `MemoryManager::create()`
	)

inline

Parameters

radiusHint the radius that will typically be used with beginBallIntersection and beginBoxIntersection. If two Values are equal, their positions must be within this radius as well. You can later change this value with clearAndSetRadiusHint().

  : m_size(0), m_memoryManager(m) {
  initOffsetArray();
  m_data.clearAndSetMemoryManager(m_memoryManager);
 
  debugAssertM(radiusHint > 0, "Cell radius must be positive");
  m_cellWidth = radiusHint;
  m_invCellWidth = 1.0f / m_cellWidth;
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::PointHashGrid	(	const Array< Value > &	init,
		float	radiusHint = `-1.0f`,
		const MemoryManager::Ref &	m = `MemoryManager::create()`
	)

inline

If radiusHint is negative, it is automatically chosen to put about 5 values in each grid cell (which means about 27 * 5 values for each beginIntersection call).

See also: clearAndSetRadiusHint()

  : m_size(0), m_memoryManager(m) { 
  initOffsetArray();
  m_data.clearAndSetMemoryManager(m_memoryManager);
 
  Point3 lo(Vector3::inf());
  Point3 hi(-lo);
 
  // Compute bounds
  Array<Entry> entry(init.size());
  for (int i = 0; i < entry.size(); ++i) {
  const Value& value = init[i];
  Point3 pos;
 
  entry[i].value = value;
  entry[i].hashCode = m_hashFunc(value);
  PosFunc::getPosition(value, entry[i].position);
 
  lo = lo.min(pos);
  hi = hi.max(pos);
  }
 
  m_bounds = AABox(lo, hi);
 
  if (radiusHint <= 0) {
  // Compute a good cell width based on the bounds.
  //
  // N numPerCell
  // ----- = ---------
  // volume r^3
 
  float numPerCell = 5;
  radiusHint = 
  (float)pow(numPerCell * m_bounds.volume() / init.size(), 1.0 / 3.0);
 
  if (radiusHint == 0) {
  // Volume must have been zero because all points were colocated.
  radiusHint = 0.1f;
  }
  }
 
  insert(init);
  }

Member Function Documentation

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

Iterator G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::begin ( ) const

inline

Iterate through all members. It is an error to mutate the HashGrid while iterating through it. Each member can be accessed by "dereferencing" the iterator:

for (Grid::Iterator i = grid.begin(); i != grid.end(), ++i) {
const Value& = *i;
...
}

  {
  return Iterator(this);
  }

Here is the caller graph for this function:

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

SphereIterator G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::begin ( const Sphere & sphere ) const

inline

Finds all values whose positions are within sphere. It is an error to mutate the PointHashGrid while iterating through it.

  {
  return SphereIterator(this, sphere);
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

BoxIterator G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::beginBoxIntersection	(	const AABox &	box,
		bool	exact = `true`
	)		const

inline

Finds all values whose positions are within box. It is an error to mutate the PointHashGrid while iterating through it.

Parameters

exact If false, the iterator will execute more quickly but will likely return some values that lie outside the box. Set exact = false if you are going to test the results against the yourself box anyway.

  {
  return BoxIterator(this, exact, box);
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

CellIterator G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::beginCells ( ) const

inline

Iterates through the non-empty cells. This is intended primarily for debugging and visualizing the data structure.

  {
  return CellIterator(this);
  }

Here is the caller graph for this function:

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

SphereIterator G3D_DEPRECATED G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::beginSphereIntersection ( const Sphere & sphere ) const

inline

Deprecated:

See also: beginIntersection

  {
  return SphereIterator(this, sphere);
  }

Here is the caller graph for this function:

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::clear ( float radiusHint )

inline

  {
  debugAssertM(radiusHint > 0, "Cell radius must be positive");
  clear();
  m_cellWidth = radiusHint;
  m_invCellWidth = 1.0f / m_cellWidth;
  }

Here is the caller graph for this function:

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::clear ( bool shrink = true )

inline

Removes all data.

Parameters

shrink If true, underlying structures are deallocated as they are freed.

  {
  m_size = 0;
  m_bounds = AABox();
  if (! shrink) {
  // Remove all data
  for (CellIterator it = beginCells(); it.isValid(); ++it) {
  it.cell().clear(true);
  }
  } else {
  m_data.clear();
  }
  ++m_epoch;
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::clearAndSetMemoryManager ( const MemoryManager::Ref & m )

inline

  {
  ++m_epoch;
  m_size = 0;
  m_bounds = AABox();
 
  m_data.clearAndSetMemoryManager(m);
  m_memoryManager = m;
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::clearAndSetRadiusHint ( float radiusHint )

inline

  {
  return clear(radiusHint);
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

const AABox& G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::conservativeBoxBounds ( ) const

inline

Returns a conservative bounding box around the contents. This is conservative because it is not updated when elements are removed.

  {
  return m_bounds;
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

bool G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::contains ( const Value & v ) const

inline

Returns true if there is a value that is exactly equal to v. This will check all neighboring cells to avoid roundoff error at cell boundaries.

  {
  Cell* cell = NULL;
  int index = 0;
  Vector3int32 cellCoord;
  return const_cast<ThisType*>(this)->find(v, cellCoord, cell, index);
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

float G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::debugGetAverageBucketSize ( ) const

inline

  {
  return m_data.debugGetAverageBucketSize();
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

int G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::debugGetDeepestBucketSize ( ) const

inline

  {
  return (int)m_data.debugGetDeepestBucketSize();
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::debugPrintStatistics ( ) const

inline

  {
  debugPrintf("Deepest bucket size = %d\n", (int)m_data.debugGetDeepestBucketSize());
  debugPrintf("Average bucket size = %g\n", m_data.debugGetAverageBucketSize());
  debugPrintf("Load factor = %g\n", m_data.debugGetLoad());
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::deleteAll ( )

inline

Calls delete on all of the values, which are assumed to be pointers. This is a helper to avoid requiring you to iterate through the data structure, removing and deleting each one. Clears the PointHashGrid at the end.

Using objects (instead of pointers) or reference counted pointers is recommended over using pointers and this deleteAll method.

  {
  for (Iterator it = begin(); it.isValid(); ++it) {
  delete *it;
  }
  clear();
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

const Iterator& G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::end ( ) const

inline

  {
  static const Iterator it;
  return it;
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

const BoxIterator& G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::endBoxIntersection ( ) const

inline

  {
  static const BoxIterator it;
  return it;
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

const CellIterator& G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::endCells ( ) const

inline

  {
  static const CellIterator it;
  return it;
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

const SphereIterator& G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::endSphereIntersection ( ) const

inline

Deprecated:

See also: SphereIterator::hasMore

  {
  static const SphereIterator it;
  return it;
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

bool G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::find	(	const Value &	v,
		Point3int32 &	foundCellCoord,
		Cell *&	foundCell,
		int &	index
	)

inlineprivate

Locate the cell and index within that cell containing v. Called by remove() and contains().

  {
  
  Point3 pos;
  PosFunc::getPosition(v, pos);
 
  Point3int32 cellCoord;
  getCellCoord(pos, cellCoord);
  for (int i = 0; i < 27; ++i) {
  Point3int32 c = cellCoord + m_offsetArray[i];
  Cell* cell = m_data.getPointer(c);
  if (cell != NULL) {
  // The cell exists
  for (int j = 0; j < cell->size(); ++j) {
  if (EqualsFunc::equals((*cell)[j].value, v)) {
  foundCell = cell;
  index = j;
  foundCellCoord = c;
  return true;
  }
  }
  } 
  }
 
  // Not found
  return false; 
  }

Here is the caller graph for this function:

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::getCellCoord	(	const Point3 &	pos,
		Point3int32 &	cellCoord
	)		const

inline

Compute the grid cell index of a real position. This is used extensively internally by PointHashGrid. It is useful to calling code to determine when an object is about to move between cells.

  {
  for (int a = 0; a < 3; ++a) {
  cellCoord[a] = iFloor(pos[a] * m_invCellWidth);
  }
  }

Here is the caller graph for this function:

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::getIntersectingMembers	(	const Sphere &	sphere,
		Array< Value > &	result
	)		const

inline

Appends results

  {
  for (SphereIterator it = beginSphereIntersection(sphere); it.isValid(); ++it) {
  result.append(*it);
  }
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::initOffsetArray ( )

inlineprotected

Initializes m_offsetArray.

  {
  int i = 0;
  Point3int32 d;
  for (d.x = -1; d.x <= +1; ++d.x) {
  for (d.y = -1; d.y <= +1; ++d.y) {
  for (d.z = -1; d.z <= +1; ++d.z) {
  m_offsetArray[i] = d;
  ++i;
  }
  }
  }
  
  // Put (0, 0, 0) first, so that contains() is most likely to find
  // the value quickly.
  i = (1 * 3 + 1) * 3 + 1;
  debugAssert(m_offsetArray[i] == Vector3int32(0,0,0));
  Vector3int32 temp = m_offsetArray[0];
  m_offsetArray[0] = m_offsetArray[i];
  m_offsetArray[i] = temp;
  }

Here is the caller graph for this function:

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::insert ( const Value & v )

inline

Insert v at position p given by getPosition(v, p). Multiple elements that are equal may be inserted; all copies will be in the data structure.

  {
  Point3 pos;
  PosFunc::getPosition(v, pos);
  Point3int32 cellCoord;
  getCellCoord(pos, cellCoord);
 
  // See if the cell already exists
  Cell& cell = m_data.getCreate(cellCoord);
 
  if (cell.size() == 0) {
  // Use the same memory manager as for the whole class
  cell.clearAndSetMemoryManager(m_memoryManager);
  }
 
  Entry& entry = cell.next();
  entry.value = v;
  entry.position = pos;
 
  // Update the bounds
  if (size() == 0) {
  m_bounds = AABox(pos);
  } else {
  m_bounds.merge(pos);
  }
 
  ++m_size;
  ++m_epoch;
  }

Here is the caller graph for this function:

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::insert ( const Array< Value > & v )

inline

Inserts all elements of the array.

  {
  for (int i = 0; i < v.size(); ++i) {
  insert(v[i]);
  }
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

PointHashGrid& G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::operator= ( const ThisType & )

private

Intentionally unimplemented: prevent assignment.

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

float G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::radiusHint ( ) const

inline

See also: clearAndSetRadiusHint()

  {
  return m_cellWidth;
  }

Here is the caller graph for this function:

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

bool G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::remove	(	const Value &	v,
		bool	shrinkIfNecessary = `true`
	)

inline

If there are multiple copies of an element, you must delete them multiple times.

Parameters

shrinkIfNecessary If true, deallocate underlying data structures as they are emptied. False increases performace at the cost of memory overhead for dynamic structures.

Returns: true if the element was found.

  {
  Cell* cell = NULL;
  int index = 0;
  Vector3int32 cellCoord;
 
  if (find(v, cellCoord, cell, index)) {
  cell->fastRemove(index, shrinkIfNecessary);
  --m_size;
  ++m_epoch;
 
  if ((cell->size() == 0) && shrinkIfNecessary) {
  // Remove the cell itself
 
  // Drop our pointer, which is about to dangle
  cell = NULL;
  const bool success = m_data.remove(cellCoord);
  (void)success;
  debugAssertM(success, "Data structure corrupt: "
  "tried to remove a cell that doesn't exist.");
  }
 
  return true;
 
  } else {
  return false;
  }
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

void G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::remove	(	const Array< Value > &	v,
		bool	shrink = `true`
	)

inline

Removes all elements of v.

  {
  for (int i = 0; i < v.size(); ++i) {
  remove(v[i], shrink);
  }
  }

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

int G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::size ( ) const

inline

Returns the number of elements.

  {
  return m_size;
  }

Here is the caller graph for this function:

Member Data Documentation

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

AABox G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::m_bounds

private

Conservative bounds; the actual data may be smaller.

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

float G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::m_cellWidth

private

Extent of a cell along one dimension.

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

CellTable G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::m_data

private

Non-empty cells indexed by grid position. Actual 3D position is position * m_cellWidth

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

int G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::m_epoch

private

Incremented every time the data structure is mutated. Used by the iterators to determine if the data structure has changed since iteration began.

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

float G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::m_invCellWidth

private

1.0 / cell width

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

MemoryManager::Ref G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::m_memoryManager

private

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

Vector3int32 G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::m_offsetArray[3 *3 *3]

private

The cube of +/-1 along each dimension. Initialized by initOffsetArray.

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>

int G3D::PointHashGrid< Value, PosFunc, EqualsFunc >::m_size

private

Number of elements.

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

dep/g3dlite/include/G3D/PointHashGrid.h

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>> class G3D::PointHashGrid< Value, PosFunc, EqualsFunc >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class Value, class PosFunc = PositionTrait<Value>, class EqualsFunc = EqualsTrait<Value>>
class G3D::PointHashGrid< Value, PosFunc, EqualsFunc >