2004-02-10 02:11:28 +01:00
/****************************************************************************
* 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 . *
* *
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.
2008-10-28 01:59:46 +01:00
* This program is free software ; you can redistribute it and / or modify *
2004-02-10 02:11:28 +01:00
* 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 $
2008-04-22 22:44:07 +02:00
Revision 1.15 2007 / 09 / 21 11 : 34 : 10 ponchio
Just a clarification comment
2007-09-21 13:34:10 +02:00
Revision 1.14 2006 / 06 / 08 08 : 52 : 02 zifnab1974
gcc 4 needs the extra template keyword
2006-06-08 10:52:02 +02:00
Revision 1.13 2005 / 06 / 24 12 : 21 : 48 ponchio
Fixed " lerp " function .
2005-06-24 14:21:48 +02:00
Revision 1.12 2005 / 04 / 14 11 : 35 : 09 ponchio
* * * empty log message * * *
2005-04-14 13:35:09 +02:00
Revision 1.11 2004 / 09 / 09 12 : 51 : 28 fasano
corrected ColorRamp code ( template specialization )
2004-09-09 14:51:28 +02:00
Revision 1.10 2004 / 09 / 09 08 : 39 : 33 cignoni
added a ' template < > ' to the specialized constructors from a enum
2004-09-09 10:39:33 +02:00
Revision 1.9 2004 / 09 / 03 13 : 58 : 48 fasano
Corretto errore sintattico nelle specializzazioni parziali ( float e char ) di due costruttori di Color4
2004-09-03 15:58:48 +02:00
Revision 1.8 2004 / 07 / 15 11 : 01 : 43 ganovelli
added inclusion of point3 . h
2004-07-15 13:01:43 +02:00
Revision 1.7 2004 / 06 / 24 07 : 55 : 50 cignoni
Now color ramp can do reverse color ramp
2004-06-24 09:55:50 +02:00
Revision 1.6 2004 / 05 / 26 15 : 10 : 29 cignoni
Corrected bug in setgrayshade
2004-05-26 17:10:29 +02:00
Revision 1.5 2004 / 05 / 07 12 : 46 : 55 cignoni
added ifdef for gcc [ Bug c + + / 14479 ]
2004-05-07 14:46:55 +02:00
Revision 1.4 2004 / 05 / 07 10 : 06 : 55 cignoni
Corrected template specialization syntax for gcc compiling
2004-05-07 12:06:55 +02:00
Revision 1.3 2004 / 03 / 10 21 : 38 : 40 cignoni
Written some documentation and added to the space module
2004-03-10 22:38:40 +01:00
Revision 1.2 2004 / 03 / 10 00 : 35 : 01 cignoni
Removed a wrong ( ? ) copy constructor
2004-03-10 01:35:01 +01:00
Revision 1.1 2004 / 02 / 10 01 : 11 : 28 cignoni
Edited Comments and GPL license
2004-02-10 02:11:28 +01:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# ifndef __VCGLIB_COLOR4
# define __VCGLIB_COLOR4
2004-07-15 13:01:43 +02:00
# include <vcg/space/point3.h>
2004-02-10 02:11:28 +01:00
# include <vcg/space/point4.h>
namespace vcg {
2004-03-10 22:38:40 +01:00
/** \addtogroup space */
/*@{*/
/**
The templated class for representing 4 entity color .
The class is templated over the ScalarType . class that is used to represent color with float or with unsigned chars . All the usual
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.
2008-10-28 01:59:46 +01:00
operator overloading ( * + - . . . ) is present .
2004-03-10 22:38:40 +01:00
*/
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.
2008-10-28 01:59:46 +01:00
template < class T >
2004-02-10 02:11:28 +01:00
class Color4 : public Point4 < T >
{
2008-10-27 20:35:17 +01:00
typedef Point4 < T > Base ;
2004-02-10 02:11:28 +01:00
public :
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.
2008-10-28 01:59:46 +01:00
/// Constant for storing standard colors.
2004-02-10 02:11:28 +01:00
/// Each color is stored in a simple in so that the bit pattern match with the one of Color4b.
enum ColorConstant {
Black = 0xff000000 ,
Gray = 0xff808080 ,
White = 0xffffffff ,
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.
2008-10-28 01:59:46 +01:00
2004-02-10 02:11:28 +01:00
Red = 0xff0000ff ,
Green = 0xff00ff00 ,
Blue = 0xffff0000 ,
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.
2008-10-28 01:59:46 +01:00
2004-02-10 02:11:28 +01:00
Cyan = 0xffffff00 ,
Yellow = 0xff00ffff ,
Magenta = 0xffff00ff ,
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.
2008-10-28 01:59:46 +01:00
2004-02-10 02:11:28 +01:00
LightGray = 0xffc0c0c0 ,
LightRed = 0xff8080ff ,
LightGreen = 0xff80ff80 ,
LightBlue = 0xffff8080 ,
DarkGray = 0xff404040 ,
DarkRed = 0xff000040 ,
DarkGreen = 0xff004000 ,
2004-05-07 12:06:55 +02:00
DarkBlue = 0xff400000
2004-02-10 02:11:28 +01:00
} ;
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.
2008-10-28 01:59:46 +01:00
2004-02-10 02:11:28 +01:00
inline Color4 ( const T nx , const T ny , const T nz , const T nw ) : Point4 < T > ( nx , ny , nz , nw ) { } ;
2004-03-10 01:35:01 +01:00
// inline Color4 ( Color4 &c) :Point4<T>(c) {};
2008-06-18 01:08:53 +02:00
inline Color4 ( const Point4 < T > & c ) : Point4 < T > ( c ) { } ;
2004-02-10 02:11:28 +01:00
inline Color4 ( ) { } ;
inline Color4 ( ColorConstant cc ) ;
2008-10-27 20:35:17 +01:00
# ifdef VCG_USE_EIGEN
template < typename OtherDerived >
inline Color4 ( const Eigen : : MatrixBase < OtherDerived > & other ) : Base ( other )
{
// TODO make sure the types are the same
}
# endif
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.
2008-10-28 01:59:46 +01:00
template < class Q >
2004-02-10 02:11:28 +01:00
inline void Import ( const Color4 < Q > & b )
{
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.
2008-10-28 01:59:46 +01:00
( * this ) [ 0 ] = T ( b [ 0 ] ) ;
( * this ) [ 1 ] = T ( b [ 1 ] ) ;
( * this ) [ 2 ] = T ( b [ 2 ] ) ;
( * this ) [ 3 ] = T ( b [ 3 ] ) ;
2004-02-10 02:11:28 +01:00
}
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.
2008-10-28 01:59:46 +01:00
template < class Q >
2008-04-22 22:44:07 +02:00
inline void Import ( const Point4 < Q > & b )
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.
2008-10-28 01:59:46 +01:00
{
( * this ) [ 0 ] = T ( b [ 0 ] ) ;
( * this ) [ 1 ] = T ( b [ 1 ] ) ;
( * this ) [ 2 ] = T ( b [ 2 ] ) ;
( * this ) [ 3 ] = T ( b [ 3 ] ) ;
2008-04-22 22:44:07 +02:00
}
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.
2008-10-28 01:59:46 +01:00
template < class Q >
2008-04-22 22:44:07 +02:00
static inline Color4 Construct ( const Color4 < Q > & b )
{
return Color4 ( T ( b [ 0 ] ) , T ( b [ 1 ] ) , T ( b [ 2 ] ) , T ( b [ 3 ] ) ) ;
}
2004-05-07 12:06:55 +02:00
//inline void Import(const Color4<float> &b);
//inline void Import(const Color4<unsigned char> &b);
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.
2008-10-28 01:59:46 +01:00
2008-07-09 17:18:08 +02:00
inline Color4 operator + ( const Color4 & p ) const
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.
2008-10-28 01:59:46 +01:00
{
2008-10-27 20:35:17 +01:00
return Color4 ( ( * this ) [ 0 ] + p . V ( ) [ 0 ] , ( * this ) [ 1 ] + p . V ( ) [ 1 ] , ( * this ) [ 2 ] + p . V ( ) [ 2 ] , ( * this ) [ 3 ] + p . V ( ) [ 3 ] ) ;
2008-07-09 17:18:08 +02:00
}
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.
2008-10-28 01:59:46 +01:00
2004-02-10 02:11:28 +01:00
inline void lerp ( const Color4 & c0 , const Color4 & c1 , const float x ) ;
inline void lerp ( const Color4 & c0 , const Color4 & c1 , const Color4 & c2 , const Point3f & ip ) ;
2004-06-24 09:55:50 +02:00
/// given a float and a range set the corresponding color in the well known red->green->blue color ramp. To reverse the direction of the ramp just swap minf and maxf.
2012-04-18 23:17:04 +02:00
inline void SetColorRamp ( const float & minf , const float & maxf , float v ) ;
2004-02-10 02:11:28 +01:00
inline void SetRGB ( unsigned char r , unsigned char g , unsigned char b )
{
2008-10-27 20:38:52 +01:00
( * this ) [ 0 ] = r ;
( * this ) [ 1 ] = g ;
( * this ) [ 2 ] = b ;
( * this ) [ 3 ] = 0 ;
2004-02-10 02:11:28 +01:00
}
void SetHSVColor ( float h , float s , float v ) {
float r , g , b ;
if ( s = = 0.0 ) { // gray color
r = g = b = v ;
2008-10-27 20:38:52 +01:00
( * this ) [ 0 ] = ( unsigned char ) ( 255 * r ) ;
( * this ) [ 1 ] = ( unsigned char ) ( 255 * g ) ;
( * this ) [ 2 ] = ( unsigned char ) ( 255 * b ) ;
( * this ) [ 3 ] = 255 ;
2004-02-10 02:11:28 +01:00
return ;
}
if ( h = = 1.0 ) h = 0.0 ;
int i = int ( floor ( h * 6.0 ) ) ;
float f = float ( h * 6.0f - floor ( h * 6.0f ) ) ;
float p = v * ( 1.0f - s ) ;
float q = v * ( 1.0f - s * f ) ;
float t = v * ( 1.0f - s * ( 1.0f - f ) ) ;
switch ( i ) {
case 0 : r = v ; g = t ; b = p ; break ;
case 1 : r = q ; g = v ; b = p ; break ;
case 2 : r = p ; g = v ; b = t ; break ;
case 3 : r = p ; g = q ; b = v ; break ;
case 4 : r = t ; g = p ; b = v ; break ;
case 5 : r = v ; g = p ; b = q ; break ;
2010-01-16 16:33:07 +01:00
default : r = 0 ; g = 0 ; b = 0 ; assert ( 0 ) ; break ;
2004-02-10 02:11:28 +01:00
}
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.
2008-10-28 01:59:46 +01:00
( * this ) [ 0 ] = ( unsigned char ) ( 255 * r ) ;
( * this ) [ 1 ] = ( unsigned char ) ( 255 * g ) ;
( * this ) [ 2 ] = ( unsigned char ) ( 255 * b ) ;
( * this ) [ 3 ] = 255 ;
2008-10-27 20:35:17 +01:00
// V()[0]=r*256;V()[1]=g*256;V()[2]=b*256;
2004-02-10 02:11:28 +01:00
}
inline static Color4 GrayShade ( float f )
{
2004-05-26 17:10:29 +02:00
return Color4 ( f , f , f , 1 ) ;
2004-02-10 02:11:28 +01:00
}
inline void SetGrayShade ( float f )
{
2004-05-26 17:10:29 +02:00
Import ( Color4 < float > ( f , f , f , 1 ) ) ;
2004-02-10 02:11:28 +01:00
}
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.
2008-10-28 01:59:46 +01:00
/** Given an integer returns a well ordering of colors
2004-02-10 02:11:28 +01:00
// so that every color differs as much as possible form the previous one
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.
2008-10-28 01:59:46 +01:00
// params:
2012-01-18 12:24:33 +01:00
// range is the maximum expected value (max of the range)
// value is the requested position (it must be <range);
2004-03-10 22:38:40 +01:00
*/
2012-01-18 12:24:33 +01:00
inline static Color4 Scatter ( int range , int value , float Sat = .3f , float Val = .9f )
2004-02-10 02:11:28 +01:00
{
2012-01-18 12:24:33 +01:00
int b , k , m = range ;
int r = range ;
2004-02-10 02:11:28 +01:00
2012-01-18 12:24:33 +01:00
for ( b = 0 , k = 1 ; k < range ; k < < = 1 )
if ( value < < 1 > = m ) {
2004-02-10 02:11:28 +01:00
if ( b = = 0 ) r = k ;
b + = k ;
2012-01-18 12:24:33 +01:00
value - = ( m + 1 ) > > 1 ;
2004-02-10 02:11:28 +01:00
m > > = 1 ;
}
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.
2008-10-28 01:59:46 +01:00
else m = ( m + 1 ) > > 1 ;
2012-01-18 12:24:33 +01:00
if ( r > range - b ) r = range - b ;
2004-02-10 02:11:28 +01:00
//TRACE("Scatter range 0..%i, in %i out %i\n",n,a,b);
Color4 rc ;
2012-01-18 12:24:33 +01:00
rc . SetHSVColor ( float ( b ) / float ( range ) , Sat , Val ) ;
2004-02-10 02:11:28 +01:00
return rc ;
}
2012-04-18 23:17:04 +02:00
inline static Color4 ColorRamp ( const float & minf , const float & maxf , float v )
{
Color4 rc ;
rc . SetColorRamp ( minf , maxf , v ) ;
return rc ;
}
2004-02-10 02:11:28 +01:00
} ;
template < class T >
inline void Color4 < T > : : lerp ( const Color4 < T > & c0 , const Color4 < T > & c1 , const float x )
{
assert ( x > = 0 ) ;
assert ( x < = 1 ) ;
2008-10-27 20:38:52 +01:00
( * this ) [ 0 ] = ( T ) ( c1 . V ( ) [ 0 ] * x + c0 . V ( ) [ 0 ] * ( 1.0f - x ) ) ;
( * this ) [ 1 ] = ( T ) ( c1 . V ( ) [ 1 ] * x + c0 . V ( ) [ 1 ] * ( 1.0f - x ) ) ;
( * this ) [ 2 ] = ( T ) ( c1 . V ( ) [ 2 ] * x + c0 . V ( ) [ 2 ] * ( 1.0f - x ) ) ;
( * this ) [ 3 ] = ( T ) ( c1 . V ( ) [ 3 ] * x + c0 . V ( ) [ 3 ] * ( 1.0f - x ) ) ;
2004-02-10 02:11:28 +01:00
}
template < class T >
inline void Color4 < T > : : lerp ( const Color4 < T > & c0 , const Color4 < T > & c1 , const Color4 < T > & c2 , const Point3f & ip )
{
assert ( fabs ( ip [ 0 ] + ip [ 1 ] + ip [ 2 ] - 1 ) < 0.00001 ) ;
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.
2008-10-28 01:59:46 +01:00
2008-10-27 20:38:52 +01:00
( * this ) [ 0 ] = ( T ) ( c0 [ 0 ] * ip [ 0 ] + c1 [ 0 ] * ip [ 1 ] + c2 [ 0 ] * ip [ 2 ] ) ;
( * this ) [ 1 ] = ( T ) ( c0 [ 1 ] * ip [ 0 ] + c1 [ 1 ] * ip [ 1 ] + c2 [ 1 ] * ip [ 2 ] ) ;
( * this ) [ 2 ] = ( T ) ( c0 [ 2 ] * ip [ 0 ] + c1 [ 2 ] * ip [ 1 ] + c2 [ 2 ] * ip [ 2 ] ) ;
( * this ) [ 3 ] = ( T ) ( c0 [ 3 ] * ip [ 0 ] + c1 [ 3 ] * ip [ 1 ] + c2 [ 3 ] * ip [ 2 ] ) ;
2004-02-10 02:11:28 +01:00
}
template < class T >
2012-04-18 23:17:04 +02:00
inline void Color4 < T > : : SetColorRamp ( const float & minf , const float & maxf , float v )
2004-02-10 02:11:28 +01:00
{
2012-04-18 23:17:04 +02:00
if ( minf > maxf ) { SetColorRamp ( maxf , minf , maxf + ( minf - v ) ) ; return ; }
2004-09-09 14:51:28 +02:00
if ( v < minf ) { * this = Color4 < T > ( Color4 < T > : : Red ) ; return ; }
2007-09-21 13:34:10 +02:00
//the case v > maxf is handled automatically at the end of the function
2004-09-09 14:51:28 +02:00
2004-02-10 02:11:28 +01:00
float step = ( maxf - minf ) / 4 ;
v - = minf ;
2004-09-09 14:51:28 +02:00
if ( v < step ) { lerp ( Color4 < T > ( Color4 < T > : : Red ) , Color4 < T > ( Color4 < T > : : Yellow ) , v / step ) ; return ; }
2004-02-10 02:11:28 +01:00
v - = step ;
2004-09-09 14:51:28 +02:00
if ( v < step ) { lerp ( Color4 < T > ( Color4 < T > : : Yellow ) , Color4 < T > ( Color4 < T > : : Green ) , v / step ) ; return ; }
2004-02-10 02:11:28 +01:00
v - = step ;
2004-09-09 14:51:28 +02:00
if ( v < step ) { lerp ( Color4 < T > ( Color4 < T > : : Green ) , Color4 < T > ( Color4 < T > : : Cyan ) , v / step ) ; return ; }
2004-02-10 02:11:28 +01:00
v - = step ;
2004-09-09 14:51:28 +02:00
if ( v < step ) { lerp ( Color4 < T > ( Color4 < T > : : Cyan ) , Color4 < T > ( Color4 < T > : : Blue ) , v / step ) ; return ; }
2004-02-10 02:11:28 +01:00
2004-09-09 14:51:28 +02:00
* this = Color4 < T > ( Color4 < T > : : Blue ) ;
2004-02-10 02:11:28 +01:00
}
2004-05-07 14:46:55 +02:00
2006-06-08 10:52:02 +02:00
# if !defined(__GNUC__) || (__GNUC__ > 3)
2004-05-07 12:06:55 +02:00
template < >
2004-05-07 14:46:55 +02:00
# endif
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.
2008-10-28 01:59:46 +01:00
template < >
2004-02-10 02:11:28 +01:00
inline void Color4 < float > : : Import ( const Color4 < unsigned char > & b )
{
2008-10-27 20:35:17 +01:00
( * this ) [ 0 ] = b [ 0 ] / 255.0f ;
( * this ) [ 1 ] = b [ 1 ] / 255.0f ;
( * this ) [ 2 ] = b [ 2 ] / 255.0f ;
( * this ) [ 3 ] = b [ 3 ] / 255.0f ;
2004-02-10 02:11:28 +01:00
}
2004-05-07 14:46:55 +02:00
2006-06-08 10:52:02 +02:00
# if !defined(__GNUC__) || (__GNUC__ > 3)
2004-05-07 14:46:55 +02:00
template < > // [Bug c++/14479] enum definition in template class with template methods causes error.
# endif
2004-05-07 12:06:55 +02:00
template < >
2004-02-10 02:11:28 +01:00
inline void Color4 < unsigned char > : : Import ( const Color4 < float > & b )
{
2008-10-27 20:35:17 +01:00
( * this ) [ 0 ] = ( unsigned char ) ( b [ 0 ] * 255.0f ) ;
( * this ) [ 1 ] = ( unsigned char ) ( b [ 1 ] * 255.0f ) ;
( * this ) [ 2 ] = ( unsigned char ) ( b [ 2 ] * 255.0f ) ;
( * this ) [ 3 ] = ( unsigned char ) ( b [ 3 ] * 255.0f ) ;
2004-02-10 02:11:28 +01:00
}
2008-04-22 22:44:07 +02:00
# if !defined(__GNUC__) || (__GNUC__ > 3)
template < > // [Bug c++/14479] enum definition in template class with template methods causes error.
# endif
template < >
inline void Color4 < unsigned char > : : Import ( const Point4 < float > & b )
{
2008-10-27 20:35:17 +01:00
( * this ) [ 0 ] = ( unsigned char ) ( b [ 0 ] * 255.0f ) ;
( * this ) [ 1 ] = ( unsigned char ) ( b [ 1 ] * 255.0f ) ;
( * this ) [ 2 ] = ( unsigned char ) ( b [ 2 ] * 255.0f ) ;
( * this ) [ 3 ] = ( unsigned char ) ( b [ 3 ] * 255.0f ) ;
2008-04-22 22:44:07 +02:00
}
# if !defined(__GNUC__) || (__GNUC__ > 3)
template < >
# endif
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.
2008-10-28 01:59:46 +01:00
template < >
2008-04-22 22:44:07 +02:00
inline Color4 < unsigned char > Color4 < unsigned char > : : Construct ( const Color4 < float > & b )
{
return Color4 < unsigned char > (
( unsigned char ) ( b [ 0 ] * 255.0f ) ,
( unsigned char ) ( b [ 1 ] * 255.0f ) ,
( unsigned char ) ( b [ 2 ] * 255.0f ) ,
( unsigned char ) ( b [ 3 ] * 255.0f ) ) ;
}
# if !defined(__GNUC__) || (__GNUC__ > 3)
template < >
# endif
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.
2008-10-28 01:59:46 +01:00
template < >
2008-04-22 22:44:07 +02:00
inline Color4 < float > Color4 < float > : : Construct ( const Color4 < unsigned char > & b )
{
return Color4 < float > (
( float ) ( b [ 0 ] ) / 255.0f ,
( float ) ( b [ 1 ] ) / 255.0f ,
( float ) ( b [ 2 ] ) / 255.0f ,
( float ) ( b [ 3 ] ) / 255.0f ) ;
}
2004-02-10 02:11:28 +01:00
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.
2008-10-28 01:59:46 +01:00
//template <class T,class S>
2004-02-10 02:11:28 +01:00
//inline void Color4<T>::Import(const Color4<S> &b)
//{
2008-10-27 20:35:17 +01:00
// V()[0] = T(b[0]);
// V()[1] = T(b[1]);
// V()[2] = T(b[2]);
// V()[3] = T(b[3]);
2004-02-10 02:11:28 +01:00
//}
//
2004-09-09 10:39:33 +02:00
template < >
2004-09-03 15:58:48 +02:00
inline Color4 < unsigned char > : : Color4 ( Color4 < unsigned char > : : ColorConstant cc )
2004-02-10 02:11:28 +01:00
{
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.
2008-10-28 01:59:46 +01:00
* ( ( int * ) this ) = cc ;
2004-02-10 02:11:28 +01:00
}
2004-09-09 10:39:33 +02:00
template < >
2004-09-03 15:58:48 +02:00
inline Color4 < float > : : Color4 ( Color4 < float > : : ColorConstant cc )
2004-02-10 02:11:28 +01:00
{
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.
2008-10-28 01:59:46 +01:00
Import ( Color4 < unsigned char > ( ( Color4 < unsigned char > : : ColorConstant ) cc ) ) ;
2004-02-10 02:11:28 +01:00
}
2008-06-18 01:08:53 +02:00
inline Color4 < float > Clamp ( Color4 < float > & c )
{
c [ 0 ] = math : : Clamp ( c [ 0 ] , 0.0f , 1.0f ) ;
c [ 1 ] = math : : Clamp ( c [ 1 ] , 0.0f , 1.0f ) ;
c [ 2 ] = math : : Clamp ( c [ 2 ] , 0.0f , 1.0f ) ;
c [ 3 ] = math : : Clamp ( c [ 3 ] , 0.0f , 1.0f ) ;
return c ;
}
2004-02-10 02:11:28 +01:00
2008-07-09 17:18:08 +02:00
template < >
inline Color4 < unsigned char > Color4 < unsigned char > : : operator + ( const Color4 < unsigned char > & p ) const
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.
2008-10-28 01:59:46 +01:00
{
return Color4 < unsigned char > (
2009-06-30 21:01:22 +02:00
( unsigned char ) ( math : : Clamp ( int ( ( * this ) [ 0 ] ) + int ( p [ 0 ] ) , 0 , 255 ) ) ,
( unsigned char ) ( math : : Clamp ( int ( ( * this ) [ 1 ] ) + int ( p [ 1 ] ) , 0 , 255 ) ) ,
( unsigned char ) ( math : : Clamp ( int ( ( * this ) [ 2 ] ) + int ( p [ 2 ] ) , 0 , 255 ) ) ,
( unsigned char ) ( math : : Clamp ( int ( ( * this ) [ 3 ] ) + int ( p [ 3 ] ) , 0 , 255 ) )
2008-07-09 17:18:08 +02:00
) ;
}
2004-02-10 02:11:28 +01:00
typedef Color4 < unsigned char > Color4b ;
typedef Color4 < float > Color4f ;
2009-07-10 15:22:24 +02:00
typedef Color4 < double > Color4d ;
2004-02-10 02:11:28 +01:00
2004-03-10 22:38:40 +01:00
/*@}*/
2004-02-10 02:11:28 +01:00
} // end of NameSpace
2004-03-10 01:35:01 +01:00
# endif
