def export_to_png(self, filename, *args, **kwargs):
'''Saves an image of the widget and its children in png format at the
specified filename. Works by removing the widget canvas from its
parent, rendering to an :class:`~kivy.graphics.fbo.Fbo`, and calling
:meth:`~kivy.graphics.texture.Texture.save`.
.. note::
The image includes only this widget and its children. If you want
to include widgets elsewhere in the tree, you must call
:meth:`~Widget.export_to_png` from their common parent, or use
:meth:`~kivy.core.window.WindowBase.screenshot` to capture the
whole window.
.. note::
The image will be saved in png format, you should include the
extension in your filename.
.. versionadded:: 1.9.0
:Parameters:
`filename`: str
The filename with which to save the png.
`scale`: float
The amount by which to scale the saved image, defaults to 1.
.. versionadded:: 1.11.0
'''
scale = kwargs.get('scale', 1)
if self.parent is not None:
canvas_parent_index = self.parent.canvas.indexof(self.canvas)
if canvas_parent_index > -1:
self.parent.canvas.remove(self.canvas)
fbo = Fbo(size=(self.width * scale, self.height * scale),
with_stencilbuffer=True)
with fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
Scale(1, -1, 1)
Scale(scale, scale, 1)
Translate(-self.x, -self.y - self.height, 0)
fbo.add(self.canvas)
fbo.draw()
fbo.texture.save(filename, flipped=False)
fbo.remove(self.canvas)
if self.parent is not None and canvas_parent_index > -1:
self.parent.canvas.insert(canvas_parent_index, self.canvas)
return True
def __init__(self, **kwargs):
super(Graph, self).__init__(**kwargs)
with self.canvas:
self._fbo = Fbo(size=self.size)
self._marker_color = Color(self.marker_color)
self._marker = Line()
with self._fbo:
self._background_color = Color(*self.background_color)
self._background_rect = Rectangle(size=self.size)
self._mesh_ticks_color = Color(*self.tick_color)
self._mesh_ticks = Mesh(mode='lines')
self._mesh_rect_color = Color(*self.border_color)
self._mesh_rect = Mesh(mode='line_strip')
with self.canvas:
Color(1, 1, 1)
self._fbo_rect = Rectangle(size=self.size)
mesh = self._mesh_rect
mesh.vertices = [0] * (5 * 4)
mesh.indices = range(5)
self._plot_area = StencilView()
self.add_widget(self._plot_area)
t = self._trigger = Clock.create_trigger(self._redraw_all)
ts = self._trigger_size = Clock.create_trigger(self._redraw_size)
tc = self._trigger_color = Clock.create_trigger(self._update_colors)
self.bind(center=ts,
padding=ts,
precision=ts,
plots=ts,
x_grid=ts,
y_grid=ts,
draw_border=ts)
self.bind(xmin=t,
xmax=t,
xlog=t,
x_ticks_major=t,
x_ticks_minor=t,
xlabel=t,
x_grid_label=t,
ymin=t,
ymax=t,
ylog=t,
y_ticks_major=t,
y_ticks_minor=t,
ylabel=t,
y_grid_label=t,
font_size=t,
label_options=t)
self.bind(tick_color=tc, background_color=tc, border_color=tc)
self._trigger()
def circle_fs(size=(64, 64)):
fbo = Fbo(size=size)
fbo.shader.fs = circle_test
with fbo:
Color(1, 1, 1)
Rectangle(size=size)
fbo.draw()
return fbo.texture
def init_fbo(self):
with self.canvas:
Color(1, 1, 1)
self.g_fbo = Fbo(size=self.size)
self.g_fbo_texture = self.g_fbo.texture
Color(1, 1, 1, 1)
PushMatrix()
self.g_scale = Scale(self.width / 2, self.height / 2, 1.)
self.build_grid()
PopMatrix()
def test_fbo_pixels(self):
from kivy.graphics import Fbo, ClearColor, ClearBuffers, Ellipse
fbo = Fbo(size=(512, 512))
with fbo:
ClearColor(0, 0, 0, 1)
ClearBuffers()
Ellipse(pos=(100, 100), size=(100, 100))
fbo.draw()
data = fbo.pixels
fbo.texture.save('results.png')
def add_roi_fbo(self, obj, new_value):
with self.canvas:
fbo = Fbo(size=self.texture.size)
color = Color(*roi_colors[new_value % len(roi_colors)])
rect = Rectangle(size=self.vid_size,
pos=self.vid_pos,
texture=fbo.texture)
self.bind(
vid_size=lambda s, *args: setattr(rect, 'size', self.vid_size),
vid_pos=lambda s, *args: setattr(rect, 'pos', self.vid_pos))
self.fbo_list.append((fbo, color, rect))
def init_camera(self):
self._release_camera()
self._android_camera = Camera.open(self._index)
params = self._android_camera.getParameters()
width, height = self._resolution
zoom = self._zoom # edit by ableity
focusmode = self._focusmode # edit by lilei
params.setPreviewSize(width, height)
params.setFocusMode(focusmode) #edit by lilei
params.setZoom(zoom) # edit by ableity
self._android_camera.setParameters(params)
# self._android_camera.setDisplayOrientation()
self.fps = 30.
pf = params.getPreviewFormat()
assert (pf == ImageFormat.NV21) # default format is NV21
self._bufsize = int(
ImageFormat.getBitsPerPixel(pf) / 8. * width * height)
self._camera_texture = Texture(width=width,
height=height,
target=GL_TEXTURE_EXTERNAL_OES,
colorfmt='rgba')
self._surface_texture = SurfaceTexture(int(self._camera_texture.id))
self._android_camera.setPreviewTexture(self._surface_texture)
self._fbo = Fbo(size=self._resolution)
self._fbo['resolution'] = (float(width), float(height))
self._fbo.shader.fs = '''
#extension GL_OES_EGL_image_external : require
#ifdef GL_ES
precision highp float;
#endif
/* Outputs from the vertex shader */
varying vec4 frag_color;
varying vec2 tex_coord0;
/* uniform texture samplers */
uniform sampler2D texture0;
uniform samplerExternalOES texture1;
uniform vec2 resolution;
void main()
{
vec2 coord = vec2(tex_coord0.y * (
resolution.y / resolution.x), 1. -tex_coord0.x);
gl_FragColor = texture2D(texture1, tex_coord0);
}
'''
with self._fbo:
self._texture_cb = Callback(
lambda instr: self._camera_texture.bind)
Rectangle(size=self._resolution)
def setupVTK(self):
Clock.schedule_interval(self.updateVTK, 1 / 1.)
with self.canvas:
self.fbo = Fbo(size=(512, 512),
clear_color=(.3, .3, .3, .8),
push_viewport=True,
with_depthbuffer=True)
self.size = self.fbo.size
Color(0, 0, 1)
Rectangle(pos=self.pos, size=self.size, texture=self.fbo.texture)
Callback(self.drawVTK, reset_context=True)
def make_screen_fbo(self, screen):
fbo = Fbo(size=screen.size, with_stencilbuffer=True)
with fbo:
ClearColor(*self.clearcolor)
ClearBuffers()
fbo.add(screen.canvas)
with fbo.before:
PushMatrix()
Translate(-screen.x, -screen.y, 0)
with fbo.after:
PopMatrix()
return fbo
def make_screen_fbo(self, screen):
fbo = Fbo(size=screen.size)
with fbo:
ClearColor(0, 0, 0, 1)
ClearBuffers()
fbo.add(screen.canvas)
with fbo.before:
PushMatrix()
Translate(-screen.x, -screen.y, 0)
with fbo.after:
PopMatrix()
return fbo
def __init__(self, **kwargs):
super(PostEffect, self).__init__(**kwargs)
self.canvas = RenderContext(use_parent_projection=True)
self.fs = Shaders.shader_pulse
self.mouse = (0, 0)
self.textures = []
with self.canvas:
self.fbo = Fbo(size=SIZE, use_parent_projection=True)
self.texture0 = Rectangle(size=SIZE)
self.texture = self.fbo.texture
self.texture.flip_vertical()
def __init__(self, **kwargs):
super(Graph, self).__init__(**kwargs)
with self.canvas:
self._fbo = Fbo(size=self.size, with_stencilbuffer=True)
with self._fbo:
self._background_color = Color(*self.background_color)
self._background_rect = Rectangle(size=self.size)
self._mesh_ticks_color = Color(*self.tick_color)
self._mesh_ticks = Mesh(mode='lines')
self._mesh_rect_color = Color(*self.border_color)
self._mesh_rect = Mesh(mode='line_strip')
with self.canvas:
Color(1, 1, 1)
self._fbo_rect = Rectangle(size=self.size,
texture=self._fbo.texture)
mesh = self._mesh_rect
mesh.vertices = [0] * (5 * 4)
mesh.indices = range(5)
self._plot_area = StencilView()
self.add_widget(self._plot_area)
self._trigger = Clock.create_trigger(self._redraw_all)
self._trigger_size = Clock.create_trigger(self._redraw_size)
self.bind(center=self._trigger_size,
padding=self._trigger_size,
font_size=self._trigger_size,
plots=self._trigger_size,
x_grid=self._trigger_size,
y_grid=self._trigger_size,
draw_border=self._trigger_size)
self.bind(xmin=self._trigger,
xmax=self._trigger,
xlog=self._trigger,
x_ticks_major=self._trigger,
x_ticks_minor=self._trigger,
xlabel=self._trigger,
x_grid_label=self._trigger,
ymin=self._trigger,
ymax=self._trigger,
ylog=self._trigger,
y_ticks_major=self._trigger,
y_ticks_minor=self._trigger,
ylabel=self._trigger,
y_grid_label=self._trigger)
self._trigger()
def hue_transform(source, hue, size=(64, 64)):
fbo = Fbo(size=size)
fbo.shader.fs = hue_xfo
# use the shader on the entire surface
fbo['hueAdjust'] = float(hue)
with fbo:
Color(1, 1, 1)
Rectangle(size=size, source=source)
fbo.draw()
return fbo.texture
def advanced_gradient(border_color=(1, 1, 0), center_color=(1, 0, 0), size=(64, 64),fs=radial_grd_fs):
fbo = Fbo(size=size)
fbo.shader.fs = fs
# use the shader on the entire surface
fbo['border_color'] = map(float, border_color)
fbo['center_color'] = map(float, center_color)
with fbo:
Color(1, 1, 1)
Rectangle(size=size)
fbo.draw()
return fbo.texture
def setup_panda(self, *largs):
self.msb = ModelShowbase()
self.msb.camLens.setFov(52.0)
self.msb.camLens.setNearFar(1.0, 10000.0)
with self.canvas:
self.fbo = Fbo(size=self.size, clear_color=(.3, .3, .3, .2))
Color(1, 1, 1)
self.viewport = Rectangle(pos=self.pos,
size=self.size,
texture=self.fbo.texture)
Callback(self.draw_panda, reset_context=True)
Clock.schedule_interval(self.update_panda, 1 / 60.)
def test_fbo_pixels(self):
from kivy.graphics import Fbo, ClearColor, ClearBuffers, Ellipse
fbo = Fbo(size=(512, 512))
with fbo:
ClearColor(0, 0, 0, 1)
ClearBuffers()
Ellipse(pos=(100, 100), size=(100, 100))
fbo.draw()
data = fbo.pixels
import pygame
surface = pygame.image.fromstring(data, (512, 512), 'RGBA', True)
pygame.image.save(surface, "results.png")
def __init__(self, **kwargs):
self.mesh_data = MeshData()
self.canvas = Canvas()
with self.canvas:
self.fbo = Fbo(size=(10, 10), compute_normal_mat=True)
self.fbo.add_reload_observer(self.populate_fbo)
with self.fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
self.populate_fbo(self.fbo)
super(GLWindow, self).__init__(**kwargs)
Clock.schedule_interval(self.update_glsl, 1 / 60.)
def __init__(self, **kwargs):
super().__init__(**kwargs)
Tex1 = Texture.create(size=T_SIZE, colorfmt="rgba", bufferfmt="float")
Tex2 = Texture.create(size=T_SIZE, colorfmt="rgba", bufferfmt="float")
Tex3 = Texture.create(size=T_SIZE, colorfmt="rgba", bufferfmt="float")
Tex4 = Texture.create(size=T_SIZE, colorfmt="rgba", bufferfmt="float")
Tex4.mag_filter = "linear"
self.fbo_edit = Fbo(clear_color=(0.5,0.5,0,1),size=(T_SIZE),texture=Tex1)
self.fbo_edit.shader.vs = open("data/shaders/vs.glsl").read()
self.fbo_edit.shader.fs = open("data/shaders/fs_edit.glsl").read()
self.fbo_edit["viewport"] = [float(s) for s in W_SIZE]
self.fbo_edit["mode"] = 0
self.fbo_mix = Fbo(clear_color=(0.5,0.5,0,1),size=(T_SIZE),texture=Tex2)
self.fbo_mix.shader.vs = open("data/shaders/vs.glsl").read()
self.fbo_mix.shader.fs = open("data/shaders/fs_mix.glsl").read()
self.fbo_mix["tex1"] = 1
self.fbo_mix["tex2"] = 2
self.fbo_mix["viewport"] = [float(s) for s in W_SIZE]
self.fbo_save = Fbo(clear_color=(0.5,0.5,0,1),size=(T_SIZE),texture=Tex3)
self.fbo_save.shader.vs = open("data/shaders/vs.glsl").read()
self.fbo_save.shader.fs = open("data/shaders/fs_save.glsl").read()
self.fbo_save["tex"] = 3
self.fbo_save["viewport"] = [float(s) for s in W_SIZE]
self.fbo_warp = Fbo(size=(T_SIZE),texture=Tex4)
self.fbo_warp.shader.vs = open("data/shaders/vs.glsl").read()
self.fbo_warp.shader.fs = open("data/shaders/fs_warp.glsl").read()
self.fbo_warp["tex"] = 4
self.fbo_warp["warp"] = 5
self.fbo_warp["viewport"] = [float(s) for s in W_SIZE]
self.tex = Texture.create(size=T_SIZE,colorfmt="rgb",bufferfmt="ubyte")
self.tex.blit_buffer(IMG)
def setup_panda(self, *largs):
self.msb = msb = ModelShowbase()
msb.camLens.setFov(52.0)
msb.camLens.setNearFar(1.0, 10000.0)
self.node = Node(node=msb.render.attachNewNode('PandaView'))
with self.canvas:
self.fbo = Fbo(size=self.size)
self.viewport = Rectangle(
pos=self.pos,
size=self.size,
)
Callback(self.draw_panda, reset_context=True)
Clock.schedule_interval(self.update_panda, 1 / 60.)
def __init__(self, **kwargs):
# Make sure opengl context exists
EventLoop.ensure_window()
self.mask_effect = kwargs.get("mask_effect", None)
self.motion_effect = kwargs.get("motion_effect", None)
self.fbo_canvas = kwargs.get("motion_effect", None)
self.canvas = RenderContext(use_parent_projection=True,
use_parent_modelview=True,
with_depthbuffer=True)
self.size = C_SIZE
with self.canvas:
#self._viewport = Rectangle(size=(800,600), pos=self.pos)
self.fbo = Fbo(size=C_SIZE,
with_depthbuffer=True,
compute_normal_mat=True,
clear_color=(0.3, 0.3, 0.7, 1))
with self.fbo.before:
#Rectangle(size=(800, 600))
PushMatrix()
self.fbo_translation = Translate(-self.x, -self.y, 0)
BindTexture(texture=self.fbo_canvas.texture, index=1)
BindTexture(texture=self.mask_effect.texture, index=4)
BindTexture(texture=self.motion_effect.texture, index=5)
with self.fbo:
Color(0, 0, 0)
BindTexture(texture=self.fbo_canvas.texture, index=1)
BindTexture(texture=self.mask_effect.texture, index=4)
BindTexture(texture=self.motion_effect.texture, index=5)
self.fbo_rectangle = Rectangle(size=C_SIZE)
self._instructions = InstructionGroup()
with self.fbo.after:
PopMatrix()
self.cbs = Callback(self.reset_gl_context)
super(EffectWidget, self).__init__(**kwargs)
self.size = C_SIZE
Clock.schedule_interval(self.update_glsl, 0)
self._instructions.add(Callback(self.setup_gl_context))
self.refresh_fbo_setup()
Clock.schedule_interval(self.update_fbos, 0)
def insert_color_ellipse(state, texture_w, texture_h, texture_name, c_r, c_g,
c_b):
"""
TODO
"""
tile_size = screen.get_tile_size(state)
texture_w *= tile_size
texture_h *= tile_size
texture = Texture.create(size=(texture_w, texture_h), colorfmt='rgba')
fbo = Fbo(size=(texture_w, texture_h), texture=texture)
with fbo:
Color(c_r, c_g, c_b)
Ellipse(pos=(0, 0), size=(texture_w, texture_h))
fbo.draw()
insert(state, texture_name, texture)
def export_scaled_png(self):
re_size = (720, 480)
image_scale = 720/self.width
fbo = Fbo(size=re_size, with_stencilbuffer=True)
with fbo:
ClearColor(0, 0, 0, 0)
ClearBuffers()
Scale(image_scale, -image_scale, image_scale)
Translate(-self.x, -self.y - self.height, 0)
fbo.add(self.canvas)
fbo.draw()
fbo.texture.save('images/complete/%s_mask.jpg'%self.img_name[:-4], flipped=False)
fbo.remove(self.canvas)
def export_to_png(self, filename, *args):
if self.parent is not None:
canvas_parent_index = self.parent.canvas.indexof(self.canvas)
self.parent.canvas.remove(self.canvas)
fbo = Fbo(size=self.size, with_stencilbuffer=True)
with fbo:
ClearColor(0, 0, 0, 1)
ClearBuffers()
Scale(1, -1, 1)
Translate(-self.x, -self.y - self.height, 0)
fbo.add(self.canvas)
fbo.draw()
fbo.texture.save(filename, flipped=False)
fbo.remove(self.canvas)
if self.parent is not None:
self.parent.canvas.insert(canvas_parent_index, self.canvas)
return True
def __init__(self, **kwargs): super(MyW, self).__init__(**kwargs) with self.canvas: self.fbo = Fbo(size=(256, 256)) Rectangle(size=(32, 32), texture=self.fbo.texture) Rectangle(pos=(32, 0), size=(64, 64), texture=self.fbo.texture) Rectangle(pos=(96, 0), size=(128, 128), texture=self.fbo.texture) Rectangle(pos=(224, 0), size=(256, 128), texture=self.fbo.texture) with self.fbo: Color(1, 0, 0, .8) Rectangle(size=(256, 64)) Color(0, 1, 1, .8) Rectangle(size=(64, 256))
def __init__(self, **kwargs):
super(FboTest, self).__init__(**kwargs)
self.positions = ((260.0, 260.0), (192.0, 192.0), (96.0, 192.0),
(192.0, 96.0), (96.0, 96.0), (32.0, 192.0),
(192.0, 32.0), (32.0, 32.0))
self.fbo = Fbo(size=(256, 256))
with self.fbo:
Color(0.56789, 0, 0, 1)
Rectangle(size=(256, 64))
Color(0, 0.56789, 0, 1)
Rectangle(size=(64, 256))
Color(0.56789, 0, 0, .5)
Rectangle(pos=(64, 64), size=(192, 64))
Color(0, 0.56789, 0, .5)
Rectangle(pos=(64, 64), size=(64, 192))
self.fbo.draw()
def __init__(self, **kwargs):
# get raw rgb thumb is available
self.thumb = kwargs.get('thumb', None)
del kwargs['thumb']
# extract controler now, we need it.
self.ctrl = kwargs.get('ctrl')
# create fbo for tiny texture
self.fbo = Fbo(size=(160, 120))
with self.fbo:
Color(1, 1, 1)
Rectangle(size=self.fbo.size)
self.fborect = Rectangle(size=self.fbo.size)
if self.thumb:
self.upload_thumb()
else:
self.update_capture()
super(Slide, self).__init__(**kwargs)
def __init__(self, **kwargs):
super(Scaled, self).__init__(**kwargs)
self.elements = []
self.pointsize = 5 # this multiplies by two according to kivy docs
with self.canvas:
self._fbo = Fbo(size=self.size)
self._rect = Rectangle(texture=self._fbo.texture)
with self._fbo:
Color(1, 1, 1)
self._fborect = Rectangle(size=self._fbo.size)
Color(0, 0, 1)
self._points = Point(pointsize=self.pointsize)
self._fbo.add_reload_observer(self._clear_fbo)
self.bind(pos=self._update_rect, size=self._update_rect)
def __init__(self, **kwargs):
super(Pad, self).__init__(**kwargs)
# Which elements exist in the grid in the normalized coordinates
self.elements = []
self.oldxy = None
with self.canvas:
self._fbo = Fbo(size=self.size)
self._rect = Rectangle(texture=self._fbo.texture)
with self._fbo:
Color(1, 1, 1)
self._fborect = Rectangle(size=self._fbo.size)
Color(1, 0, 0)
self._fbo.add_reload_observer(self._clear_fbo)
self.bind(pos=self._update_rect, size=self._update_rect)
def export_to_png(self, filename, *args):
'''Saves an image of the widget and its children in png format at the
specified filename. Works by removing the widget canvas from its
parent, rendering to an :class:`~kivy.graphics.fbo.Fbo`, and calling
:meth:`~kivy.graphics.texture.Texture.save`.
.. note::
The image includes only this widget and its children. If you want to
include widgets elsewhere in the tree, you must call
:meth:`~Widget.export_to_png` from their common parent, or use
:meth:`~kivy.core.window.Window.screenshot` to capture the whole
window.
.. note::
The image will be saved in png format, you should include the
extension in your filename.
.. versionadded:: 1.8.1
'''
if self.parent is not None:
canvas_parent_index = self.parent.canvas.indexof(self.canvas)
self.parent.canvas.remove(self.canvas)
fbo = Fbo(size=self.size)
with fbo:
ClearColor(0, 0, 0, 1)
ClearBuffers()
Translate(-self.x, -self.y, 0)
fbo.add(self.canvas)
fbo.draw()
fbo.texture.save(filename)
fbo.remove(self.canvas)
if self.parent is not None:
self.parent.canvas.insert(canvas_parent_index, self.canvas)
return True
def __init__(self, **kwargs):
self.lock = Lock()
self.gl_depth = -3
self.mesh_data = MeshData()
self.mesh_data.vertices = np.array([0, 0, 0, 0, 0, 0, 0, 0])
self.mesh_data.indices = np.array([0])
self.points = None
self.canvas = Canvas()
with self.canvas:
self.fbo = Fbo(size=(10, 10), compute_normal_mat=True)
self.fbo.add_reload_observer(self.populate_fbo)
with self.fbo:
ClearColor(1, 1, 1, 1)
ClearBuffers()
self.populate_fbo(self.fbo)
super(ObjectRenderer, self).__init__(**kwargs)
Clock.schedule_interval(self.update_glsl, 1 / 10.)
