# vispy.visuals.transforms.linear module#

class vispy.visuals.transforms.linear.MatrixTransform(matrix=None)#

Bases: `BaseTransform`

Affine transformation class

Parameters:
matrixarray-like | None

4x4 array to use for the transform.

Isometric = False#
Linear = True#
NonScaling = False#
Orthogonal = False#
glsl_imap = '\n        vec4 affine_transform_imap(vec4 pos) {\n            return \$inv_matrix * pos;\n        }\n    '#
glsl_map = '\n        vec4 affine_transform_map(vec4 pos) {\n            return \$matrix * pos;\n        }\n    '#
imap(coords)#

Inverse map coordinates

Parameters:
coordsarray-like

Coordinates to inverse map.

Returns:
coordsndarray

Coordinates.

property inv_matrix#
map(coords)#

Map coordinates

Parameters:
coordsarray-like

Coordinates to map.

Returns:
coordsndarray

Coordinates.

property matrix#
reset()#
rotate(angle, axis)#

Rotate the matrix by some angle about a given axis.

The rotation is applied after the transformations already present in the matrix.

Parameters:
anglefloat

The angle of rotation, in degrees.

axisarray-like

The x, y and z coordinates of the axis vector to rotate around.

scale(scale, center=None)#

Scale the matrix about a given origin.

The scaling is applied after the transformations already present in the matrix.

Parameters:
scalearray-like

Scale factors along x, y and z axes.

centerarray-like or None

The x, y and z coordinates to scale around. If None, (0, 0, 0) will be used.

set_frustum(l, r, b, t, n, f)#

Set the frustum

Parameters:
lfloat

Left.

rfloat

Right.

bfloat

Bottom.

tfloat

Top.

nfloat

Near.

ffloat

Far.

set_mapping(points1, points2)#

Set to a 3D transformation matrix that maps points1 onto points2.

Parameters:
points1array-like, shape (4, 3)

Four starting 3D coordinates.

points2array-like, shape (4, 3)

Four ending 3D coordinates.

set_ortho(l, r, b, t, n, f)#

Set ortho transform

Parameters:
lfloat

Left.

rfloat

Right.

bfloat

Bottom.

tfloat

Top.

nfloat

Near.

ffloat

Far.

set_perspective(fov, aspect, near, far)#

Set the perspective

Parameters:
fovfloat

Field of view.

aspectfloat

Aspect ratio.

nearfloat

Near location.

farfloat

Far location.

Return a shader Function that accepts only a single vec4 argument and defines new attributes / uniforms supplying the Function with any static input.

translate(pos)#

Translate the matrix

The translation is applied after the transformations already present in the matrix.

Parameters:
posarrayndarray

Position to translate by.

class vispy.visuals.transforms.linear.NullTransform#

Bases: `BaseTransform`

Transform having no effect on coordinates (identity transform).

Isometric = True#
Linear = True#
NonScaling = True#
Orthogonal = True#
glsl_imap = 'vec4 null_transform_imap(vec4 pos) {return pos;}'#
glsl_map = 'vec4 null_transform_map(vec4 pos) {return pos;}'#
imap(coords)#

Inverse map coordinates

Parameters:
coordsarray-like

Coordinates to inverse map.

map(coords)#

Map coordinates

Parameters:
coordsarray-like

Coordinates to map.

class vispy.visuals.transforms.linear.STTransform(scale=None, translate=None)#

Bases: `BaseTransform`

Transform performing only scale and translate, in that order.

Parameters:
scalearray-like

Scale factors for X, Y, Z axes.

translatearray-like

Scale factors for X, Y, Z axes.

Isometric = False#
Linear = True#
NonScaling = False#
Orthogonal = True#
as_matrix()#
classmethod from_mapping(x0, x1)#

Create an STTransform from the given mapping

See set_mapping for details.

Parameters:
x0array-like

Start.

x1array-like

End.

Returns:
tinstance of STTransform

The transform.

glsl_imap = '\n        vec4 st_transform_imap(vec4 pos) {\n            return vec4((pos.xyz - \$translate.xyz * pos.w) / \$scale.xyz,\n                        pos.w);\n        }\n    '#
glsl_map = '\n        vec4 st_transform_map(vec4 pos) {\n            return vec4(pos.xyz * \$scale.xyz + \$translate.xyz * pos.w, pos.w);\n        }\n    '#
imap(coords)#

Invert map coordinates

Parameters:
coordsarray-like

Coordinates to inverse map.

Returns:
coordsndarray

Coordinates.

map(coords)#

Map coordinates

Parameters:
coordsarray-like

Coordinates to map.

Returns:
coordsndarray

Coordinates.

move(move)#

Change the translation of this transform by the amount given.

Parameters:
movearray-like

The values to be added to the current translation of the transform.

property scale#
set_mapping(x0, x1, update=True)#

Configure this transform such that it maps points x0 => x1

Parameters:
x0array-like, shape (2, 2) or (2, 3)

Start location.

x1array-like, shape (2, 2) or (2, 3)

End location.

updatebool

If False, then the update event is not emitted.

Examples

For example, if we wish to map the corners of a rectangle:

```>>> p1 = [[0, 0], [200, 300]]
```

onto a unit cube:

```>>> p2 = [[-1, -1], [1, 1]]
```

then we can generate the transform as follows:

```>>> tr = STTransform()
>>> tr.set_mapping(p1, p2)
>>> assert tr.map(p1)[:,:2] == p2  # test
```

Return a shader Function that accepts only a single vec4 argument and defines new attributes / uniforms supplying the Function with any static input.

property translate#
zoom(zoom, center=(0, 0, 0), mapped=True)#

Update the transform such that its scale factor is changed, but the specified center point is left unchanged.

Parameters:
zoomarray-like

Values to multiply the transformâ€™s current scale factors.

centerarray-like

The center point around which the scaling will take place.

mappedbool

Whether center is expressed in mapped coordinates (True) or unmapped coordinates (False).