Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

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 713 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 718 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 722 of file vec3.h.

00722                          : vec[0](0),vec[1](0),vec[2](0)*/ {
00723                         vec[0] = static_cast<Type>(0);
00724                         vec[1] = static_cast<Type>(0);
00725                 }

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 733 of file vec3.h.

00734                 {
00735                         vec[0] = static_cast<Type>(x);
00736                         vec[1] = static_cast<Type>(y);
00737                 }

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 744 of file vec3.h.

References v.

00745                 {
00746                         vec[0] = static_cast<Type>(v[0]);
00747                         vec[1] = static_cast<Type>(v[1]);
00748                 }

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

Copy constructor copies vector elements.

Definition at line 753 of file vec3.h.

References v.

00754                 {
00755                         vec[0] = static_cast<Type>(v[0]);
00756                         vec[1] = static_cast<Type>(v[1]);
00757                 }

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

Destructor.

Definition at line 761 of file vec3.h.

00761 {}


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 816 of file vec3.h.

References v.

00817                 {
00818                         vector < Type > v(2);
00819                         v[0] = vec[0];
00820                         v[1] = vec[1];
00821                         return v;
00822                 }

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 880 of file vec3.h.

00880 { 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 897 of file vec3.h.

00898                 {
00899                         return &vec[0];
00900                 }

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 808 of file vec3.h.

References v.

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

00809                 {
00810                         return static_cast<Type>((vec[0] * v[0] + vec[1] * v[1]));
00811                 }

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 907 of file vec3.h.

00908                 {
00909                         return &vec[2];
00910                 }

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

Calculate its length.

Returns:
The vector's length Warning - float precision

Definition at line 787 of file vec3.h.

References sqrt(), and t.

00788                 {
00789                         float t = (float)(vec[0] * vec[0] + vec[1] * vec[1]);
00790                         return (float)sqrt(t);
00791                 }

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 768 of file vec3.h.

References EMAN::length().

00769                 {
00770                 // Warning - float precision
00771                         float len = length();
00772                         if (len != 0) {
00773                                 vec[0] = static_cast<Type> (vec[0] / len);
00774                                 vec[1] = static_cast<Type> (vec[1] / len);
00775                         }
00776                         else {
00777                                 set_value(0, 0);
00778                         }
00779                         return len;
00780                 }

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 887 of file vec3.h.

00888                 {
00889                         return 2;
00890                 }

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 962 of file vec3.h.

00962                                                         {
00963                         vec[0] = static_cast<Type>(vec[0]*d);
00964                         vec[1] = static_cast<Type>(vec[1]*d);
00965                         return *this;
00966                 }

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 929 of file vec3.h.

00929                                                         {
00930                         vec[0] = static_cast<Type>(vec[0]+d);
00931                         vec[1] = static_cast<Type>(vec[1]+d);
00932                         return *this;
00933                 }

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 918 of file vec3.h.

References v.

00918                                                               {
00919                         vec[0] = static_cast<Type>(vec[0]+v[0]);
00920                         vec[1] = static_cast<Type>(vec[1]+v[1]);
00921                         return *this;
00922                 }

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 951 of file vec3.h.

00951                                                         {
00952                         vec[0] = static_cast<Type>(vec[0]-d);
00953                         vec[1] = static_cast<Type>(vec[1]-d);
00954                         return *this;
00955                 }

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 940 of file vec3.h.

References v.

00940                                                               {
00941                         vec[0] = static_cast<Type>(vec[0]-v[0]);
00942                         vec[1] = static_cast<Type>(vec[1]-v[1]);
00943                         return *this;
00944                 }

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 973 of file vec3.h.

00973                                                         {
00974                         vec[0] = static_cast<Type>(vec[0]/d);
00975                         vec[1] = static_cast<Type>(vec[1]/d);
00976                         return *this;
00977                 }

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 871 of file vec3.h.

00871 { 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 862 of file vec3.h.

00862 { 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 849 of file vec3.h.

00850                 {
00851                         vec[0] =  x;
00852                         vec[1] =  y;
00853                 }

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 829 of file vec3.h.

References v.

00830                 {
00831                         vec[0] =  static_cast<Type>(v[0]);
00832                         vec[1] =  static_cast<Type>(v[1]);;
00833                 }

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 840 of file vec3.h.

00841                 {
00842                         vec[index] = static_cast<Type>(value);
00843                 }

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 797 of file vec3.h.

00798                 {
00799                         return  vec[0] * vec[0] + vec[1] * vec[1] ;
00800                 }


Member Data Documentation

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

Definition at line 981 of file vec3.h.


The documentation for this class was generated from the following file:
Generated on Tue Jun 11 13:49:53 2013 for EMAN2 by  doxygen 1.3.9.1