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

make point2 derived Eigen's Matrix, and a set of minimal fixes to make meshlab compile 

with both old and new version. The fixes include:
- dot product: vec0 * vec1 => vec0.dot(vec1) (I added .dot() to the old Point classes too)
- Transpose: Transpose is an Eigen type, so we cannot keep it if Eigen is used. Therefore
  I added a .tranpose() to old matrix classes, and modified most of the Transpose() to transpose()
  both in vcg and meshlab. In fact, transpose() are free with Eigen, it simply returns a transpose
  expression without copies. On the other be carefull:  m = m.transpose() won't work as expected,
  here me must evaluate to a temporary: m = m.transpose().eval(); However, this operation in very
  rarely needed: you transpose at the same sime you set m, or you use m.transpose() directly.
- the last issue is Normalize which both modifies *this and return a ref to it. This behavior
  don't make sense anymore when using expression template, e.g., in (a+b).Normalize(), the type
  of a+b if not a Point (or whatever Vector types), it an expression of the addition of 2 points,
  so we cannot modify the value of *this, since there is no value. Therefore I've already changed
  all those .Normalize() of expressions to the Eigen's version .normalized().
- Finally I've changed the Zero to SetZero in the old Point classes too.
This commit is contained in:
Paolo Cignoni 2008-10-28 00:59:46 +00:00
parent 393ec38d54
commit 7befff7bec
32 changed files with 1150 additions and 913 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
vcg/complex/local_optimization/tri_edge_collapse_quadric.h
View File

@ -403,7 +403,7 @@ public:
{
if(Params().NormalCheck){
nn=NormalizedNormal(*x.F());
ndiff=nn*on[i++];
ndiff=nn.dot(on[i++]);
if(ndiff<MinCos) MinCos=ndiff;
}
if(Params().QualityCheck){
@ -416,7 +416,7 @@ public:
{
if(Params().NormalCheck){
nn=NormalizedNormal(*x.F());
ndiff=nn*on[i++];
ndiff=nn.dot(on[i++]);
if(ndiff<MinCos) MinCos=ndiff;
}
if(Params().QualityCheck){
@ -542,7 +542,7 @@ static void InitQuadric(TriMeshType &m)
if(!Params().UseArea)
p.Normalize();
p.SetOffset( p.Direction() * (*pf).V(0)->cP());
p.SetOffset( p.Direction().dot((*pf).V(0)->cP()));
// Calcolo quadrica delle facce
q.ByPlane(p);
@ -559,10 +559,10 @@ static void InitQuadric(TriMeshType &m)
// Nota che la lunghezza dell'edge DEVE essere Normalizzata
// poiche' la pesatura in funzione dell'area e'gia fatta in p.Direction()
// Senza la normalize il bordo e' pesato in funzione della grandezza della mesh (mesh grandi non decimano sul bordo)
pb.SetDirection(p.Direction() ^ ( (*pf).V1(j)->cP() - (*pf).V(j)->cP() ).Normalize());
pb.SetDirection(p.Direction() ^ ( (*pf).V1(j)->cP() - (*pf).V(j)->cP() ).normalized());
if( (*pf).IsB(j) ) pb.SetDirection(pb.Direction()* (ScalarType)Params().BoundaryWeight); // amplify border planes
else pb.SetDirection(pb.Direction()* (ScalarType)(Params().BoundaryWeight/100.0)); // and consider much less quadric for quality
pb.SetOffset(pb.Direction() * (*pf).V(j)->cP());
pb.SetOffset(pb.Direction().dot((*pf).V(j)->cP()));
q.ByPlane(pb);
if( (*pf).V (j)->IsW() ) QH::Qd((*pf).V (j)) += q; // Sommo le quadriche

22
vcg/complex/trimesh/autoalign_4pcs.h
View File

@ -110,10 +110,10 @@ private:
/* returns the closest point between to segments x1-x2 and x3-x4. */
void IntersectionLineLine( const CoordType & x1,const CoordType & x2,const CoordType & x3,const CoordType & x4,
CoordType&x){
void IntersectionLineLine(const CoordType & x1,const CoordType & x2,const CoordType & x3,const CoordType & x4, CoordType&x)
{
CoordType a = x2-x1, b = x4-x3, c = x3-x1;
x = x1 + a * ( (c^b)*(a^b)) / (a^b).SquaredNorm();
x = x1 + a * ((c^b).dot(a^b)) / (a^b).SquaredNorm();
}
@ -289,7 +289,7 @@ FourPCS<MeshType>::SelectCoplanarBase(){
int id = rand()/(float)RAND_MAX * (P->vert.size()-1);
ScalarType dd = (P->vert[id].P() - B[1]).Norm();
if( ( dd < side + dtol) && (dd > side - dtol)){
ScalarType angle = fabs( ( P->vert[id].P()-B[1]).Normalize() * (B[1]-B[0]).Normalize());
ScalarType angle = fabs( ( P->vert[id].P()-B[1]).normalized().dot((B[1]-B[0]).normalized()));
if( angle < bestv){
bestv = angle;
best = id;
@ -301,7 +301,7 @@ FourPCS<MeshType>::SelectCoplanarBase(){
B[2] = P->vert[best].P();
//printf("B[2] %d\n",best);
CoordType n = ((B[0]-B[1]).Normalize() ^ (B[2]-B[1]).Normalize()).Normalize();
CoordType n = ((B[0]-B[1]).normalized() ^ (B[2]-B[1]).normalized()).normalized();
CoordType B4 = B[1] + (B[0]-B[1]) + (B[2]-B[1]);
VertexType * v =0;
ScalarType dist,radius = dtol*4.0;
@ -322,7 +322,7 @@ FourPCS<MeshType>::SelectCoplanarBase(){
return false;
best = -1; bestv=std::numeric_limits<float>::max();
for(i = 0; i <closests.size(); ++i){
ScalarType angle = fabs((closests[i]->P() - B[1]).Normalize() * n);
ScalarType angle = fabs((closests[i]->P() - B[1]).normalized().dot(n));
if( angle < bestv){
bestv = angle;
best = i;
@ -337,8 +337,8 @@ FourPCS<MeshType>::SelectCoplanarBase(){
std::swap(B[1],B[2]);
IntersectionLineLine(B[0],B[1],B[2],B[3],x);
r1 = (x - B[0])*(B[1]-B[0]) / (B[1]-B[0]).SquaredNorm();
r2 = (x - B[2])*(B[3]-B[2]) / (B[3]-B[2]).SquaredNorm();
r1 = (x - B[0]).dot(B[1]-B[0]) / (B[1]-B[0]).SquaredNorm();
r2 = (x - B[2]).dot(B[3]-B[2]) / (B[3]-B[2]).SquaredNorm();
if( ((B[0]+(B[1]-B[0])*r1)-(B[2]+(B[3]-B[2])*r2)).Norm() > prs.delta )
return false;
@ -374,10 +374,10 @@ FourPCS<MeshType>::IsTransfCongruent(FourPoints fp,vcg::Matrix44<ScalarType> & m
for(int i = 0 ; i < 4; ++i) fix.push_back(fp[i]);
vcg::Point3<ScalarType> n,p;
n = (( B[1]-B[0]).Normalize() ^ ( B[2]- B[0]).Normalize())*( B[1]- B[0]).Norm();
n = (( B[1]-B[0]).normalized() ^ ( B[2]- B[0]).normalized())*( B[1]- B[0]).Norm();
p = B[0] + n;
mov.push_back(p);
n = (( fp[1]-fp[0]).Normalize() ^ (fp[2]- fp[0]).Normalize())*( fp[1]- fp[0]).Norm();
n = (( fp[1]-fp[0]).normalized() ^ (fp[2]- fp[0]).normalized())*( fp[1]- fp[0]).Norm();
p = fp[0] + n;
fix.push_back(p);
@ -565,7 +565,7 @@ int FourPCS<MeshType>::EvaluateSample(CandiType & fp, CoordType & tp, CoordType
>(*Q,ugridQ,vq,radius, dist );
if(v!=0)
if( v->N() * np -angle >0) return 1; else return -1;
if( v->N().dot(np) -angle >0) return 1; else return -1;
}

2
vcg/complex/trimesh/clean.h
View File

@ -1152,7 +1152,7 @@ static bool TestIntersection(FaceType *f0,FaceType *f1)
//no adiacent faces
if ( (f0!=f1) && (!ShareEdge(f0,f1))
&& (!ShareVertex(f0,f1)) )
return (vcg::Intersection<FaceType>((*f0),(*f1)));
return (vcg::Intersection_<FaceType>((*f0),(*f1)));
return false;
}

6
vcg/complex/trimesh/clustering.h
View File

@ -345,9 +345,9 @@ class Clustering
{
CoordType N=vcg::Normal(m.face[i]);
int badOrient=0;
if( N*(*ti).v[0]->n <0) ++badOrient;
if( N*(*ti).v[1]->n <0) ++badOrient;
if( N*(*ti).v[2]->n <0) ++badOrient;
if( N.dot((*ti).v[0]->n) <0) ++badOrient;
if( N.dot((*ti).v[1]->n) <0) ++badOrient;
if( N.dot((*ti).v[2]->n) <0) ++badOrient;
if(badOrient>2)
std::swap(m.face[i].V(0),m.face[i].V(1));
}

2
vcg/complex/trimesh/create/resampler.h
View File

@ -176,7 +176,7 @@ template <class OLD_MESH_TYPE,class NEW_MESH_TYPE, class FLT>
dir.Normalize();
//direction of normal inside the mesh
if ((dir*closestNorm)<0)
if ((dir.dot(closestNorm))<0)
dist=-dist;
//the intersection exist
return true;

2
vcg/complex/trimesh/hole.h
View File

@ -212,7 +212,7 @@ namespace vcg {
void ComputeAngle()
{
angle=Angle(cP(2)-cP(0), cP(1)-cP(0));
ScalarType flipAngle = n * e0.v->N();
ScalarType flipAngle = n.dot(e0.v->N());
if(flipAngle<0) angle = (2.0 *(float)M_PI) - angle;
}

6
vcg/complex/trimesh/inertia.h
View File

@ -345,9 +345,15 @@ static void Covariance(const MeshType & m, vcg::Point3<ScalarType> & bary, vcg::
const float da = n.Norm();
n/=da*da;
#ifndef VCG_USE_EIGEN
A.SetColumn(0, P1-P0);
A.SetColumn(1, P2-P0);
A.SetColumn(2, n);
#else
A.col(0) = P1-P0;
A.col(1) = P2-P0;
A.col(2) = n;
#endif
CoordType delta = P0 - bary;
/* DC is calculated as integral of (A*x+delta) * (A*x+delta)^T over the triangle,

2
vcg/complex/trimesh/refine.h
View File

@ -118,7 +118,7 @@ struct MidPoint : public std::unary_function<face::Pos<typename MESH_TYPE::Fac
nv.P()= (ep.f->V(ep.z)->P()+ep.f->V1(ep.z)->P())/2.0;
if( MESH_TYPE::HasPerVertexNormal())
nv.N()= (ep.f->V(ep.z)->N()+ep.f->V1(ep.z)->N()).Normalize();
nv.N()= (ep.f->V(ep.z)->N()+ep.f->V1(ep.z)->N()).normalized();
if( MESH_TYPE::HasPerVertexColor())
nv.C().lerp(ep.f->V(ep.z)->C(),ep.f->V1(ep.z)->C(),.5f);

26
vcg/complex/trimesh/update/curvature.h
View File

@ -190,8 +190,8 @@ public:
M.SetZero();
for (int i = 0; i < vertices.size(); ++i) {
CoordType edge = (central_vertex->cP() - vertices[i].vert->cP());
float curvature = (2.0f * (central_vertex->cN() * edge) ) / edge.SquaredNorm();
CoordType T = (Tp*edge).Normalize();
float curvature = (2.0f * (central_vertex->cN().dot(edge)) ) / edge.SquaredNorm();
CoordType T = (Tp*edge).normalized();
tempMatrix.ExternalProduct(T,T);
M += tempMatrix * weights[i] * curvature ;
}
@ -360,21 +360,21 @@ public:
// get the estimate of curvatures from eigenvalues and eigenvectors
// find the 2 most tangent eigenvectors (by finding the one closest to the normal)
int best = 0; ScalarType bestv = fabs( (*vi).cN() * eigenvectors.GetColumn(0).Normalize());
int best = 0; ScalarType bestv = fabs( (*vi).cN().dot(eigenvectors.GetColumn(0).normalized()) );
for(int i = 1 ; i < 3; ++i){
ScalarType prod = fabs((*vi).cN() * eigenvectors.GetColumn(i).Normalize());
ScalarType prod = fabs((*vi).cN().dot(eigenvectors.GetColumn(i).normalized()));
if( prod > bestv){bestv = prod; best = i;}
}
(*vi).PD1() = eigenvectors.GetColumn( (best+1)%3).Normalize();
(*vi).PD2() = eigenvectors.GetColumn( (best+2)%3).Normalize();
(*vi).PD1() = eigenvectors.GetColumn( (best+1)%3).normalized();
(*vi).PD2() = eigenvectors.GetColumn( (best+2)%3).normalized();
// project them to the plane identified by the normal
vcg::Matrix33<ScalarType> rot;
ScalarType angle = acos((*vi).PD1()*(*vi).N());
ScalarType angle = acos((*vi).PD1().dot((*vi).N()));
rot.SetRotateRad( - (M_PI*0.5 - angle),(*vi).PD1()^(*vi).N());
(*vi).PD1() = rot*(*vi).PD1();
angle = acos((*vi).PD2()*(*vi).N());
angle = acos((*vi).PD2().dot((*vi).N()));
rot.SetRotateRad( - (M_PI*0.5 - angle),(*vi).PD2()^(*vi).N());
(*vi).PD2() = rot*(*vi).PD2();
@ -495,7 +495,7 @@ public:
}
else
{
(*vi).Kh() = (((TDContr)[*vi]* (*vi).cN()>0)?1.0:-1.0)*((TDContr)[*vi] / (TDAreaPtr) [*vi].A).Norm();
(*vi).Kh() = (((TDContr)[*vi].dot((*vi).cN())>0)?1.0:-1.0)*((TDContr)[*vi] / (TDAreaPtr) [*vi].A).Norm();
(*vi).Kg() /= (TDAreaPtr)[*vi].A;
}
}
@ -616,7 +616,7 @@ public:
normalized_edge/=edge_length;
Point3<ScalarType> n1 = p.F()->cN();n1.Normalize();
Point3<ScalarType> n2 = p.FFlip()->cN();n2.Normalize();
ScalarType n1n2 = (n1 ^ n2)* normalized_edge;
ScalarType n1n2 = (n1 ^ n2).dot(normalized_edge);
n1n2 = math::Max<ScalarType >(math::Min<ScalarType> ( 1.0,n1n2),-1.0);
ScalarType beta = math::Asin(n1n2);
m33[0][0] += beta*edge_length*normalized_edge[0]*normalized_edge[0];
@ -645,7 +645,11 @@ public:
ScalarType normal = std::numeric_limits<ScalarType>::min();
int normI = 0;
for(int i = 0; i < 3; ++i)
if( fabs((*vi).N().Normalize() * vect.GetRow(i)) > normal ){normal= fabs((*vi).N().Normalize() * vect.GetRow(i)); normI = i;}
if( fabs((*vi).N().Normalize().dot(vect.GetRow(i))) > normal )
{
normal= fabs((*vi).N().Normalize().dot(vect.GetRow(i)));
normI = i;
}
int maxI = (normI+2)%3;
int minI = (normI+1)%3;
if(fabs(lambda[maxI]) < fabs(lambda[minI])) std::swap(maxI,minI);

2
vcg/math/base.h
View File

@ -135,6 +135,8 @@ namespace math {
inline double Asin(const double v) { return asin(v); }
inline double Atan2(const double v0,const double v1) { return atan2(v0,v1); }
template <typename T> inline static T Sqr(T a) { return a*a; }
template<class T> inline const T & Min(const T &a, const T &b){
if (a<b) return a; else return b;
}

2
vcg/math/eigen.h
View File

@ -24,6 +24,8 @@
#ifndef EIGEN_VCGLIB
#define EIGEN_VCGLIB
// TODO enable the vectorization
#define EIGEN_DONT_VECTORIZE
#define EIGEN_MATRIXBASE_PLUGIN <vcg/math/eigen_vcgaddons.h>
#include "../Eigen/LU"

37
vcg/math/eigen_vcgaddons.h
View File

@ -197,23 +197,6 @@ EIGEN_DEPRECATED Derived& operator-=(const Scalar k)
// }
// };
/*!
* \deprecated use (*this) * vec.asDiagonal() or (*this) * mat.mark<Diagonal>()
* Matrix multiplication by a diagonal matrix
*/
// EIGEN_DEPRECATED Matrix<Scalar> operator*(const MatrixDiagBase &m) const
// {
// assert(_columns == _rows);
// assert(_columns == m.Dimension());
// int i,j;
// Matrix<Scalar> result(_rows, _columns);
//
// for (i=0; i<result._rows; i++)
// for (j=0; j<result._columns; j++)
// result[i][j]*= m[j];
//
// return result;
// };
/*!
* \deprecated use *this = a * b.transpose()
@ -268,22 +251,36 @@ EIGEN_DEPRECATED void SetIdentity()
* \param j the column index
* \param v ...
*/
EIGEN_DEPRECATED void SetColumn(const unsigned int j, Scalar* v)
EIGEN_DEPRECATED void SetColumn(unsigned int j, Scalar* v)
{
col(j) = Map<Matrix<Scalar,RowsAtCompileTime,1> >(v,cols(),1);
};
/** \deprecated use *this.col(i) = other */
template<typename OtherDerived>
EIGEN_DEPRECATED void SetColumn(unsigned int j, const MatrixBase<OtherDerived>& other)
{
col(j) = other;
};
/*!
* \deprecated use *this.row(i) = expression
* Set the elements of the <I>i</I>-th row to v[j]
* \param i the row index
* \param v ...
*/
EIGEN_DEPRECATED void SetRow(const unsigned int i, Scalar* v)
EIGEN_DEPRECATED void SetRow(unsigned int i, Scalar* v)
{
row(i) = Map<Matrix<Scalar,1,ColsAtCompileTime> >(v,1,rows());
};
/** \deprecated use *this.row(i) = other */
template<typename OtherDerived>
EIGEN_DEPRECATED void SetRow(unsigned int j, const MatrixBase<OtherDerived>& other)
{
row(j) = other;
};
/*!
* \deprecated use *this.diagonal() = expression
* Set the diagonal elements <I>v<SUB>i,i</SUB></I> to v[i]
@ -333,5 +330,5 @@ EIGEN_DEPRECATED inline Scalar SquaredNorm() const { return norm2(); }
EIGEN_DEPRECATED inline Derived& Normalize() { normalize(); return derived(); }
/** \deprecated use .cross(p) */
inline EvalType operator ^ (const Derived& p ) const { return this->cross(p); }
EIGEN_DEPRECATED inline EvalType operator ^ (const Derived& p ) const { return this->cross(p); }

2
vcg/math/linear.h
View File

@ -56,7 +56,7 @@ namespace vcg {
class Linear{
public:
typedef T ScalarType;
inline void Zero();
inline void SetZero();
T operator + ( T const & p) const;
T operator - ( T const & p) const;
T operator * ( const ScalarType );

15
vcg/math/matrix.h
View File

@ -49,21 +49,6 @@ namespace ndim{
/** \addtogroup math */
/* @{ */
/*!
* This class represent a diagonal <I>m</I><EFBFBD><I>m</I> matrix.
*/
class MatrixDiagBase{public:
virtual const int & Dimension()const =0;
virtual const float operator[](const int & i) const = 0;
};
template<int N, class S>
class MatrixDiag: public Point<N,S>, public MatrixDiagBase{
public:
const int & Dimension() const {return N;}
MatrixDiag(const Point<N,S>&p):Point<N,S>(p){}
};
/*!
* This class represent a generic <I>m</I><EFBFBD><I>n</I> matrix. The class is templated over the scalar type field.
* @param Scalar (Templete Parameter) Specifies the ScalarType field.

2
vcg/math/matrix33.h
View File

@ -243,7 +243,7 @@ Matrix33<S> RotationMatrix(vcg::Point3<S> v0,vcg::Point3<S> v1,bool normalized=t
v0.Normalize();
v1.Normalize();
}
S dot=(v0*v1);
S dot=v0.dot(v1);
///control if there is no rotation
if (dot>((S)1-epsilon))
{

2
vcg/simplex/vertex/distance.h
View File

@ -92,7 +92,7 @@ class PointNormalDistanceFunctor {
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()*vp.cN()),(ScalarType) Beta()) / (Gamma()*h +0.1));
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();

24
vcg/space/color4.h
View File

@ -133,19 +133,19 @@ public:
template <class Q>
inline void Import(const Color4<Q> & b )
{
Point4<T>::V()[0] = T(b[0]);
Point4<T>::V()[1] = T(b[1]);
Point4<T>::V()[2] = T(b[2]);
Point4<T>::V()[3] = T(b[3]);
(*this)[0] = T(b[0]);
(*this)[1] = T(b[1]);
(*this)[2] = T(b[2]);
(*this)[3] = T(b[3]);
}
template <class Q>
inline void Import(const Point4<Q> & b )
{
Point4<T>::V()[0] = T(b[0]);
Point4<T>::V()[1] = T(b[1]);
Point4<T>::V()[2] = T(b[2]);
Point4<T>::V()[3] = T(b[3]);
(*this)[0] = T(b[0]);
(*this)[1] = T(b[1]);
(*this)[2] = T(b[2]);
(*this)[3] = T(b[3]);
}
template <class Q>
@ -203,10 +203,10 @@ public:
case 4: r=t; g=p; b=v; break;
case 5: r=v; g=p; b=q; break;
}
Point4<T>::V()[0]=(unsigned char)(255*r);
Point4<T>::V()[1]=(unsigned char)(255*g);
Point4<T>::V()[2]=(unsigned char)(255*b);
Point4<T>::V()[3]=255;
(*this)[0]=(unsigned char)(255*r);
(*this)[1]=(unsigned char)(255*g);
(*this)[2]=(unsigned char)(255*b);
(*this)[3]=255;
// V()[0]=r*256;V()[1]=g*256;V()[2]=b*256;
}

359
vcg/space/deprecated_point2.h Normal file
View File

@ -0,0 +1,359 @@
/****************************************************************************
* 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. *
* *
****************************************************************************/
/****************************************************************************
History
$Log: not supported by cvs2svn $
Revision 1.9 2006/10/07 16:51:43 m_di_benedetto
Implemented Scale() method (was only declared).
Revision 1.8 2006/01/19 13:53:19 m_di_benedetto
Fixed product by scalar and SquaredNorm()
Revision 1.7 2005/10/15 19:11:49 m_di_benedetto
Corrected return type in Angle() and protected member access in unary operator -
Revision 1.6 2005/03/18 16:34:42 fiorin
minor changes to comply gcc compiler
Revision 1.5 2004/05/10 13:22:25 cignoni
small syntax error Math -> math in Angle
Revision 1.4 2004/04/05 11:57:32 cignoni
Add V() access function
Revision 1.3 2004/03/10 17:42:40 tarini
Added comments (Dox) !
Added Import(). Costruct(), ScalarType... Corrected cross prod (sign). Added Angle. Now using Math:: stuff for trigon. etc.
Revision 1.2 2004/03/03 15:07:40 cignoni
renamed protected member v -> _v
Revision 1.1 2004/02/13 00:44:53 cignoni
First commit...
****************************************************************************/
#ifndef __VCGLIB_POINT2
#define __VCGLIB_POINT2
#include <assert.h>
#include <vcg/math/base.h>
namespace vcg {
/** \addtogroup space */
/*@{*/
/**
The templated class for representing a point in 2D space.
The class is templated over the ScalarType class that is used to represent coordinates.
All the usual operator overloading (* + - ...) is present.
*/
template <class P2ScalarType> class Point2
{
protected:
/// The only data member. Hidden to user.
P2ScalarType _v[2];
public:
/// the scalar type
typedef P2ScalarType ScalarType;
enum {Dimension = 2};
//@{
/** @name Access to Coords.
access to coords is done by overloading of [] or explicit naming of coords (X,Y,)
("p[0]" or "p.X()" are equivalent) **/
inline const ScalarType &X() const {return _v[0];}
inline const ScalarType &Y() const {return _v[1];}
inline ScalarType &X() {return _v[0];}
inline ScalarType &Y() {return _v[1];}
inline const ScalarType * V() const
{
return _v;
}
inline ScalarType & V( const int i )
{
assert(i>=0 && i<2);
return _v[i];
}
inline const ScalarType & V( const int i ) const
{
assert(i>=0 && i<2);
return _v[i];
}
inline const ScalarType & operator [] ( const int i ) const
{
assert(i>=0 && i<2);
return _v[i];
}
inline ScalarType & operator [] ( const int i )
{
assert(i>=0 && i<2);
return _v[i];
}
//@}
/// empty constructor (does nothing)
inline Point2 () { }
/// x,y constructor
inline Point2 ( const ScalarType nx, const ScalarType ny )
{
_v[0] = nx; _v[1] = ny;
}
/// copy constructor
inline Point2 ( Point2 const & p)
{
_v[0]= p._v[0]; _v[1]= p._v[1];
}
/// copy
inline Point2 & operator =( Point2 const & p)
{
_v[0]= p._v[0]; _v[1]= p._v[1];
return *this;
}
/// sets the point to (0,0)
inline void SetZero()
{ _v[0] = 0;_v[1] = 0;}
/// dot product
inline ScalarType operator * ( Point2 const & p ) const
{
return ( _v[0]*p._v[0] + _v[1]*p._v[1] );
}
/// cross product
inline ScalarType operator ^ ( Point2 const & p ) const
{
return _v[0]*p._v[1] - _v[1]*p._v[0];
}
//@{
/** @name Linearity for 2d points (operators +, -, *, /, *= ...) **/
inline Point2 operator + ( Point2 const & p) const
{
return Point2<ScalarType>( _v[0]+p._v[0], _v[1]+p._v[1] );
}
inline Point2 operator - ( Point2 const & p) const
{
return Point2<ScalarType>( _v[0]-p._v[0], _v[1]-p._v[1] );
}
inline Point2 operator * ( const ScalarType s ) const
{
return Point2<ScalarType>( _v[0] * s, _v[1] * s );
}
inline Point2 operator / ( const ScalarType s ) const
{
return Point2<ScalarType>( _v[0] / s, _v[1] / s );
}
inline Point2 & operator += ( Point2 const & p)
{
_v[0] += p._v[0]; _v[1] += p._v[1];
return *this;
}
inline Point2 & operator -= ( Point2 const & p)
{
_v[0] -= p._v[0]; _v[1] -= p._v[1];
return *this;
}
inline Point2 & operator *= ( const ScalarType s )
{
_v[0] *= s; _v[1] *= s;
return *this;
}
inline Point2 & operator /= ( const ScalarType s )
{
_v[0] /= s; _v[1] /= s;
return *this;
}
//@}
/// returns the norm (Euclidian)
inline ScalarType Norm( void ) const
{
return math::Sqrt( _v[0]*_v[0] + _v[1]*_v[1] );
}
/// returns the squared norm (Euclidian)
inline ScalarType SquaredNorm( void ) const
{
return ( _v[0]*_v[0] + _v[1]*_v[1] );
}
inline Point2 & Scale( const ScalarType sx, const ScalarType sy )
{
_v[0] *= sx;
_v[1] *= sy;
return * this;
}
/// normalizes, and returns itself as result
inline Point2 & Normalize( void )
{
ScalarType n = math::Sqrt(_v[0]*_v[0] + _v[1]*_v[1]);
if(n>0.0) { _v[0] /= n; _v[1] /= n; }
return *this;
}
/// points equality
inline bool operator == ( Point2 const & p ) const
{
return (_v[0]==p._v[0] && _v[1]==p._v[1]);
}
/// disparity between points
inline bool operator != ( Point2 const & p ) const
{
return ( (_v[0]!=p._v[0]) || (_v[1]!=p._v[1]) );
}
/// lexical ordering
inline bool operator < ( Point2 const & p ) const
{
return (_v[1]!=p._v[1])?(_v[1]<p._v[1]):
(_v[0]<p._v[0]);
}
/// lexical ordering
inline bool operator > ( Point2 const & p ) const
{
return (_v[1]!=p._v[1])?(_v[1]>p._v[1]):
(_v[0]>p._v[0]);
}
/// lexical ordering
inline bool operator <= ( Point2 const & p ) const
{
return (_v[1]!=p._v[1])?(_v[1]< p._v[1]):
(_v[0]<=p._v[0]);
}
/// lexical ordering
inline bool operator >= ( Point2 const & p ) const
{
return (_v[1]!=p._v[1])?(_v[1]> p._v[1]):
(_v[0]>=p._v[0]);
}
/// returns the distance to another point p
inline ScalarType Distance( Point2 const & p ) const
{
return Norm(*this-p);
}
/// returns the suqared distance to another point p
inline ScalarType SquaredDistance( Point2 const & p ) const
{
return Norm2(*this-p);
}
/// returns the angle with X axis (radiants, in [-PI, +PI] )
inline ScalarType Angle() const {
return math::Atan2(_v[1],_v[0]);
}
/// transform the point in cartesian coords into polar coords
inline Point2 & Cartesian2Polar()
{
ScalarType t = Angle();
_v[0] = Norm();
_v[1] = t;
return *this;
}
/// transform the point in polar coords into cartesian coords
inline Point2 & Polar2Cartesian()
{
ScalarType l = _v[0];
_v[0] = (ScalarType)(l*math::Cos(_v[1]));
_v[1] = (ScalarType)(l*math::Sin(_v[1]));
return *this;
}
/// rotates the point of an angle (radiants, counterclockwise)
inline Point2 & Rotate( const ScalarType rad )
{
ScalarType t = _v[0];
ScalarType s = math::Sin(rad);
ScalarType c = math::Cos(rad);
_v[0] = _v[0]*c - _v[1]*s;
_v[1] = t *s + _v[1]*c;
return *this;
}
/// Questa funzione estende il vettore ad un qualsiasi numero di dimensioni
/// paddando gli elementi estesi con zeri
inline ScalarType Ext( const int i ) const
{
if(i>=0 && i<2) return _v[i];
else return 0;
}
/// imports from 2D points of different types
template <class T>
inline void Import( const Point2<T> & b )
{
_v[0] = b.X(); _v[1] = b.Y();
}
/// constructs a 2D points from an existing one of different type
template <class T>
static Point2 Construct( const Point2<T> & b )
{
return Point2(b.X(),b.Y());
}
}; // end class definition
template <class T>
inline T Angle( Point2<T> const & p0, Point2<T> const & p1 )
{
return p1.Angle() - p0.Angle();
}
template <class T>
inline Point2<T> operator - ( Point2<T> const & p ){
return Point2<T>( -p[0], -p[1] );
}
template <class T>
inline Point2<T> operator * ( const T s, Point2<T> const & p ){
return Point2<T>( p[0] * s, p[1] * s );
}
template <class T>
inline T Norm( Point2<T> const & p ){
return p.Norm();
}
template <class T>
inline T SquaredNorm( Point2<T> const & p ){
return p.SquaredNorm();
}
template <class T>
inline Point2<T> & Normalize( Point2<T> & p ){
return p.Normalize();
}
template <class T>
inline T Distance( Point2<T> const & p1,Point2<T> const & p2 ){
return Norm(p1-p2);
}
template <class T>
inline T SquaredDistance( Point2<T> const & p1,Point2<T> const & p2 ){
return SquaredNorm(p1-p2);
}
typedef Point2<short> Point2s;
typedef Point2<int> Point2i;
typedef Point2<float> Point2f;
typedef Point2<double> Point2d;
/*@}*/
} // end namespace
#endif

2
vcg/space/deprecated_point4.h
View File

@ -101,7 +101,7 @@ public:
{
_v[0]= p._v[0]; _v[1]= p._v[1]; _v[2]= p._v[2]; _v[3]= p._v[3];
}
inline void Zero()
inline void SetZero()
{
_v[0] = _v[1] = _v[2] = _v[3]= 0;
}

2
vcg/space/fitting3.h
View File

@ -88,7 +88,7 @@ Point3<S> PlaneFittingPoints( std::vector< Point3<S> > & samples,Plane3<S> &p){
d[1]=res[1][mini];
d[2]=res[2][mini];
p.SetOffset(c*d/d.Norm());
p.SetOffset(c.dot(d)/d.Norm());
p.SetDirection(d/d.Norm());
return eval;

22
vcg/space/intersection3.h
View File

@ -271,12 +271,12 @@ namespace vcg {
Point3t p21 = p2-p1;
Point3t p20 = p2-p0;
ScalarType delta0_p01 = p10*p1;
ScalarType delta1_p01 = -p10*p0;
ScalarType delta0_p02 = p20*p2;
ScalarType delta2_p02 = -p20*p0;
ScalarType delta1_p12 = p21*p2;
ScalarType delta2_p12 = -p21*p1;
ScalarType delta0_p01 = p10.dot(p1);
ScalarType delta1_p01 = -p10.dot(p0);
ScalarType delta0_p02 = p20.dot(p2);
ScalarType delta2_p02 = -p20.dot(p0);
ScalarType delta1_p12 = p21.dot(p2);
ScalarType delta2_p12 = -p21.dot(p1);
// the closest point can be one of the vertices of the triangle
if (delta1_p01<=ScalarType(0.0) && delta2_p02<=ScalarType(0.0)) { witness = p0; }
@ -284,10 +284,10 @@ namespace vcg {
else if (delta0_p02<=ScalarType(0.0) && delta1_p12<=ScalarType(0.0)) { witness = p2; }
else
{
ScalarType temp = p10*p2;
ScalarType temp = p10.dot(p2);
ScalarType delta0_p012 = delta0_p01*delta1_p12 + delta2_p12*temp;
ScalarType delta1_p012 = delta1_p01*delta0_p02 - delta2_p02*temp;
ScalarType delta2_p012 = delta2_p02*delta0_p01 - delta1_p01*(p20*p1);
ScalarType delta2_p012 = delta2_p02*delta0_p01 - delta1_p01*(p20.dot(p1));
// otherwise, can be a point lying on same edge of the triangle
if (delta0_p012<=ScalarType(0.0))
@ -366,10 +366,10 @@ namespace vcg {
typedef typename SEGMENTTYPE::ScalarType T;
const T epsilon = T(1e-8);
T k = pl.Direction() * (sg.P1()-sg.P0());
T k = pl.Direction().dot((sg.P1()-sg.P0()));
if( (k > -epsilon) && (k < epsilon))
return false;
T r = (pl.Offset() - pl.Direction()*sg.P0())/k; // Compute ray distance
T r = (pl.Offset() - pl.Direction().dot(sg.P0()))/k; // Compute ray distance
if( (r<0) || (r > 1.0))
return false;
po = sg.P0()*(1-r)+sg.P1() * r;
@ -404,7 +404,7 @@ namespace vcg {
/// intersection between two triangles
template<typename TRIANGLETYPE>
inline bool Intersection(const TRIANGLETYPE & t0,const TRIANGLETYPE & t1){
inline bool Intersection_(const TRIANGLETYPE & t0,const TRIANGLETYPE & t1){
return NoDivTriTriIsect(t0.P0(0),t0.P0(1),t0.P0(2),
t1.P0(0),t1.P0(1),t1.P0(2));
}

4
vcg/space/normal_extrapolation.h
View File

@ -224,7 +224,7 @@ namespace vcg
for (unsigned int n=0; n<k; n++)
if (iPlane->index<nearest_planes[n]->index)
riemannian_graph[iPlane->index].push_back( RiemannianEdge( nearest_planes[n], 1.0f - fabs(iPlane->normal * nearest_planes[n]->normal)) );
riemannian_graph[iPlane->index].push_back(RiemannianEdge(nearest_planes[n], 1.0f - fabs(iPlane->normal .dot(nearest_planes[n]->normal))));
}
// Step 3: compute the minimum spanning tree (MST) over the Riemannian graph (we use the Kruskal algorithm)
@ -338,7 +338,7 @@ namespace vcg
{
if (callback!=NULL && ((++progress%step)==0) && (percentage=int((maxSize-queueSize)*100/maxSize))<100) (callback)(percentage, message);
if (current_node->vertex->N()*current_node->sons[s]->vertex->N()<ScalarType(0.0f))
if (current_node->vertex->N().dot(current_node->sons[s]->vertex->N())<ScalarType(0.0f))
current_node->sons[s]->vertex->N() *= ScalarType(-1.0f);
border.push( current_node->sons[s] );
maxSize = vcg::math::Max<int>(maxSize, queueSize);

2
vcg/space/point.h
View File

@ -194,7 +194,7 @@ public:
**/
/// sets a PointType to Zero
inline void Zero()
inline void SetZero()
{
for(unsigned int ii = 0; ii < Dimension;++ii)
V(ii) = S();

307
vcg/space/point2.h
View File

@ -20,282 +20,166 @@
* for more details. *
* *
****************************************************************************/
/****************************************************************************
History
$Log: not supported by cvs2svn $
Revision 1.9 2006/10/07 16:51:43 m_di_benedetto
Implemented Scale() method (was only declared).
Revision 1.8 2006/01/19 13:53:19 m_di_benedetto
Fixed product by scalar and SquaredNorm()
Revision 1.7 2005/10/15 19:11:49 m_di_benedetto
Corrected return type in Angle() and protected member access in unary operator -
Revision 1.6 2005/03/18 16:34:42 fiorin
minor changes to comply gcc compiler
Revision 1.5 2004/05/10 13:22:25 cignoni
small syntax error Math -> math in Angle
Revision 1.4 2004/04/05 11:57:32 cignoni
Add V() access function
Revision 1.3 2004/03/10 17:42:40 tarini
Added comments (Dox) !
Added Import(). Costruct(), ScalarType... Corrected cross prod (sign). Added Angle. Now using Math:: stuff for trigon. etc.
Revision 1.2 2004/03/03 15:07:40 cignoni
renamed protected member v -> _v
Revision 1.1 2004/02/13 00:44:53 cignoni
First commit...
****************************************************************************/
#ifndef VCG_USE_EIGEN
#include "deprecated_point2.h"
#else
#ifndef __VCGLIB_POINT2
#define __VCGLIB_POINT2
#include <assert.h>
#include "../math/eigen.h"
#include <vcg/math/base.h>
namespace vcg{
template<class Scalar> class Point2;
}
namespace Eigen{
template<typename Scalar>
struct ei_traits<vcg::Point2<Scalar> > : ei_traits<Eigen::Matrix<Scalar,2,1> > {};
}
namespace vcg {
/** \addtogroup space */
/*@{*/
/**
The templated class for representing a point in 2D space.
The class is templated over the ScalarType class that is used to represent coordinates.
The class is templated over the Scalar class that is used to represent coordinates.
All the usual operator overloading (* + - ...) is present.
*/
template <class P2ScalarType> class Point2
template <class _Scalar> class Point2 : public Eigen::Matrix<_Scalar,2,1>
{
protected:
/// The only data member. Hidden to user.
P2ScalarType _v[2];
typedef Eigen::Matrix<_Scalar,2,1> _Base;
using _Base::coeff;
using _Base::coeffRef;
using _Base::setZero;
using _Base::data;
using _Base::V;
public:
/// the scalar type
typedef P2ScalarType ScalarType;
_EIGEN_GENERIC_PUBLIC_INTERFACE(Point2,_Base);
typedef Scalar ScalarType;
VCG_EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Point2)
enum {Dimension = 2};
//@{
/** @name Access to Coords.
access to coords is done by overloading of [] or explicit naming of coords (X,Y,)
("p[0]" or "p.X()" are equivalent) **/
inline const ScalarType &X() const {return _v[0];}
inline const ScalarType &Y() const {return _v[1];}
inline ScalarType &X() {return _v[0];}
inline ScalarType &Y() {return _v[1];}
inline const ScalarType * V() const
{
return _v;
}
inline ScalarType & V( const int i )
inline const Scalar &X() const {return data()[0];}
inline const Scalar &Y() const {return data()[1];}
inline Scalar &X() {return data()[0];}
inline Scalar &Y() {return data()[1];}
inline Scalar & V( const int i )
{
assert(i>=0 && i<2);
return _v[i];
return data()[i];
}
inline const ScalarType & V( const int i ) const
inline const Scalar & V( const int i ) const
{
assert(i>=0 && i<2);
return _v[i];
}
inline const ScalarType & operator [] ( const int i ) const
{
assert(i>=0 && i<2);
return _v[i];
}
inline ScalarType & operator [] ( const int i )
{
assert(i>=0 && i<2);
return _v[i];
return data()[i];
}
//@}
/// empty constructor (does nothing)
inline Point2 () { }
/// x,y constructor
inline Point2 ( const ScalarType nx, const ScalarType ny )
{
_v[0] = nx; _v[1] = ny;
}
inline Point2 ( const Scalar nx, const Scalar ny ) : Base(nx,ny) {}
/// copy constructor
inline Point2 ( Point2 const & p)
{
_v[0]= p._v[0]; _v[1]= p._v[1];
}
/// copy
inline Point2 & operator =( Point2 const & p)
{
_v[0]= p._v[0]; _v[1]= p._v[1];
return *this;
}
/// sets the point to (0,0)
inline void Zero()
{ _v[0] = 0;_v[1] = 0;}
/// dot product
inline ScalarType operator * ( Point2 const & p ) const
{
return ( _v[0]*p._v[0] + _v[1]*p._v[1] );
}
inline Point2(Point2 const & p) : Base(p) {}
template<typename OtherDerived>
inline Point2(const Eigen::MatrixBase<OtherDerived>& other) : Base(other) {}
/// cross product
inline ScalarType operator ^ ( Point2 const & p ) const
inline Scalar operator ^ ( Point2 const & p ) const
{
return _v[0]*p._v[1] - _v[1]*p._v[0];
return data()[0]*p.data()[1] - data()[1]*p.data()[0];
}
//@{
/** @name Linearity for 2d points (operators +, -, *, /, *= ...) **/
inline Point2 operator + ( Point2 const & p) const
inline Point2 & Scale( const Scalar sx, const Scalar sy )
{
return Point2<ScalarType>( _v[0]+p._v[0], _v[1]+p._v[1] );
}
inline Point2 operator - ( Point2 const & p) const
{
return Point2<ScalarType>( _v[0]-p._v[0], _v[1]-p._v[1] );
}
inline Point2 operator * ( const ScalarType s ) const
{
return Point2<ScalarType>( _v[0] * s, _v[1] * s );
}
inline Point2 operator / ( const ScalarType s ) const
{
return Point2<ScalarType>( _v[0] / s, _v[1] / s );
}
inline Point2 & operator += ( Point2 const & p)
{
_v[0] += p._v[0]; _v[1] += p._v[1];
data()[0] *= sx;
data()[1] *= sy;
return * this;
}
inline Point2 & operator -= ( Point2 const & p)
{
_v[0] -= p._v[0]; _v[1] -= p._v[1];
return *this;
}
inline Point2 & operator *= ( const ScalarType s )
{
_v[0] *= s; _v[1] *= s;
return *this;
}
inline Point2 & operator /= ( const ScalarType s )
{
_v[0] /= s; _v[1] /= s;
return *this;
}
//@}
/// returns the norm (Euclidian)
inline ScalarType Norm( void ) const
{
return math::Sqrt( _v[0]*_v[0] + _v[1]*_v[1] );
}
/// returns the squared norm (Euclidian)
inline ScalarType SquaredNorm( void ) const
{
return ( _v[0]*_v[0] + _v[1]*_v[1] );
}
inline Point2 & Scale( const ScalarType sx, const ScalarType sy )
{
_v[0] *= sx;
_v[1] *= sy;
return * this;
}
/// normalizes, and returns itself as result
inline Point2 & Normalize( void )
{
ScalarType n = math::Sqrt(_v[0]*_v[0] + _v[1]*_v[1]);
if(n>0.0) { _v[0] /= n; _v[1] /= n; }
return *this;
}
/// points equality
inline bool operator == ( Point2 const & p ) const
{
return (_v[0]==p._v[0] && _v[1]==p._v[1]);
}
/// disparity between points
inline bool operator != ( Point2 const & p ) const
{
return ( (_v[0]!=p._v[0]) || (_v[1]!=p._v[1]) );
}
/// lexical ordering
inline bool operator < ( Point2 const & p ) const
{
return (_v[1]!=p._v[1])?(_v[1]<p._v[1]):
(_v[0]<p._v[0]);
return (data()[1]!=p.data()[1])?(data()[1]<p.data()[1]):
(data()[0]<p.data()[0]);
}
/// lexical ordering
inline bool operator > ( Point2 const & p ) const
{
return (_v[1]!=p._v[1])?(_v[1]>p._v[1]):
(_v[0]>p._v[0]);
return (data()[1]!=p.data()[1])?(data()[1]>p.data()[1]):
(data()[0]>p.data()[0]);
}
/// lexical ordering
inline bool operator <= ( Point2 const & p ) const
{
return (_v[1]!=p._v[1])?(_v[1]< p._v[1]):
(_v[0]<=p._v[0]);
return (data()[1]!=p.data()[1])?(data()[1]< p.data()[1]):
(data()[0]<=p.data()[0]);
}
/// lexical ordering
inline bool operator >= ( Point2 const & p ) const
{
return (_v[1]!=p._v[1])?(_v[1]> p._v[1]):
(_v[0]>=p._v[0]);
}
/// returns the distance to another point p
inline ScalarType Distance( Point2 const & p ) const
{
return Norm(*this-p);
}
/// returns the suqared distance to another point p
inline ScalarType SquaredDistance( Point2 const & p ) const
{
return Norm2(*this-p);
return (data()[1]!=p.data()[1])?(data()[1]> p.data()[1]):
(data()[0]>=p.data()[0]);
}
/// returns the angle with X axis (radiants, in [-PI, +PI] )
inline ScalarType Angle() const {
return math::Atan2(_v[1],_v[0]);
inline Scalar Angle() const {
return math::Atan2(data()[1],data()[0]);
}
/// transform the point in cartesian coords into polar coords
inline Point2 & Cartesian2Polar()
{
ScalarType t = Angle();
_v[0] = Norm();
_v[1] = t;
Scalar t = Angle();
data()[0] = this->norm();
data()[1] = t;
return *this;
}
/// transform the point in polar coords into cartesian coords
inline Point2 & Polar2Cartesian()
{
ScalarType l = _v[0];
_v[0] = (ScalarType)(l*math::Cos(_v[1]));
_v[1] = (ScalarType)(l*math::Sin(_v[1]));
Scalar l = data()[0];
data()[0] = (Scalar)(l*math::Cos(data()[1]));
data()[1] = (Scalar)(l*math::Sin(data()[1]));
return *this;
}
/// rotates the point of an angle (radiants, counterclockwise)
inline Point2 & Rotate( const ScalarType rad )
inline Point2 & Rotate( const Scalar rad )
{
ScalarType t = _v[0];
ScalarType s = math::Sin(rad);
ScalarType c = math::Cos(rad);
Scalar t = data()[0];
Scalar s = math::Sin(rad);
Scalar c = math::Cos(rad);
_v[0] = _v[0]*c - _v[1]*s;
_v[1] = t *s + _v[1]*c;
data()[0] = data()[0]*c - data()[1]*s;
data()[1] = t *s + data()[1]*c;
return *this;
}
/// Questa funzione estende il vettore ad un qualsiasi numero di dimensioni
/// paddando gli elementi estesi con zeri
inline ScalarType Ext( const int i ) const
inline Scalar Ext( const int i ) const
{
if(i>=0 && i<2) return _v[i];
if(i>=0 && i<2) return data()[i];
else return 0;
}
/// imports from 2D points of different types
template <class T>
inline void Import( const Point2<T> & b )
{
_v[0] = b.X(); _v[1] = b.Y();
data()[0] = b.X(); data()[1] = b.Y();
}
/// constructs a 2D points from an existing one of different type
template <class T>
@ -303,8 +187,6 @@ public:
{
return Point2(b.X(),b.Y());
}
}; // end class definition
@ -314,41 +196,6 @@ inline T Angle( Point2<T> const & p0, Point2<T> const & p1 )
return p1.Angle() - p0.Angle();
}
template <class T>
inline Point2<T> operator - ( Point2<T> const & p ){
return Point2<T>( -p[0], -p[1] );
}
template <class T>
inline Point2<T> operator * ( const T s, Point2<T> const & p ){
return Point2<T>( p[0] * s, p[1] * s );
}
template <class T>
inline T Norm( Point2<T> const & p ){
return p.Norm();
}
template <class T>
inline T SquaredNorm( Point2<T> const & p ){
return p.SquaredNorm();
}
template <class T>
inline Point2<T> & Normalize( Point2<T> & p ){
return p.Normalize();
}
template <class T>
inline T Distance( Point2<T> const & p1,Point2<T> const & p2 ){
return Norm(p1-p2);
}
template <class T>
inline T SquaredDistance( Point2<T> const & p1,Point2<T> const & p2 ){
return SquaredNorm(p1-p2);
}
typedef Point2<short> Point2s;
typedef Point2<int> Point2i;
typedef Point2<float> Point2f;
@ -357,3 +204,5 @@ typedef Point2<double> Point2d;
/*@}*/
} // end namespace
#endif
#endif

11
vcg/space/point3.h
View File

@ -38,6 +38,17 @@ template<class Scalar> class Point3;
namespace Eigen{
template<typename Scalar>
struct ei_traits<vcg::Point3<Scalar> > : ei_traits<Eigen::Matrix<Scalar,3,1> > {};
template<typename Scalar>
struct NumTraits<vcg::Point3<Scalar> > : NumTraits<Scalar>
{
enum {
ReadCost = 3,
AddCost = 3,
MulCost = 3
};
};
}
namespace vcg {

13
wrap/gl/addons.h
View File

@ -51,13 +51,22 @@ namespace vcg
enum DrawMode {DMUser,DMWire,DMSolid} ;
private:
///used to find right trasformation in case of rotation
static void XAxis( vcg::Point3f zero, vcg::Point3f uno, Matrix44f & tr){
///used to find right transformation in case of rotation
static void XAxis(vcg::Point3f zero, vcg::Point3f uno, Matrix44f & tr)
{
#ifndef VCG_USE_EIGEN
tr.SetZero();
*((vcg::Point3f*)&tr[0][0]) = uno-zero;
GetUV(*((vcg::Point3f*)tr[0]),*((vcg::Point3f*)tr[1]),*((vcg::Point3f*)tr[2]));
tr[3][3] = 1.0;
*((vcg::Point3f*)&tr[3][0]) = zero;
#else
tr.col(0).start<3>().setZero();
tr.row(0).start<3>() = (uno-zero).normalized(); // n
tr.row(1).start<3>() = tr.row(0).start<3>().unitOrthogonal(); // u
tr.row(2).start<3>() = tr.row(0).start<3>().cross(tr.row(1).start<3>()).normalized(); // v
tr.row(3) << zero.transpose(), 1.;
#endif
}
//set drawingmode parameters

15
wrap/gl/space.h
View File

@ -280,8 +280,21 @@ template <class TetraType>
#ifdef VCG_USE_EIGEN
template<typename Derived, int Rows=Derived::RowsAtCompileTime, int Cols=Derived::ColsAtCompileTime>
struct EvalToKnownPointType;
template<typename Derived> struct EvalToKnownPointType<Derived,2,1>
{ typedef Point2<typename Derived::Scalar> Type; };
template<typename Derived> struct EvalToKnownPointType<Derived,3,1>
{ typedef Point3<typename Derived::Scalar> Type; };
template<typename Derived> struct EvalToKnownPointType<Derived,4,1>
{ typedef Point4<typename Derived::Scalar> Type; };
#define _WRAP_EIGEN_XPR(FUNC) template<typename Derived> \
inline void FUNC(const Eigen::MatrixBase<Derived>& p) { FUNC(p.eval()); }
inline void FUNC(const Eigen::MatrixBase<Derived>& p) { \
FUNC(typename EvalToKnownPointType<Derived>::Type(p)); }
_WRAP_EIGEN_XPR(glVertex)
_WRAP_EIGEN_XPR(glNormal)

2
wrap/gui/coordinateframe.cpp
View File

@ -352,7 +352,7 @@ void MovableCoordinateFrame::RotateToAlign(const Point3f source, const Point3f d
Point3f axis = dest ^ source;
float sinangle = axis.Norm();
float cosangle = dest * source;
float cosangle = dest.dot(source);
float angle = math::Atan2(sinangle,cosangle);
if( math::Abs(angle) < EPSILON )

2
wrap/io_trimesh/import_ptx.h
View File

@ -417,7 +417,7 @@ namespace io {
{
raggio = -((*fi).V(0)->P() + (*fi).V(1)->P() + (*fi).V(2)->P()) / 3.0;
raggio.Normalize();
if((raggio * (*fi).N()) < limit)
if((raggio.dot((*fi).N())) < limit)
Allocator<OpenMeshType>::DeleteFace(m,*fi);
}