plotter

Defines main class Plotter to manage actors and 3D rendering.

Plotter

class vedo.plotter.Plotter(shape=(1, 1), N=None, pos=(0, 0), size='auto', screensize='auto', title='vedo', bg='white', bg2=None, axes=None, sharecam=True, resetcam=True, interactive=None, offscreen=False, qtWidget=None)

Bases: object

Main class to manage actors.

Parameters

• shape (list) – shape of the grid of renderers in format (rows, columns). Ignored if N is specified.

• N (int) – number of desired renderers arranged in a grid automatically.

• pos (list) – (x,y) position in pixels of top-left corner of the rendering window on the screen

• size – size of the rendering window. If ‘auto’, guess it based on screensize.

• screensize – physical size of the monitor screen

• bg – background color or specify jpg image file name with path

• bg2 – background color of a gradient towards the top

• axes (int) –

  • 0, no axes

  • 1, draw three gray grid walls

  • 2, show cartesian axes from (0,0,0)

  • 3, show positive range of cartesian axes from (0,0,0)

  • 4, show a triad at bottom left

  • 5, show a cube at bottom left

  • 6, mark the corners of the bounding box

  • 7, draw a 3D ruler at each side of the cartesian axes

  • 8, show the VTK CubeAxesActor object

  • 9, show the bounding box outLine,

  • 10, show three circles representing the maximum bounding box,

  • 11, show a large grid on the x-y plane (use with zoom=8)

  • 12, show polar axes.

  • 13, draw a simple ruler at the bottom of the window

Axis type-1 can be fully customized by passing a dictionary axes=dict(). Check Axes() for the available options.

Parameters

• sharecam (bool) – if False each renderer will have an independent vtkCamera

• interactive (bool) – if True will stop after show() to allow interaction w/ window

• offscreen (bool) – if True will not show the rendering window

• qtWidget (QVTKRenderWindowInteractor) – render in a Qt-Widget using an QVTKRenderWindowInteractor. Overrides offscreen to True Overrides interactive to False See Also: examples qt_windows1.py and qt_windows2.py

add(actors, at=None, render=True, resetcam=False)

Append input object to the internal list of actors to be shown.

Parameters

• at (int) – add the object at the specified renderer

• render (bool) – render the scene after adding the object

addButton(fnc, states=('On', 'Off'), c=('w', 'w'), bc=('dg', 'dr'), pos=(0.7, 0.05), size=24, font='Normografo', bold=False, italic=False, alpha=1, angle=0)

Add a button to the renderer window.

Parameters

• states (list) – a list of possible states, e.g. [‘On’, ‘Off’]

• c – a list of colors for each state

• bc – a list of background colors for each state

• pos – 2D position in pixels from left-bottom corner

• size – size of button font

• font (str) – font type (arial, courier, times)

• bold (bool) – bold face (False)

• italic (bool) – italic face (False)

• alpha (float) – opacity level

• angle (float) – anticlockwise rotation in degrees

buttons.py

addCallback(eventName, func, priority=0.0, verbose=False)

Add a function to be executed while show() is active. Information about the event can be acquired with method getEvent().

Return a unique id for the callback.

The callback function (see example below) exposes a dictionary with the following information:

• name: event name,

• id: event unique identifier,

• priority: event priority (float),

• interactor: the interactor object,

• at: renderer nr. where the event occured

• actor: object picked by the mouse

• picked3d: point picked in world coordinates

• keyPressed: key pressed as string

• picked2d: screen coords of the mouse pointer

• delta2d: shift wrt previous position (to calculate speed, direction)

• delta3d: …same but in 3D world coords

• angle2d: angle of mouse movement on screen

• speed2d: speed of mouse movement on screen

• speed3d: speed of picked point in world coordinates

• isPoints: True if of class

• isMesh: True if of class

• isAssembly: True if of class

• isVolume: True if of class Volume

• isPicture: True if of class

Frequently used events are:

• KeyPress, KeyRelease: listen to keyboard events

• LeftButtonPress, LeftButtonRelease: listen to mouse clicks

• MiddleButtonPress, MiddleButtonRelease

• RightButtonPress, RightButtonRelease

• MouseMove: listen to mouse pointer changing position

• MouseWheelForward, MouseWheelBackward

• Enter, Leave: listen to mouse entering or leaving the window

• Pick, StartPick, EndPick: listen to object picking

• ResetCamera, ResetCameraClippingRange

• Error, Warning

• Char

• Timer

Check the complete list of events here:

https://vtk.org/doc/nightly/html/classvtkCommand.html

Example

from vedo import *

def func(evt): # called every time the mouse moves
    # evt is a dotted dictionary
    if not evt.actor:
        return  # no hit, return
    print("point coords =", evt.picked3d)
    # print("full event dump:", evt)

elli = Ellipsoid()
plt = show(elli, axes=1, interactive=False)
plt.addCallback('MouseMove', func)
interactive()

addCutterTool(obj=None, mode='box', invert=False)

Create an interactive tool to cut away parts of a mesh or volume.

Parameters

• mode (str) – either “box”, “plane” or “sphere”

• invert (bool) – invert selection (inside-out)

cutter.py

addGlobalAxes(axtype=None, c=None)

Draw axes on scene. Available axes types:

Parameters

axtype (int) –

• 0, no axes,

• 1, draw three gray grid walls

• 2, show cartesian axes from (0,0,0)

• 3, show positive range of cartesian axes from (0,0,0)

• 4, show a triad at bottom left

• 5, show a cube at bottom left

• 6, mark the corners of the bounding box

• 7, draw a 3D ruler at each side of the cartesian axes

• 8, show the vtkCubeAxesActor object

• 9, show the bounding box outLine

• 10, show three circles representing the maximum bounding box

• 11, show a large grid on the x-y plane

• 12, show polar axes

• 13, draw a simple ruler at the bottom of the window

Axis type-1 can be fully customized by passing a dictionary axes=dict().

Example

from vedo import Box, show
b = Box(pos=(0,0,0), length=80, width=90, height=70).alpha(0)

show(b, axes={ 'xtitle':'Some long variable [a.u.]',
               'numberOfDivisions':4,
               # ...
             }
)

customAxes1.py customAxes2.py customAxes3.py

customIndividualAxes.py

addHoverLegend(at=0, c=None, pos='bottom-left', font='Calco', s=0.75, bg='auto', alpha=0.1, precision=2, maxlength=24, useInfo=False)

Add a legend with 2D text which is triggered by hovering the mouse on an object.

The created text object are stored in plotter.hoverLegends.

Parameters

• c – text color. If None then black or white is chosen automatically

• pos (str) – text positioning

• font (str) – text font

• s (float) – text size factor

• bg – background color of the 2D box containing the text

• alpha (float) – box transparency

• precision (int) – number of significant digits

• maxlength (int) – maximum number of characters per line

• useInfo (bool) – visualize the content of the obj.info attribute

addIcon(icon, pos=3, size=0.08)

Add an inset icon mesh into the same renderer.

Parameters

• pos – icon position in the range [1-4] indicating one of the 4 corners, or it can be a tuple (x,y) as a fraction of the renderer size.

• size (float) – size of the square inset.

icon.py

addInset(*actors, **options)

Add a draggable inset space into a renderer.

Parameters

• at (int) – specify the renderer number

• pos – icon position in the range [1-4] indicating one of the 4 corners, or it can be a tuple (x,y) as a fraction of the renderer size.

• size (float) – size of the square inset.

• draggable (bool) – if True the subrenderer space can be dragged around.

• c – color of the inset frame when dragged

inset.py

addLegendBox(**kwargs)

Add a legend to the top right

addSlider2D(sliderfunc, xmin, xmax, value=None, pos=4, title='', font='', titleSize=1, c=None, showValue=True)

Add a slider widget which can call an external custom function.

Parameters

• sliderfunc – external function to be called by the widget

• xmin (float) – lower value

• xmax (float) – upper value

• value (float) – current value

• pos (list) – position corner number: horizontal [1-5] or vertical [11-15] it can also be specified by corners coordinates [(x1,y1), (x2,y2)]

• title (str) – title text

• titleSize (float) – title text scale [1.0]

• font (str) – title font [arial, courier]

• showValue (bool) – if true current value is shown

sliders1.py sliders2.py

addSlider3D(sliderfunc, pos1, pos2, xmin, xmax, value=None, s=0.03, t=1, title='', rotation=0, c=None, showValue=True)

Add a 3D slider widget which can call an external custom function.

Parameters

• sliderfunc – external function to be called by the widget

• pos1 (list) – first position coordinates

• pos2 (list) – second position coordinates

• xmin (float) – lower value

• xmax (float) – upper value

• value (float) – initial value

• s (float) – label scaling factor

• t (float) – tube scaling factor

• title (str) – title text

• c – slider color

• rotation (float) – title rotation around slider axis

• showValue (bool) – if True current value is shown

sliders3d.py

addSplineTool(points, pc='k', ps=8, lc='r4', ac='g5', lw=2, closed=False, interactive=True)

Add a spline tool to the current plotter. Nodes of the spline can be dragged in space with the mouse. Clicking on the line itself adds an extra point. Selecting a point and pressing del removes it.

Parameters

• points (Mesh, Points, array) – the set of vertices forming the spline nodes.

• pc (str, optional) – point color. The default is ‘k’.

• ps (str, optional) – point size. The default is 8.

• lc (str, optional) – line color. The default is ‘r4’.

• ac (str, optional) – active point marker color. The default is ‘g5’.

• lw (int, optional) – line width. The default is 2.

• closed (bool, optional) – spline is meant to be closed. The default is False.

Returns

Return type

SplineTool object.

allowInteraction()

Call this method from inside a loop to allow mouse and keyboard interaction.

backgroundColor(c1=None, c2=None, at=None)

Set the color of the background for the current renderer. A different renderer index can be specified by keyword at.

Parameters

• c1 (list, optional) – background main color. The default is None.

• c2 (list, optional) – background color for the upper part of the window. The default is None.

• at (int, optional) – renderer index. The default is 0.

clear(actors=None, at=None)

Delete specified list of actors, by default delete all.

close()

Close the Plotter instance and release resources.

closeWindow()

Close the current or the input rendering window.

computeWorldPosition(pos2d, at=0, objs=(), bounds=(), offset=None, pixeltol=None, worldtol=None)

Transform a 2D point on the screen into a 3D point inside the rendering scene.

Parameters

• pos2d (list) – 2D screen coordinates point.

• at (int, optional) – renderer number. The default is 0.

• objs (list, optional) – list of Mesh objects to project the point onto. The default is ().

• bounds (list, optional) – specify a bounding box as [xmin,xmax, ymin,ymax, zmin,zmax]. The default is ().

• offset (float, optional) – specify an offset value. The default is None (will use system defaults).

• pixeltol (int, optional) – screen tolerance in pixels. The default is None (will use system defaults).

• worldtol (float, optional) – world coordinates tolerance. The default is None (will use system defaults).

Returns

the point in 3D world coordinates.

Return type

numpy array

export(filename='scene.npz')

Export scene to file to HTML, X3D or Numpy file.

flyTo(point, at=0)

Fly camera to the specified point.

Parameters

• point (list) – point in space to place camera.

• at (int, optional) – Renderer number. The default is 0.

• Example –

  from vedo import Cone
  Cone().show(axes=1).flyTo([1,0,0]).show()
  

getMeshes(at=None, includeNonPickables=False)

Return a list of Meshes from the specified renderer.

Parameters

• at (int) – specify which renderer to look into.

• includeNonPickables (bool) – include non-pickable objects

getVolumes(at=None, includeNonPickables=False)

Return a list of Volumes from the specified renderer.

Parameters

• at (int) – specify which renderer to look into.

• includeNonPickables (bool) – include non-pickable objects

load(filename, unpack=True, force=False)

Load objects from file. The output will depend on the file extension. See examples below.

Parameters

• unpack (bool) – only for multiblock data, if True returns a flat list of objects.

• force (bool) – when downloading a file ignore any previous cached downloads and force a new one.

Example

from vedo import datadir, load, show

# Return a list of 2 Mesh
g = load([datadir+'250.vtk', datadir+'290.vtk'])
show(g)

# Return a list of meshes by reading all files in a directory
# (if directory contains DICOM files then a Volume is returned)
g = load('mydicomdir/')
show(g)

# Return a Volume. Color/Opacity transfer function can be specified too.
g = load(datadir+'embryo.slc')
g.c(['y','lb','w']).alpha((0.0, 0.4, 0.9, 1)).show()

moveCamera(camstart, camstop, fraction)

Takes as input two vtkCamera objects and returns a new vtkCamera that is at an intermediate position:

fraction=0 -> camstart, fraction=1 -> camstop.

Press shift-C key in interactive mode to dump a python snipplet of parameters for the current camera view.

pop(at=0, render=False)

Remove the last added object from the rendering window

remove(actors, at=None, render=False, resetcam=False)

Remove input object to the internal list of actors to be shown.

Parameters

• at (int) – remove the object at the specified renderer

• render (bool) – render the scene after removing the object

removeCallback(cid)

Remove a callback function by its id or a whole category of callbacks by their name.

Parameters

cid (int,str) – unique id of the callback. If an event name is passed all callbacks of that type are removed

render(resetcam=False)

Render the scene.

resetCamera()

Reset the camera position and zooming.

screenshot(filename='screenshot.png', scale=None, returnNumpy=False)

Take a screenshot of the Plotter window.

Parameters

• scale (int) – set image magnification

• returnNumpy (bool) – return a numpy array of the image

show(*actors, at=None, axes=None, resetcam=None, zoom=False, interactive=None, viewup='', azimuth=0, elevation=0, roll=0, camera=None, interactorStyle=0, rate=None, bg=None, bg2=None, size=None, title=None, q=False)

Render a list of actors.

If filename is given, its type is guessed based on its extension. Supported formats are: vtu, vts, vtp, ply, obj, stl, 3ds, xml, neutral, gmsh, pcd, xyz, txt, byu, tif, slc, vti, mhd, png, jpg. Otherwise it will be interpreted as a comment to appear on the top-left of the window.

Parameters

• at (int) – number of the renderer to plot to, if more than one exists

• shape (list) –

  Number of sub-render windows inside of the main window. Specify two across with shape=(2, 1) and a two by two grid with shape=(2, 2). By default there is only one renderer. Can also accept a shape as string descriptor. E.g.

  • shape=”3|1” means 3 plots on the left and 1 on the right,

  • shape=”4/2” means 4 plots on top of 2 at bottom.

• axes (int) –

  set the type of axes to be shown

  • 0, no axes

  • 1, draw three customizable gray grid walls

  • 2, show cartesian axes from (0,0,0)

  • 3, show positive range of cartesian axes from (0,0,0)

  • 4, show a triad at bottom left

  • 5, show a cube at bottom left

  • 6, mark the corners of the bounding box

  • 7, draw a 3D ruler at each side of the cartesian axes

  • 8, show the vtkCubeAxesActor object

  • 9, show the bounding box outLine

  • 10, show three circles representing the maximum bounding box

  • 11, show a large grid on the x-y plane (use with zoom=8)

  • 12, show polar axes

  • 13, draw a simple ruler at the bottom of the window

• azimuth/elevation/roll (float) – move camera accordingly

• viewup (str) – either [‘x’, ‘y’, ‘z’] to set vertical direction

• resetcam (bool) – re-adjust camera position to fit objects

• camera (dict) –

  Camera parameters can further be specified with a dictionary assigned to the camera keyword (E.g. show(camera={‘pos’:(1,2,3), ‘thickness’:1000,}))

  • pos, (list), the position of the camera in world coordinates

  • focalPoint (list), the focal point of the camera in world coordinates

  • viewup (list), the view up direction vector for the camera

  • distance (float), set the focal point to the specified distance from the camera position.

  • clippingRange (float), distance of the near and far clipping planes along

    the direction of projection.

  • parallelScale (float),

    scaling used for a parallel projection, i.e. the height of the viewport in world-coordinate distances. The default is 1. Note that the “scale” parameter works as an “inverse scale”, larger numbers produce smaller images. This method has no effect in perspective projection mode.

  • thickness (float),

    set the distance between clipping planes. This method adjusts the far clipping plane to be set a distance ‘thickness’ beyond the near clipping plane.

  • viewAngle (float),

    the camera view angle, which is the angular height of the camera view measured in degrees. The default angle is 30 degrees. This method has no effect in parallel projection mode. The formula for setting the angle up for perfect perspective viewing is: angle = 2*atan((h/2)/d) where h is the height of the RenderWindow (measured by holding a ruler up to your screen) and d is the distance from your eyes to the screen.

• interactive (bool) – pause and interact with window (True) or continue execution (False)

• rate (float) – maximum rate of show() in Hertz

• interactorStyle (int) – set the type of interaction - 0 = TrackballCamera [default] - 1 = TrackballActor - 2 = JoystickCamera - 3 = JoystickActor - 4 = Flight - 5 = RubberBand2D - 6 = RubberBand3D - 7 = RubberBandZoom - 8 = Context - 9 = 3D - 10 = Terrain - 11 = Unicam - 12 = Image

• q (bool) – force program to quit after show() command returns.

showInset(*actors, **options)

DEPRECATED, please use addInset() instead.

timerCallback(action, timerId=None, dt=10, oneShot=False)

Activate or destroy an existing Timer Event callback.

Parameters

• action (str) – Either “create” or “destroy”.

• timerId (int) – When destroying the timer, the ID of the timer as returned when created.

• dt (int) – time in milliseconds between each repeated call

• oneShot (bool) – create a one shot timer of prescribed duration instead of a repeating one.

topicture(scale=None)

Generate a Picture object from the current rendering window.

Parameters

scale (int) – set image magnification

useParallelProjection(value=True, at=0)

Use parallel projection at a specified renderer. Object is seen from “infinite” distance, e.i. remove any perspective effects.

clear

vedo.plotter.clear(actor=None, at=None)

Clear specific actor or list of actors from the current rendering window. Keyword at specify the reneder to be cleared.

closePlotter

vedo.plotter.closePlotter()

Close the current instance of Plotter and its rendering window.

closeWindow

vedo.plotter.closeWindow(plotterInstance=None)

Close the current or the input rendering window.

interactive

vedo.plotter.interactive()

Start the rendering window interaction mode.

ioff

vedo.plotter.ioff()

Set interactive mode OFF for the current window.

When calling show() image will be rendered but python script execution will continue, the graphic window will be not responsive to interaction.

ion

vedo.plotter.ion()

Set interactive mode ON for the current window.

When calling show() python script exectution will stop and control will stay on the graphic window allowing mouse/keyboard interaction.

show

vedo.plotter.show(*actors, at=None, shape=(1, 1), N=None, pos=(0, 0), size='auto', screensize='auto', title='vedo', bg='white', bg2=None, axes=None, interactive=None, offscreen=False, sharecam=True, resetcam=True, zoom=None, viewup='', azimuth=0, elevation=0, roll=0, camera=None, interactorStyle=0, q=False, new=False)

Create on the fly an instance of class Plotter and show the object(s) provided.

Allowed input objects types are: str, Mesh, Volume, Picture, Assembly vtkPolyData, vtkActor, vtkActor2D, vtkImageActor, vtkAssembly or vtkVolume.

If filename is given, its type is guessed based on its extension. Supported formats are: vtu, vts, vtp, ply, obj, stl, 3ds, xml, neutral, gmsh, pcd, xyz, txt, byu, tif, slc, vti, mhd, png, jpg.

Parameters

• at (int) – number of the renderer to plot to, if more than one exists

• shape (list) –

  Number of sub-render windows inside of the main window. Specify two across with shape=(2, 1) and a two by two grid with shape=(2, 2). By default there is only one renderer. Can also accept a shape as string descriptor. E.g.:

  • shape=”3|1” means 3 plots on the left and 1 on the right,

  • shape=”4/2” means 4 plots on top of 2 at bottom.

• axes (int) –

  set the type of axes to be shown

  • 0, no axes

  • 1, draw three gray grid walls

  • 2, show cartesian axes from (0,0,0)

  • 3, show positive range of cartesian axes from (0,0,0)

  • 4, show a triad at bottom left

  • 5, show a cube at bottom left

  • 6, mark the corners of the bounding box

  • 7, draw a 3D ruler at each side of the cartesian axes

  • 8, show the vtkCubeAxesActor object

  • 9, show the bounding box outLine

  • 10, show three circles representing the maximum bounding box

  • 11, show a large grid on the x-y plane

  • 12, show polar axes

  • 13, draw a simple ruler at the bottom of the window

  Axis type-1 can be fully customized by passing a dictionary axes=dict() where: Check addons.Axes() for the full list of options.

• azimuth/elevation/roll (float) – move camera accordingly

• viewup (str) – either [‘x’, ‘y’, ‘z’] or a vector to set vertical direction

• resetcam (bool) – re-adjust camera position to fit objects

• camera (dict) –

  Camera parameters can further be specified with a dictionary assigned to the camera keyword (E.g. show(camera={‘pos’:(1,2,3), ‘thickness’:1000,}))

  • pos, (list), the position of the camera in world coordinates

  • focalPoint (list), the focal point of the camera in world coordinates

  • viewup (list), the view up direction for the camera

  • distance (float), set the focal point to the specified distance from the camera position.

  • clippingRange (float), distance of the near and far clipping planes along the direction

    of projection.

  • parallelScale (float),

    scaling used for a parallel projection, i.e. the height of the viewport in world-coordinate distances. The default is 1. Note that the “scale” parameter works as an “inverse scale”, larger numbers produce smaller images. This method has no effect in perspective projection mode.

  • thickness (float),

    set the distance between clipping planes. This method adjusts the far clipping plane to be set a distance ‘thickness’ beyond the near clipping plane.

  • viewAngle (float),

    the camera view angle, which is the angular height of the camera view measured in degrees. The default angle is 30 degrees. This method has no effect in parallel projection mode. The formula for setting the angle up for perfect perspective viewing is: angle = 2*atan((h/2)/d) where h is the height of the RenderWindow (measured by holding a ruler up to your screen) and d is the distance from your eyes to the screen.

• interactive (bool) – pause and interact with window (True) or continue execution (False)

• rate (float) – maximum rate of show() in Hertz

• interactorStyle (int) –

  set the type of interaction

  • 0 = TrackballCamera [default]

  • 1 = TrackballActor

  • 2 = JoystickCamera

  • 3 = JoystickActor

  • 4 = Flight

  • 5 = RubberBand2D

  • 6 = RubberBand3D

  • 7 = RubberBandZoom

  • 8 = Context

  • 9 = 3D

  • 10 = Terrain

  • 11 = Unicam

• q (bool) – force program to quit after show() command returns.

• new (bool) – if set to True, a call to show will instantiate a new Plotter object (a new window) instead of reusing the first created.

Returns

the current Plotter class instance.

Note

With multiple renderers, keyword at can become a list, e.g.

from vedo import *
s = Sphere()
c = Cube()
p = Paraboloid()
show(s, c, at=[0, 1], shape=(3,1))
show(p, at=2, interactive=True)
#
# is equivalent to:
plt = Plotter(shape=(3,1))
s = Sphere()
c = Cube()
p = Paraboloid()
plt.show(s, at=0)
plt.show(p, at=1)
plt.show(c, at=2, interactive=True)