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

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/demo/multistroke/gesturedatabase.py

@@ -0,0 +1,180 @@
+__all__ = ('GestureDatabase', 'GestureDatabaseItem')
+
+from kivy.clock import Clock
+from kivy.lang import Builder
+from kivy.properties import NumericProperty, StringProperty
+from kivy.properties import ListProperty, ObjectProperty
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.floatlayout import FloatLayout
+from kivy.uix.popup import Popup
+from kivy.graphics import Rectangle, Color
+from kivy.multistroke import Recognizer
+
+# local libraries
+from helpers import InformationPopup
+
+
+Builder.load_file('gesturedatabase.kv')
+
+
+class GestureExportPopup(Popup):
+    pass
+
+
+class GestureImportPopup(Popup):
+    pass
+
+
+class GestureDatabaseItem(FloatLayout):
+    name = StringProperty('(no name)')
+    template_count = NumericProperty(0)
+    gesture_list = ListProperty([])
+
+    def __init__(self, **kwargs):
+        super(GestureDatabaseItem, self).__init__(**kwargs)
+        self.rect = None
+        self._draw_trigger = Clock.create_trigger(self.draw_item, 0)
+        self.update_template_count()
+        self.bind(gesture_list=self.update_template_count)
+        self.register_event_type('on_select')
+        self.register_event_type('on_deselect')
+
+    def toggle_selected(self, *l):
+        self._draw_rect(clear=True)
+        if self.ids.select.state == 'down':
+            self.dispatch('on_select')
+            self.ids.select.text = 'Deselect'
+        else:
+            self.dispatch('on_deselect')
+            self.ids.select.text = 'Select'
+
+    def update_template_count(self, *l):
+        tpl_count = 0
+        for g in self.gesture_list:
+            tpl_count += len(g.templates)
+        self.template_count = tpl_count
+
+    def draw_item(self, *l):
+        self.ids.namelbl.pos = self.pos
+        self.ids.namelbl.y += 90
+        self.ids.stats.pos = self.pos
+        self.ids.stats.y += 40
+        self.ids.select.pos = self.pos
+        self._draw_rect()
+
+    def _draw_rect(self, clear=False, *l):
+        col = self.ids.select.state == 'down' and 1 or .2
+        with self.canvas:
+            Color(col, 0, 0, .15)
+            if self.rect or clear:
+                self.canvas.remove(self.rect)
+            self.rect = Rectangle(size=self.size, pos=self.pos)
+
+    def on_select(*l):
+        pass
+
+    def on_deselect(*l):
+        pass
+
+
+class GestureDatabase(GridLayout):
+    selected_count = NumericProperty(0)
+    recognizer = ObjectProperty(None)
+    export_popup = ObjectProperty(GestureExportPopup())
+    import_popup = ObjectProperty(GestureImportPopup())
+    info_popup = ObjectProperty(InformationPopup())
+
+    def __init__(self, **kwargs):
+        super(GestureDatabase, self).__init__(**kwargs)
+        self.redraw_all = Clock.create_trigger(self._redraw_gesture_list, 0)
+        self.export_popup.ids.save_btn.bind(on_press=self.perform_export)
+        self.import_popup.ids.filechooser.bind(on_submit=self.perform_import)
+
+    def import_gdb(self):
+        self.gdict = {}
+        for gesture in self.recognizer.db:
+            if gesture.name not in self.gdict:
+                self.gdict[gesture.name] = []
+            self.gdict[gesture.name].append(gesture)
+
+        self.selected_count = 0
+        self.ids.gesture_list.clear_widgets()
+        for k in sorted(self.gdict, key=lambda n: n.lower()):
+            gitem = GestureDatabaseItem(name=k, gesture_list=self.gdict[k])
+            gitem.bind(on_select=self.select_item)
+            gitem.bind(on_deselect=self.deselect_item)
+            self.ids.gesture_list.add_widget(gitem)
+
+    def select_item(self, *l):
+        self.selected_count += 1
+
+    def deselect_item(self, *l):
+        self.selected_count -= 1
+
+    def mass_select(self, *l):
+        if self.selected_count:
+            for i in self.ids.gesture_list.children:
+                if i.ids.select.state == 'down':
+                    i.ids.select.state = 'normal'
+                    i.draw_item()
+        else:
+            for i in self.ids.gesture_list.children:
+                if i.ids.select.state == 'normal':
+                    i.ids.select.state = 'down'
+                    i.draw_item()
+
+    def unload_gestures(self, *l):
+        if not self.selected_count:
+            self.recognizer.db = []
+            self.ids.gesture_list.clear_widgets()
+            self.selected_count = 0
+            return
+
+        for i in self.ids.gesture_list.children[:]:
+            if i.ids.select.state == 'down':
+                self.selected_count -= 1
+                for g in i.gesture_list:
+                    # if g in self.recognizer.db:  # not needed, for testing
+                    self.recognizer.db.remove(g)
+                    self.ids.gesture_list.remove_widget(i)
+
+    def perform_export(self, *l):
+        path = self.export_popup.ids.filename.text
+        if not path:
+            self.export_popup.dismiss()
+            self.info_popup.text = 'Missing filename'
+            self.info_popup.open()
+            return
+        elif not path.lower().endswith('.kg'):
+            path += '.kg'
+
+        self.save_selection_to_file(path)
+
+        self.export_popup.dismiss()
+        self.info_popup.text = 'Gestures exported!'
+        self.info_popup.open()
+
+    def perform_import(self, filechooser, *l):
+        count = len(self.recognizer.db)
+        for f in filechooser.selection:
+            self.recognizer.import_gesture(filename=f)
+        self.import_gdb()
+        self.info_popup.text = ("Imported %d gestures.\n" %
+                                (len(self.recognizer.db) - count))
+        self.import_popup.dismiss()
+        self.info_popup.open()
+
+    def save_selection_to_file(self, filename, *l):
+        if not self.selected_count:
+            self.recognizer.export_gesture(filename=filename)
+        else:
+            tmpgdb = Recognizer()
+            for i in self.ids.gesture_list.children:
+                if i.ids.select.state == 'down':
+                    for g in i.gesture_list:
+                        tmpgdb.db.append(g)
+            tmpgdb.export_gesture(filename=filename)
+
+    def _redraw_gesture_list(self, *l):
+        for child in self.ids.gesture_list.children:
+            child._draw_trigger()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/demo/multistroke/helpers.py

@@ -0,0 +1,30 @@
+__all__ = ('InformationPopup', )
+
+from kivy.uix.popup import Popup
+from kivy.properties import StringProperty
+from kivy.factory import Factory
+from kivy.lang import Builder
+from kivy.clock import Clock
+
+Builder.load_string('''
+<InformationPopup>:
+    auto_dismiss: True
+    size_hint: None, None
+    size: 400, 200
+    on_open: root.dismiss_trigger()
+    title: root.title
+    Label:
+        text: root.text
+''')
+
+
+class InformationPopup(Popup):
+    title = StringProperty('Information')
+    text = StringProperty('')
+
+    def __init__(self, time=1.5, **kwargs):
+        super(InformationPopup, self).__init__(**kwargs)
+        self.dismiss_trigger = Clock.create_trigger(self.dismiss, time)
+
+
+Factory.register('InformationPopup', cls=InformationPopup)

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/demo/multistroke/historymanager.kv

@@ -0,0 +1,164 @@
+<GestureHistoryManager>:
+    rows: 1
+    spacing: 10
+    GridLayout:
+        cols: 1
+        size_hint_x: None
+        width: 150
+        canvas:
+            Color: 
+                rgba: 1, 1, 1, .1
+            Rectangle:
+                size: self.size
+                pos: self.pos
+
+        Button:
+            text: 'Clear History'
+            size_hint_y: None
+            height: 50
+            on_press: root.clear_history()
+
+        ScrollView:
+            id: scrollview
+            scroll_type: ['bars', 'content']
+            bar_width: 4
+            GridLayout:
+                id: history
+                cols: 1
+                size_hint: 1, None
+                height: self.minimum_height
+
+<GestureSettingsForm>:
+    orientation: 'vertical'
+    spacing: 10
+    GridLayout:
+        id: settings
+        cols: 1
+        top: root.top
+        Label:
+            text: '[b]Results (scroll for more)[/b]'
+            markup: True
+            size_hint_y: None
+            height: 30
+            halign: 'left'
+            valign: 'middle'
+            text_size: self.size
+            canvas:
+                Color:
+                    rgba: 47 / 255., 167 / 255., 212 / 255., .4
+                Rectangle:   
+                    pos: self.x, self.y + 1
+                    size: self.size
+                Color:
+                    rgb: .5, .5, .5
+                Rectangle:
+                    pos: self.x, self.y - 2
+                    size: self.width, 1
+
+        GridLayout:
+            id: analysis
+            top: root.top
+            rows: 1
+
+<GestureVisualizer>:
+    canvas:
+        Color: 
+            rgba: 1, 1, 1, self.selected and .3 or .1
+        Rectangle:
+            pos: self.pos
+            size: self.size
+
+
+<RecognizerResultDetails>:
+    canvas:
+        Color: 
+            rgba: 1, 0, 0, .1
+        Rectangle:
+            size: self.size
+            pos: self.pos
+
+    ScrollView:
+        id: result_scrollview
+        scroll_type: ['bars', 'content']
+        bar_width: 4
+        GridLayout:
+            id: result_list
+            cols: 1
+            size_hint: 1, None
+            height: self.minimum_height
+
+    Button:
+        size_hint: None, None
+        width: 150
+        height: 70
+        text: 'Re-analyze'
+        on_press: root.dispatch('on_reanalyze_selected')
+
+
+<RecognizerResultLabel>:
+    size_hint_y: None
+    height: 70
+    markup: True
+    halign: 'left'
+    valign: 'top'
+    text_size: self.size
+
+
+<AddGestureSettings>:
+    MultistrokeSettingTitle:
+        title: 'New gesture settings'
+        desc: 'Affects how to future input is matched against new gesture'
+
+    MultistrokeSettingBoolean:
+        id: permute
+        title: 'Use Heap Permute algorithm?'
+        desc:
+            ('This will generate all possible stroke orders from the ' +
+            'input. Only suitable for gestures with 1-3 strokes (or ' +
+            'the number of templates will be huge)')
+        button_text: 'Heap Permute?'
+        value: True
+        
+    MultistrokeSettingBoolean:
+        id: stroke_sens
+        title: 'Require same number of strokes?'
+        desc: 
+            ('When enabled, the new gesture will only match candidates ' +
+            'with exactly the same stroke count. Enable if possible.')
+        button_text: 'Stroke sensitive?'
+        value: True
+        
+    MultistrokeSettingBoolean:
+        id: orientation_sens
+        title: 'Is gesture orientation sensitive?'
+        desc: 
+            ('Enable to differentiate gestures that differ only by ' +
+            'orientation (d/p, b/q, w/m), disable for gestures that ' +
+            'look the same in any orientation (like a circle)')
+        button_text: 'Orientation\nsensitive?'
+        value: True
+
+    MultistrokeSettingSlider:
+        id: angle_sim
+        title: 'Angle similarity threshold'
+        type: 'float'
+        desc: 
+            ('Use a low number to distinguish similar gestures, higher ' +
+            'number to match similar gestures (with differing angle)')
+        value: 30.
+        min: 1.0
+        max: 179.0
+
+    MultistrokeSettingString:
+        id: name
+        title: 'Gesture name'
+        type: 'float'
+        desc:
+            ('Name of new gesture (including all generated templates). ' +
+            'You can have as many gestures with the same name as you need')
+
+    Button:
+        size_hint_y: None
+        height: 40
+        text: 'Add to database'
+        on_press: root.parent.parent.parent.add_selected_to_database()

Kivy_examples-2.3.1.dev0.data/data/share/kivy-examples/demo/multistroke/historymanager.py

@@ -0,0 +1,276 @@
+__all__ = ('GestureHistoryManager', 'GestureVisualizer')
+
+from kivy.app import App
+from kivy.clock import Clock
+from kivy.lang import Builder
+from kivy.uix.widget import Widget
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.gridlayout import GridLayout
+from kivy.uix.label import Label
+from kivy.graphics import Color, Line
+from kivy.properties import ObjectProperty, BooleanProperty
+from kivy.compat import PY2
+
+# local libraries
+from helpers import InformationPopup
+from settings import MultistrokeSettingsContainer
+
+
+# refuse heap permute for gestures with more strokes than 3
+# (you can increase it, but 4 strokes = 384 templates, 5 = 3840)
+MAX_PERMUTE_STROKES = 3
+
+Builder.load_file('historymanager.kv')
+
+
+class GestureHistoryManager(GridLayout):
+    selected = ObjectProperty(None, allownone=True)
+
+    def __init__(self, **kwargs):
+        super(GestureHistoryManager, self).__init__(**kwargs)
+        self.gesturesettingsform = GestureSettingsForm()
+        rr = self.gesturesettingsform.rrdetails
+        rr.bind(on_reanalyze_selected=self.reanalyze_selected)
+        self.infopopup = InformationPopup()
+        self.recognizer = App.get_running_app().recognizer
+
+    def reanalyze_selected(self, *l):
+        # recognize() can block the UI with max_gpf=100, show a message
+        self.infopopup.text = 'Please wait, analyzing ..'
+        self.infopopup.auto_dismiss = False
+        self.infopopup.open()
+
+        # Get a reference to the original GestureContainer object
+        gesture_obj = self.selected._result_obj._gesture_obj
+
+        # Reanalyze the candidate strokes using current database
+        res = self.recognizer.recognize(gesture_obj.get_vectors(),
+                                        max_gpf=100)
+
+        # Tag the result with the gesture object (it didn't change)
+        res._gesture_obj = gesture_obj
+
+        # Tag the selected item with the updated ProgressTracker
+        self.selected._result_obj = res
+        res.bind(on_complete=self._reanalyze_complete)
+
+    def _reanalyze_complete(self, *l):
+        self.gesturesettingsform.load_visualizer(self.selected)
+        self.infopopup.dismiss()
+
+    def add_selected_to_database(self, *l):
+        if self.selected is None:
+            raise Exception('add_gesture_to_database before load_visualizer?')
+
+        if self.gesturesettingsform.addsettings is None:
+            raise Exception('add_gesture_to_database missing addsetings?')
+
+        ids = self.gesturesettingsform.addsettings.ids
+
+        name = ids.name.value.strip()
+        if name == '':
+            self.infopopup.auto_dismiss = True
+            self.infopopup.text = 'You must specify a name for the gesture'
+            self.infopopup.open()
+            return
+
+        permute = ids.permute.value
+        sensitive = ids.orientation_sens.value
+        strokelen = ids.stroke_sens.value
+        angle_sim = ids.angle_sim.value
+
+        cand = self.selected._result_obj._gesture_obj.get_vectors()
+
+        if permute and len(cand) > MAX_PERMUTE_STROKES:
+            t = "Can't heap permute %d-stroke gesture " % (len(cand))
+            self.infopopup.text = t
+            self.infopopup.auto_dismiss = True
+            self.infopopup.open()
+            return
+
+        self.recognizer.add_gesture(
+            name,
+            cand,
+            use_strokelen=strokelen,
+            orientation_sensitive=sensitive,
+            angle_similarity=angle_sim,
+            permute=permute)
+
+        self.infopopup.text = 'Gesture added to database'
+        self.infopopup.auto_dismiss = True
+        self.infopopup.open()
+
+    def clear_history(self, *l):
+        if self.selected:
+            self.visualizer_deselect()
+        self.ids.history.clear_widgets()
+
+    def visualizer_select(self, visualizer, *l):
+        if self.selected is not None:
+            self.selected.selected = False
+        else:
+            self.add_widget(self.gesturesettingsform)
+
+        self.gesturesettingsform.load_visualizer(visualizer)
+        self.selected = visualizer
+
+    def visualizer_deselect(self, *l):
+        self.selected = None
+        self.remove_widget(self.gesturesettingsform)
+
+    def add_recognizer_result(self, result, *l):
+        '''The result object is a ProgressTracker with additional
+        data; in main.py it is tagged with the original GestureContainer
+        that was analyzed (._gesture_obj)'''
+
+        # Create a GestureVisualizer that draws the gesture on canvas
+        visualizer = GestureVisualizer(result._gesture_obj,
+                                       size_hint=(None, None), size=(150, 150))
+
+        # Tag it with the result object so AddGestureForm.load_visualizer
+        # has the results to build labels in the scrollview
+        visualizer._result_obj = result
+
+        visualizer.bind(on_select=self.visualizer_select)
+        visualizer.bind(on_deselect=self.visualizer_deselect)
+
+        # Add the visualizer to the list of gestures in 'history' screen
+        self.ids.history.add_widget(visualizer)
+        self._trigger_layout()
+        self.ids.scrollview.update_from_scroll()
+
+
+class RecognizerResultLabel(Label):
+    '''This Label subclass is used to show a single result from the
+    gesture matching process (is a child of GestureHistoryManager)'''
+    pass
+
+
+class RecognizerResultDetails(BoxLayout):
+    '''Contains a ScrollView of RecognizerResultLabels, ie the list of
+    matched gestures and their score/distance (is a child of
+    GestureHistoryManager)'''
+    def __init__(self, **kwargs):
+        super(RecognizerResultDetails, self).__init__(**kwargs)
+        self.register_event_type('on_reanalyze_selected')
+
+    def on_reanalyze_selected(self, *l):
+        pass
+
+
+class AddGestureSettings(MultistrokeSettingsContainer):
+    pass
+
+
+class GestureSettingsForm(BoxLayout):
+    '''This is the main content of the GestureHistoryManager, the form for
+    adding a new gesture to the recognizer. It is added to the widget tree
+    when a GestureVisualizer is selected.'''
+
+    def __init__(self, **kwargs):
+        super(GestureSettingsForm, self).__init__(**kwargs)
+        self.infopopup = InformationPopup()
+        self.rrdetails = RecognizerResultDetails()
+        self.addsettings = None
+        self.app = App.get_running_app()
+
+    def load_visualizer(self, visualizer):
+        if self.addsettings is None:
+            self.addsettings = AddGestureSettings()
+            self.ids.settings.add_widget(self.addsettings)
+
+        self.visualizer = visualizer
+        analysis = self.ids.analysis
+        analysis.clear_widgets()
+        analysis.add_widget(self.rrdetails)
+
+        scrollv = self.rrdetails.ids.result_scrollview
+        resultlist = self.rrdetails.ids.result_list
+        resultlist.clear_widgets()
+
+        r = visualizer._result_obj.results
+
+        if not len(r):
+            lbl = RecognizerResultLabel(text='[b]No match[/b]')
+            resultlist.add_widget(lbl)
+            scrollv.scroll_y = 1
+            return
+
+        if PY2:
+            d = r.iteritems
+        else:
+            d = r.items
+
+        for one in sorted(d(), key=lambda x: x[1]['score'],
+                          reverse=True):
+            data = one[1]
+            lbl = RecognizerResultLabel(
+                text='Name: [b]' + data['name'] + '[/b]' +
+                     '\n      Score: ' + str(data['score']) +
+                     '\n      Distance: ' + str(data['dist']))
+            resultlist.add_widget(lbl)
+
+        # Make sure the top is visible
+        scrollv.scroll_y = 1
+
+
+class GestureVisualizer(Widget):
+    selected = BooleanProperty(False)
+
+    def __init__(self, gesturecontainer, **kwargs):
+        super(GestureVisualizer, self).__init__(**kwargs)
+
+        self._gesture_container = gesturecontainer
+
+        self._trigger_draw = Clock.create_trigger(self._draw_item, 0)
+        self.bind(pos=self._trigger_draw, size=self._trigger_draw)
+        self._trigger_draw()
+
+        self.register_event_type('on_select')
+        self.register_event_type('on_deselect')
+
+    def on_touch_down(self, touch):
+        if not self.collide_point(touch.x, touch.y):
+            return
+        self.selected = not self.selected
+        self.dispatch(self.selected and 'on_select' or 'on_deselect')
+
+    # FIXME: This seems inefficient, is there a better way??
+    def _draw_item(self, dt):
+        g = self._gesture_container
+        bb = g.bbox
+        minx, miny, maxx, maxy = bb['minx'], bb['miny'], bb['maxx'], bb['maxy']
+        width, height = self.size
+        xpos, ypos = self.pos
+
+        if g.height > g.width:
+            to_self = (height * 0.85) / g.height
+        else:
+            to_self = (width * 0.85) / g.width
+
+        self.canvas.remove_group('gesture')
+
+        cand = g.get_vectors()
+        col = g.color
+        for stroke in cand:
+            out = []
+            append = out.append
+            for vec in stroke:
+                x, y = vec
+                x = (x - minx) * to_self
+                w = (maxx - minx) * to_self
+                append(x + xpos + (width - w) * .85 / 2)
+
+                y = (y - miny) * to_self
+                h = (maxy - miny) * to_self
+                append(y + ypos + (height - h) * .85 / 2)
+
+            with self.canvas:
+                Color(col[0], col[1], col[2], mode='rgb')
+                Line(points=out, group='gesture', width=2)
+
+    def on_select(self, *l):
+        pass
+
+    def on_deselect(self, *l):
+        pass