PySide6.QtGui.QVector2D¶

class QVector2D¶

The QVector2D class represents a vector or vertex in 2D space. More…

Synopsis¶

Methods¶

def __init__()
def __reduce__()
def __repr__()
def distanceToLine()
def distanceToPoint()
def isNull()
def length()
def lengthSquared()
def normalize()
def normalized()
def __ne__()
def __mul__()
def __imul__()
def __add__()
def __iadd__()
def __sub__()
def __isub__()
def __div__()
def operator/=()
def __eq__()
def operator[]()
def setX()
def setY()
def toPoint()
def toPointF()
def toTuple()
def toVector3D()
def toVector4D()
def x()
def y()

Static functions¶

def dotProduct()

Note

This documentation may contain snippets that were automatically translated from C++ to Python. We always welcome contributions to the snippet translation. If you see an issue with the translation, you can also let us know by creating a ticket on https:/bugreports.qt.io/projects/PYSIDE

Detailed Description¶

Vectors are one of the main building blocks of 2D representation and drawing. They consist of two finite floating-point coordinates, traditionally called x and y.

The QVector2D class can also be used to represent vertices in 2D space. We therefore do not need to provide a separate vertex class.

See also

QVector3D QVector4D QQuaternion

__init__()¶

Constructs a null vector, i.e. with coordinates (0, 0).

__init__(point)

Parameters:: point – QPoint

Constructs a vector with x and y coordinates from a 2D point.

__init__(point)

Parameters:: point – QPointF

Constructs a vector with x and y coordinates from a 2D point.

__init__(vector)

Parameters:: vector – QVector3D

Constructs a vector with x and y coordinates from a 3D vector. The z coordinate of vector is dropped.

See also

toVector3D()

__init__(vector)

Parameters:: vector – QVector4D

Constructs a vector with x and y coordinates from a 3D vector. The z and w coordinates of vector are dropped.

See also

toVector4D()

__init__(xpos, ypos)

Parameters:

xpos – float
ypos – float

Constructs a vector with coordinates (xpos, ypos). Both coordinates must be finite.

__reduce__()¶

Return type:: str

__repr__()¶

Return type:: str

distanceToLine(point, direction)¶

Parameters:

point – QVector2D
direction – QVector2D

Return type:

float

Returns the distance that this vertex is from a line defined by point and the unit vector direction.

If direction is a null vector, then it does not define a line. In that case, the distance from point to this vertex is returned.

See also

distanceToPoint()

distanceToPoint(point)¶

Parameters:: point – QVector2D
Return type:: float

Returns the distance from this vertex to a point defined by the vertex point.

See also

distanceToLine()

static dotProduct(v1, v2)¶

Parameters:

v1 – QVector2D
v2 – QVector2D

Return type:

float

Returns the dot product of v1 and v2.

isNull()¶

Return type:: bool

Returns true if the x and y coordinates are set to 0.0, otherwise returns false.

length()¶

Return type:: float

Returns the length of the vector from the origin.

See also

lengthSquared() normalized()

lengthSquared()¶

Return type:: float

Returns the squared length of the vector from the origin. This is equivalent to the dot product of the vector with itself.

See also

length() dotProduct()

normalize()¶

Normalizes the current vector in place. Nothing happens if this vector is a null vector or the length of the vector is very close to 1.

See also

length() normalized()

normalized()¶

Return type:: QVector2D

Returns the normalized unit vector form of this vector.

If this vector is null, then a null vector is returned. If the length of the vector is very close to 1, then the vector will be returned as-is. Otherwise the normalized form of the vector of length 1 will be returned.

See also

length() normalize()

__ne__(v2)¶

Parameters:: v2 – QVector2D
Return type:: bool

Returns true if v1 is not equal to v2; otherwise returns false. This operator uses an exact floating-point comparison.

__mul__(v2)¶

Parameters:: v2 – QVector2D
Return type:: QVector2D

Returns the QVector2D object formed by multiplying each component of v1 by the corresponding component of v2.

Note

This is not a cross product of v1 and v2 in any sense. (Its components add up to the dot product of v1 and v2.)