reference

This documentation is automatically generated from the openFrameworks source code using doxygen and refers to the most recent release, version 0.12.0.

ofVec2f is a class for storing a two dimensional vector. More...

#include <ofVec2f.h>

Public Member Functions

 ofVec2f (const glm::vec2 &v)
 
 ofVec2f (const glm::vec3 &v)
 
 ofVec2f (const glm::vec4 &v)
 
 operator glm::vec2 () const
 
Construct a 2D vector
 ofVec2f ()
 Construct a 2D vector.
 
 ofVec2f (float scalar)
 Construct a 2D vector with x and y set to scalar
 
 ofVec2f (float x, float y)
 Construct a 2D vector with specific x and `y components.
 
 ofVec2f (const ofVec3f &vec)
 Create a 2D vector (ofVec2f) from a 3D vector (ofVec3f) by \throwing away the z component of the 3D vector.
 
 ofVec2f (const ofVec4f &vec)
 Create a 2D vector (ofVec2f) from a 4D vector (ofVec4f) by throwing away the z and w components of the 4D vector.
 
Access components
float * getPtr ()
 Returns a pointer to the memory position of the first element of the vector (x); the second element (y) immediately follows it in memory.
 
const float * getPtr () const
 
float & operator[] (int n)
 Allows to access the x and y components of an ofVec2f as though it is an array.
 
float operator[] (int n) const
 
void set (float x, float y)
 Set x and y components of this vector with just one function call.
 
void set (const ofVec2f &vec)
 Set the x and y components of this vector by copying the corresponding values from vec.
 
void set (float scalar)
 
Comparison
bool operator== (const ofVec2f &vec) const
 Check for equality between two ofVec2f.
 
bool operator!= (const ofVec2f &vec) const
 Check for inequality between two ofVec2f.
 
bool match (const ofVec2f &vec, float tolerance=0.0001f) const
 Returns true if each component is close enough to its corresponding component in vec, where what is close enough is determined by the value of tolerance:
 
bool isAligned (const ofVec2f &vec, float tolerance=0.0001f) const
 Determine if two vectors are aligned.
 
bool isAlignedRad (const ofVec2f &vec, float tolerance=0.0001f) const
 Determine if two vectors are aligned with tolerance in radians.
 
bool align (const ofVec2f &vec, float tolerance=0.0001f) const
 Determine if two vectors are aligned.
 
bool alignRad (const ofVec2f &vec, float tolerance=0.0001f) const
 Determine if two vectors are aligned with tolerance in radians.
 
Operators
ofVec2f operator+ (const ofVec2f &vec) const
 Super easy vector addition. Returns a new vector (x+vec.x,y+vec.y).
 
ofVec2f operator+ (const float f) const
 Returns a new vector with a float value f added to both x and y members.
 
ofVec2foperator+= (const ofVec2f &vec)
 Super easy addition assignment. Adds vec.x to x, and adds vec.y to y.
 
ofVec2foperator+= (const float f)
 Adds a float value f to both x and y members.
 
ofVec2f operator- (const ofVec2f &vec) const
 Super easy vector subtraction. Returns a new vector (x-vec.x,y-vec.y).
 
ofVec2f operator- (const float f) const
 Returns a new vector with a float value f subtracted from both x and y members.
 
ofVec2f operator- () const
 Returns a new ofVec2f that is the inverted version (mirrored in X and Y) of this vector.
 
ofVec2foperator-= (const ofVec2f &vec)
 Super easy subtraction assignment. Subtracts vec.x from x, and subtracts vec.y from y.
 
ofVec2foperator-= (const float f)
 Subtract a float value f from both x and y members.
 
ofVec2f operator* (const ofVec2f &vec) const
 Returns a new vector (x*vec.x , y*vec.y).
 
ofVec2f operator* (const float f) const
 Return a new ofVec2f that is this vector scaled by multiplying both x and y members by the float.
 
ofVec2foperator*= (const ofVec2f &vec)
 Multiplies x by vec.x, and multiplies y by vec.y.
 
ofVec2foperator*= (const float f)
 Scale this vector by multiplying both x and y members by f.
 
ofVec2f operator/ (const ofVec2f &vec) const
 Returns a new vector (x/vec.x,y/vec.y).
 
ofVec2f operator/ (const float f) const
 Return a new ofVec2f that is this vector scaled by dividing both x and y members by f.
 
ofVec2foperator/= (const ofVec2f &vec)
 Divides x by vec.x, and divides y by vec.y.
 
ofVec2foperator/= (const float f)
 Scale this vector by dividing both x and y members by f.
 
Simple manipulations
ofVec2f getScaled (const float length) const
 
ofVec2fscale (const float length)
 Scales this vector up or down so that it has the requested length.
 
ofVec2f getRotated (float angle) const
 Returns a new vector that is the result of rotating this vector by 'angle' degrees about the origin.
 
ofVec2f getRotated (float angle, const ofVec2f &pivot) const
 Returns a new vector that is the result of rotating this vector by 'angle' degrees about the point 'pivot'.
 
ofVec2f getRotatedRad (float angle) const
 Returns a new vector that is the result of rotating this vector by 'angle' radians about the origin.
 
ofVec2f getRotatedRad (float angle, const ofVec2f &pivot) const
 Returns a new vector that is the result of rotating this vector by 'angle' radians about the origin.
 
ofVec2frotate (float angle)
 Rotates this vector by 'angle' degrees about the origin.
 
ofVec2frotate (float angle, const ofVec2f &pivot)
 Rotates this vector by 'angle' degrees about the point 'pivot'.
 
ofVec2frotateRad (float angle)
 Rotates this vector by 'angle' radians about the origin.
 
ofVec2frotateRad (float angle, const ofVec2f &pivot)
 Rotates this vector by 'angle' radians about the point 'pivot'.
 
ofVec2f getMapped (const ofVec2f &origin, const ofVec2f &vx, const ofVec2f &vy) const
 Get vector mapped to new coordinate system.
 
ofVec2fmap (const ofVec2f &origin, const ofVec2f &vx, const ofVec2f &vy)
 Maps this vector from its default coordinate system – origin (0,0), X direction (1,0), Y direction (0,1) – to a new coordinate system defined with origin at origin, X direction vx, and Y direction vy.
 
Distance
float distance (const ofVec2f &pnt) const
 Distance between two points.
 
float squareDistance (const ofVec2f &pnt) const
 Distance between two points squared.
 
Interpolation
ofVec2f getInterpolated (const ofVec2f &pnt, float p) const
 Linear interpolation.
 
ofVec2finterpolate (const ofVec2f &pnt, float p)
 Linear interpolation.
 
ofVec2f getMiddle (const ofVec2f &pnt) const
 Calculate and return the midpoint between this vector and pnt.
 
ofVec2fmiddle (const ofVec2f &pnt)
 Set this vector to the midpoint between itself and pnt.
 
ofVec2faverage (const ofVec2f *points, std::size_t num)
 Average vector over an array of points.
 
Limit
ofVec2f getNormalized () const
 Returns a normalized copy of this vector.
 
ofVec2fnormalize ()
 Normalize the vector.
 
ofVec2f getLimited (float max) const
 Get vector limited by length.
 
ofVec2flimit (float max)
 Restrict the length (magnitude) of this vector to a maximum of max units by scaling down if necessary.
 
Measurement
float length () const
 Return the length (magnitude) of this vector.
 
float lengthSquared () const
 Return the squared length (squared magnitude) of this vector.
 
float angle (const ofVec2f &vec) const
 Calculate the angle to another vector in degrees.
 
float angleRad (const ofVec2f &vec) const
 Calculate the angle to another vector in radians.
 
Perpendicular
ofVec2f getPerpendicular () const
 Return the normalized ofVec2f that is perpendicular to this vector (ie rotated 90 degrees and normalized).
 
ofVec2fperpendicular ()
 Set this vector to its own normalized perpendicular (by rotating 90 degrees and normalizing).
 
float dot (const ofVec2f &vec) const
 Returns the dot product of this vector with 'vec'.
 

Public Attributes

float x
 Stores the x component of the vector.
 
float y
 Stores the y component of the vector.
 

Detailed Description

ofVec2f is a class for storing a two dimensional vector.

Moving through space requires knowledge of where things are and where they are going. Vector Maths is the class of mathematics that gives us control over these things in space, allowing for elegant and intuitive descriptions of complex structures and movement. Vectors are at the heart of animations, particle systems, and 2D and 3D graphics.

Vectors in mathematics in general are entities with magnitude (also called length) and direction. A vector whose magnitude is 1 (ie a vector that is normalized) is called a unit vector. Unit vectors are very handy for storing directions as they can be easily scaled up (or down) to represent motion in a particular direction with a particular length.

You will also see the term vector used to describe an array of objects in C++ (such as text strings). Don't let this confuse you, they are quite different: one of them is a mathematical term for a fixed-length list of numbers that you can do mathematical operations on, the other is a C++-specific term that means 'dynamically sizeable array'.

ofVec2f has two member variables, x and y, which allow to conveniently store 2D properties of an object such as its position, velocity, or acceleration.

ofVec2f v1; // v1.x is 0, v1.y is 0
v1.set( 10, 50 ); // now v1.x is 10, v1.y is 50
ofVec2f is a class for storing a two dimensional vector.
Definition ofVec2f.h:72
void set(float x, float y)
Set x and y components of this vector with just one function call.

Using ofVec2f greatly simplifies arithmetic operations in two dimensions. For example if you have two vectors v1 and v2, both of which represent a 2D change in position, you can find the total change of position of both of them just by doing an addition v1 + v2:

ofVec2f v1(5, 2); // v1 represents walking 5 steps forward then 2 steps sideways
v2.set(1, 1); // v2 represents walking 1 step forward then 1 step sideways
// what happens if you do v1 followed by v2? just add v1 and v2 together:
ofVec2f result = v1 + v2; // result is 6 steps forward then 3 steps sideways

You can scale an ofVec2f by multiplying it with a float:

ofVec2f v1(5, 2); // walk 5 steps forward and 2 steps right
// what happens if we do v1 three times?
ofVec2f result = v1 * 3; // result is 15 steps forward and 6 steps right

This also works for subtraction and division.

As you can see this really makes dealing with vectors as easy as dealing with single floats or ints, and can reduce the number of lines of code you have to write by half, at the same time making your code much easier to read and understand!

See also
ofVec3f for 3D vectors
ofVec4f for 4D vectors

Constructor & Destructor Documentation

◆ ofVec2f() [1/8]

ofVec2f::ofVec2f ( )

Construct a 2D vector.

ofVec2f v1; // default: v1.x is 0, v1.y is 0
ofVec2f v2 = ofVec2f(40, 20); // v2.x is 40, v2.y is 20
ofVec3f v3(0.1, 0.3); // v3.x is 0.1, v3.y is 0.3
ofVec2f()
Construct a 2D vector.
ofVec3f is a class for storing a three dimensional vector.
Definition ofVec3f.h:79

◆ ofVec2f() [2/8]

ofVec2f::ofVec2f ( float  scalar)
explicit

Construct a 2D vector with x and y set to scalar

◆ ofVec2f() [3/8]

ofVec2f::ofVec2f ( float  x,
float  y 
)

Construct a 2D vector with specific x and `y components.

ofVec2f v1; // default: v1.x is 0, v1.y is 0
ofVec2f v2 = ofVec2f(40, 20); // v2.x is 40, v2.y is 20
ofVec3f v3(0.1, 0.3); // v3.x is 0.1, v3.y is 0.3
Parameters
xThe x component
yThe y component

◆ ofVec2f() [4/8]

ofVec2f::ofVec2f ( const ofVec3f vec)

Create a 2D vector (ofVec2f) from a 3D vector (ofVec3f) by \throwing away the z component of the 3D vector.

ofVec3f mom3d(40, 20, 50); // 3d vector
ofVec2f v(mom3d); // v.x is 40, v.y is 20

◆ ofVec2f() [5/8]

ofVec2f::ofVec2f ( const ofVec4f vec)

Create a 2D vector (ofVec2f) from a 4D vector (ofVec4f) by throwing away the z and w components of the 4D vector.

ofVec4f mom4d(40, 20, 50, 80); // 4d vector
ofVec2f v(mom4d); // v.x is 40, v.y is 20
Definition ofVec4f.h:11

◆ ofVec2f() [6/8]

ofVec2f::ofVec2f ( const glm::vec2 &  v)

◆ ofVec2f() [7/8]

ofVec2f::ofVec2f ( const glm::vec3 &  v)

◆ ofVec2f() [8/8]

ofVec2f::ofVec2f ( const glm::vec4 &  v)

Member Function Documentation

◆ align()

bool ofVec2f::align ( const ofVec2f vec,
float  tolerance = 0.0001f 
) const

Determine if two vectors are aligned.

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(4, 2);
v1.align(v2) // returns true
bool align(const ofVec2f &vec, float tolerance=0.0001f) const
Determine if two vectors are aligned.
Parameters
vecThe vector to compare alignment with
tolerancean angle tolerance/threshold (specified in degrees) for deciding if the vectors are sufficiently aligned.
Returns
true if both vectors are aligned (pointing in the same direction).

◆ alignRad()

bool ofVec2f::alignRad ( const ofVec2f vec,
float  tolerance = 0.0001f 
) const

Determine if two vectors are aligned with tolerance in radians.

Parameters
vecThe vector to compare alignment with
tolerancean angle tolerance/threshold (specified in radians) for deciding if the vectors are sufficiently aligned.
See also
align()

◆ angle()

float ofVec2f::angle ( const ofVec2f vec) const

Calculate the angle to another vector in degrees.

ofVec2f v1(1,0);
ofVec2f v2(0,1);
float angle = v1.angle(v2); // angle is 90
float angle(const ofVec2f &vec) const
Calculate the angle to another vector in degrees.
Parameters
vecThe vector to calculate the angle to
Returns
The angle in degrees (-180...180)

◆ angleRad()

float ofVec2f::angleRad ( const ofVec2f vec) const

Calculate the angle to another vector in radians.

ofVec2f v1(1,0);
ofVec2f v2(0,1);
float angle = v1.angleRad(v2); // angle is HALF_PI
Parameters
vecThe vector to calculate the angle to
Returns
The angle in radians (-PI...PI)

◆ average()

ofVec2f & ofVec2f::average ( const ofVec2f points,
std::size_t  num 
)

Average vector over an array of points.

Sets this vector to be the average (centre of gravity or centroid) of a given array of ofVec2f.

int numPoints = 10;
ofVec2f points[numPoints];
for ( int i=0; i<numPoints; i++ ) {
points[i].set( ofRandom(0,100), ofRandom(0,100) );
}
ofVec2f centroid;
centroid.average( points, numPoints );
// centroid now is the centre of gravity/average of all the random points
ofVec2f & average(const ofVec2f *points, std::size_t num)
Average vector over an array of points.
float ofRandom(float max)
Get a random floating point number between 0 and max.
Definition ofMath.cpp:47
Parameters
pointsThe array of ofVec2f to avarage over
numspecifies the number of ofVec2f in the array.
Returns
Vector that is the avarage of the points in the array

◆ distance()

float ofVec2f::distance ( const ofVec2f pnt) const

Distance between two points.

Treats both this vector and pnt as points in 2D space, and calculates and returns the distance between them.

ofVec2f p1( 3, 4 );
ofVec2f p2( 6, 8 );
float distance = p1.distance( p2 ); // distance is 5
float distance(const ofVec2f &pnt) const
Distance between two points.

Distance involves a square root calculation, which is one of the slowest things you can do in programming. If you don't need an exact number but rather just a rough idea of distance (for example when finding the shortest distance of a bunch of points to a reference point, where it doesn't matter exactly what the distances are, you just want the shortest), you can use squareDistance() instead.

Parameters
pntThe point to calculate the distance to
Returns
The distance as float
See also
squareDistance()

◆ dot()

float ofVec2f::dot ( const ofVec2f vec) const

Returns the dot product of this vector with 'vec'.

The dot product of two vectors, also known as the scalar product, is the product of the magnitude of the two vectors and the cosine of the angle between them.

One interpretation of the dot product is as a measure of how closely two vectors align with each other. If they point in exactly the same direction, their dot product will simply be the product of their magnitudes, if they are perpendicular, their dot product will be 0, and if they point in opposite directions, their dot product will be negative.

The dot product is in contrast to the cross product, which returns a vector rather than a scalar.

ofVec2f a1(2, 0); // magnitude 2, parallel to x-axis
ofVec2f b1(3, 4); // magnitude 5, 53.13 degree angle to a1
float dot = a1.dot(b1); // dot is 2 * 5 * cos(53.13) = 6.0
ofVec2f a2(1, 0); // magnitude 1, parallel to x-axis
ofVec2f b2(0, 1); // magnitude 1, 90 degree angle to a2
dot = a2.dot(b2); // dot is 1 * 1 * cos(90) = 0.0
ofVec2f a3(0, 1); // magnitude 1, parallel to y-axis
ofVec2f b3(0, -1); // magnitude 1, 180 degree angle to a3
dot = a3.dot(b3); // dot is 1 * 1 * cos(180) = -1.0
float dot(const ofVec2f &vec) const
Returns the dot product of this vector with 'vec'.

◆ getInterpolated()

ofVec2f ofVec2f::getInterpolated ( const ofVec2f pnt,
float  p 
) const

Linear interpolation.

Perform a linear interpolation of this vector's position towards pnt and return the interpolated position without altering the original vector.

p is normally between 0 and 1 and where 0 means stay the original position and 1 means move all the way to pnt, but you can also have p greater than 1 overshoot pnt, or less than 0 to move backwards away from pnt.

ofVec2f v1( 0, 5 );
ofVec2f v2( 10, 10 );
ofVec3f v3 = v1.getInterpolated( v2, 0.5 ); // v3 is (5, 7.5)
ofVec3f v4 = v1.getInterpolated( v2, 0.8 ); // v4 is (8, 9)
ofVec3f getInterpolated(const ofVec3f &pnt, float p) const
Perform a linear interpolation of this vector's position towards 'pnt' and return the interpolated ve...
Parameters
pntThe point to move towards
pThe amount to move towards pnt
See also
interpolate()

◆ getLimited()

ofVec2f ofVec2f::getLimited ( float  max) const

Get vector limited by length.

ofVec2f v1(5, 1); // length is about 5.1
ofVec2f v2(2, 1); // length is about 2.2
ofVec2f v1Limited = v1.getLimited(3);
// v1Limited is (2.9417, 0.58835) which has length of 3 in the same direction as v1
ofVec2f v2Limited = v2.getLimited(3);
// v2Limited is (2, 1) (same as v2)
ofVec2f getLimited(float max) const
Get vector limited by length.
See also
limit()
Parameters
maxThe maximum length of the vector to return
Returns
A copy of this vector with its length (magnitude) restricted to a maximum of max units by scaling down if necessary.

◆ getMapped()

ofVec2f ofVec2f::getMapped ( const ofVec2f origin,
const ofVec2f vx,
const ofVec2f vy 
) const

Get vector mapped to new coordinate system.

In most cases you want vx and vy to be perpendicular and of unit length; if they are not perpendicular you will have shearing as part of the mapping, and if they are not of unit length you will have scaling as part of the mapping.

Returns
A new ofVec2f calculated by copying this vector and then mapping from its default coordinate system – origin (0,0), X direction (1,0), Y direction (0,1) – to a new coordinate system defined with origin at origin, X direction vx, and Y direction vy.

◆ getMiddle()

ofVec2f ofVec2f::getMiddle ( const ofVec2f pnt) const

Calculate and return the midpoint between this vector and pnt.

ofVec2f v1(5, 0);
ofVec2f v2(10, 10);
ofVec3f mid = v1.getMiddle(v2); // mid gets (7.5, 5)
ofVec3f getMiddle(const ofVec3f &pnt) const
Calculate and return the midpoint between this vector and 'pnt'.
Parameters
pntThe vector to find the middle to
Returns
The middle between this vector and pnt
See also
middle()

◆ getNormalized()

ofVec2f ofVec2f::getNormalized ( ) const

Returns a normalized copy of this vector.

Normalization means to scale the vector so that its length (magnitude) is exactly 1, at which stage all that is left is the direction. A normalized vector is usually called a unit vector, and can be used to represent a pure direction (heading).

ofVec2f v1(5, 0);
ofVec2f v1Normalized = v1.getNormalized(); // (1, 0)
ofVec2f v2(5, 5);
ofVec2f v2Normalized = v2.getNormalized(); // (√2, √2)
ofVec2f getNormalized() const
Returns a normalized copy of this vector.

◆ getPerpendicular()

ofVec2f ofVec2f::getPerpendicular ( ) const

Return the normalized ofVec2f that is perpendicular to this vector (ie rotated 90 degrees and normalized).

PERPENDICULAR Image courtesy of Wikipedia

ofVec2f v(2, 5);
ofVec2f u = v.getPerpendicular(); // u is (0.928, -0.371)
ofVec2f getPerpendicular() const
Return the normalized ofVec2f that is perpendicular to this vector (ie rotated 90 degrees and normali...
See also
perpendicular()

◆ getPtr() [1/2]

float * ofVec2f::getPtr ( )
inline

Returns a pointer to the memory position of the first element of the vector (x); the second element (y) immediately follows it in memory.

ofVec2f v1 = ofVec2f(40, 20);
float * v1Ptr = v1.getPtr();
float x = *(v1Ptr); // x is 40
float y = *(v1Ptr+1); // y is 20
float y
Stores the y component of the vector.
Definition ofVec2f.h:82
float x
Stores the x component of the vector.
Definition ofVec2f.h:79
float * getPtr()
Returns a pointer to the memory position of the first element of the vector (x); the second element (...
Definition ofVec2f.h:159

This is very useful when using arrays of ofVec2fs to store geometry information, as it allows the vector to be treated as a simple C array of floats that can be passed verbatim to OpenGL.

◆ getPtr() [2/2]

const float * ofVec2f::getPtr ( ) const
inline

◆ getRotated() [1/2]

ofVec2f ofVec2f::getRotated ( float  angle) const

Returns a new vector that is the result of rotating this vector by 'angle' degrees about the origin.

ofVec2f v1(1, 0);
ofVec2f v2 = v1.getRotated(45); // v2 is (0.707, 0.707)
ofVec2f getRotated(float angle) const
Returns a new vector that is the result of rotating this vector by 'angle' degrees about the origin.
See also
getRotatedRad()
rotate()

◆ getRotated() [2/2]

ofVec2f ofVec2f::getRotated ( float  angle,
const ofVec2f pivot 
) const

Returns a new vector that is the result of rotating this vector by 'angle' degrees about the point 'pivot'.

◆ getRotatedRad() [1/2]

ofVec2f ofVec2f::getRotatedRad ( float  angle) const

Returns a new vector that is the result of rotating this vector by 'angle' radians about the origin.

ofVec2f v1(1, 0);
ofVec2f v2 = v1.getRotatedRad(PI / 4); // v2 is (0.707, 0.707)
ofVec2f getRotatedRad(float angle) const
Returns a new vector that is the result of rotating this vector by 'angle' radians about the origin.
#define PI
Definition ofMathConstants.h:21

◆ getRotatedRad() [2/2]

ofVec2f ofVec2f::getRotatedRad ( float  angle,
const ofVec2f pivot 
) const

Returns a new vector that is the result of rotating this vector by 'angle' radians about the origin.

◆ getScaled()

ofVec2f ofVec2f::getScaled ( const float  length) const

Return a new ofVec2f that is the result of scaling this vector up or down so that it has the requested length.

ofVec2f v1( 3, 4 ); // length is 5
ofVec2f v2 = v1.getScaled( 15 ); // ( 9, 12 ), length is now 15
ofVec2f getScaled(const float length) const

ofVec2f

See also
scale()

◆ interpolate()

ofVec2f & ofVec2f::interpolate ( const ofVec2f pnt,
float  p 
)

Linear interpolation.

Perform a linear interpolation of this vector's position towards pnt. p controls the amount to move towards pnt. p is normally between 0 and 1 and where 0 means stay the original position and 1 means move all the way to pnt, but you can also have p greater than 1 overshoot pnt, or less than 0 to move backwards away from pnt.

ofVec2f v1( 0, 5 );
ofVec2f v2( 10, 10 );
// go go gadget zeno
v1.interpolate( v2, 0.5 ); // v1 is now (5, 7.5)
v1.interpolate( v2, 0.5 ); // v1 is now (7.5, 8.75)
v1.interpolate( v2, 0.5 ); // v1 is now (8.75, 9.375)
v1.interpolate( v2, 0.5 ); // v1 is now (9.375, 9.6875)
See also
getInterpolated()

◆ isAligned()

bool ofVec2f::isAligned ( const ofVec2f vec,
float  tolerance = 0.0001f 
) const

Determine if two vectors are aligned.

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(4, 2);
v1.isAligned(v2) // returns true
bool isAligned(const ofVec2f &vec, float tolerance=0.0001f) const
Determine if two vectors are aligned.
Parameters
vecThe vector to compare alignment with
tolerancean angle tolerance/threshold (specified in degrees) for deciding if the vectors are sufficiently aligned.
Returns
true if both vectors are aligned (pointing in the same direction).

◆ isAlignedRad()

bool ofVec2f::isAlignedRad ( const ofVec2f vec,
float  tolerance = 0.0001f 
) const

Determine if two vectors are aligned with tolerance in radians.

Parameters
vecThe vector to compare alignment with
tolerancean angle tolerance/threshold (specified in radians) for deciding if the vectors are sufficiently aligned.
See also
isAligned()

◆ length()

float ofVec2f::length ( ) const

Return the length (magnitude) of this vector.

ofVec2f v(3, 4);
float len = v.length(); // len is 5 (3,4,5 triangle)

length() involves a square root calculation, which is one of the slowest things you can do in programming. If you don't need an exact number but rather just a rough idea of a length (for example when finding the shortest distance of a bunch of points to a reference point, where it doesn't matter exactly what the lengths are, you just want the shortest), you can use lengthSquared() instead.

See also
lengthSquared()

◆ lengthSquared()

float ofVec2f::lengthSquared ( ) const

Return the squared length (squared magnitude) of this vector.

ofVec2f v(3, 4);
float len = v.length(); // len is 5 (3,4,5 triangle)

Use as a much faster alternative to length() if you don't need to know an accurate length but rather just a rough idea of a length (for example when finding the shortest distance of a bunch of points to a reference point, where it doesn't matter exactly what the lengths are, you just want the shortest). It avoids the square root calculation that is ordinarily required to calculate a length.

See also
length()

◆ limit()

ofVec2f & ofVec2f::limit ( float  max)

Restrict the length (magnitude) of this vector to a maximum of max units by scaling down if necessary.

ofVec2f v1(5, 1); // length is about 5.1
ofVec2f v2(2, 1); // length is about 2.2
v1.limit(3);
// v1 is now (2.9417, 0.58835) which has length of 3 in the same direction as at initialization
v2.limit(3);
// v2 is unchanged
See also
limit()

◆ map()

ofVec2f & ofVec2f::map ( const ofVec2f origin,
const ofVec2f vx,
const ofVec2f vy 
)

Maps this vector from its default coordinate system – origin (0,0), X direction (1,0), Y direction (0,1) – to a new coordinate system defined with origin at origin, X direction vx, and Y direction vy.

In most case you want vx and vy to be perpendicular and of unit length; if they are not perpendicular you will have shearing as part of the mapping, and if they are not of unit length you will have scaling as part of the mapping.

See also
perpendicular()

◆ match()

bool ofVec2f::match ( const ofVec2f vec,
float  tolerance = 0.0001f 
) const

Returns true if each component is close enough to its corresponding component in vec, where what is close enough is determined by the value of tolerance:

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(40.01, 19.999);
// v1.match(v2, 0.1) returns true
// v1.match(v2, 0.001) returns false

This is handy if, for example, you want to find out when a point becomes close enough to another point to trigger an event.

◆ middle()

ofVec2f & ofVec2f::middle ( const ofVec2f pnt)

Set this vector to the midpoint between itself and pnt.

ofVec2f v1( 0, 5 );
ofVec2f v2( 10, 10 );
v1.middle( v2 ); // v1 is now (5, 7.5)
v1.middle( v2 ); // v1 is now (7.5, 8.75)
v1.middle( v2 ); // v1 is now (8.75, 9.375)
v1.middle( v2 ); // v1 is now (9.375, 9.6875)
See also
getMiddle()

◆ normalize()

ofVec2f & ofVec2f::normalize ( )

Normalize the vector.

Normalizing means to scale the vector so that its length (magnitude) is exactly 1, at which stage all that is left is the direction. A normalized vector is usually called a unit vector, and can be used to represent a pure direction (heading).

ofVec2f v1(5, 0);
v1.normalize(); // v2 is now (1, 0)
ofVec2f v2(5, 5);
v2.normalize(); // v2 is now (√2, √2)
See also
getNormalized()

◆ operator glm::vec2()

ofVec2f::operator glm::vec2 ( ) const

◆ operator!=()

bool ofVec2f::operator!= ( const ofVec2f vec) const

Check for inequality between two ofVec2f.

ofVec2f v1(40, 20);
ofVec2f v2(50, 30);
ofVec2f v3(40, 20);
// ( v1 != v2 ) is true
// ( v1 != v3 ) is false
Returns
true if any component is different to its corresponding component in vec, ie if 'x != vec.x' or 'y != vec.y', otherwise returns false.

◆ operator*() [1/2]

ofVec2f ofVec2f::operator* ( const float  f) const

Return a new ofVec2f that is this vector scaled by multiplying both x and y members by the float.

ofVec2f v1(2, 5);
ofVec2f v2 = v1 * 4; // (8, 20)

◆ operator*() [2/2]

ofVec2f ofVec2f::operator* ( const ofVec2f vec) const

Returns a new vector (x*vec.x , y*vec.y).

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(2, 4);
ofVec2f v3 = v1 * v2; // (80, 80)

Useful for scaling a 2D point by a non-uniform scale.

◆ operator*=() [1/2]

ofVec2f & ofVec2f::operator*= ( const float  f)

Scale this vector by multiplying both x and y members by f.

ofVec2f v1(2, 5);
v1 *= 4; // (8, 20)

◆ operator*=() [2/2]

ofVec2f & ofVec2f::operator*= ( const ofVec2f vec)

Multiplies x by vec.x, and multiplies y by vec.y.

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(2, 4);
v1 *= v2; // v1 is now (80, 80)

Useful for scaling a 2D point by a non-uniform scale.

◆ operator+() [1/2]

ofVec2f ofVec2f::operator+ ( const float  f) const

Returns a new vector with a float value f added to both x and y members.

ofVec2f v1(2, 5);
ofVec2f v2 = v1 + 10; // (12, 15)

◆ operator+() [2/2]

ofVec2f ofVec2f::operator+ ( const ofVec2f vec) const

Super easy vector addition. Returns a new vector (x+vec.x,y+vec.y).

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(25, 50);
ofVec3f v3 = v1 + v2; // v3 is (65, 70)

◆ operator+=() [1/2]

ofVec2f & ofVec2f::operator+= ( const float  f)

Adds a float value f to both x and y members.

ofVec2f v1(2, 5);
v1 += 10; // (12, 15)

◆ operator+=() [2/2]

ofVec2f & ofVec2f::operator+= ( const ofVec2f vec)

Super easy addition assignment. Adds vec.x to x, and adds vec.y to y.

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(25, 50);
v1 += v2; // v1 is (65, 70)

◆ operator-() [1/3]

ofVec2f ofVec2f::operator- ( ) const

Returns a new ofVec2f that is the inverted version (mirrored in X and Y) of this vector.

ofVec2f v1(2, 5);
ofVec2f v2 = -v1; // (-2, -5)

◆ operator-() [2/3]

ofVec2f ofVec2f::operator- ( const float  f) const

Returns a new vector with a float value f subtracted from both x and y members.

ofVec2f v1(2, 5);
ofVec2f v2 = v1 - 10; // (-8, -5)

◆ operator-() [3/3]

ofVec2f ofVec2f::operator- ( const ofVec2f vec) const

Super easy vector subtraction. Returns a new vector (x-vec.x,y-vec.y).

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(25, 50);
ofVec3f v3 = v1 - v2; // v3 is (15, -30)

◆ operator-=() [1/2]

ofVec2f & ofVec2f::operator-= ( const float  f)

Subtract a float value f from both x and y members.

ofVec2f v1(2, 5);
v1 -= 10; // (-8, -5)

◆ operator-=() [2/2]

ofVec2f & ofVec2f::operator-= ( const ofVec2f vec)

Super easy subtraction assignment. Subtracts vec.x from x, and subtracts vec.y from y.

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(25, 50);
v1 -= v2; // v1 is (15, -30)

◆ operator/() [1/2]

ofVec2f ofVec2f::operator/ ( const float  f) const

Return a new ofVec2f that is this vector scaled by dividing both x and y members by f.

ofVec2f v1(2, 5);
ofVec2f v2 = v1 / 4; // (0.5, 1.25)

◆ operator/() [2/2]

ofVec2f ofVec2f::operator/ ( const ofVec2f vec) const

Returns a new vector (x/vec.x,y/vec.y).

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(2, 4);
ofVec3f v3 = v1 / v2; // (20, 5)

Useful for scaling a 2D point by a non-uniform scale.

◆ operator/=() [1/2]

ofVec2f & ofVec2f::operator/= ( const float  f)

Scale this vector by dividing both x and y members by f.

ofVec2f v1(2, 5);
v1 /= 4; // (0.5, 1.25)

◆ operator/=() [2/2]

ofVec2f & ofVec2f::operator/= ( const ofVec2f vec)

Divides x by vec.x, and divides y by vec.y.

ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(2, 4);
v1 *= v2; // v1 is now (20, 5)

Useful for scaling a 2D point by a non-uniform scale.

◆ operator==()

bool ofVec2f::operator== ( const ofVec2f vec) const

Check for equality between two ofVec2f.

ofVec2f v1(40, 20);
ofVec2f v2(50, 30);
ofVec2f v3(40, 20);
// ( v1 == v2 ) is false
// ( v1 == v3 ) is true
Returns
true if each component is the same as the corresponding component in vec, ie if x == vec.x and y == vec.y; otherwise returns false.

◆ operator[]() [1/2]

float & ofVec2f::operator[] ( int  n)
inline

Allows to access the x and y components of an ofVec2f as though it is an array.

ofVec2f v1 = ofVec2f(40, 20);
float x = v1[0]; // x is 40
float y = v1[1]; // y is 20

This function can be handy if you want to do the same operation to both x and y components, as it means you can just make a for loop that repeats twice.

◆ operator[]() [2/2]

float ofVec2f::operator[] ( int  n) const
inline

◆ perpendicular()

ofVec2f & ofVec2f::perpendicular ( )

Set this vector to its own normalized perpendicular (by rotating 90 degrees and normalizing).

PERPENDICULAR Image courtesy of Wikipedia

ofVec2f v(2, 5);
v.perpendicular(); // v is (0.928, -0.371)
See also
getPerpendicular()

◆ rotate() [1/2]

ofVec2f & ofVec2f::rotate ( float  angle)

Rotates this vector by 'angle' degrees about the origin.

ofVec2f v1(1, 0);
v1.rotate(45); // v1 is now (0.707, 0.707)
See also
getRotated()

◆ rotate() [2/2]

ofVec2f & ofVec2f::rotate ( float  angle,
const ofVec2f pivot 
)

Rotates this vector by 'angle' degrees about the point 'pivot'.

◆ rotateRad() [1/2]

ofVec2f & ofVec2f::rotateRad ( float  angle)

Rotates this vector by 'angle' radians about the origin.

ofVec2f v1(1, 0);
v1.rotateRad(PI / 4); // v1 is now (0.707, 0.707)
See also
getRotatedRad()

◆ rotateRad() [2/2]

ofVec2f & ofVec2f::rotateRad ( float  angle,
const ofVec2f pivot 
)

Rotates this vector by 'angle' radians about the point 'pivot'.

◆ scale()

ofVec2f & ofVec2f::scale ( const float  length)

Scales this vector up or down so that it has the requested length.

ofVec2f v1( 3, 4 ); // length is 5
v1.scale( 15 ); // v1 is now (9, 12), with length 15
See also
getScaled()

◆ set() [1/3]

void ofVec2f::set ( const ofVec2f vec)

Set the x and y components of this vector by copying the corresponding values from vec.

ofVec2f v1(40, 20);
v2.set(v1); // v2.x is 40, v2.y is 20

◆ set() [2/3]

void ofVec2f::set ( float  scalar)

◆ set() [3/3]

void ofVec2f::set ( float  x,
float  y 
)

Set x and y components of this vector with just one function call.

~~~~{.cpp} ofVec2f v1;//#include "ofConstants.h" */ //#include "glm/fwd.hpp" /** v1.set(40, 20); ~~~~

◆ squareDistance()

float ofVec2f::squareDistance ( const ofVec2f pnt) const

Distance between two points squared.

Treats both this vector and pnt as points in 2D space, and calculates and returns the squared distance between them.

ofVec2f p1( 3, 4 );
ofVec2f p2( 6, 8 );
float distance = p1.distance( p2 ); // distance is 5

Use as a much faster alternative to distance if you don't need to know an exact number but rather just a rough idea of distance (for example when finding the shortest distance of a bunch of points to a reference point, where it doesn't matter exactly what the distances are, you just want the shortest). It avoids the square root calculation that is ordinarily required to calculate a length.

Returns
The distance squared as float
See also
distance()

Member Data Documentation

◆ x

float ofVec2f::x

Stores the x component of the vector.

◆ y

float ofVec2f::y

Stores the y component of the vector.


The documentation for this class was generated from the following files:
  • /Users/icq4ever/Desktop/oF0120/libs/openFrameworks/math/ofVec2f.h
  • /Users/icq4ever/Desktop/oF0120/libs/openFrameworks/math/ofVec2f.cpp
  • /Users/icq4ever/Desktop/oF0120/libs/openFrameworks/math/ofVec4f.cpp