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
|
/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004 \/)\/ *
* 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. *
* *
****************************************************************************/
// marco :
// comments
// corrected bug
/****************************************************************************
History
****************************************************************************/
#ifndef __VCGLIB_VERTEX_DISTANCE
#define __VCGLIB_VERTEX_DISTANCE
#include <vcg/math/base.h>
#include <vcg/space/point3.h>
namespace vcg {
namespace vertex{
template <class SCALARTYPE>
class PointDistanceFunctor {
public:
typedef Point3<SCALARTYPE> QueryType;
static inline const Point3<SCALARTYPE> & Pos(const QueryType & qt) {return qt;}
template <class VERTEXTYPE>
/*
* @param v [IN] is a reference to the current object being tested,
* @param p [IN] is the query point,
* @param minDist [IN/OUT] is in input the reject distance and in output the closest distance,
* @param q [OUT] is the closest point.
*
* @remarks The operator returns true if the closest distance is less than input reject distance.
*
*/
inline bool operator () (const VERTEXTYPE & v, const Point3<SCALARTYPE> & p, SCALARTYPE & minDist, Point3<SCALARTYPE> & q) const
{
// convert the coordinates of p from SCALARTYPE to VERTEXTYPE::ScalarType type
const Point3<typename VERTEXTYPE::ScalarType> fp = Point3<typename VERTEXTYPE::ScalarType>::Construct(p);
typename VERTEXTYPE::ScalarType md; // distance between v and fp
md = (v.P() - fp).Norm();
if (md <= minDist)
{
minDist = (SCALARTYPE)(md); // minDist is updated to the closest distance
q = v.P(); // q is the current closest point
return true;
}
return false;
}
};
template <class VERTYPE>
class PointNormalDistanceFunctor {
public:
typedef VERTYPE QueryType;
typedef typename VERTYPE::ScalarType ScalarType;
static inline const Point3<typename VERTYPE::ScalarType> & Pos(const QueryType & qt) {return qt.P();}
static ScalarType & Alpha(){static ScalarType alpha = 1.0; return alpha;}
static ScalarType & Beta(){static ScalarType beta= 1.0; return beta;}
static ScalarType & Gamma(){static ScalarType gamma= 1.0; return gamma;}
static ScalarType & InterPoint (){static ScalarType interpoint= 1.0; return interpoint;}
template <class VERTEXTYPE, class SCALARTYPE>
inline bool operator () (const VERTEXTYPE & v, const VERTEXTYPE & vp, SCALARTYPE & minDist, Point3<SCALARTYPE> & q) {
float h = vcg::Distance(v.cP(),vp.P()) ;
float dev = InterPoint() * ( pow((ScalarType) (1-v.cN().dot(vp.cN())), (ScalarType)Beta()) / (Gamma()*h +0.1));
if(h+dev < minDist){
minDist = h+dev;
q = v.P();
return true;
}
// minDist = h +0.0* (1-v.cN()*vp.cN()) / (h + 0.1);
return false;
}
};
template <class VERTEXYPE>
class PointScaledDistanceFunctor {
public:
typedef typename VERTEXYPE::ScalarType ScalarType;
typedef Point3<ScalarType> QueryType;
static inline const Point3<ScalarType> & Pos(const QueryType & qt) {return qt;}
static Point3<ScalarType> & Cen(){static Point3<ScalarType> cen(0,0,0); return cen;}
inline bool operator () (const VERTEXYPE & p, const QueryType & qp, ScalarType & minDist, Point3<ScalarType> & q) {
Point3<ScalarType> ed = (qp-p.P());
Point3<ScalarType> dir = (p.P()-Cen()).Normalize();
Point3<ScalarType> odir = (dir^((ed)^dir)).Normalize();
ScalarType d = fabs(ed * dir) + fabs(ed *odir);
if(d < minDist){
minDist = d;
q = p.P();
return true;
}
return false;
}
};
template <class VertexType>
class ApproximateGeodesicDistanceFunctor {
public:
typedef typename VertexType::ScalarType ScalarType;
static inline const Point3<ScalarType> & Pos(const VertexType & qt) {return qt.P();}
inline bool operator () (const VertexType & v, const VertexType & vp, ScalarType & minDist, Point3<ScalarType> & q) {
ScalarType gd = ApproximateGeodesicDistance(v.cP(),v.cN(),vp.cP(),vp.cN());
if (gd <= minDist)
{
minDist =gd; // minDist is updated to the closest distance
q = v.P(); // q is the current closest point
return true;
}
return false;
}
inline ScalarType operator () (const Point3<ScalarType>& p0, const Point3<ScalarType>& n0,
const Point3<ScalarType>& p1, const Point3<ScalarType>& n1) {
return ApproximateGeodesicDistance(p0,n0,p1,n1);
}
};
} // end namespace vertex
} // end namespace vcg
#endif
|
