Provides classes representing different transform types suitable for use with visuals and scenes.
vispy.visuals.transforms.
ChainTransform
Bases: vispy.visuals.transforms.base_transform.BaseTransform
vispy.visuals.transforms.base_transform.BaseTransform
BaseTransform subclass that performs a sequence of transformations in order. Internally, this class uses shaders.FunctionChain to generate its glsl_map and glsl_imap functions.
Arguments:
See transforms property.
transforms
Isometric
Linear
NonScaling
Orthogonal
append
Add a new transform to the end of this chain.
The transform to use.
glsl_imap
glsl_map
imap
Inverse map coordinates
Coordinates to inverse map.
Coordinates.
map
Map coordinates
Coordinates to map.
prepend
Add a new transform to the beginning of this chain.
shader_imap
see shader_map.
shader_map
Return a shader Function that accepts only a single vec4 argument and defines new attributes / uniforms supplying the Function with any static input.
simplified
A simplified representation of the same transformation.
The list of transform that make up the transform chain.
The order of transforms is given such that the last transform in the list is the first to be invoked when mapping coordinates through the chain.
For example, the following two mappings are equivalent:
# Map coordinates through individual transforms: trans1 = STTransform(scale=(2, 3), translate=(0, 1)) trans2 = PolarTransform() mapped = trans1.map(trans2.map(coords)) # Equivalent mapping through chain: chain = ChainTransform([trans1, trans2]) mapped = chain.map(coords)
LogTransform
Transform perfoming logarithmic transformation on three axes.
Maps (x, y, z) => (log(base.x, x), log(base.y, y), log(base.z, z))
No transformation is applied for axes with base == 0.
If base < 0, then the inverse function is applied: x => base.x ** x
Base for the X, Y, Z axes.
base
base is a tuple (x, y, z) containing the log base that should be applied to each axis of the input vector. If any axis has a base <= 0, then that axis is not affected.
Return obj mapped through the inverse transformation.
array with shape (…, 2) or (…, 3)
Return obj mapped through the forward transformation.
MatrixTransform
Affine transformation class
4x4 array to use for the transform.
inv_matrix
matrix
reset
rotate
Rotate the matrix by some angle about a given axis.
The rotation is applied after the transformations already present in the matrix.
The angle of rotation, in degrees.
The x, y and z coordinates of the axis vector to rotate around.
scale
Scale the matrix about a given origin.
The scaling is applied after the transformations already present in the matrix.
Scale factors along x, y and z axes.
The x, y and z coordinates to scale around. If None, (0, 0, 0) will be used.
set_frustum
Set the frustum
Left.
Right.
Bottom.
Top.
Near.
Far.
set_mapping
Set to a 3D transformation matrix that maps points1 onto points2.
Four starting 3D coordinates.
Four ending 3D coordinates.
set_ortho
Set ortho transform
set_perspective
Set the perspective
Field of view.
Aspect ratio.
Near location.
Far location.
translate
Translate the matrix
The translation is applied after the transformations already present in the matrix.
Position to translate by.
NullTransform
Transform having no effect on coordinates (identity transform).
PanZoomTransform
Bases: vispy.visuals.transforms.linear.STTransform
vispy.visuals.transforms.linear.STTransform
Pan-zoom transform
The canvas to attch to.
The aspect ratio to apply.
Keyword arguments to pass to the underlying STTransform.
attach
Attach this tranform to a canvas
The canvas.
canvas_tr
on_mouse_move
Mouse move handler
The event.
on_mouse_wheel
Mouse wheel handler
on_resize
Resize handler
PolarTransform
Polar transform
Maps (theta, r, z) to (x, y, z), where x = r*cos(theta) and y = r*sin(theta).
STTransform
Transform performing only scale and translate, in that order.
Scale factors for X, Y, Z axes.
as_matrix
from_mapping
Create an STTransform from the given mapping
See set_mapping for details.
Start.
End.
The transform.
Invert map coordinates
move
Change the translation of this transform by the amount given.
The values to be added to the current translation of the transform.
Configure this transform such that it maps points x0 => x1
Start location.
End location.
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
zoom
Update the transform such that its scale factor is changed, but the specified center point is left unchanged.
Values to multiply the transform’s current scale factors.
The center point around which the scaling will take place.
Whether center is expressed in mapped coordinates (True) or unmapped coordinates (False).
TransformSystem
Bases: object
object
TransformSystem encapsulates information about the coordinate systems needed to draw a Visual.
Visual rendering operates in six coordinate systems:
Visual - arbitrary local coordinate frame of the visual. Vertex buffers used by the visual are usually specified in this coordinate system.
Scene - This is an isometric coordinate system used mainly for lighting calculations.
Document - This coordinate system has units of _logical_ pixels, and should usually represent the pixel coordinates of the canvas being drawn to. Visuals use this coordinate system to make measurements for font size, line width, and in general anything that is specified in physical units (px, pt, mm, in, etc.). In most circumstances, this is exactly the same as the canvas coordinate system.
Canvas - This coordinate system represents the logical pixel coordinates of the canvas. It has its origin in the top-left corner of the canvas, and is typically the coordinate system that mouse and touch events are reported in. Note that, by convention, _logical_ pixels are not necessarily the same size as the _physical_ pixels in the framebuffer that is being rendered to.
Framebuffer - The buffer coordinate system has units of _physical_ pixels, and should usually represent the coordinates of the current framebuffer (on the canvas or an FBO) being rendered to. Visuals use this coordinate system primarily for antialiasing calculations. It is also the coorinate system used by glFragCoord. In most cases, this will have the same scale as the document and canvas coordinate systems because the active framebuffer is the back buffer of the canvas, and the canvas will have _logical_ and _physical_ pixels of the same size. However, the scale may be different in the case of high-resolution displays, or when rendering to an off-screen framebuffer with different scaling or boundaries than the canvas.
Render - This coordinate system is the obligatory system for vertices returned by a vertex shader. It has coordinates (-1, -1) to (1, 1) across the current glViewport. In OpenGL terminology, this is called clip coordinates.
The canvas being drawn to.
The dot-per-inch resolution of the document coordinate system. By default this is set to the resolution of the canvas.
Notes
By default, TransformSystems are configured such that the document coordinate system matches the logical pixels of the canvas,
1. To convert local vertex coordinates to normalized device coordinates in the vertex shader, we first need a vertex shader that supports configurable transformations:
vec4 a_position; void main() { gl_Position = $transform(a_position); }
Next, we supply the complete chain of transforms when drawing the visual:
def draw(tr_sys):tr = tr_sys.get_full_transform() self.program[‘transform’] = tr.shader_map() self.program[‘a_position’] = self.vertex_buffer self.program.draw(‘triangles’)
tr = tr_sys.get_full_transform() self.program[‘transform’] = tr.shader_map() self.program[‘a_position’] = self.vertex_buffer self.program.draw(‘triangles’)
2. Draw a line whose width is given in mm. To start, we need normal vectors for each vertex, which tell us the direction the vertex should move in order to set the line width:
vec4 a_position; vec4 a_normal; float u_line_width; float u_dpi; void main() { // map vertex position and normal vector to the document cs vec4 doc_pos = $visual_to_doc(a_position); vec4 doc_normal = $visual_to_doc(a_position + a_normal) - doc_pos; // Use DPI to convert mm line width to logical pixels float px_width = (u_line_width / 25.4) * dpi; // expand by line width doc_pos += normalize(doc_normal) * px_width; // finally, map the remainder of the way to normalized device // coordinates. gl_Position = $doc_to_render(a_position); }
In this case, we need to access the transforms independently, so get_full_transform() is not useful here:
get_full_transform()
def draw(tr_sys): # Send two parts of the full transform separately self.program['visual_to_doc'] = tr_sys.visual_to_doc.shader_map() doc_to_render = (tr_sys.framebuffer_transform * tr_sys.document_transform) self.program['visual_to_doc'] = doc_to_render.shader_map() self.program['u_line_width'] = self.line_width self.program['u_dpi'] = tr_sys.dpi self.program['a_position'] = self.vertex_buffer self.program['a_normal'] = self.normal_buffer self.program.draw('triangles')
Draw a triangle with antialiasing at the edge.
Using inverse transforms in the fragment shader
canvas
The Canvas being drawn to.
canvas_transform
Transform mapping from canvas coordinate frame to framebuffer coordinate frame.
configure
Automatically configure the TransformSystem:
canvas_transform maps from the Canvas logical pixel coordinate system to the framebuffer coordinate system, taking into account the logical/physical pixel scale factor, current FBO position, and y-axis inversion.
framebuffer_transform maps from the current GL viewport on the framebuffer coordinate system to clip coordinates (-1 to 1).
The GL viewport rectangle (x, y, w, h). If None, then it is assumed to cover the entire canvas.
The size of the active FBO. If None, then it is assumed to have the same size as the canvas’s framebuffer.
The position and size (x, y, w, h) of the FBO in the coordinate system of the canvas’s framebuffer. If None, then the bounds are assumed to cover the entire active framebuffer.
Optionally set the canvas for this TransformSystem. See the canvas property.
document_transform
Transform mapping from document coordinate frame to the framebuffer (physical pixel) coordinate frame.
dpi
Physical resolution of the document coordinate system (dots per inch).
framebuffer_transform
Transform mapping from pixel coordinate frame to rendering coordinate frame.
get_transform
Return a transform mapping between any two coordinate systems.
The starting coordinate system to map from. Must be one of: visual, scene, document, canvas, framebuffer, or render.
The ending coordinate system to map to. Must be one of: visual, scene, document, canvas, framebuffer, or render.
pixel_scale
scene_transform
Transform mapping from scene coordinate frame to document coordinate frame.
visual_transform
Transform mapping from visual local coordinate frame to scene coordinate frame.