class methods

- ofVec2f()
- align()
- alignRad()
- angle()
- angleRad()
- average()
- distance()
- dot()
- getInterpolated()
- getLimited()
- getMiddle()
- getNormalized()
- getPerpendicular()
- getPtr()
- getRotated()
- getRotatedRad()
- getScaled()
- interpolate()
- isAligned()
- isAlignedRad()
- length()
- limit()
- map()
- match()
- middle()
- normalize()
- one()
- operator!=()
- operator*()
- operator*=()
- operator+()
- operator+=()
- operator-()
- operator-=()
- operator/()
- operator/=()
- operator==()
- operator[]()
- perpendicular()
- rotate()
- rotateRad()
- scale()
- set()
- squareDistance()
- zero()

variables

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
```

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
ofVec2f v2;
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!

# ofVec2f()

## ofVec2f::ofVec2f()

# ofVec2f(...)

## ofVec2f::ofVec2f(const ofVec3f &vec)

# ofVec2f(...)

## ofVec2f::ofVec2f(const ofVec4f &vec)

# ofVec2f(...)

## ofVec2f::ofVec2f(float scalar)

*Documentation from code comments*

*Documentation from code comments*

Construct a 2D vector with `x`

and `y`

set to `scalar`

# ofVec2f(...)

## ofVec2f::ofVec2f(float x, float y)

# align(...)

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

Returns true if both vectors are aligned (pointing in the same direction). tolerance is an angle tolerance/threshold (specified in degrees) for deciding if the vectors are sufficiently aligned.

```
ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(4, 2);
// v1.align(v2) returns true
```

*Documentation from code comments*

*Documentation from code comments*

Determine if two vectors are aligned

```
ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(4, 2);
v1.align(v2) // returns true
```

**Parameters:**

vec The vector to compare alignment with

tolerance an 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)

Just like align but the angle tolerance is specified in radians rather than degrees.

*Documentation from code comments*

*Documentation from code comments*

Determine if two vectors are aligned with tolerance in radians

**Parameters:**

vec The vector to compare alignment with

tolerance an angle tolerance/threshold (specified in radians) for deciding if the vectors are sufficiently aligned.

**See also**: align()

# angle(...)

## float ofVec2f::angle(const ofVec2f &vec)

# angleRad(...)

## float ofVec2f::angleRad(const ofVec2f &vec)

# average(...)

## ofVec2f & ofVec2f::average(const ofVec2f *points, size_t num)

Sets this vector to be the average (*centre of gravity* or *centroid*) of a given array of ofVec2fs. points is the array of ofVec2fs and num specifies the number of ofVec2fs in the array.

```
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
```

*Documentation from code comments*

*Documentation from code comments*

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
```

**Parameters:**

points The array of ofVec2f to avarage over

num specifies 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)

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
```

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.

# dot(...)

## float ofVec2f::dot(const ofVec2f &vec)

Calculate and return the dot product of this vector with vec.

*Dot product* (less commonly known as *Euclidean inner product*) expresses the angular relationship between two vectors. In other words it is a measure of how *parallel* two vectors are. If they are completely perpendicular the dot product is 0; if they are completely parallel their dot product is either 1 if they are pointing in the same direction, or -1 if they are pointing in opposite directions.

Image courtesy of Wikipedia

```
ofvec2f a1(1, 0);
ofVec2f b1(0, 1); // 90 degree angle to a1
dot = a1.dot(b1); // dot is 0, ie cos(90)
ofVec2f a2(1, 0);
ofVec2f b2(1, 1); // 45 degree angle to a2
b2.normalize(); // vectors should to be unit vectors (normalized)
float dot = a2.dot(b2); // dot is 0.707, ie cos(45)
ofVec2f a3(1, 0);
ofVec2f b3(-1, 0); // 180 degree angle to a3
dot = a3.dot(b3); // dot is -1, ie cos(180)
```

*Documentation from code comments*

*Documentation from code comments*

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
```

# getInterpolated(...)

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

Perform a linear interpolation of this vector's position towards pnt and return the interpolated position without altering the original vector. 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 );
ofVec3f v3 = v1.getInterpolated( v2, 0.5 ); // v3 is (5, 7.5)
ofVec3f v4 = v1.getInterpolated( v2, 0.8 ); // v4 is (8, 9)
```

# getLimited(...)

## ofVec2f ofVec2f::getLimited(float max)

Return a copy of this vector with its length (magnitude) restricted 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
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)
```

*Documentation from code comments*

*Documentation from code comments*

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)
```

**See also**: limit()

**Parameters:**

max The 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.

# getMiddle(...)

## ofVec2f ofVec2f::getMiddle(const ofVec2f &pnt)

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)
```

*Documentation from code comments*

*Documentation from code comments*

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)
```

**Parameters:**

pnt The vector to find the middle to

**Returns**: The middle between this vector and `pnt`

**See also**: middle()

# getNormalized()

## ofVec2f ofVec2f::getNormalized()

Return 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)
```

# getPerpendicular()

## ofVec2f ofVec2f::getPerpendicular()

# getPtr()

## float * ofVec2f::getPtr()

*Documentation from code comments*

*Documentation from code comments*

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
```

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.

# getRotated(...)

## ofVec2f ofVec2f::getRotated(float angle)

# getRotated(...)

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

Like getRotated but rotates around pivot rather than around the origin.

*Documentation from code comments*

*Documentation from code comments*

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

# getRotatedRad(...)

## ofVec2f ofVec2f::getRotatedRad(float angle)

# getRotatedRad(...)

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

Like getRotatedRad but rotates around pivot rather than around the origin.

*Documentation from code comments*

*Documentation from code comments*

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)

# interpolate(...)

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

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)
```

# isAligned(...)

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

*Documentation from code comments*

*Documentation from code comments*

Determine if two vectors are aligned

```
ofVec2f v1 = ofVec2f(40, 20);
ofVec2f v2 = ofVec2f(4, 2);
v1.isAligned(v2) // returns true
```

**Parameters:**

vec The vector to compare alignment with

tolerance an 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)

*Documentation from code comments*

*Documentation from code comments*

Determine if two vectors are aligned with tolerance in radians

**Parameters:**

vec The vector to compare alignment with

tolerance an angle tolerance/threshold (specified in radians) for deciding if the vectors are sufficiently aligned.

**See also**: isAligned()

# length()

## float ofVec2f::length()

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 squareLength instead.

# 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
```

# 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.*

# match(...)

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

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)

# 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(); // v1 is now (1, 0)
ofVec2f v2(5, 5);
v2.normalize(); // v2 is now (√2, √2)
```

# operator!=(...)

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

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.

```
ofVec2f v1(40, 20);
ofVec2f v2(50, 30);
ofVec2f v3(40, 20);
// ( v1 != v2 ) is true
// ( v1 != v3 ) is false
```

*Documentation from code comments*

*Documentation from code comments*

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*(...)

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

# operator*=(...)

## 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+(...)

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

# operator+(...)

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

# operator+=(...)

## 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+=(...)

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

# operator-()

## ofVec2f ofVec2f::operator-()

# operator-(...)

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

# operator-(...)

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

# operator-=(...)

## 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-=(...)

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

# operator/(...)

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

# operator/=(...)

## 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==(...)

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

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.

```
ofVec2f v1(40, 20);
ofVec2f v2(50, 30);
ofVec2f v3(40, 20);
// ( v1 == v2 ) is false
// ( v1 == v3 ) is true
```

*Documentation from code comments*

*Documentation from code comments*

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[](...)

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

*Documentation from code comments*

*Documentation from code comments*

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.

# perpendicular()

## ofVec2f & ofVec2f::perpendicular()

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

Image courtesy of Wikipedia

```
ofVec2f v(2, 5);
v.perpendicular(); // v is (0.928, -0.371)
```

# rotate(...)

## ofVec2f & ofVec2f::rotate(float angle)

Rotate this vector by angle degrees around the origin.

```
ofVec2f v1(1, 0);
v1.rotate( 45 ); // (√2, √2)
v1.rotate( 45 ); // (0, 1)
```

# rotate(...)

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

Like rotate but rotates around pivot rather than around the origin.

*Documentation from code comments*

*Documentation from code comments*

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

# rotateRad(...)

## ofVec2f & ofVec2f::rotateRad(float angle)

Rotate this vector by angle radians around the origin.

```
ofVec2f v1(1, 0);
v1.rotate( PI/4 ); // (√2, √2)
v1.rotate( PI/4 ); // (0, 1)
```

*Documentation from code comments*

*Documentation from code comments*

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(...)

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

Like rotateRad but rotates around pivot rather than around the origin.

*Documentation from code comments*

*Documentation from code comments*

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
```

# set(...)

## void ofVec2f::set(const ofVec2f &vec)

# set(...)

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

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

```
ofVec2f v1;
v1.set(40, 20);
```

*Documentation from code comments*

*Documentation from code comments*

v1.set(40, 20); ~~~~

# squareDistance(...)

## float ofVec2f::squareDistance(const ofVec2f &pnt)

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.

Last updated Monday, 02 May 2022 21:26:40 UTC - c4ed899893d7465420943c80e392393888fb9d15

If you have any doubt about the usage of this module you can ask in the forum.

If you want to contribute better documentation or start documenting this section you can do so here

If you find anything wrong with this docs you can report any error by opening an issue