sequence.py

import os
import time
import uuid
import functools
import threading
import numpy as np

from kivy.lang import Builder
from kivy.utils import platform
from kivy.app import App
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.button import Button
from kivy.uix.screenmanager import ScreenManager
from kivy.uix.gridlayout import GridLayout
from kivy.clock import Clock, mainthread
from kivy.graphics import Color, Rectangle
from kivy.properties import StringProperty, ObjectProperty, NumericProperty, ListProperty, BooleanProperty
from kivy.uix.tabbedpanel import TabbedPanel
from kivy.uix.behaviors import ButtonBehavior
from kivy.uix.scrollview import ScrollView
from kivy.uix.scatterlayout import ScatterLayout
from kivy.uix.stencilview import StencilView

from kivymd.uix.button import MDRaisedButton, MDFlatButton, MDFloatingActionButton
from kivymd.uix.list import MDList, OneLineListItem, TwoLineListItem, ThreeLineListItem



# from kivymd.uix.tab import MDTabbedPanel, MDTab
from kivymd.uix.toolbar import MDToolbar
from kivymd.uix.textfield import MDTextField
from .mddialog import  MDDialog
from kivymd.uix.label import MDLabel
from .widgetsmd import MDNumberInput, yesno_box
from kivymd.uix.list import MDList
from ui.kivy.cam import CameraClick

from ui.kivy.widgets import apply_image
from ui.kivy import widgets

import kivy.garden.mapview
from kivy.garden.mapview import MapSource, MapMarker, MapMarkerPopup


from .widgetsmd import BDDialog
from . import chaining
from .i18n import i18nstr, I18NProperty as _, I18NContainerBehavior


class BoxStencil(BoxLayout, StencilView):
    """
    see https://kivy.org/doc/stable/api-kivy.uix.stencilview.html
    """
    def on_touch_down(self, touch):
        if self.collide_point(*touch.pos):
            super().on_touch_down(touch)


if platform=='android':
    from jnius import autoclass

    PythonActivity = autoclass('org.kivy.android.PythonActivity')
    Intent = autoclass('android.content.Intent')
    String = autoclass('java.lang.String')

Builder.load_string("""
<SequenceCapture>:
    thumbs:thumbs
    # cam:cam
    orientation:'vertical'
    BoxLayout:
        orientation:'horizontal'
        size_hint:1,1
        BoxLayout:
            orientation:'vertical'
            size_hint:.1,1
            ThumbListView:
                id:thumbs
                size_hint:1,.9
            MDFloatingActionButton:
                id:btn_next
                icon:                'check'
                opposite_colors:    True
                elevation_normal:    8
                pos_hint:            {'center_x': 0.5, 'center_y': 0.2}
                # disabled: disable_the_buttons.active
                on_release:root.dispatch("on_capture_done")
        BoxLayout:
            id:cam_container
        # CameraClick:
        #     id:cam
        #     # config:root.project.config
        #     target_dir:root.sequence_path or '.'
        #     on_photo_shot:root.reload_thumbs()
    # MDRaisedButton:
    #     id:btn_next
    #     size_hint:1,None
    #     height:'48dp'
    #     text:'next'
    #     on_release:root.dispatch("on_capture_done")

""")


class SequenceCapture(BoxLayout):
    """
    capture a sequence of images
    """
    project = ObjectProperty(None)
    sequence = ObjectProperty(None)
    sequence_path = StringProperty(None)
    cam = ObjectProperty()

    def __init__(self, *a, **kw):
        super(SequenceCapture, self).__init__(*a, **kw)
        self.register_event_type("on_capture_done")

    def on_sequence(self, *a, **kw):
        print("SequenceCapture: sequence changed, self.project:", self.project)
        self.sequence_path = self.sequence.path
        self.thumbs.read_dir(self.sequence_path)
        self.ids.btn_next.text='next:'+self.sequence.relpath
        if self.cam:
            self.cam.target_dir = self.sequence_path

    def on_project(self, *a, **kw):
        print('SequenceCapture: project changed:', self.project)
        if self.cam:
            self.cam.config=self.project.config

    def reload_thumbs(self, *a):
        print('reload_thunbs')
        self.thumbs.read_dir(self.sequence_path, incremental=True)

    def init_cam(self):
        if not self.cam:
            # CameraClick:
            # id:cam
            # # config:root.project.config
            # target_dir:root.sequence_path or '.'
            # on_photo_shot:root.reload_thumbs()
            # import pdb;pdb.set_trace()
            camclick = CameraClick(id='cam', target_dir=self.sequence_path or '.')
            camclick.bind(on_photo_shot=self.reload_thumbs)
            self.ids.cam_container.add_widget(camclick)
            self.cam = camclick
            self.cam.config = self.project.config

    def on_capture_done(self):
        """dummy handler"""


Builder.load_string("""
<SequenceProps>:
    cols:1
    # row_default_height:40
    # row_force_default:True
    orientation:'vertical'
    padding: dp(48)
    spacing:10
    # height: 120  #self.minimum_height

    # Label:
    #     text:'name'
    # TextInput:
    #     id:name
    #     text:root.propose_name()
    BoxLayout:
        size_hint:1,None
        height:list.height
        MDList:
            id:list
            cols:1
            size_hint:1,None
            orientation:'vertical'
        
            MDTextField:
                id:name
                hint_text: "Poltername"
                helper_text: root.text_pile_name
                helper_text_mode: "persistent"
                text:root.propose_name()
                size_hint:1,None
                # height:'80sp'
                
            MDNumberInput:
                id:length
                helper_text:root.text_log_length
                helper_text_mode:'persistent'
                size_hint:1,None
                value:4
                textsize:15
                step:.5
                height:'60sp'
                
            MDTextField:
                id:service_provider
                hint_text:root.text_service_provider
                
            MDTextField:
                id:comment
                hint_text:root.text_comment
                
            MDLabeledCheckbox:
                id:overlapping
                text: root.text_overlapping 
                size_hint:1,None
                active:True
                height:'40sp'
    
            TwoLineListItem:
                id:sequence_id
                text: 'id'
                # secondary_text: 
        
            MDRaisedButton:
                text:root.text_next
                on_release:root.props_changed()
                
            TwoLineListItem:
                text: root.text_location
                secondary_text:str(root.location) if root.location else ''
""")


class SequenceProps(ScrollView):
    """"""
    data = ObjectProperty({})
    location = ObjectProperty()
    show_delete = BooleanProperty(False)

    text_next = _('next')
    text_location = _('location')
    text_overlapping = _('overlapping')
    text_comment = _('comment')
    text_service_provider = _('service provider')
    text_log_length = _('log length')
    text_pile_name = _('pile name')
    text_delete_pile = _('delete pile')

    def __init__(self, *a, **kw):
        super().__init__(*a, **kw)
        self.register_event_type("on_props_changed")
        self.register_event_type("on_delete_selected")
        self.bind(data=self.on_data)
        Clock.schedule_once(self.after_init)

    def after_init(self, *a):
        delete_button=MDRaisedButton(text=self.text_delete_pile)
        delete_button.bind(
            on_release=lambda dt:
            self.dispatch("on_delete_selected"))

        if self.show_delete:
            self.ids.list.add_widget(delete_button)

    def on_data(self, *a):
        print('SequenceProps:on_data', self.data)
        self.ids.length.value=self.data.get('length', 4)
        self.ids.name.text=self.data.get('name', '')
        self.ids.service_provider.text=self.data.get('service_provider','')
        self.ids.sequence_id.secondary_text='<%s>' % self.data.get('id','')
        self.ids.comment.text = self.data.get('comment','')
        self.ids.overlapping.active = self.data.get('overlapping', True)

    def propose_name(self):
        return "neuer polter"

    def read_fields(self):
        self.data['length'] = self.ids.length.value
        self.data['name'] = self.ids.name.text
        self.data['service_provider'] = self.ids.service_provider.text
        self.data['comment'] = self.ids.comment.text
        self.data['overlapping'] = self.ids.overlapping.active

    def props_changed(self, *a):
        self.read_fields()
        self.dispatch("on_props_changed")

    def on_props_changed(self, *a, **kw):
        """dummy default handler"""

    def on_delete_selected(self, *a):
        """"""


Builder.load_string("""
<SequencesList>:
    orientation:'vertical'
    sequences_list:sequences_list
    
    ScrollView:
        size_hint:1,1
        MDList:
            id:sequences_list
            size_hint_y: None
            # height: self.minimum_size[1]
            cols: 1
    BoxLayout:
        size_hint:1,.2
        orientation:'horizontal'
        MDRaisedButton:
            text:'Neuen Polter anlegen'
            on_release: root.dispatch('on_new_sequence')
        MDFlatButton:
            text:'reload'
            on_release: root.load()
""")


class SequencesList(BoxLayout):
    """
    SequenceContainer
    """

    sequences = ObjectProperty()

    def __init__(self, *a, **kw):
        super(SequencesList, self).__init__(*a, **kw)
        self.register_event_type("on_new_sequence")
        self.register_event_type("on_sequence_selected")

    def on_sequences(self, *a):
        print('on_sequences')
        Clock.schedule_once(self.load, 0)

    def load(self, *a, **kw):
        """draws itself"""
        t=time.time()
        print('begin SequencesList::load')
        sequences = list(self.sequences.list_sequences(do_load=True))
        # sequences = filter(lambda x:x.has_location, sequences)

        sequences = sorted(sequences, key=lambda x:x.name, reverse=True)
        self.sequences_list.clear_widgets()
        for sequence in sequences:

            butt = OneLineListItem(text=sequence.name, size_hint_y=None, height=44)
            butt.sequence = sequence
            butt.bind(on_release=self.on_select)
            self.sequences_list.add_widget(butt)
            self.sequences_list.height += butt.height

        print('en SeuencesList::load:', time.time()-t)
    def on_new_sequence(self):
        """dummy handler"""

    def on_sequence_selected(self, sequence_name):
        """dummy handler"""

    def on_select(self, butt):
        print('sequeces_list:', butt.text)
        self.dispatch("on_sequence_selected", butt.text)


Builder.load_string("""
<SequenceMarkerPopup>:
    lat: 50.6394
    lon: 3.057
    popup_size: dp(230), dp(130)
    
    Bubble:
        BoxLayout:
            orientation: "vertical"
            padding: "5dp"

            on_touch_down:
                root.handle_touchdown(*args)
            Label:
                text: root.sequence.name
                markup: True
                halign: "center"
            Button:
                size_hint:1,.3
                text: 'open'
                on_release: root.dispatch("on_clicked")
""")


class SequenceMarkerPopup(MapMarkerPopup):
    """
    this content will be displayed on the map when clicking on a marker
    """
    sequence = ObjectProperty()

    def __init__(self, *a, **kw):
        # super(ButtonBehavior, self).__init__(*a, **kw)
        super(SequenceMarkerPopup, self).__init__(*a, **kw)
        self.register_event_type("on_clicked")

    def on_clicked(self, *a):
        """dummy handler"""

    def handle_touchdown(self, widget, event, **kw):
        print('touchdown')
        if not widget.collide_point(*event.pos):
            print('event outside widget')
            self.is_open=False


Builder.load_string("""
<SequencesMapView>:
    id:mapview
    mapview:mapview
    MapView:
        id: mapview
        zoom: 15
""")


class SequencesMapView(BoxLayout):
    """"""
    sequences = ObjectProperty()
    """thats the sequences container"""

    def __init__(self, sequences, *a, **kw):
        super(SequencesMapView, self).__init__( *a, **kw)
        self.sequences=sequences
        self.register_event_type("on_sequence_selected")

    def on_sequence_selected(self, *a):
        """dummy handler"""

    def on_sequences(self, *a):
        print('on_sequences')
        Clock.schedule_once(self.draw, 0)

    def on_marker_pressed(self, marker):
        print("marker pressed:", marker, marker.sequence)
        self.dispatch("on_sequence_selected", marker.sequence.name)

    def open_sequence(self, sequence, *a):
        self.dispatch("on_sequence_selected", sequence.name)

    def draw(self, *a):
        """draws itself"""
        # import pdb;pdb.set_trace()
        sequences = list(self.sequences.list_sequences(do_load=True))
        sequences = [x for x in sequences if x.has_location]
        sequences = sorted(sequences, key=lambda x:x.name, reverse=True)
        latest=sequences[:10]
        locs=[x.location for x in latest]

        # compute the medium location of recent N sequences
        medium_location=functools.reduce(lambda a,b: ((a[0]+b[0])/2,(a[1]+b[1])/2), locs)

        print('medium:', medium_location)

        self.mapview.center_on(*medium_location)

        for sequence in sequences:
            lat, int = sequence.location
            # print lat, long
            # marker=MapMarker(lon=long, lat=lat, on_press=self.on_marker_pressed)
            marker=SequenceMarkerPopup(lon=int, lat=lat, sequence=sequence)
            marker.bind(on_clicked=functools.partial(self.open_sequence, sequence))
            marker.sequence=sequence
            self.mapview.add_marker(marker)


Builder.load_string("""
<SequenceThumbView>:
    content:content
    orientation:'vertical'

    AsyncImage:
        id:content
        # source:root.source
""")


class SequenceThumbView(ButtonBehavior, BoxLayout):
    """
    Thumbnail view on an image file, does automatic
    resize to width
    """
    owner = ObjectProperty()
    source = StringProperty()
    fname = StringProperty()
    image = ObjectProperty()  # model.PositiveImage

    def __init__(self, image, *a, **kw):
        # super(SequenceThumbView, self).__init__(*a,**kw)  # damn, warum geht das nicht???

        ButtonBehavior.__init__(self, *a, **kw)
        self.register_event_type("on_img_click")

        self.image=image

    @property
    def path(self):
        return self.image.path

    def on_release(self, *a, **kw):
        self.dispatch("on_img_click", self.image)

    def on_img_click(self, source):
        """default handler for image selection"""
        # print 'img select default handler:', source

    def on_image(self, widget, image):
        """loads image from PositiveImage"""
        # self.source=source
        # width=self.width
        width=250
        # print 'on_source: width:', self.width
        if widget == self:
            # img = imread(source, True, width=width)

            apply_image(self.content, image.img)

            # print 'ThumbView::set_image : ', width


Builder.load_string("""
<SequenceThumbListView>:
    do_scroll_x:False
    GridLayout:
        id:content
        cols:1
        spacing:2
        size_hint:1,None

        # Label:
        #     text:'thumbs here'
""")


class SequenceThumbListView(ScrollView):
    """"""
    sequence = ObjectProperty()  # model.Sequence

    def __init__(self, *a, **kw):
        super(SequenceThumbListView, self).__init__(*a, **kw)
        self.register_event_type("on_image_select")

    def add_image(self, image):

        thumb = SequenceThumbView(image=image, owner=self, size_hint=(1, None))
        thumb.bind(on_img_click=self.on_img_click)
        self.ids.content.height += thumb.height
        self.ids.content.add_widget(thumb)

    @property
    def fnames(self):
        # import pdb;pdb.set_trace()
        return [t.path for t in self.ids.content.children]

    def read_sequence(self, sequence, reset=False, incremental=True):
        if reset:
            self.ids.content.clear_widgets()
            self.ids.content.height = 0

        for pimg in sequence:
            self.add_image(pimg)

    def reload(self, reset=True, incremental=True):
        self.read_sequence(self.sequence, reset=reset, incremental=incremental)

    def on_sequence(self, *a):
        self.read_sequence(self.sequence, True)

    def on_img_click(self, widget, image):
        # self.parent.ids.editor.source = source
        self.dispatch('on_image_select', image)

    def on_image_select(self, imgpath):
        """dummy impl"""

from kivymd.uix.bottomsheet import MDGridBottomSheet, MDBottomSheet

Builder.load_string("""
<SequenceImageInformation>:
    orientation:'vertical'

    MDList:
        TwoLineListItem:
            text:'image path'
            secondary_text:root.image.path if root.image else '--'
    
        TwoLineListItem:
            text:'shapes detected'
            secondary_text:str(root.image.count_detected_shapes)
    
        TwoLineListItem:
            text:'unique shapes'
            secondary_text:str(root.image.count_unique_shapes)
    
        TwoLineListItem:
            text:'area of shapes detected'
            secondary_text:str(root.image.area_detected_shapes)
    
        TwoLineListItem:
            text:'area unique'
            secondary_text:str(root.image.area_unique_shapes)

        TwoLineListItem:
            text:'distance'
            secondary_text:str(root.image.distance)
        
        TwoLineListItem:
            text:'camera FOV'
            secondary_text:str(root.image.camera_fov)
            
        TwoLineListItem:
            text:'resolution'
            secondary_text:str(root.image.img.shape)

        TwoLineListItem:
            text:'resolution undistorted'
            secondary_text:str(root.image.img_undistorted.shape)

        TwoLineListItem:
            text:'width'
            secondary_text:str(root.image.width)

        TwoLineListItem:
            text:'ref width'
            secondary_text:str(root.image.ref_width)
            
        TwoLineListItem:
            text:'location'
            secondary_text:str(root.image.location)

""")


class SequenceImageInformation(ScrollView):
    """"""
    image = ObjectProperty(None)

    def __init__(self, *a, **kw):
        super(SequenceImageInformation, self).__init__(*a, **kw)

from kivymd.uix.list import MDList
from kivy.uix.scrollview import ScrollView


Builder.load_string("""
<SequenceImageDetectionOptions>:
    cols:1
    size_hint:1,None
    orientation:'vertical'
    # MDList:
    
    DropDownList:
        # text:'stages-18'
        width: sp(160)
        text: root.cascade_name
        id: cascades_list
        values: root.cascade_names
        # values:[] # root.project.list_cascades() if root.project else []

    MDNumberInput:
        id:scale_factor
        height:sp(48)
        size_hint:None,None
        value: root.scale_factor
        step:.01
        minimum:1.01
        textsize:6
        hint_text:'scale factor'
    
    
    MDNumberInput:
        height:sp(48)
        datatype:int
        textsize:6
        hint_text:'min neighbors'
        id:min_neighbors
        size_hint:None,None
        value: root.min_neighbors
        step:1
        minimum:0

    MDLabeledCheckbox:
        id:smooth
        size_hint:1, None
        text:root.text_smooth
        active:root.smooth
    
""")

class SequenceImageDetectionOptions(BoxLayout):
    """"""
    scale_factor = NumericProperty()
    min_neighbors = NumericProperty()
    cascade_name = StringProperty('lbp-16-11')
    cascade_names = ListProperty([])
    smooth = BooleanProperty()

    text_smooth = _('smooth')


Builder.load_string("""
<SequenceImageView>:
    orientation:'vertical'
    image_widget:image
    # cascades_list:cascades_list
    # status: status
    RelativeLayout:
        size_hint:1,1
        BoxStencil:
            size_hint:1,1
            ScatterLayout:
                size_hint:1,1
                do_rotation:False
                AsyncImage:
                    id:image
""")


class SequenceImageView(BoxLayout, widgets.ImageClassifierMixin):
    """
    View class for displaying model.PositiveImage
    """
    image = ObjectProperty()
    predecessor = ObjectProperty()  # precious image in sequence
    successor = ObjectProperty()    # next image in sequence
    sequence = ObjectProperty()

    def on_image(self, *a):
        apply_image(self.image_widget, self.image.img_undistorted)
        # self.ids.info.text = "distance: %s, ref:%s" % \
        #                      (self.image.distance, self.image.ref_distance)
        self.clear_detections()
        self.update()
        # apply_image(self.image_widget, self.image.img)

    def on_sequence(self, *a):
        """"""
        # self.cascades_list.values = self.sequence.list_cascades()
        # import pdb;pdb.set_trace()

    def detect_shapes(self):
        print('detect_shapes:')
        cascade = self.sequence.load_cascade(self.cascades_list.text)
        self.image.detect_and_store_shapes(cascade,
                                           draw_markers=False,
                                           scale_factor=self.ids.scale_factor.value,
                                           min_neighbors=self.ids.min_neighbors.value)

        self.update()

    def draw_shapes(self, shapes, circle_color=(1,1,0), text_color=(1,0,0), autoclear=True):
        if autoclear:
            self.clear_detections()
        with self.image_widget.canvas.after:
            for (x, y, radius) in shapes:
                self.draw_circle(x, y, radius, color=circle_color)
                diameter = self.image.pixel2cm(radius*2)
                diameter_rounded = int(np.round(diameter))
                text = str(diameter_rounded)
                # text="%s - %s" % (diameter_rounded, radius * 2)
                self.draw_centered_text(x, y, text, color=text_color)

    def draw(self):
        if self.image.detected_shapes is not None:
            self.draw_shapes(self.image.detected_shapes, circle_color=(.7, .7, .7), text_color=(.7,.7,.7, 1))

        if self.image.unique_shapes is not None:
            self.draw_shapes(self.image.unique_shapes, circle_color=(1, 1, 0), text_color=(1, 0, 0), autoclear=False)

        # if self.image.shadow_shapes is not None:
        #     self.draw_shapes(self.image.shadow_shapes, circle_color=(.7,.7,.7), text_color=(0, 1, 0), autoclear=False)

    def update(self):
        self.draw()

    def show_info(self):
        if self.image:
            content = SequenceImageInformation(image=self.image)

            dialog = BDDialog(title="Information",
                              # content=content,
                              auto_dismiss=True,
                              size_hint=(1, 1)
                              )

            dialog.content = content
            dialog.add_action_button("Ok", lambda *x: dialog.dismiss())
            dialog.open()


Builder.load_string("""
<ProgressContent>:
    # height:200
    orientation:'vertical'
    log:log
    sublog:sublog
    details: details
    valign: 'middle'
    size_hint_y:None
    BoxLayout:
        # MDLabel:
        #     text:'Task'
        MDLabel:
            id:log
            text:root.text_detection_task
            theme_text_color: 'Primary'
    BoxLayout:
        MDLabel:
            id:sublog
            text:root.text_progress
            theme_text_color: 'Primary'

    MDLabel:
        id:details
        theme_text_color: 'Primary'
""")


class ProgressContent(BoxLayout):
    """"""
    # def __init__(self, *a, **kw):
    #     import pdb;pdb.set_trace()
    #     super(ProgressContent, self).__init__(self, *a, **kw)
    text_detection_task = _('detection task')
    text_progress = _('progress')

Builder.load_string("""
<SequenceView>:
    orientation:'horizontal'
    image_view:image_view
    thumbs:thumbs
    image_view:image_view
    status:status
    # substatus:substatus
    # progress:progress
    # anchor_x:'left'
    
    SequenceThumbListView:
        id:thumbs
        width:200
        size_hint:.25,1
        sequence:root.sequence
        on_image_select:root.on_image_select(*args)
    BoxLayout:
        orientation:'vertical'
        size_hint: 1,1
        SequenceImageView:
            id: image_view
            sequence: root.sequence
            size_hint: 1,.95
        BoxLayout:
            id:buttons
            size_hint:1, None
            height:root.ids.compute.height * 1.2
            valign:'middle'
            canvas:
                Color:
                    rgb: 1,1,1
                Rectangle:
                    pos:0,0
                    size:self.size    
                
            MDRaisedButton:
                id:compute
                text:'berechnen!'
                # on_release:root.detect_dedup()
                on_release:root.start_computation()
                
            MDIconButton:
                icon:'file-document'
                # text:'properties'
                on_release:root.show_props()
                
            MDIconButton:
                icon:'share-variant'
                on_release:root.on_share()
                
            MDIconButton:
                icon:'content-copy'
                on_release:root.on_capture_dependent_sequence()

            MDIconButton:
                icon:'information-outline'
                on_release:root.ids.image_view.show_info()
                
            BoxLayout:
                orientation:'vertical'
                MDLabel:
                    id: status
                    theme_text_color: 'Primary'
                    
                # MDLabel:
                #     id: substatus
                    
            MDIconButton:
                icon:'settings'
                on_release:root.options_dialog()
                    
""")


class SequenceView(BoxLayout):
    """"""
    project = ObjectProperty()
    path = StringProperty()
    project_path = StringProperty()
    sequence_path = StringProperty()
    sequence = ObjectProperty()
    progress_dialog = ObjectProperty(None, allownone=True)
    scale_factor = NumericProperty(1.08)
    min_neighbors = NumericProperty(3)
    cascade_name = StringProperty('lbp-16-11')
    smooth = BooleanProperty(False)

    text_properties = _('properties')
    text_options = _('options')
    text_shapes_detected = _('shapes detected')
    text_detecting = _('log detection')
    text_progress = _('progress')
    text_dedup = _('dedup')
    text_dedupped = _('dedupped')
    text_keypoints = _('keypoints')
    text_ready = _('ready')

    def __init__(self, *a, **kw):
        super(SequenceView, self).__init__(*a, **kw)
        Clock.schedule_once(self.after_init, 0)
        self.register_event_type('on_new_dependent_sequence')
        self.register_event_type('on_sequence_deleted')

    def on_new_dependent_sequence(self, *a):
        """dummy handler"""

    def on_sequence_deleted(self, *a):
        """"""

    def after_init(self, *a):
        app=App.get_running_app()
        if app.show_editor:
            editorbutton=MDRaisedButton(text='editor')
            editorbutton.bind(on_release=self.open_editor)
            self.ids.buttons.add_widget(editorbutton)

    def open_editor(self, *a):
        # import pdb;pdb.set_trace()
        wiz=self.parent.parent.parent
        wiz.switch_to_editor()

    def on_sequence(self, *a):
        # self.ids.lbl.text=self.sequence.path
        # import pdb;pdb.set_trace()
        print('on_sequence:', end=' ')
        print(self.sequence.path)
        # self.ids.sequence_images.path=self.sequence.path

    def on_image_select(self, widget, image):
        self.image_view.image=image

    def reload(self, **kw):
        self.thumbs.reload(*kw)
        if len(self.sequence) > 0:
            self.image_view.image = self.sequence[0]

    def detect_shapes(self, *a):
        cascade = self.sequence.load_cascade(self.cascade_name)
        self.sequence.detect_and_store_shapes(cascade,
            draw_markers=False,
            scale_factor=self.scale_factor,
            min_neighbors=self.imin_neighbors,
            smooth=self.ids.smooth.state)
        self.update_progress(self.shapes_detected, self.dedup_shapes)
        # Clock.schedule_once(self.dedup_shapes, 0)

    def dedup_shapes(self, *a):
        self.sequence.deduplicate_shapes()
        self.summarize()

    def detect_dedup(self):
        Clock.schedule_once(functools.partial(self.update_progress, self.text_detecting, self.detect_shapes), 0)

    def start_computation(self):
        # self.detect_dedup()
        cascade = self.sequence.load_cascade(self.cascade_name)
        detect = self.sequence.detect_and_store_shapes_generator(cascade,
            draw_markers=False,
            scale_factor=self.scale_factor,
            min_neighbors=self.min_neighbors,
            smooth=self.smooth
            )



        content=ProgressContent()
        self.progress_dialog = MDDialog(
                                        content=content,
                                        title=self.text_progress,
                                        size_hint=(.5, .5),
                                        auto_dismiss=False
                                        )
        content.bind(size=content.setter('size'))
        # self.progress_dialog.add_action_button("Dismiss",
        #                               action=lambda *x: self.progress_dialog.dismiss())

        self.progress_dialog.open()

        if self.sequence.overlapping:
            dedup = self.sequence.deduplicate_shapes_generator()

            all = chaining.clock_chain([
                functools.partial(self.log_step, self.text_detecting),
                [detect, self.log_detect],
                functools.partial(self.log_step, self.text_dedup),
                [dedup, self.log_dedup],
                functools.partial(self.log_step, self.text_ready),
                self.summarize,
                self.show_first_image,
                self.progress_dialog.dismiss
            ],
            self.log_exception)
        else:
            all = chaining.clock_chain([
                functools.partial(self.log_step, self.text_detecting),
                [detect, self.log_detect],
                functools.partial(self.log_step, self.text_ready),
                self.summarize,
                self.show_first_image,
                self.progress_dialog.dismiss
            ],
                self.log_exception)

        all()

    def log_detect(self, r):
        self.progress_dialog.content.sublog.text = (self.text_shapes_detected + " : %s") % (r + 1)

    def log_dedup(self, r):
        dlg=self.progress_dialog.content
        dlg.sublog.text = (self.text_dedup + " : %s , %s") % (r['index']+1, r['index']+2)
        dlg.details.text = (self.text_keypoints + ' : %s') % r['keypoints']

    def log_step(self, msg):
        self.progress_dialog.content.log.text = str(msg)

    def log_exception(self, ex, *a):
        self.progress_dialog.content.log.text = "EXCEPTION:%s" % ex
        Clock.schedule_once(self.progress_dialog.dismiss, 5)

    @mainthread
    def update_progress(self, msg, next, *a):
        self.progress.text=msg
        Clock.schedule_once(next, 0)

    def summarize(self):
        self.status.text = """V:{:.2f} / #:{:d} / A:{:.2f}""".format(self.sequence.volume,
                                                                     self.sequence.count_unique_shapes,
                                                                     self.sequence.area_unique_shapes)

    def show_first_image(self):
        self.image_view.image = self.sequence.images[0]
        self.image_view.draw()

    def show_props_screen(self):
        wiz=self.parent.parent.parent
        # import pdb;pdb.set_trace()
        wiz.switch_to_sequence_props()

    def show_props(self):
        content = SequenceProps(location=self.sequence.location,
                                show_delete=True)
        content.data = self.sequence.metadata
        dlg = BDDialog( title=self.text_properties,
                       size_hint=(1,1), auto_dismiss=True)
        def handle(content):
            # content.data.write_metadata()
            dlg.dismiss()

        dlg.content = content
        dlg.content.bind(on_props_changed=handle,
                         on_delete_selected=self.on_delete_selected)
        dlg.open()

    def on_delete_selected(self, widget, *a):
        def on_delete():
            widget.dialog.dismiss()
            self.delete_me()

        yesno_box("Loeschen",
                  "Soll diese Aufnahme wirklich geloescht werden?",
                  on_yes=on_delete,
                  )

    def delete_me(self):
        """deletes the current sequence, navigates to overview"""
        print("delete selected!!")
        sname, sid=self.sequence.name, self.sequence.id
        self.project.sequences.delete_sequence(self.sequence)
        self.dispatch("on_sequence_deleted", sid, sname)
        # import pdb;pdb.set_trace()


    def options_dialog(self):
        # import pdb;pdb.set_trace()
        print("options dialog")
        dialog = BDDialog(title=self.text_options,
                          auto_dismiss=True,
                          size_hint=(.8, .8),)

        # import pdb;pdb.set_trace()
        options = SequenceImageDetectionOptions(
                          scale_factor=self.scale_factor,
                          min_neighbors=self.min_neighbors,
                          cascade_names=self.sequence.list_cascades(),
                          cascade_name=self.cascade_name,
                          smooth=self.smooth
                        )

        def on_options(*a):
            # import pdb;pdb.set_trace()
            self.scale_factor = options.ids.scale_factor.value
            self.min_neighbors = options.ids.min_neighbors.value
            self.cascade_name = options.ids.cascades_list.text
            self.smooth = options.ids.smooth.active
            dialog.dismiss()

        dialog.add_action_button("Ok", on_options)
        dialog.content = options
        dialog.open()

    def on_share(self):
        location=self.sequence.location
        name=self.sequence.name
        service_provider = self.sequence.metadata.get('service_provider')
        length = self.sequence.length
        volume = int(np.round(self.sequence.volume))
        comment = self.sequence.metadata.get('comment','')

        url="http://maps.google.com/?q=%s,%s" % location

        msg="""
Polter:%s
Dienstleister:%s
Laenge:%s
FM:%s
%s
%s
"""     % (name, service_provider, length, volume, comment, url)

        # print 'share!:',msg
        self.share(msg)

    def share(self, msg):
        print('share msg:', msg)

        if platform != 'android':
            print('only android is supported, you have:', platform)
            return

        intent = Intent()
        intent.setAction(Intent.ACTION_SEND)
        intent.putExtra(Intent.EXTRA_TEXT, String(msg))
        intent.setType('text/plain')
        chooser = Intent.createChooser(intent, String("Polterinformation"))
        PythonActivity.mActivity.startActivity(chooser)

    def on_capture_dependent_sequence(self):
        id=str(uuid.uuid4())
        print('new dep seq',id, self.sequence.id)
        data={
            'name':self.sequence.name+"'",
            'service_provider':self.sequence.metadata['service_provider'],
            'comment':self.sequence.metadata.get('comment','')
        }

        self.dispatch('on_new_dependent_sequence', id, self.sequence.id, data, self.sequence)


Builder.load_string("""
<SequenceScreen>:
    id:sequence_view
    do_default_tab:False
    # MDTab:
    #     id:screen_sequence_view
    #     name:'screen_sequence_view'
    #     text:'view'
            
    SequenceView:
        id:sequence_view
        sequence: root.sequence
        path: root.sequence_path
        project_path:root.project_path  # for cascades dropdown
        project:root.project
        sequence_path:root.sequence_path
        on_new_dependent_sequence: root.new_dependent_sequence(*args)
        on_sequence_deleted:root.sequence_deleted(args[1],args[2])
        
    # TabbedPanelItem:
    #     id:screen_editor
    #     name:'screen_editor'
    #     text:'editor'
    #     ImageBrowser:
    #         id:sequence_images
    #         path: root.sequence_path
    #         project_path:root.project_path  # for cascades dropdown
    #         sequence_path:root.sequence_path

""")


class SequenceScreen(BoxLayout):
    """view class for a single sequence"""
    project = ObjectProperty()
    path = StringProperty()
    project_path = StringProperty()
    sequence_path = StringProperty()
    sequence = ObjectProperty()

    def __init__(self, **kw):
        super().__init__(**kw)
        self.register_event_type("on_sequence_deleted")

    def sequence_deleted(self, sid, name):
        print("sequence_deleted: ", sid, name)
        self.dispatch("on_sequence_deleted", sid, name)

    def on_sequence_deleted(self, *a):
        """"""

    def on_sequence(self, *a):
        # import pdb;pdb.set_trace()
        if 'sequence_images' in self.ids:
            self.ids.sequence_images.path = self.sequence.path

    def reload(self, **kw):
        self.sequence.load(load_img_data=True)
        self.ids.sequence_view.reload(**kw)

    def new_dependent_sequence(self, widget, id, ref_id, data, orig_sequence):
        print('new dependent seq', id, ref_id)
        wiz=self.parent.parent
        wiz.capture_sequence(id, ref_id, data, orig_sequence)

from ui.kivy.editor import ImageBrowser


Builder.load_string("""
<SequenceEditorScreen>:
    id:screen_editor
    name:'screen_editor'
    text:'editor'
    ImageBrowser:
        id:sequence_images
        path: root.sequence_path
        project_path:root.project_path  # for cascades dropdown
        sequence_path:root.sequence_path
""")


class SequenceEditorScreen(BoxLayout):
    """"""
    project = ObjectProperty()
    path = StringProperty()
    project_path = StringProperty()
    sequence_path = StringProperty()
    sequence = ObjectProperty()

    def on_sequence(self, *a):
        # import pdb;pdb.set_trace()
        if 'sequence_images' in self.ids:
            self.ids.sequence_images.path = self.sequence.path

    def reload(self, **kw):
        self.sequence.load(load_img_data=True)
        self.ids.sequence_view.reload(**kw)


Builder.load_string("""
<SequenceWizard>:
    props:props
    capture:capture
    sequence_images:sequence_images
    sequences_list:sequences_list
    
    Screen:
        name:'screen_list'
        SequencesList:
            id:sequences_list
            # sequences_path: root.sequences_path
            on_new_sequence: root.capture_sequence()
            on_sequence_selected: root.open_sequence(args[1])
            
    Screen:
        # map view for sequences
        id:map_screen
        name:'screen_map'
            
    Screen:
        name:'screen_props'
        SequenceProps:
            id:props
            data:root.sequence.metadata if root.sequence else {}
            on_props_changed: root.switch_to_sequence_view()
            
    Screen:
        name:'screen_capture'
        SequenceCapture:
            id:capture
            on_capture_done:root.switch_to_sequence_view()

    Screen:
        name:'screen_sequence_view'
        SequenceScreen:
            id:sequence_images
            sequence: root.sequence
            path: root.sequence_path
            project: root.project
            project_path:root.project_path  # for cascades dropdown
            on_sequence_deleted: root.sequence_deleted(args[1], args[2])
    Screen:
        name:'screen_sequence_editor'
        SequenceEditorScreen:
            id:sequence_image_editor
            sequence: root.sequence
            path: root.sequence_path
            project: root.project
            project_path:root.project_path  # for cascades dropdown

""")


class SequenceWizard(ScreenManager):
    """"""
    project = ObjectProperty()
    project_path = StringProperty()
    sequences_path = StringProperty()
    sequence = ObjectProperty(None)
    sequence_path = StringProperty()
    sequence_container=ObjectProperty()

    text_new_pile = _('new pile')

    def on_sequence(self, *a, **kw):
        # print 'SequenceWizard::on_sequence:', a, kw
        self.sequence_path=self.sequence.path
        # print '!!!!!!:', self.sequence.metadata
        self.ids.props.data=self.sequence.metadata

    def sequence_deleted(self, sid, name):
        self.switch_to_list()

    def on_project(self, *a, **kw):
        print('SequenceWizard::on_path:', a, kw)
        self.project_path = self.project.path
        self.capture.project = self.project
        self.sequences_path = self.project.sequences_path
        self.sequence_container = self.project.sequence_container(self.project.sequences_path)
        self.switch_to_list()

    def switch_to_new_sequence(self):
        self.current='screen_props'

    def switch_to_sequence_props(self):
        self.current='screen_props'
        # import pdb;pdb.set_trace()
        self.ids.props.data=self.sequence.metadata

    def switch_to_capture(self, props, id=None, ref_id=None, orig_sequence=None, *a):
        self.sequence = self.project.sequences.sequence(props.ids.name.text,
                                                        create=True,
                                                        metadata=props.data,
                                                        id=id,
                                                        ref_id=ref_id)
        if orig_sequence:
            orig_sequence.next_id=id
        self.capture.sequence = self.sequence
        self.ids.capture.init_cam()
        print('new sequence:', self.sequence.name)
        self.current = 'screen_capture'

    def switch_to_sequence_view(self):
        """switch to editor view"""
        self.current = 'screen_sequence_view'
        self.sequence_images.reload(incremental=False)

    def switch_to_editor(self):
        """switch to editor view"""
        self.current = 'screen_sequence_editor'
        self.sequence_images.reload(incremental=False)

    def switch_to_list(self):
        self.current = 'screen_list'
        self.sequence_container=self.project.sequence_container(self.sequences_path)
        self.sequences_list.sequences=self.sequence_container
        self.sequences_list.load()

    def init_map_screen(self, force_new=False):
        """creates the map view on first access"""
        if force_new or ('map_view' not in self.ids):
            mapview=SequencesMapView(self.sequence_container)
            mapview.bind(on_sequence_selected=lambda widget, sequence:self.open_sequence(sequence))

            self.ids.map_screen.add_widget(mapview)
            self.ids['map_view']=mapview

    def switch_to_map(self):
        """open map view"""
        self.current='screen_map'
        # import pdb;pdb.set_trace()
        self.sequence_container=self.project.sequence_container(self.sequences_path)

        self.init_map_screen()
        # TODO: self.ids.screen_map_view initialisieren

    def open_sequence(self, name):
        self.sequence = self.project.sequences.sequence(name, do_load=True)
        self.ids.props.data=self.sequence.metadata
        # import pdb;pdb.set_trace()
        self.current = 'screen_sequence_view'

    def open_screen(self, screen_name):
        self.current = screen_name

    def capture_sequence(self, id=None, ref_id=None, data=None, orig_sequence=None):
        if data is None:
            data={}
        content = SequenceProps()
        content.data = data
        dlg = BDDialog(title=self.text_new_pile, size_hint=(1,1), auto_dismiss=True)
        def handle(content):
            content.read_fields()
            self.switch_to_capture(content, id=id, ref_id=ref_id, orig_sequence=orig_sequence)
            dlg.dismiss()
        dlg.content=content
        content.bind(on_props_changed=handle)
        dlg.open()