def hack_mlabsavefig(self, fname, size):
oldx, oldy = self.scene.scene_editor.get_size()
curx, cury = self.scene.scene_editor.control.Parent.Parent.Size
cury -= 32 #the mayavi toolbar takes up 32 space, which is not what
#we are setting
self.scene.scene_editor.set_size((curx, cury))
self.txt.visible = False #label visibility is fixed in mayavi 4.3.1
magnif_desired = max(size[0] // curx, size[1] // cury) + 1
newsize = (int(size[0] / magnif_desired),
int(size[1] / magnif_desired))
self.scene.scene_editor.set_size(newsize)
from tvtk.api import tvtk
filter = tvtk.WindowToImageFilter(read_front_buffer=True)
filter.magnification = int(magnif_desired)
self.scene.scene_editor._lift()
filter.input = self.scene.scene_editor._renwin
ex = tvtk.PNGWriter()
ex.file_name = fname
ex.input = filter.output
self.scene.scene_editor._exporter_write(ex)
#reset the old size
self.scene.scene_editor.set_size((oldx, oldy))
#restore the 3D region text if it was previously enabled
self.txt.visible = self.ds.opts.show_floating_text
def save_png(self, file_name):
"""Save to a PNG image file."""
if len(file_name) != 0:
w2if = self._get_window_to_image()
ex = tvtk.PNGWriter()
ex.file_name = file_name
configure_input(ex, w2if)
self._exporter_write(ex)
def export_picture(self, filename):
w2if = tvtk.WindowToImageFilter()
w2if.magnification = 2
w2if.input = self.render_window
ex = tvtk.PNGWriter()
ex.file_name = filename
ex.input = w2if.output
ex.write()
def scene_to_png(scene):
w2if = tvtk.WindowToImageFilter()
w2if.input = scene.render_window
ex = tvtk.PNGWriter()
ex.write_to_memory = True
configure_input(ex, w2if)
ex.update()
ex.write()
data = base64.b64encode(ex.result.to_array()).decode('ascii')
html = '<img src="data:image/png;base64,%s" alt="PNG image"></img>'
return html % data
def save_png(self, file_name):
"""Save to a PNG image file."""
if len(file_name) != 0:
w2if = tvtk.WindowToImageFilter(read_front_buffer=True)
w2if.magnification = self.magnification
self._lift()
w2if.input = self._renwin
ex = tvtk.PNGWriter()
ex.file_name = file_name
ex.input = w2if.output
self._exporter_write(ex)
def save_png(self, file_name):
"""Save to a PNG image file."""
if len(file_name) != 0:
w2if = tvtk.WindowToImageFilter(
read_front_buffer=not self.off_screen_rendering)
w2if.magnification = self.magnification
self._lift()
w2if.input = self._renwin
ex = tvtk.PNGWriter()
ex.file_name = file_name
configure_input(ex, w2if)
self._exporter_write(ex)
def on_key_down(iren_style, key):
rendrr = iren_style.GetCurrentRenderer()
rendrr = tvtk.to_tvtk(rendrr)
if key == '+':
for act in rendrr.actors:
act.property.point_size *= 1.1
elif key == '-':
for act in rendrr.actors:
act.property.point_size /= 1.1
elif key == 's':
ren_win = rendrr.render_window
w2if = tvtk.WindowToImageFilter(input=ren_win)
w2if.update()
writer = tvtk.PNGWriter(file_name=snapshot_file, input=w2if.output)
writer.write()
def _handle_failed_image(idiff, src_img, pngr, img_fname):
"""Writes all the necessary images when an image comparison
failed."""
f_base, f_ext = os.path.splitext(img_fname)
# write out the difference file in full.
pngw = tvtk.PNGWriter(file_name=f_base + ".diff.png")
configure_input(pngw, idiff)
pngw.write()
# write the difference image scaled and gamma adjusted for the
# dashboard.
sz = pngr.output.dimensions
if sz[1] <= 250.0:
mag = 1.0
else:
mag = 250.0/sz[1]
shrink = tvtk.ImageResample(interpolate=1)
configure_input(shrink, idiff.output)
shrink.set_axis_magnification_factor(0, mag)
shrink.set_axis_magnification_factor(1, mag)
gamma = tvtk.ImageShiftScale(shift=0, scale=10)
configure_input(gamma, shrink)
jpegw = tvtk.JPEGWriter(file_name=f_base + ".diff.small.jpg",
quality=85)
configure_input(jpegw, gamma)
jpegw.write()
# write out the image that was generated.
pngw.trait_set(file_name=f_base + ".test.png")
configure_input(pngw, src_img)
pngw.write()
# write out a smaller version of the image that was generated.
configure_input(shrink, idiff.input)
jpegw.trait_set(file_name=f_base + ".test.small.jpg")
configure_input(jpegw, shrink)
jpegw.write()
# write out the valid image that matched.
configure_input(shrink, idiff.image)
jpegw.trait_set(file_name=f_base + ".small.jpg")
configure_input(jpegw, shrink)
jpegw.write()
def render_bitmap(self,
width,
height,
filename=None,
azimuth=15.0,
elevation=30.0,
roll=0.0,
zoom=1.0,
pan_h=0.0,
pan_v=0.0):
renderer = tvtk.Renderer()
for actor in self.scene.actor_list:
renderer.add_actor(actor)
renderer.background = (1, 1, 0.8)
renderer.reset_camera()
camera = renderer.active_camera
camera.roll(roll)
camera.elevation(elevation)
camera.azimuth(azimuth)
camera.dolly(zoom)
camera.yaw(pan_h)
camera.pitch(pan_v)
renderWindow = tvtk.RenderWindow()
renderWindow.off_screen_rendering = True
renderWindow.add_renderer(renderer)
renderWindow.size = (width, height)
renderWindow.render()
windowToImageFilter = tvtk.WindowToImageFilter()
windowToImageFilter.input = renderWindow
windowToImageFilter.update()
writer = tvtk.PNGWriter()
if filename is not None:
writer.file_name = filename
writer.write_to_memory = False
else:
writer.write_to_memory = True
writer.input_connection = windowToImageFilter.output_port
writer.write()
#data = numpy.asarray(writer.result).tostring()
return writer.result
def _render_animation_fired(self):
self.stop = True
n_frames_render = self.render_to_frame - self.render_from_frame
# prepare the render window
renwin = self._figure.scene.render_window
aa_frames = renwin.aa_frames
renwin.aa_frames = 8
renwin.alpha_bit_planes = 1
# turn on off screen rendering
#renwin.off_screen_rendering = True
# set size of window
if self.fix_image_size:
orig_size = renwin.size
renwin.size = self.image_size
# render the frames
progress = ProgressDialog(title="Rendering", max=n_frames_render,
show_time=True, can_cancel=True)
progress.open()
self.is_rendering_animation = True
for frame in range(self.render_from_frame, self.render_to_frame + 1):
# move animation to desired frame, this will also render the scene
self.current_frame = frame
# prepare window to image writer
render = tvtk.WindowToImageFilter(input=renwin, magnification=1)#, input_buffer_type='rgba')
if not self.fix_image_size:
render.magnification = self.magnification
exporter = tvtk.PNGWriter(file_name=path.join(self.render_directory, self.render_name_pattern % frame))
configure_input(exporter,render)
exporter.write()
do_continue, skip = progress.update(frame - self.render_from_frame)
if not do_continue:
break
# reset the render window to old values
renwin.aa_frames = aa_frames
if self.fix_image_size:
renwin.size = orig_size
#renwin.off_screen_rendering = False
self.is_rendering_animation = False
progress.close()
def compare_image_with_saved_image(src_img,
img_fname,
threshold=10,
allow_resize=True):
"""Compares a source image (src_img, which is a tvtk.ImageData)
with the saved image file whose name is given in the second
argument. If the image file does not exist the image is generated
and stored. If not the source image is compared to that of the
figure. This function also handles multiple images and finds the
best matching image. If `allow_resize` is True then the images
are rescaled if they are not of the same size.
"""
f_base, f_ext = os.path.splitext(os.path.abspath(img_fname))
if not os.path.isfile(img_fname):
# generate the image
pngw = tvtk.PNGWriter(file_name=img_fname, input=src_img)
pngw.write()
if VERBOSE:
print "Creating baseline image '%s'." % img_fname
return
pngr = tvtk.PNGReader(file_name=img_fname)
pngr.update()
if allow_resize:
src_resample = tvtk.ImageResample(input=src_img,
interpolate=1,
interpolation_mode='cubic')
img_resample = tvtk.ImageResample(input=pngr.output,
interpolate=1,
interpolation_mode='cubic')
_set_scale(src_resample, img_resample)
idiff = tvtk.ImageDifference(input=src_resample.output,
image=img_resample.output)
else:
idiff = tvtk.ImageDifference(input=src_img, image=pngr.output)
idiff.update()
min_err = idiff.thresholded_error
img_err = min_err
best_img = img_fname
err_index = 0
count = 0
if min_err > threshold:
count = 1
test_failed = 1
err_index = -1
while 1: # keep trying images till we get the best match.
new_fname = f_base + "_%d.png" % count
if not os.path.exists(new_fname):
# no other image exists.
break
# since file exists check if it matches.
pngr.file_name = new_fname
pngr.update()
if allow_resize:
_set_scale(src_resample, img_resample)
idiff.update()
alt_err = idiff.thresholded_error
if alt_err < threshold:
# matched,
err_index = count
test_failed = 0
min_err = alt_err
img_err = alt_err
best_img = new_fname
break
else:
if alt_err < min_err:
# image is a better match.
err_index = count
min_err = alt_err
img_err = alt_err
best_img = new_fname
count = count + 1
# closes while loop.
if test_failed:
_handle_failed_image(idiff, src_img, pngr, best_img)
_print_image_error(img_err, err_index, f_base)
msg = "Failed image test: %f\n" % idiff.thresholded_error
raise AssertionError, msg
# output the image error even if a test passed
_print_image_success(img_err, err_index)
def __png_writer_default(self):
return tvtk.PNGWriter(write_to_memory=True)
m = tvtk.PolyDataMapper() # Note that VTK's GetOutput method is special because it has two call # signatures: GetOutput() and GetOutput(int N) (which gets the N'th # output). In tvtk it is represented as both a property and as a # method. Using the output property will work fine if all you want is # the default output. OTOH if you want the N'th output use # get_output(N). m.input = cs.output # or m.input = cs.get_output() # Create the actor and set its mapper. a = tvtk.Actor(mapper=m) # Create a Renderer, add the actor and set its background color. ren = tvtk.Renderer(background=(0.1, 0.2, 0.4)) ren.add_actor(a) ren.reset_camera() # Create a RenderWindow, add the renderer and set its size. rw = tvtk.RenderWindow(size=(300, 300)) rw.off_screen_rendering = 1 rw.add_renderer(ren) w2if = tvtk.WindowToImageFilter() w2if.magnification = 2 w2if.input = rw ex = tvtk.PNGWriter() ex.file_name = "example.png" ex.input = w2if.output ex.write()
def ipython_view(self, width, height, view={}):
import ipywidgets as widgets
from IPython.display import Image, display, clear_output
renderer = tvtk.Renderer()
for actor in self.scene.actor_list:
renderer.add_actor(actor)
renderer.background = (1, 1, 0.8)
#
renderer.reset_camera()
camera = renderer.active_camera
if "position" in view:
camera.position = view['position']
if "focal_point" in view:
camera.focal_point = view['focal_point']
if "view_up" in view:
camera.view_up = view['view_up']
#
renderWindow = tvtk.RenderWindow()
renderWindow.off_screen_rendering = True
renderWindow.add_renderer(renderer)
renderWindow.size = (width, height)
renderWindow.render()
windowToImageFilter = tvtk.WindowToImageFilter()
windowToImageFilter.input = renderWindow
windowToImageFilter.update()
#
filename = "/dev/shm/temp_vtk_put.png"
writer = tvtk.PNGWriter()
writer.file_name = filename
writer.write_to_memory = False
writer.input_connection = windowToImageFilter.output_port
writer.write()
view_out = {}
def show():
clear_output(wait=True)
renderer.reset_camera_clipping_range()
renderer.modified()
renderWindow.render()
windowToImageFilter.input = renderWindow
windowToImageFilter.modified()
windowToImageFilter.update()
writer.write()
view_out.update({
"position": tuple(camera.position),
"view_up": tuple(camera.view_up),
"focal_point": tuple(camera.focal_point)
})
return display(Image(filename), grp)
def r_up(arg):
camera.orthogonalize_view_up()
camera.elevation(10)
return show()
def r_down(arg):
camera.orthogonalize_view_up()
camera.elevation(-10)
return show()
def r_left(arg):
camera.orthogonalize_view_up()
camera.azimuth(10)
return show()
def r_right(arg):
camera.orthogonalize_view_up()
camera.azimuth(-10)
return show()
def pan_left(arg):
camera.orthogonalize_view_up()
camera.yaw(-2)
return show()
def pan_right(arg):
camera.orthogonalize_view_up()
camera.yaw(2)
return show()
def pan_up(arg):
camera.orthogonalize_view_up()
camera.pitch(-2)
return show()
def pan_down(arg):
camera.orthogonalize_view_up()
camera.pitch(2)
return show()
def roll_left(arg):
camera.roll(10)
return show()
def roll_right(arg):
camera.roll(-10)
return show()
def zoom_in(arg):
camera.dolly(1.2)
return show()
def zoom_out(arg):
camera.dolly(0.8)
return show()
b1 = widgets.Button(description='\u2191')
b1.on_click(r_up)
b2 = widgets.Button(description='\u2193')
b2.on_click(r_down)
b3 = widgets.Button(description='\u2190')
b3.on_click(r_left)
b4 = widgets.Button(description='\u2192')
b4.on_click(r_right)
b5 = widgets.Button(description='\u21ba')
b5.on_click(roll_left)
b6 = widgets.Button(description='\u21bb')
b6.on_click(roll_right)
b7 = widgets.Button(description='+')
b7.on_click(zoom_in)
b8 = widgets.Button(description='-')
b8.on_click(zoom_out)
b9 = widgets.Button(description='\u2190')
b9.on_click(pan_left)
b10 = widgets.Button(description='\u2192')
b10.on_click(pan_right)
b11 = widgets.Button(description='\u2191')
b11.on_click(pan_up)
b12 = widgets.Button(description='\u2193')
b12.on_click(pan_down)
grp1 = widgets.HBox(border_style="solid",
border_width=1,
border_radius=5,
padding=2,
margin=1)
grp1.children = [b1, b2, b3, b4, b5, b6]
grp2 = widgets.HBox(border_style="solid",
border_width=1,
border_radius=5,
padding=2,
margin=1)
grp2.children = [b7, b8, b9, b10, b11, b12]
grp = widgets.HBox(children=[grp1, grp2])
show()
return view_out
