EMAN::Vec2< Type > Class Template Reference
[unit test in Python]

The Vec2 is precisely the same as Vec3 except it works exclusively in 2D Note there are convenient typedef so one needn't bother about using template terminology typedef Vec2<float> Vec2f; typedef Vec2<int> Vec2i; typedef Vec2double> Vec2d; // Not recommended for use unless precision is addressed in this class. More...

#include <vec3.h>

Collaboration diagram for EMAN::Vec2< Type >:

Collaboration graph
[legend]
List of all members.

Public Types

typedef Type type
 One can always cast to the type of a Vec2 by accessing Vec2<Type>::type.

Public Member Functions

 Vec2 ()
 contruct a Vec2 object with all elements equal to 0.
template<typename Type2, typename Type3>
 Vec2 (const Type2 &x, const Type3 &y)
 contruct a Vec2 object given (x,y) or (x,y,z) values.
template<typename Type2>
 Vec2 (const vector< Type2 > &v)
 Construct a Vec2 object given a std::vector object.
template<typename Type2>
 Vec2 (const Vec2< Type2 > &v)
 Copy constructor copies vector elements.
 ~Vec2 ()
 Destructor.
float normalize ()
 Normalize the vector and return its length before the normalization.
float length () const
 Calculate its length.
Type squared_length () const
 Calculate its squared length.
template<typename Type2>
Type dot (const Vec2< Type2 > &v) const
 Calculate the dot product of 'this' vector with a second vector.
vector< Type > as_list () const
 Return the values of this vector as a std::vector.
template<typename Type2>
void set_value (const vector< Type2 > &v)
 Set new values using a std::vector object.
template<typename Type2>
void set_value_at (int index, const Type2 &value)
 Set values at a particular index.
void set_value (const Type &x, const Type &y)
 Set new values to this vector object.
Type operator[] (int i) const
 Get the ith item of the vector.
Type & operator[] (int i)
 Get the ith item of the vector.
Type at (int i)
 Get the ith item of the vector.
int number_of_element ()
 For python __len__.
Type * begin ()
 Add this function to make it iterable in Python, so we can call list() or tuple() to convert Vec3f in python to a list or tuple.
Type * end ()
 Add this function to make it iterable in Python, so we can call list() or tuple() to convert Vec3f in python to a list or tuple.
template<typename Type2>
Vec2< Type > & operator+= (const Vec2< Type2 > &v)
 'this' += v; Add the 2 vectors by adding item by item.
template<typename Type2>
Vec2< Type > & operator+= (const Type2 &d)
 'this' += d.
template<typename Type2>
Vec2< Type > & operator-= (const Vec2< Type2 > &v)
 'this' -= v; Minus the 2 vectors item by item.
template<typename Type2>
Vec2< Type > & operator-= (const Type2 &d)
 'this' -= d; Minus a number from each item of 'this' vector.
template<typename Type2>
Vec2< Type > & operator *= (const Type2 &d)
 'this' *= d; Multiply a number on each item of 'this' vector.
template<typename Type2>
Vec2< Type > & operator/= (const Type2 &d)
 'this' /= d; Divide a number on each item of 'this' vector.

Private Attributes

Type vec [2]

Detailed Description

template<typename Type>
class EMAN::Vec2< Type >

The Vec2 is precisely the same as Vec3 except it works exclusively in 2D Note there are convenient typedef so one needn't bother about using template terminology typedef Vec2<float> Vec2f; typedef Vec2<int> Vec2i; typedef Vec2double> Vec2d; // Not recommended for use unless precision is addressed in this class.

Author:
David Woolford (based on the work of who ever wrote the original Vec3f and Vec3i classes - extracted into a template)
Date:
August 2008 ?

Definition at line 504 of file vec3.h.


Member Typedef Documentation

template<typename Type>
typedef Type EMAN::Vec2< Type >::type

One can always cast to the type of a Vec2 by accessing Vec2<Type>::type.

Definition at line 509 of file vec3.h.


Constructor & Destructor Documentation

template<typename Type>
EMAN::Vec2< Type >::Vec2 (  )  [inline]

contruct a Vec2 object with all elements equal to 0.

Definition at line 513 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00513                          : vec[0](0),vec[1](0),vec[2](0)*/ {
00514                         vec[0] = static_cast<Type>(0);
00515                         vec[1] = static_cast<Type>(0);
00516                 }

template<typename Type>
template<typename Type2, typename Type3>
EMAN::Vec2< Type >::Vec2 ( const Type2 &  x,
const Type3 &  y 
) [inline]

contruct a Vec2 object given (x,y) or (x,y,z) values.

Parameters:
x Value of the first item.
y Value of the second item. default to 0.

Definition at line 524 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00525                 {
00526                         vec[0] = static_cast<Type>(x);
00527                         vec[1] = static_cast<Type>(y);
00528                 }

template<typename Type>
template<typename Type2>
EMAN::Vec2< Type >::Vec2 ( const vector< Type2 > &  v  )  [inline]

Construct a Vec2 object given a std::vector object.

The std::vector object should have at least 3 items.

Parameters:
v The std::vector object. It should have at least 3 items.

Definition at line 535 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00536                 {
00537                         vec[0] = static_cast<Type>(v[0]);
00538                         vec[1] = static_cast<Type>(v[1]);
00539                 }

template<typename Type>
template<typename Type2>
EMAN::Vec2< Type >::Vec2 ( const Vec2< Type2 > &  v  )  [inline]

Copy constructor copies vector elements.

Definition at line 544 of file vec3.h.

References v, and EMAN::Vec2< Type >::vec.

00545                 {
00546                         vec[0] = static_cast<Type>(v[0]);
00547                         vec[1] = static_cast<Type>(v[1]);
00548                 }

template<typename Type>
EMAN::Vec2< Type >::~Vec2 (  )  [inline]

Destructor.

Definition at line 552 of file vec3.h.

00552 {}


Member Function Documentation

template<typename Type>
vector<Type> EMAN::Vec2< Type >::as_list (  )  const [inline]

Return the values of this vector as a std::vector.

Returns:
The std::vector version of this vector.

Definition at line 607 of file vec3.h.

References v, and EMAN::Vec2< Type >::vec.

00608                 {
00609                         vector < Type > v(2);
00610                         v[0] = vec[0];
00611                         v[1] = vec[1];
00612                         return v;
00613                 }

template<typename Type>
Type EMAN::Vec2< Type >::at ( int  i  )  [inline]

Get the ith item of the vector.

Used in the left side of the assignment.

Parameters:
i The index of the item to get. Its validality is not checked.
Returns:
The ith item of the vector.

Definition at line 671 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00671 { return vec[i]; }

template<typename Type>
Type* EMAN::Vec2< Type >::begin ( void   )  [inline]

Add this function to make it iterable in Python, so we can call list() or tuple() to convert Vec3f in python to a list or tuple.

Returns:
the iterator (here is the pointer) of the first element

Definition at line 688 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00689                 {
00690                         return &vec[0];
00691                 }

template<typename Type>
template<typename Type2>
Type EMAN::Vec2< Type >::dot ( const Vec2< Type2 > &  v  )  const [inline]

Calculate the dot product of 'this' vector with a second vector.

Parameters:
v The second vector to do the dot product.
Returns:
The dot product.

Definition at line 599 of file vec3.h.

References v, and EMAN::Vec2< Type >::vec.

Referenced by EMAN::operator *(), and EMAN::Util::point_is_in_triangle_2d().

00600                 {
00601                         return static_cast<Type>((vec[0] * v[0] + vec[1] * v[1]));
00602                 }

template<typename Type>
Type* EMAN::Vec2< Type >::end ( void   )  [inline]

Add this function to make it iterable in Python, so we can call list() or tuple() to convert Vec3f in python to a list or tuple.

Returns:
the iterator (here is the pointer) of the one beyond the last element.

Definition at line 698 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00699                 {
00700                         return &vec[2];
00701                 }

template<typename Type>
float EMAN::Vec2< Type >::length (  )  const [inline]

Calculate its length.

Returns:
The vector's length Warning - float precision

Definition at line 578 of file vec3.h.

References sqrt(), t, and EMAN::Vec2< Type >::vec.

Referenced by EMAN::Vec2< Type >::normalize().

00579                 {
00580                         float t = (float)(vec[0] * vec[0] + vec[1] * vec[1]);
00581                         return (float)sqrt(t);
00582                 }

template<typename Type>
float EMAN::Vec2< Type >::normalize (  )  [inline]

Normalize the vector and return its length before the normalization.

Returns:
The length of the Vec before normalization.

Definition at line 559 of file vec3.h.

References EMAN::Vec2< Type >::length(), EMAN::Vec2< Type >::set_value(), and EMAN::Vec2< Type >::vec.

00560                 {
00561                 // Warning - float precision
00562                         float len = length();
00563                         if (len != 0) {
00564                                 vec[0] = static_cast<Type> (vec[0] / len);
00565                                 vec[1] = static_cast<Type> (vec[1] / len);
00566                         }
00567                         else {
00568                                 set_value(0, 0);
00569                         }
00570                         return len;
00571                 }

template<typename Type>
int EMAN::Vec2< Type >::number_of_element (  )  [inline]

For python __len__.

Returns:
the number of elements in this container. it's always 2.

Definition at line 678 of file vec3.h.

00679                 {
00680                         return 2;
00681                 }

template<typename Type>
template<typename Type2>
Vec2<Type>& EMAN::Vec2< Type >::operator *= ( const Type2 &  d  )  [inline]

'this' *= d; Multiply a number on each item of 'this' vector.

Parameters:
d The number to multiply.
Returns:
The new 'this' as a result of multiplication.

Definition at line 753 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00753                                                         {
00754                         vec[0] = static_cast<Type>(vec[0]*d);
00755                         vec[1] = static_cast<Type>(vec[1]*d);
00756                         return *this;
00757                 }

template<typename Type>
template<typename Type2>
Vec2<Type>& EMAN::Vec2< Type >::operator+= ( const Type2 &  d  )  [inline]

'this' += d.

Add d to each item of this vector.

Parameters:
d The number used to be added to this vector.
Returns:
The new 'this' as a result of add.

Definition at line 720 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00720                                                         {
00721                         vec[0] = static_cast<Type>(vec[0]+d);
00722                         vec[1] = static_cast<Type>(vec[1]+d);
00723                         return *this;
00724                 }

template<typename Type>
template<typename Type2>
Vec2<Type>& EMAN::Vec2< Type >::operator+= ( const Vec2< Type2 > &  v  )  [inline]

'this' += v; Add the 2 vectors by adding item by item.

Parameters:
v The vector used to be added to 'this' vector.
Returns:
The new 'this' as a result of add.

Definition at line 709 of file vec3.h.

References v, and EMAN::Vec2< Type >::vec.

00709                                                               {
00710                         vec[0] = static_cast<Type>(vec[0]+v[0]);
00711                         vec[1] = static_cast<Type>(vec[1]+v[1]);
00712                         return *this;
00713                 }

template<typename Type>
template<typename Type2>
Vec2<Type>& EMAN::Vec2< Type >::operator-= ( const Type2 &  d  )  [inline]

'this' -= d; Minus a number from each item of 'this' vector.

Parameters:
d The number used to be substracted from 'this' vector.
Returns:
The new 'this' as a result of substraction.

Definition at line 742 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00742                                                         {
00743                         vec[0] = static_cast<Type>(vec[0]-d);
00744                         vec[1] = static_cast<Type>(vec[1]-d);
00745                         return *this;
00746                 }

template<typename Type>
template<typename Type2>
Vec2<Type>& EMAN::Vec2< Type >::operator-= ( const Vec2< Type2 > &  v  )  [inline]

'this' -= v; Minus the 2 vectors item by item.

Parameters:
v The vector used to be substracted from 'this' vector.
Returns:
The new 'this' as a result of substraction.

Definition at line 731 of file vec3.h.

References v, and EMAN::Vec2< Type >::vec.

00731                                                               {
00732                         vec[0] = static_cast<Type>(vec[0]-v[0]);
00733                         vec[1] = static_cast<Type>(vec[1]-v[1]);
00734                         return *this;
00735                 }

template<typename Type>
template<typename Type2>
Vec2<Type>& EMAN::Vec2< Type >::operator/= ( const Type2 &  d  )  [inline]

'this' /= d; Divide a number on each item of 'this' vector.

Parameters:
d The number to divide.
Returns:
The new 'this' as a result of division.

Definition at line 764 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00764                                                         {
00765                         vec[0] = static_cast<Type>(vec[0]/d);
00766                         vec[1] = static_cast<Type>(vec[1]/d);
00767                         return *this;
00768                 }

template<typename Type>
Type& EMAN::Vec2< Type >::operator[] ( int  i  )  [inline]

Get the ith item of the vector.

Used in the left side of the assignment.

Parameters:
i The index of the item to get. Its validality is not checked.
Returns:
The ith item of the vector.

Definition at line 662 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00662 { return vec[i]; }

template<typename Type>
Type EMAN::Vec2< Type >::operator[] ( int  i  )  const [inline]

Get the ith item of the vector.

Used in the right side of the assignment.

Parameters:
i The index of the item to get. Its validality is not checked.
Returns:
The ith item of the vector.

Definition at line 653 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00653 { return vec[i]; }

template<typename Type>
void EMAN::Vec2< Type >::set_value ( const Type &  x,
const Type &  y 
) [inline]

Set new values to this vector object.

Parameters:
x Value of the first item.
y Value of the second item.

Definition at line 640 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00641                 {
00642                         vec[0] =  x;
00643                         vec[1] =  y;
00644                 }

template<typename Type>
template<typename Type2>
void EMAN::Vec2< Type >::set_value ( const vector< Type2 > &  v  )  [inline]

Set new values using a std::vector object.

Parameters:
v A std::vector object used to set 'this' vector's value. It should have at least 3 items.

Definition at line 620 of file vec3.h.

References EMAN::Vec2< Type >::vec.

Referenced by EMAN::Vec2< Type >::normalize().

00621                 {
00622                         vec[0] =  static_cast<Type>(v[0]);
00623                         vec[1] =  static_cast<Type>(v[1]);;
00624                 }

template<typename Type>
template<typename Type2>
void EMAN::Vec2< Type >::set_value_at ( int  index,
const Type2 &  value 
) [inline]

Set values at a particular index.

Parameters:
index The index to be set
value The value to be set

Definition at line 631 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00632                 {
00633                         vec[index] = static_cast<Type>(value);
00634                 }

template<typename Type>
Type EMAN::Vec2< Type >::squared_length (  )  const [inline]

Calculate its squared length.

no sqrt called

Returns:
The vector's length squared.

Definition at line 588 of file vec3.h.

References EMAN::Vec2< Type >::vec.

00589                 {
00590                         return  vec[0] * vec[0] + vec[1] * vec[1] ;
00591                 }


Member Data Documentation

template<typename Type>
Type EMAN::Vec2< Type >::vec[2] [private]

Definition at line 772 of file vec3.h.

Referenced by EMAN::Vec2< Type >::as_list(), EMAN::Vec2< Type >::at(), EMAN::Vec2< Type >::begin(), EMAN::Vec2< Type >::dot(), EMAN::Vec2< Type >::end(), EMAN::Vec2< Type >::length(), EMAN::Vec2< Type >::normalize(), EMAN::Vec2< Type >::operator *=(), EMAN::Vec2< Type >::operator+=(), EMAN::Vec2< Type >::operator-=(), EMAN::Vec2< Type >::operator/=(), EMAN::Vec2< Type >::operator[](), EMAN::Vec2< Type >::set_value(), EMAN::Vec2< Type >::set_value_at(), EMAN::Vec2< Type >::squared_length(), and EMAN::Vec2< Type >::Vec2().


The documentation for this class was generated from the following file:
Generated on Tue May 25 17:18:25 2010 for EMAN2 by  doxygen 1.4.7