You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
264 lines
9.9 KiB
264 lines
9.9 KiB
/**************************************************************************** |
|
* VCGLib o o * |
|
* Visual and Computer Graphics Library o o * |
|
* _ O _ * |
|
* Copyright(C) 2004-2016 \/)\/ * |
|
* Visual Computing Lab /\/| * |
|
* ISTI - Italian National Research Council | * |
|
* \ * |
|
* All rights reserved. * |
|
* * |
|
* This program is free software; you can redistribute it and/or modify * |
|
* it under the terms of the GNU General Public License as published by * |
|
* the Free Software Foundation; either version 2 of the License, or * |
|
* (at your option) any later version. * |
|
* * |
|
* This program is distributed in the hope that it will be useful, * |
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of * |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * |
|
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * |
|
* for more details. * |
|
* * |
|
****************************************************************************/ |
|
|
|
///** Returns the closest posistion of a point _p and its distance |
|
//@param _p a 3d point |
|
//@param _maxDist maximum distance not to search beyond. |
|
//@param _getPointDistance (templated type) a functor object used to calculate distance from a grid object to the point _p. |
|
//@param _minDist the returned closest distance |
|
//@param _closestPt the returned closest point |
|
//@return The closest element |
|
//*/ |
|
///* |
|
// A DISTFUNCT object must implement an operator () with signature: |
|
// bool operator () (const ObjType& obj, const CoordType & _p, ScalarType & min_dist, CoordType & _closestPt); |
|
//*/ |
|
#ifndef __VCGLIB_GRID_CLOSEST |
|
#define __VCGLIB_GRID_CLOSEST |
|
|
|
#include <vcg/space/index/space_iterators.h> |
|
|
|
namespace vcg{ |
|
|
|
template <class SPATIAL_INDEX, class OBJPOINTDISTFUNCTOR, class OBJMARKER> |
|
typename SPATIAL_INDEX::ObjPtr GridClosest(SPATIAL_INDEX &Si, |
|
OBJPOINTDISTFUNCTOR _getPointDistance, |
|
OBJMARKER & _marker, |
|
const typename OBJPOINTDISTFUNCTOR::QueryType & _p_obj, |
|
const typename SPATIAL_INDEX::ScalarType & _maxDist, |
|
typename SPATIAL_INDEX::ScalarType & _minDist, |
|
typename SPATIAL_INDEX:: CoordType &_closestPt) |
|
{ |
|
typedef typename SPATIAL_INDEX::ObjPtr ObjPtr; |
|
typedef typename SPATIAL_INDEX::CoordType CoordType; |
|
typedef typename SPATIAL_INDEX::ScalarType ScalarType; |
|
typedef typename SPATIAL_INDEX::Box3x Box3x; |
|
|
|
Point3<ScalarType> _p = OBJPOINTDISTFUNCTOR::Pos(_p_obj); |
|
// Initialize min_dist with _maxDist to exploit early rejection test. |
|
_minDist = _maxDist; |
|
|
|
ObjPtr winner=NULL; |
|
_marker.UnMarkAll(); |
|
ScalarType newradius = Si.voxel.Norm(); |
|
ScalarType radius; |
|
Box3i iboxdone,iboxtodo; |
|
CoordType t_res; |
|
typename SPATIAL_INDEX::CellIterator first,last,l; |
|
if(Si.bbox.IsInEx(_p)) |
|
{ |
|
Point3i _ip; |
|
Si.PToIP(_p,_ip); |
|
Si.Grid( _ip[0],_ip[1],_ip[2], first, last ); |
|
for(l=first;l!=last;++l) |
|
{ |
|
ObjPtr elem=&(**l); |
|
if (!elem->IsD()) |
|
{ |
|
if (_getPointDistance((**l), _p_obj,_minDist, t_res)) // <-- NEW: use of distance functor |
|
{ |
|
winner=elem; |
|
_closestPt=t_res; |
|
newradius=_minDist; // |
|
} |
|
_marker.Mark(elem); |
|
} |
|
} |
|
iboxdone=Box3i(_ip,_ip); |
|
} |
|
|
|
int ix,iy,iz; |
|
Box3i ibox(Point3i(0,0,0),Si.siz-Point3i(1,1,1)); |
|
do |
|
{ |
|
radius=newradius; |
|
Box3x boxtodo=Box3x(_p,radius); |
|
//boxtodo.Intersect(Si.bbox); |
|
Si.BoxToIBox(boxtodo, iboxtodo); |
|
iboxtodo.Intersect(ibox); |
|
if(!boxtodo.IsNull()) |
|
{ |
|
for (ix=iboxtodo.min[0]; ix<=iboxtodo.max[0]; ix++) |
|
for (iy=iboxtodo.min[1]; iy<=iboxtodo.max[1]; iy++) |
|
for (iz=iboxtodo.min[2]; iz<=iboxtodo.max[2]; iz++) |
|
if(ix<iboxdone.min[0] || ix>iboxdone.max[0] || // this test is to avoid to re-process already analyzed cells. |
|
iy<iboxdone.min[1] || iy>iboxdone.max[1] || |
|
iz<iboxdone.min[2] || iz>iboxdone.max[2] ) |
|
{ |
|
Si.Grid( ix, iy, iz, first, last ); |
|
for(l=first;l!=last;++l) if (!(**l).IsD()) |
|
{ |
|
ObjPtr elem=&(**l); |
|
if (!elem->IsD()) |
|
{ |
|
if( ! _marker.IsMarked(elem)) |
|
{ |
|
if (_getPointDistance((**l), _p_obj, _minDist, t_res)) |
|
{ |
|
winner=elem; |
|
_closestPt=t_res; |
|
}; |
|
_marker.Mark(elem); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
if(!winner) newradius=radius+Si.voxel.Norm(); |
|
else newradius = _minDist; |
|
iboxdone=iboxtodo; |
|
} |
|
while (_minDist>radius); |
|
|
|
return winner; |
|
} |
|
|
|
template <class SPATIALINDEXING,class OBJPOINTDISTFUNCTOR, class OBJMARKER, |
|
class OBJPTRCONTAINER, class DISTCONTAINER, class POINTCONTAINER> |
|
unsigned int GridGetKClosest(SPATIALINDEXING &_Si, |
|
OBJPOINTDISTFUNCTOR & _getPointDistance, |
|
OBJMARKER & _marker, |
|
const unsigned int _k, |
|
const typename SPATIALINDEXING::CoordType & _p, |
|
const typename SPATIALINDEXING::ScalarType & _maxDist, |
|
OBJPTRCONTAINER & _objectPtrs, |
|
DISTCONTAINER & _distances, |
|
POINTCONTAINER & _points) |
|
{ |
|
typedef vcg::ClosestIterator<SPATIALINDEXING,OBJPOINTDISTFUNCTOR,OBJMARKER> ClosestIteratorType; |
|
ClosestIteratorType Cli=ClosestIteratorType(_Si,_getPointDistance); |
|
Cli.SetMarker(_marker); |
|
Cli.Init(_p,_maxDist); |
|
unsigned int i=0; |
|
_objectPtrs.clear(); |
|
_distances.clear(); |
|
_points.clear(); |
|
while ((!Cli.End())&&(i<_k)) |
|
{ |
|
_objectPtrs.push_back(&(*Cli)); |
|
_distances.push_back(Cli.Dist()); |
|
_points.push_back(Cli.NearestPoint()); |
|
++Cli; |
|
i++; |
|
} |
|
return (i); |
|
} |
|
|
|
template <class SPATIALINDEXING,class OBJRAYISECTFUNCTOR, class OBJMARKER> |
|
typename SPATIALINDEXING::ObjPtr GridDoRay(SPATIALINDEXING &_Si, |
|
OBJRAYISECTFUNCTOR &_rayIntersector, |
|
OBJMARKER &_marker, |
|
const Ray3<typename SPATIALINDEXING::ScalarType> & _ray, |
|
const typename SPATIALINDEXING::ScalarType & _maxDist, |
|
typename SPATIALINDEXING::ScalarType & _t) |
|
{ |
|
typedef vcg::RayIterator<SPATIALINDEXING,OBJRAYISECTFUNCTOR,OBJMARKER> RayIteratorType; |
|
RayIteratorType RayIte=RayIteratorType(_Si,_rayIntersector,_maxDist); |
|
RayIte.SetMarker(_marker); |
|
RayIte.Init(_ray); |
|
|
|
if (!RayIte.End()) |
|
{ |
|
_t=RayIte.Dist(); |
|
return(&(*RayIte)); |
|
} |
|
return 0; |
|
} |
|
|
|
|
|
template <class SPATIALINDEXING, class OBJPOINTDISTFUNCTOR, class OBJMARKER, class OBJPTRCONTAINER, class DISTCONTAINER, class POINTCONTAINER> |
|
unsigned int GridGetInSphere(SPATIALINDEXING &_Si, |
|
OBJPOINTDISTFUNCTOR & _getPointDistance, |
|
OBJMARKER & _marker, |
|
const typename SPATIALINDEXING::CoordType & _p, |
|
const typename SPATIALINDEXING::ScalarType & _r, |
|
OBJPTRCONTAINER & _objectPtrs, |
|
DISTCONTAINER & _distances, |
|
POINTCONTAINER & _points) |
|
{ |
|
typedef vcg::ClosestIterator<SPATIALINDEXING,OBJPOINTDISTFUNCTOR,OBJMARKER> ClosestIteratorType; |
|
ClosestIteratorType Cli=ClosestIteratorType(_Si,_getPointDistance); |
|
Cli.SetMarker(_marker); |
|
Cli.Init(_p,_r); |
|
_objectPtrs.clear(); |
|
_distances.clear(); |
|
_points.clear(); |
|
while (!Cli.End()) |
|
{ |
|
_objectPtrs.push_back(&(*Cli)); |
|
_distances.push_back(Cli.Dist()); |
|
_points.push_back(Cli.NearestPoint()); |
|
++Cli; |
|
} |
|
return ((int)_objectPtrs.size()); |
|
} |
|
|
|
template <class SPATIALINDEXING,class OBJMARKER, class OBJPTRCONTAINER> |
|
unsigned int GridGetInBox(SPATIALINDEXING &_Si, |
|
OBJMARKER & _marker, |
|
const vcg::Box3<typename SPATIALINDEXING::ScalarType> &_bbox, |
|
OBJPTRCONTAINER & _objectPtrs) |
|
{ |
|
typename SPATIALINDEXING::CellIterator first,last,l; |
|
_objectPtrs.clear(); |
|
vcg::Box3i ibbox; |
|
Box3i Si_ibox(Point3i(0,0,0),_Si.siz-Point3i(1,1,1)); |
|
_Si.BoxToIBox(_bbox, ibbox); |
|
ibbox.Intersect(Si_ibox); |
|
_marker.UnMarkAll(); |
|
if (ibbox.IsNull()) |
|
return 0; |
|
else |
|
{ |
|
int ix,iy,iz; |
|
for (ix=ibbox.min[0]; ix<=ibbox.max[0]; ix++) |
|
{ |
|
for (iy=ibbox.min[1]; iy<=ibbox.max[1]; iy++) |
|
{ |
|
for (iz=ibbox.min[2]; iz<=ibbox.max[2]; iz++) |
|
{ |
|
_Si.Grid( ix, iy, iz, first, last ); |
|
for(l=first;l!=last;++l) |
|
{ |
|
if (!(**l).IsD()) |
|
{ |
|
typename SPATIALINDEXING::ObjPtr elem=&(**l); |
|
vcg::Box3<typename SPATIALINDEXING::ScalarType> box_elem; |
|
elem->GetBBox(box_elem); |
|
if(( ! _marker.IsMarked(elem))&&(box_elem.Collide(_bbox))) |
|
{ |
|
_objectPtrs.push_back(elem); |
|
_marker.Mark(elem); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
} |
|
return (static_cast<unsigned int>(_objectPtrs.size())); |
|
} |
|
} |
|
|
|
}//end namespace vcg |
|
#endif |
|
|
|
|