manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Added DynamicSpatialHAshTable class

This commit is contained in:
Nico Pietroni 2005-09-21 14:22:49 +00:00
parent ab22877d1d
commit 15405e5e3c
1 changed files with 62 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

208
vcg/space/index/spatial_hashing.h
View File

@ -24,6 +24,11 @@
History History
$Log: not supported by cvs2svn $ $Log: not supported by cvs2svn $
Revision 1.8 2005/09/19 13:35:45 pietroni
use of standard grid interface
use of vector instead of map inside the cell
removed closest iterator
Revision 1.7 2005/06/15 11:44:47 pietroni Revision 1.7 2005/06/15 11:44:47 pietroni
minor changes minor changes
@ -69,12 +74,14 @@ added vcg header
namespace vcg{ namespace vcg{
/** Spatial Hash Table /** Spatial Hash Table
Spatial Hashing as described in Spatial Hashing as described in
"Optimized Spatial Hashing for Coll ision Detection of Deformable Objects", "Optimized Spatial Hashing for Coll ision Detection of Deformable Objects",
Matthias Teschner and Bruno Heidelberger and Matthias Muller and Danat Pomeranets and Markus Gross Matthias Teschner and Bruno Heidelberger and Matthias Muller and Danat Pomeranets and Markus Gross
*/ */
template < typename ContainerType,class FLT=float > template < typename ContainerType,class FLT=double>
class SpatialHashTable:public BasicGrid<FLT> class SpatialHashTable:public BasicGrid<FLT>
{ {
@ -100,26 +107,14 @@ namespace vcg{
ObjType& operator *(){return (*this->first);} ObjType& operator *(){return (*this->first);}
}; };
//typedef typename std::map<ObjType*,int> CellContainerType;
typedef typename std::vector<EntryType> CellContainerType; typedef typename std::vector<EntryType> CellContainerType;
typedef typename CellContainerType::iterator IteMap; typedef typename CellContainerType::iterator IteMap;
typedef typename EntryType* CellIterator; typedef typename EntryType* CellIterator;
////iterator to elems on a cell (need to define method Elem() for Space Iterators)
//class CellIterator :public IteMap
//{
// //std::vector<int>::iterator i;
//public:
// CellIterator(){}
// inline CellIterator & operator = ( IteMap const &c)
// {this->); };
// ObjType* operator *(){return ((* this)->first);}
//};
//This Class Identify the cell //This Class Identify the cell
struct Cell struct Cell
{ {
private: protected:
///the min and max point corresponding to the cell - used to inverse hashing ///the min and max point corresponding to the cell - used to inverse hashing
//CoordType min;//coordinate min of the cell //CoordType min;//coordinate min of the cell
@ -146,13 +141,6 @@ namespace vcg{
cell_n=_cell; cell_n=_cell;
} }
/////return true if the element is in the cell
//bool IsIn(ObjType* sim)
//{
// int n=elem.count(sim);
// assert((n==0)||(n==1));
// return (n==1);
//}
///return the number of elements stored in the cell ///return the number of elements stored in the cell
int Size() int Size()
@ -171,36 +159,46 @@ namespace vcg{
void Update(ObjType* sim, const int & _tempMark) void Update(ObjType* sim, const int & _tempMark)
{ {
IteMap I; IteMap I;
if (Find(sim,I))///update temporary mark if (Find(sim,I))
{///update temporary mark
(*I).second=_tempMark; (*I).second=_tempMark;
}
else else
_entries.push_back(EntryType(sim,_tempMark)); _entries.push_back(EntryType(sim,_tempMark));
//at the end update the temporary mark on the simplex ////at the end update the temporary mark on the simplex
sim->Mark()=_tempMark; //_UpdateHMark(sim);
//Assert(); //Assert();
} }
///given an iterator to the instance of the entry in the cell /////given an iterator to the instance of the entry in the cell
///return true if the the entry is valid /////return true if the the entry is valid
///(using temporary mark). /////(using temporary mark).
bool IsUpdated(IteMap &I) //bool IsUpdated(IteMap &I)
{ //{
return ((*I).second >= (*I).first->Mark()); // if (Use_Mark)
} // return ((*I).second >= (*I).first->HMark());
// else
// return true;
//}
///given an simplex pointer /////given an simplex pointer
///return true if the the entry corripondent to that /////return true if the the entry corripondent to that
///simplex is valid or not /////simplex is valid or not
///(using temporary mark). /////(using temporary mark).
bool IsUpdated(ObjType* sim) //bool IsUpdated(ObjType* sim)
{ //{
IteMap I; // if (Use_Mark)
if (Find(sim,I)) // {
return(IsUpdated(I)); // IteMap I;
else // if (Find(sim,I))
return false; // return(IsUpdated(I));
} // else
// return false;
// }
// else return true;
//}
Point3i CellN() Point3i CellN()
{return cell_n;} {return cell_n;}
@ -211,112 +209,11 @@ namespace vcg{
bool operator !=(const Cell &h) bool operator !=(const Cell &h)
{return ((cell_n!=h.CellN()));} {return ((cell_n!=h.CellN()));}
protected:
virtual void UpdateHMark(ObjType* s){}
}; // end struct Cell }; // end struct Cell
////This Class Identify the cell
//struct Cell
//{
//private:
// ///the min and max point corresponding to the cell - used to inverse hashing
// //CoordType min;//coordinate min of the cell
// //CoordType max;//coordinate max of the cell
// Point3i cell_n;//cell number
// //iterator to the map element into the cell
// //typedef typename CellContainerType::iterator IteMap;
//public:
// //elements
// CellContainerType _entries;
// Cell()
// {}
// Cell(ObjType* sim,Point3i _cell,const int &_tempMark)
// {
// _entries.insert(EntryType(sim,_tempMark));
// /*min=_min;
// max=_max;
// assert(min<max);*/
// cell_n=_cell;
// }
// ///return true if the element is in the cell
// bool IsIn(ObjType* sim)
// {
// int n=elem.count(sim);
// assert((n==0)||(n==1));
// return (n==1);
// }
// ///return the number of elements stored in the cell
// int Size()
// {return (int)(_entries.size());}
// ///update or insert an element into a cell
// void Update(ObjType* sim, const int & _tempMark)
// {
// IteMap I=_entries.find(sim);
// if (I!=_entries.end())//the entry exist in the cell
// (*I).second=_tempMark;
// else
// _entries.insert(_entries.begin(),EntryType(sim,_tempMark));
// //at the end update the temporary mark on the simplex
// sim->Mark()=_tempMark;
// //Assert();
// }
// ///given an iterator to the instance of the entry in the cell
// ///return true if the the entry is valid
// ///(using temporary mark).
// bool IsUpdated(CellIterator &I)
// {
// return ((*I).second >= (*I).first->Mark());
// }
// ///given an simplex pointer
// ///return true if the the entry corripondent to that
// ///simplex is valid or not
// ///(using temporary mark).
// bool IsUpdated(ObjType* sim)
// {
// IteMap I=_entries.find(sim);
// if (I!=_entries.end())
// return(IsUpdated(I));
// else
// return false;
// }
// ////add to the vector all simplexes of the map that have a right timestamp or are not deleted
// //void Elems(std::vector<ObjType*> & res)
// //{
// // for (IteMap ite=_entries.begin();ite!=_entries.end();ite++)
// // {
// // ObjType* sim=(*ite).first;
// // if (IsUpdated(ite)&&(!sim->IsD()))
// // res.push_back(sim);
// // }
// //}
// Point3i CellN()
// {return cell_n;}
// bool operator ==(const Cell &h)
// {return (cell_n==h.CellN());}
// bool operator !=(const Cell &h)
// {return ((cell_n!=h.CellN()));}
//}; // end struct Cell
//hash table definition //hash table definition
typedef typename STDEXT::hash_multimap<int,Cell> Htable; typedef typename STDEXT::hash_multimap<int,Cell> Htable;
//record of the hash table //record of the hash table
@ -344,7 +241,6 @@ namespace vcg{
{ {
int h=Hash(cell); int h=Hash(cell);
hash_table.insert(HRecord(h,Cell(s,cell,tempMark))); hash_table.insert(HRecord(h,Cell(s,cell,tempMark)));
s->Mark()=tempMark;
//Assert(); //Assert();
} }
@ -376,6 +272,8 @@ namespace vcg{
} }
} }
virtual void _UpdateHMark(ObjType* s){}
///insert an element in a specified cell if the cell doesn't exist than ///insert an element in a specified cell if the cell doesn't exist than
///create it. ///create it.
void _InsertInCell(ObjType* s,Point3i cell) void _InsertInCell(ObjType* s,Point3i cell)
@ -385,6 +283,8 @@ namespace vcg{
_InsertNewHentry(s,cell); _InsertNewHentry(s,cell);
else///there is the entry specified by the iterator I so update only the temporary mark else///there is the entry specified by the iterator I so update only the temporary mark
(*I).second.Update(s,tempMark); (*I).second.Update(s,tempMark);
_UpdateHMark(s);
} }
// hashing // hashing
@ -553,9 +453,9 @@ namespace vcg{
hash_table.clear(); hash_table.clear();
} }
void SetHashSpace() void SetHashKeySpace(int n)
{ {
HashSpace HashSpace=n;
} }
void UpdateTmark() void UpdateTmark()
@ -564,6 +464,16 @@ namespace vcg{
}; // end class }; // end class
/** Spatial Hash Table Dynamic
Update the Hmark value on the simplex for dynamic updating of contents of the cell.
The simplex must have the HMark() function.
*/
template < typename ContainerType,class FLT=double>
class DynamicSpatialHashTable:SpatialHashTable<ContainerType,FLT>
{
void _UpdateHMark(ObjType* s){s->HMark()=tempMark;}
};
}// end namespace }// end namespace
#undef P0 #undef P0