Kivy-examples 2.3.1.dev0__py3-none-any.whl

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kinect/kinectviewer.py

@@ -0,0 +1,283 @@
+import freenect
+from time import sleep
+from threading import Thread
+from collections import deque
+from kivy.app import App
+from kivy.clock import Clock
+from kivy.properties import NumericProperty, StringProperty
+from kivy.graphics import RenderContext, Color, Rectangle
+from kivy.graphics.texture import Texture
+from kivy.core.window import Window
+from kivy.uix.widget import Widget
+from kivy.uix.slider import Slider
+from kivy.uix.boxlayout import BoxLayout
+
+
+fragment_header = '''
+#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;
+
+/* custom input */
+uniform float depth_range;
+uniform vec2 size;
+'''
+
+hsv_func = '''
+vec3 HSVtoRGB(vec3 color) {
+    float f,p,q,t, hueRound;
+    int hueIndex;
+    float hue, saturation, v;
+    vec3 result;
+
+    /* just for clarity */
+    hue = color.r;
+    saturation = color.g;
+    v = color.b;
+
+    hueRound = floor(hue * 6.0);
+    hueIndex = mod(int(hueRound), 6.);
+    f = (hue * 6.0) - hueRound;
+    p = v * (1.0 - saturation);
+    q = v * (1.0 - f*saturation);
+    t = v * (1.0 - (1.0 - f)*saturation);
+
+    switch(hueIndex) {
+        case 0:
+            result = vec3(v,t,p);
+        break;
+        case 1:
+            result = vec3(q,v,p);
+        break;
+        case 2:
+            result = vec3(p,v,t);
+        break;
+        case 3:
+            result = vec3(p,q,v);
+        break;
+        case 4:
+            result = vec3(t,p,v);
+        break;
+        case 5:
+            result = vec3(v,p,q);
+        break;
+    }
+    return result;
+}
+'''
+
+rgb_kinect = fragment_header + '''
+void main (void) {
+    float value = texture2D(texture0, tex_coord0).r;
+    value = mod(value * depth_range, 1.);
+    vec3 col = vec3(0., 0., 0.);
+    if ( value <= 0.33 )
+        col.r = clamp(value, 0., 0.33) * 3.;
+    if ( value <= 0.66 )
+        col.g = clamp(value - 0.33, 0., 0.33) * 3.;
+    col.b = clamp(value - 0.66, 0., 0.33) * 3.;
+    gl_FragColor = vec4(col, 1.);
+}
+'''
+
+points_kinect = fragment_header + hsv_func + '''
+void main (void) {
+    // threshold used to reduce the depth (better result)
+    const int th = 5;
+
+    // size of a square
+    int square = floor(depth_range);
+
+    // number of square on the display
+    vec2 count = size / square;
+
+    // current position of the square
+    vec2 pos = floor(tex_coord0.xy * count) / count;
+
+    // texture step to pass to another square
+    vec2 step = 1 / count;
+
+    // texture step to pass to another pixel
+    vec2 pxstep = 1 / size;
+
+    // center of the square
+    vec2 center = pos + step / 2.;
+
+    // calculate average of every pixels in the square
+    float s = 0, x, y;
+    for (x = 0; x < square; x++) {
+        for (y = 0; y < square; y++) {
+            s += texture2D(texture0, pos + pxstep * vec2(x,y)).r;
+        }
+    }
+    float v = s / (square * square);
+
+    // threshold the value
+    float dr = th / 10.;
+    v = min(v, dr) / dr;
+
+    // calculate the distance between the center of the square and current
+    // pixel; display the pixel only if the distance is inside the circle
+    float vdist = length(abs(tex_coord0 - center) * size / square);
+    float value = 1 - v;
+    if ( vdist < value ) {
+        vec3 col = HSVtoRGB(vec3(value, 1., 1.));
+        gl_FragColor = vec4(col, 1);
+    }
+}
+'''
+hsv_kinect = fragment_header + hsv_func + '''
+void main (void) {
+    float value = texture2D(texture0, tex_coord0).r;
+    value = mod(value * depth_range, 1.);
+    vec3 col = HSVtoRGB(vec3(value, 1., 1.));
+    gl_FragColor = vec4(col, 1.);
+}
+'''
+
+
+class KinectDepth(Thread):
+
+    def __init__(self, *largs, **kwargs):
+        super(KinectDepth, self).__init__(*largs, **kwargs)
+        self.daemon = True
+        self.queue = deque()
+        self.quit = False
+        self.index = 0
+
+    def run(self):
+        q = self.queue
+        while not self.quit:
+            depths = freenect.sync_get_depth(index=self.index)
+            if depths is None:
+                sleep(2)
+                continue
+            q.appendleft(depths)
+
+    def pop(self):
+        return self.queue.pop()
+
+
+class KinectViewer(Widget):
+
+    depth_range = NumericProperty(7.7)
+
+    shader = StringProperty("rgb")
+
+    index = NumericProperty(0)
+
+    def __init__(self, **kwargs):
+        # change the default canvas to RenderContext, we can change the shader
+        self.canvas = RenderContext()
+        self.canvas.shader.fs = hsv_kinect
+
+        # add kinect depth provider, and start the thread
+        self.kinect = KinectDepth()
+        self.kinect.start()
+
+        # parent init
+        super(KinectViewer, self).__init__(**kwargs)
+
+        # allocate texture for pushing depth
+        self.texture = Texture.create(
+            size=(640, 480), colorfmt='luminance', bufferfmt='ushort')
+        self.texture.flip_vertical()
+
+        # create default canvas element
+        with self.canvas:
+            Color(1, 1, 1)
+            Rectangle(size=Window.size, texture=self.texture)
+
+        # add a little clock to update our glsl
+        Clock.schedule_interval(self.update_transformation, 0)
+
+    def on_index(self, instance, value):
+        self.kinect.index = value
+
+    def on_shader(self, instance, value):
+        if value == 'rgb':
+            self.canvas.shader.fs = rgb_kinect
+        elif value == 'hsv':
+            self.canvas.shader.fs = hsv_kinect
+        elif value == 'points':
+            self.canvas.shader.fs = points_kinect
+
+    def update_transformation(self, *largs):
+        # update projection mat and uvsize
+        self.canvas['projection_mat'] = Window.render_context['projection_mat']
+        self.canvas['depth_range'] = self.depth_range
+        self.canvas['size'] = list(map(float, self.size))
+        try:
+            value = self.kinect.pop()
+        except:
+            return
+        f = value[0].astype('ushort') * 32
+        self.texture.blit_buffer(
+            f.tostring(), colorfmt='luminance', bufferfmt='ushort')
+        self.canvas.ask_update()
+
+
+class KinectViewerApp(App):
+
+    def build(self):
+        root = BoxLayout(orientation='vertical')
+
+        self.viewer = viewer = KinectViewer(
+            index=self.config.getint('kinect', 'index'),
+            shader=self.config.get('shader', 'theme'))
+        root.add_widget(viewer)
+
+        toolbar = BoxLayout(size_hint=(1, None), height=50)
+        root.add_widget(toolbar)
+
+        slider = Slider(min=1., max=32., value=1.)
+
+        def update_depth_range(instance, value):
+            viewer.depth_range = value
+
+        slider.bind(value=update_depth_range)
+        toolbar.add_widget(slider)
+
+        return root
+
+    def build_config(self, config):
+        config.add_section('kinect')
+        config.set('kinect', 'index', '0')
+        config.add_section('shader')
+        config.set('shader', 'theme', 'rgb')
+
+    def build_settings(self, settings):
+        settings.add_json_panel('Kinect Viewer', self.config, data='''[
+            { "type": "title", "title": "Kinect" },
+            { "type": "numeric", "title": "Index",
+              "desc": "Kinect index, from 0 to X",
+              "section": "kinect", "key": "index" },
+            { "type": "title", "title": "Shaders" },
+            { "type": "options", "title": "Theme",
+              "desc": "Shader to use for a specific visualization",
+              "section": "shader", "key": "theme",
+              "options": ["rgb", "hsv", "points"]}
+        ]''')
+
+    def on_config_change(self, config, section, key, value):
+        if config is not self.config:
+            return
+        token = (section, key)
+        if token == ('kinect', 'index'):
+            self.viewer.index = int(value)
+        elif token == ('shader', 'theme'):
+            if value == 'rgb':
+                self.viewer.canvas.shader.fs = rgb_kinect
+            elif value == 'hsv':
+                self.viewer.shader = value
+
+
+if __name__ == '__main__':
+    KinectViewerApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/app_button.kv

@@ -0,0 +1,9 @@
+#:kivy 1.0
+
+Widget:
+    Button:
+        text: "Hello World"
+
+    Button:
+        text: "I'm another label"
+        pos: (200, 200)

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/app_camera.kv

@@ -0,0 +1,25 @@
+Camera:
+    canvas:
+        Color:
+            rgb: (1, 1, 1)
+        Rectangle:
+            texture: self.texture
+            size: (320, 240)
+        Color:
+            rgb: (0.5, 0, 1)
+        Rectangle:
+            texture: self.texture
+            pos: (320, 0)
+            size: (320, 240)
+        Color:
+            rgb: (0, 1, 0)
+        Rectangle:
+            texture: self.texture
+            pos: (320, 240)
+            size: (320, 240)
+        Color:
+            rgb: (1, 0, 0)
+        Rectangle:
+            texture: self.texture
+            pos: (0, 240)
+            size: (320, 240)

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/app_fbo.kv

@@ -0,0 +1,11 @@
+#:kivy 1.0
+
+Widget:
+    canvas:
+        Fbo:
+            size: (200, 200)
+        Color:
+            rgba: (0.7, 0.3, 0.5, 0.7)
+        Rectangle:
+            size: (200, 200)
+            pos: (200, 200)

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/app_layout.kv

@@ -0,0 +1,23 @@
+BoxLayout:
+    Button:
+        id: bswitch
+
+    BoxLayout:
+
+        orientation: 'vertical' if bswitch.state == 'down' else 'horizontal'
+
+        Button:
+            id: btn1
+            text: 'Button 1'
+
+        Button:
+            text: btn1.state
+
+        Button:
+            text: 'Button 3'
+
+        Button:
+            text: 'Button 4'
+
+        Button:
+            text: 'Button 5'

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/app_logo.kv

@@ -0,0 +1,36 @@
+Widget:
+    Video:
+        id: myvideo
+        source: '../widgets/cityCC0.mpg'
+        play: mybutton.state == 'down'
+        canvas:
+            Color:
+                rgb: (1, 1, 1)
+            BorderImage:
+                texture: self.texture
+                size: self.texture_size
+
+    Image:
+        source: 'kivy.jpg'
+        canvas:
+            PushMatrix:
+            Rotate:
+                angle: 1
+            BorderImage:
+                border: 250, 250, 250, 250
+                texture: self.texture
+                size: self.texture_size
+            PopMatrix:
+
+    Button:
+        id: mybutton
+        text: 'Push me'
+        pos: 100, 100
+
+    Slider:
+        width: myvideo.width
+        height: 25
+        min: 0
+        max: myvideo.duration
+        value: myvideo.position
+        pos: myvideo.pos

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/app_scatter.kv

@@ -0,0 +1,6 @@
+Widget:
+    Scatter:
+        size: image.texture_size
+        Image:
+            id: image
+            source: 'kivy.jpg'

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/app_stencil.kv

@@ -0,0 +1,27 @@
+Widget:
+    canvas:
+
+        StencilPush
+
+        # create a rectangle mask, from pos 100, 100, with a 100, 100 size.
+        Rectangle:
+            pos: 100, 100
+            size: 100, 100
+
+        StencilUse
+
+        # we want to show a big green rectangle, however, the previous stencil
+        # mask will crop us :)
+        Color:
+            rgb: 0, 1, 0
+        Rectangle:
+            size: 900, 900
+
+        StencilUnUse
+
+        # Remove the mask previously set
+        Rectangle:
+            pos: 100, 100
+            size: 100, 100
+
+        StencilPop

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/app_video.kv

@@ -0,0 +1,42 @@
+BoxLayout:
+
+    orientation: 'vertical'
+    spacing: 5
+    padding: 5
+
+    Video:
+        id: myvideo
+        source: '../widgets/cityCC0.mpg'
+        fit_mode: "contain"
+        on_eos: self.play = True; print('woot we are looping!')
+
+    BoxLayout:
+        size_hint_y: None
+        height: 30
+
+        Label:
+            id: mylabel
+            text: str(myvideo.position)
+
+        Slider:
+            value: myvideo.position
+            max: myvideo.duration
+            on_value: print(args[1])
+
+    BoxLayout:
+        size_hint_y: None
+        height: 50
+        spacing: 5
+
+        ToggleButton:
+            group: 'video'
+            text: 'Play'
+            state: 'down' if myvideo.play else 'normal'
+            on_press: myvideo.play = True
+
+        ToggleButton:
+            group: 'video'
+            text: 'Stop'
+            state: 'down' if not myvideo.play else 'normal'
+            on_press: myvideo.play = False
+

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/builder_template.py

@@ -0,0 +1,28 @@
+from kivy.lang import Builder
+from kivy.app import App
+from kivy.uix.boxlayout import BoxLayout
+
+Builder.load_string('''
+[BlehItem@BoxLayout]:
+    orientation: 'vertical'
+    Label:
+        text: str(ctx.idx)
+    Button:
+        text: ctx.word
+''')
+
+
+class BlehApp(App):
+
+    def build(self):
+        root = BoxLayout()
+        for idx, word in enumerate(('Hello', 'World')):
+            wid = Builder.template('BlehItem', **{
+                'idx': idx, 'word': word,
+            })
+            root.add_widget(wid)
+        return root
+
+
+if __name__ == '__main__':
+    BlehApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/ids/id_in_kv/id_in_kv.py

@@ -0,0 +1,20 @@
+'''
+The use of id in KV
+===================
+
+This small example shows how to refer from one widget
+to another within KV.
+'''
+
+import kivy
+kivy.require('1.8.0')
+
+from kivy.app import App
+
+
+class TestApp(App):
+    pass
+
+
+if __name__ == '__main__':
+    TestApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/ids/id_in_kv/test.kv

@@ -0,0 +1,11 @@
+#:kivy 1.8.0
+
+BoxLayout:
+    orientation: 'vertical'
+    TextInput:
+        # setting the id of the widget
+        id: my_id
+        text: 'The text of the label is set within kivy'
+    Label:
+        # showing the text of the textinput by referring on the id
+        text: my_id.text

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/ids/kv_and_py/kv_and_py.py

@@ -0,0 +1,34 @@
+'''
+Referring on ids from Python
+=============================
+
+This example shows how to refer to an id from a Python file.
+'''
+
+import kivy
+kivy.require('1.8.0')
+
+from kivy.app import App
+from kivy.uix.boxlayout import BoxLayout
+
+
+class RootWidget(BoxLayout):
+
+    def first_function(self, status):
+        # print out the given parameter
+        print(status)
+        # check the status of the switch by referring on the id
+        if self.ids.my_switch.active is True:
+            # set the text of the label by referring on the id
+            self.ids.my_label.text = 'Switch is ON'
+        else:
+            # set the text of the label by referring on the id
+            self.ids.my_label.text = 'Switch is OFF'
+
+
+class TestApp(App):
+    pass
+
+
+if __name__ == '__main__':
+    TestApp().run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/ids/kv_and_py/test.kv

@@ -0,0 +1,11 @@
+#:kivy 1.8.0
+
+RootWidget:
+    BoxLayout:
+        orientation: 'vertical'
+        Switch:
+            id: my_switch
+            on_active: root.first_function(self.active)
+        Label:
+            id: my_label
+            text: 'This text will be changed by the python file'

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/kv/kvrun.py

@@ -0,0 +1,38 @@
+from kivy.app import App
+from kivy.clock import Clock
+from kivy.lang import Builder
+from kivy.core.window import Window
+
+
+class KvApp(App):
+    def __init__(self, filename, **kwargs):
+        self.filename = filename
+        super(KvApp, self).__init__(**kwargs)
+
+    def _print_fps(self, *largs):
+        print('FPS: %2.4f (real draw: %d)' % (
+            Clock.get_fps(), Clock.get_rfps()))
+
+    def _reload_keypress(self, instance, code, *largs):
+        if code != 286:
+            return
+        for child in Window.children[:]:
+            Window.remove_widget(child)
+        root = Builder.load_file(self.filename)
+        Window.add_widget(root)
+
+    def build(self):
+        Clock.schedule_interval(self._print_fps, 1)
+        Window.bind(on_keyboard=self._reload_keypress)
+        return Builder.load_file(self.filename)
+
+
+if __name__ == '__main__':
+    import sys
+    import os
+
+    if len(sys.argv) < 2:
+        print('Usage: %s filename.kv' % os.path.basename(sys.argv[0]))
+        sys.exit(1)
+
+    KvApp(filename=sys.argv[1]).run()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/miscellaneous/clipboard.py

@@ -0,0 +1,63 @@
+from kivy.lang import Builder
+from kivy.uix.label import Label
+from kivy.base import runTouchApp
+from kivy.uix.boxlayout import BoxLayout
+
+import os
+
+Builder.load_string('''
+#:import Clipboard kivy.core.clipboard.Clipboard
+<Clip>:
+    orientation: 'vertical'
+    GridLayout:
+        cols: 3
+        size_hint_y: None
+        height: self.minimum_height
+        Button:
+            text: 'Paste raw'
+            size_hint_y: None
+            height: 60
+            on_release: root.make_labels(Clipboard.paste())
+
+        Button:
+            text: 'Paste & format'
+            size_hint_y: None
+            height: 60
+            on_release: root.make_pretty_labels(Clipboard.paste())
+
+        Button:
+            text: 'Remove widgets'
+            size_hint_y: None
+            height: 60
+            on_release: container.clear_widgets()
+
+    ScrollView:
+        GridLayout:
+            cols: 1
+            id: container
+            size_hint_y: None
+            height: self.minimum_height
+''')
+
+
+class Clip(BoxLayout):
+    def make_labels(self, values):
+        """Creates widgets from raw clipboard i.e. for each character in the
+        list that is provided by Clipboard.paste()
+        """
+        print(repr(values))
+        for value in values:
+            label = Label(text=value, size_hint_y=None, height=30)
+            self.ids.container.add_widget(label)
+
+    def make_pretty_labels(self, values):
+        """Creates widgets from a list of values made by splitting clipboard
+        by the default OS line separator. Useful when copying columns of data.
+        """
+        print(repr(values))
+        for value in values.split(os.linesep):
+            label = Label(text=value, size_hint_y=None, height=30)
+            self.ids.container.add_widget(label)
+
+
+runTouchApp(Clip())