Esempio n. 1
0
    def on_press(self):
        # Setup the scatter layout to show in the popup
        scatter = Scatter(do_rotation=False,
                          size_int=(300, 300),
                          scale_min=1.0,
                          scale_max=10.0)

        image_source = join(globals_.photo_path, 'thumbs',
                            basename(self.source))

        image = AsyncImage(source=image_source)
        scatter.add_widget(image)
        # Resize the scatter object
        multiplier = 6
        mat = Matrix().scale(multiplier, multiplier, multiplier)
        scatter.apply_transform(mat)

        popup = Popup(title=basename(self.source),
                      content=scatter,
                      size_hint=(0.8, 1),
                      pos_hint={
                          'x': 0.0,
                          'y': 0.0
                      })
        popup.open()
Esempio n. 2
0
class TestCamera(App):
    def __init__(self, **kwargs):
        super(TestCamera, self).__init__(**kwargs)
        self._camera = None

    def _camera_toggle(self, val):
        self._camera.play = not self._camera.play

    def _led_toggle(self, val):
        if self._led_state == GPIO.LOW:
            self._led_state = GPIO.HIGH
            self._toggle.text = "LED ON"
        else:
            self._led_state = GPIO.LOW
            self._toggle.text = "LED OFF"
        GPIO.output(LED_Pin, self._led_state)



    def _show_demo_results(self, val):
        popup = Popup(title='Reconstruction Results',
                      content=Label(text=
                        'TOTAL TARGET CELLS                          : 52\n'+
                        'TOTAL FOUND  CELLS                           : 77\n'+
                        'TOTAL FILTERED CELLS                        : 0\n'+
                        'TOTAL BEADS FOR TARGET CELLS      : 235\n'+
                        'AVERAGE BEADS/CELL                         : 4'),
                      size_hint=(None, None), size=(400, 200))
        popup.open()

    def _show_carousel(self, log_file):
        local_recon = '/home/pi/recon'
        prefix = log_file.split('.', 1)[0]
        carousel = Carousel(direction='right')
        for filename in os.listdir(local_recon):
            if filename.startswith(prefix) and filename.endswith('.png'):
                src = os.path.join(local_recon, filename)
                image = Image(source=src, allow_stretch=True,  size=(620, 460))
                carousel.add_widget(image)
        popup = Popup(title='Reconstruction Results',
                      content=carousel,
                      size_hint=(None, None), size=(640, 480))
        popup.open()


    def _request_capture(self, val):
        self._camera.capture__full_res_frame()

    def _request_ref_capture(self, val):
        self._camera.capture__full_res_ref()


    def _toggle_object_detection(self, val):
        detecting = not self._camera.get_object_detection()
        self._camera.set_object_detection(detecting)
        if not detecting:
            self._object_detection.source = '/home/pi/d3-ui/img/object_detection_off.png'
        else:
            self._object_detection.source = '/home/pi/d3-ui/img/object_detection_on.png'

    def _change_exposure(self, instance, val):
        self._camera.set_exposure(int(val))

    def _do_reset_scatter(self, val):
        # move the
        mat = Matrix().scale(10,10,10).translate(0,-150,0)
        self._scatter.transform = mat

    def _auto_change_exposure(self, val):
        # go in steps
        self._auto_centroiding = True
        self._auto_centroid.source = '/home/pi/d3-ui/img/distribution_centroid_on.png'
        t = Thread(name='centroid_thread',
                   target=self._do_auto_change_exposure)
        t.start()

    def _auto_change_exposure_done(self, l):
        # go in steps
        self._auto_centroiding = True
        self._auto_centroid.source = '/home/pi/d3-ui/img/distribution_centroid_off.png'

    # basic pid loop....
    def _do_auto_change_exposure(self):
        epsilon = 1
        previous_error = 0
        integral = 0
        error = 127 - self._histogram.centroid
        dt = 1
        Kp = 0.5
        #Kd = 0.6
        #Ki = 0.6
        Kd = 0.1
        Ki = 0
        tries = 0
        max_tries = 15
        while abs(error) > epsilon and tries < max_tries:
            try:
                integral = integral + error*dt
                derivative = (error - previous_error)/dt
                output = Kp*error + Ki*integral + Kd*derivative + self._camera.get_exposure()
                # set exposure to the output
                if(output < self._exposure_slider.max and output > self._exposure_slider.min):
                    self._camera.set_exposure(int(output))
                    # let the exposure settle
                    sleep(.4)
                previous_error = error
                error = 127 - self._histogram.centroid
                tries += 1
            except:
                e = sys.exc_info()[0]
                Logger.exception('Exception! %s', e)
        Clock.schedule_once(self._auto_change_exposure_done)


    def _exit_app(self, val):
        self._camera.play = False
        # give it a 1/4 sec to shu down the camera
        sleep(0.25)
        App.get_running_app().stop()
        import sys
        sys.exit()

    def _update_histogram(self, val):
        frame = self._camera.get_current_frame()
        self._histogram.set_data(frame)

        #self._histogram.set_pil_image(self._camera.get_current_frame())
        #npImage = np.array(frame)

        #hist_full = cv2.calcHist([npImage],[0],None,[256],[0,256]).ravel()
        #self._plot.points = [(x, hist_full[x]) for x in range(0,256)]


        #plt.plot(hist_full,color = 'b')
        #plt.clf()
        #plt.hist(npImage.ravel(), 256,[0,256])
        #plt.xlim([0,256])
        #self._histogram.draw()


    def _update_fps(self, l):
        self._fps.text = "FPS: %d" % self._camera.get_fps()
        self._exposure.text = "Exposure: %d" % self._camera.get_exposure()
        self._centroid.text = "C: %d" % self._histogram.centroid

        # todo: change this to be event-driven
        if self._camera.is_uploading():
            if self._uploading.pos_hint['pos'][0] < 0:
                self._uploading.pos_hint = {'pos':(0.0,0.9)}
                self._uploadingAmt.pos_hint = {'pos': (0.0, 0.8)}
                self._upload_progress.pos_hint = {'pos':(0.2,0.9)}
                #self._demo.pos_hint = {'pos': (0.0, 0.7)}
                self._snap.enabled = False
            self._upload_progress.value = 100 * self._camera.get_uploaded_size() / self._camera.get_total_upload_size()
            self._uploadingAmt.text = '%d kB' % int(self._camera.get_uploaded_size() / 1000)
        else:
            if self._uploading.pos_hint['pos'][0] >= 0:
                try:
                    self._uploading.pos_hint = {'pos':(-1,-1)}
                    self._upload_progress.pos_hint = {'pos':(-1,-1)}
                    self._uploadingAmt.pos_hint = {'pos': (-1, -1)}
                    self._upload_progress.pos_hint = {'pos':(-1,-1)}

                    #self._demo.pos_hint = {'pos': (-1, -1)}
                    self._snap.enabled = True
                except:
                    e = sys.exc_info()[0]
                    Logger.exception('Exception! %s', e)

    def updateImages(self):
        if not self._is_updating:
            t = Thread(name='image_thread',
                       target=self._do_download)
            t.start()

    def _do_download(self):
        try:
            self._is_updating = True
            local_recon ='/home/pi/recon'

            if not os.path.exists(local_recon):
                os.makedirs(local_recon)

            dbx = dropbox.Dropbox("Yk7MLEza3NAAAAAAAAABGyzVVQi_3q7CkUoPjSjO6tWId31ogOM0KiBcdowZoB0b")
            # dbx = dropbox.Dropbox("Yk7MLEza3NAAAAAAAAAAp3MyYSImy0N0-3IMflqMPenGwEWJPqxAWeOAFzKu6y9A")
            # remote_path = '/input_test/D3RaspberryPi/%s' % os.path.basename(file)
            remote_recon = '/input/D3RaspberryPi/recon/'

            mode = dropbox.files.WriteMode.overwrite
            #mtime = os.path.getmtime(file)

            # list the folder contents
            try:
                res = dbx.files_list_folder(remote_recon)
                for entry in res.entries:
                    local_file = os.path.join(local_recon, entry.name)
                    if not os.path.exists (local_file):
                        # download and overwrite it
                        md, dl_res = dbx.files_download(entry.path_lower)
                        file = open(local_file, 'w')
                        file.write(dl_res.content)
                        file.close
                #delete items no longer in dropbox
                # for localfile in os.listdir(local_recon):
                #     local_file = os.path.join(local_recon, entry.name)
                #     if not os.path.exists (local_file):
                #         # download and overwrite it
                #         md, dl_res = dbx.files_download(local_file)
                #         file = open(local_file, 'w')
                #         file.write(dl_res.content)
                #         file.close
                Clock.schedule_once(self.updateResultsButton, 0.5)
            except dropbox.exceptions.ApiError as err:
                print('*** API error', err)
                return None
        except:
            e = sys.exc_info()[0]
            Logger.exception('Exception! %s', e)
            Clock.schedule_once(self.updateResultsButton, 0.5)
        self._is_updating = False

    def updateResultsButton(self, dt=None):
        try:
            # todo: contact dropbox
            local_recon = '/home/pi/recon'
            for local_file in os.listdir(local_recon):
                if local_file.endswith('.raw.log.iphone.log'):
                    btn = Button(text=local_file, size_hint_y=None, height=44)
                    btn.bind(on_release=lambda btn: self._show_carousel(btn.text))
                    self._dropdown.add_widget(btn)
        except:
            # do nothing
            print('error')

    def build(self):

        GPIO.setmode(GPIO.BCM)
        GPIO.setup(LED_Pin, GPIO.OUT)
        self._led_state =  GPIO.LOW
        GPIO.output(LED_Pin, self._led_state)

        #layout = BoxLayout(orientation='vertical')
        layout = FloatLayout(size=(800, 480), pos=(0,0))

        self._toggle = ToggleButton(text='LED OFF',
           size_hint=(0.2,0.2), pos_hint={'pos':(0.8,0)})

        self._snap = Button(text='Capture',
           size_hint=(0.2,0.2), pos_hint={'pos':(0.8,0.2)})

        self._snapref = Button(text='Reference',
           size_hint=(0.2,0.2), pos_hint={'pos':(0.8,0.4)})

        self._demo = Button(text='Demo Results',
           size_hint=(0.2,0.1), pos_hint={'pos': (0.0, 0.7)})

        self._auto_centroid = ImageButton(size_hint=(0.1,0.1), pos_hint={'pos':(0.7,0)},
            source='/home/pi/d3-ui/img/distribution_centroid_off.png')

        self._object_detection = ImageButton(size_hint=(0.1,0.1), pos_hint={'pos':(0.7,0.1)},
            source='/home/pi/d3-ui/img/object_detection_off.png')

        self._reset_scatter = ImageButton(size_hint=(0.1,0.1), pos_hint={'pos':(0.7,0.2)},
            source='/home/pi/d3-ui/img/reset_scatter.png')


        self._exit = Button(text='X', size_hint=(0.05,0.05),
                            pos_hint={'pos':(0.95,0.95)})

        self._fps = Label(text='FPS: 0', size_hint=(0.1,0.1),
                          pos_hint={'pos':(0.8,0.9)})
        self._uploading = Label(text='Uploading...', size_hint=(0.2,0.1),
                          pos_hint={'pos':(-1,-1)}, color=[0,0,1,0])
        self._uploadingAmt = Label(text='', size_hint=(0.2,0.1),
                          pos_hint={'pos':(-1,-1)}, color=[0,0,1,0])

        self._exposure = Label(text='Exposure: 0', size_hint=(0.2,0.1),
                          pos_hint={'pos':(0,0)})

        self._centroid = Label(text='C:0', size_hint=(0.1,0.1),
                          pos_hint={'pos':(0.79,0.83)}, color=[1,0,0,1])

        self._exposure_slider = Slider(min=0, max=2500, value=333,
                          size_hint=(0.5,0.1),
                          pos_hint={'pos':(0.2,0)}  )

        self._upload_progress = ProgressBar(max=100, size_hint=(0.5,0.1),
                          pos_hint={'pos':(-1,-1)})

        self._camera = CameraD3(resolution=(640,480),
                                fourcc="GREY",
                                capture_resolution=(3872, 2764),
                                capture_fourcc="Y16 ",
                                size_hint=(1,1),
                                pos_hint={'pos':(0,0)},
                                play=True, )

        self._dropdown = DropDown()

        # create a big main button
        self._imageResultsButton = Button(text='Image Explorer',pos_hint={'pos': (0.0, 0.6)}, size_hint=(0.2, 0.1))

        # show the dropdown menu when the main button is released
        # note: all the bind() calls pass the instance of the caller (here, the
        # mainbutton instance) as the first argument of the callback (here,
        # dropdown.open.).
        self._imageResultsButton.bind(on_release=self._dropdown.open)

        # one last thing, listen for the selection in the dropdown list and
        # assign the data to the button text.
        self._dropdown.bind(on_select=lambda instance, x: setattr(self._imageResultsButton, 'text', x))



        # self._camera = CameraD3(resolution=(1280,720),
        #                         play=True, fourcc="GREY")

        # self._camera = CameraD3(resolution=(3872, 2764),
        #                       play=True, fourcc="Y16 ")

        # self._camera = CameraD3(resolution=(1920,1080),
        #                        play=True, fourcc="GREY")

        # self._camera = CameraD3(resolution=(2560, 1920),
        #                        play=True, fourcc="GREY")

        self._histogram = Histogram(
            size_hint=(0.2,0.3), pos_hint={'pos':(0.8,0.6)})

        self._demo.bind(on_press=self._show_demo_results)
        self._toggle.bind(on_press=self._led_toggle)
        self._snap.bind(on_press=self._request_capture)
        self._snapref.bind(on_press=self._request_ref_capture)
        self._exit.bind(on_press=self._exit_app)
        self._auto_centroid.bind(on_press=self._auto_change_exposure)
        self._object_detection.bind(on_press=self._toggle_object_detection)
        self._exposure_slider.bind(value=self._change_exposure)
        self._reset_scatter.bind(on_press=self._do_reset_scatter)

        #update.bind(on_press=self._update_histogram)
        self._camera.fbind('on_frame_complete',self._update_histogram)

        self._scatter = Scatter(size_hint=(None, None), size=(200,200),)
        self._scatter.add_widget(self._camera)
        #layout.add_widget(self._camera)
        layoutInner = FloatLayout(size_hint=(0.8, 1), pos_hint={'x':0,'y':0})
        layoutInner.add_widget(self._scatter)
        layout.add_widget(layoutInner)

        mat = Matrix().scale(10,10,10).translate(0,-150,0)
        self._scatter.apply_transform(mat)
        layout.add_widget(self._imageResultsButton)
        layout.add_widget(self._uploading)
        layout.add_widget(self._uploadingAmt)
        layout.add_widget(self._demo)
        layout.add_widget(self._histogram)
        layout.add_widget(self._snap)
        layout.add_widget(self._snapref)
        layout.add_widget(self._exit)
        layout.add_widget(self._centroid)
        layout.add_widget(self._exposure_slider)
        layout.add_widget(self._upload_progress)
        layout.add_widget(self._auto_centroid)
        layout.add_widget(self._object_detection)
        layout.add_widget(self._reset_scatter)

        layout.add_widget(self._exposure)
        layout.add_widget(self._fps)
        Clock.schedule_interval(self._update_fps, 2)
        layout.add_widget(self._toggle)
        #layout.add_widget(update)

        self._is_updating = False
        self.updateImages()
        return layout
Esempio n. 3
0
File: main.py Progetto: IanCal/Baess
class MyApp(App):

    def build(self):
        Window.bind(on_key_down=self.on_key_down) 
        self.loadData()
        self.activeTrack = None
        self.currentLayer = 0
        self.appstructure = FloatLayout()
        width, height = Window.size
        self.menu = Menu()
        self.menu.onNewTrack(self.newTrack)
        self.menu.onNewPoint(self.newPoint)
        self.menu.onDeletePoint(self.deletePoint)
        self.menu.onSetClass(self.setClass)
        self.menu.onFindUnclassified(self.jumpToUnclassified)
        self.menu.onShowStats(self.showStats)
        self.menu.onSave(self.save)
        self.core = Scatter(auto_bring_to_front=False)
        self.core.add_widget(self.getCurrentLayer().getContents())
        self.appstructure.add_widget(self.core)
        self.appstructure.add_widget(self.menu.getContents())
        self.zoomSlider = Slider(orientation='vertical', min=1, max=10, size_hint=(0.05,1),pos_hint={'x':0.95})
        self.zoomSlider.bind(on_touch_move=self.on_touch_move)
        self.zoomSlider.bind(on_touch_down=self.on_touch_down)
        self.zoomSlider.bind(on_touch_up=self.on_touch_up)
        self.appstructure.add_widget(self.zoomSlider)
        self.imagelabel = Label(text=self.getCurrentLayer().getSource(), size_hint=(1,0.05), pos_hint={'y':0})
        self.appstructure.add_widget(self.imagelabel)
        self.zooming = False
        return self.appstructure


    def loadImages(self):
        def isImage(fname):
            for ext in [".png", ".jpg", ".tiff", ".jpeg", ".bmp"]:
                if fname.lower().endswith(ext):
                    return True
            return False
                    
        self.layers = []
        for img in sortByFirstNumber(listdir("images")):
            if isImage(img):
                self.layers.append(Layer("images/"+img))

    def loadData(self):
        self.loadImages()
        self.tracks = []
        try:
            trackreps = load(open("saveFile.data"))
        except:
            return
        for trackrep in trackreps:
            track = Track(self.setActive)
            for pointrep in trackrep['points']:
                point = Point(pointrep[1])
                track.addPoint(point, pointrep[0])
                self.layers[pointrep[0]].addPoint(point)
                point.setPos(pointrep[1])
            track.setClassification(trackrep['classification'])
            track.setInactive()
            self.tracks.append(track)
    
    def save(self):
        self.saveTo("backup-"+datetime.today().strftime("%Y-%m-%d-%H-%M-%S")+".data")
        self.saveTo("saveFile.data")

    def saveTo(self, fileName):
        #save to file ...
        def trackRepresentation(track):
            trackrep = {'classification':track.getClassification()}
            trackrep['points'] = []
            for layer in range(len(self.layers)):
                point = track.getPointForLayer(layer) 
                if point:
                    trackrep['points'].append((layer, point.getPos()))
            return trackrep

        savetracks = []
        for track in self.tracks:
            savetracks.append(trackRepresentation(track))
        print savetracks
        dump(savetracks, open(fileName, 'w+'))

    def on_touch_down(self, slider, ev):
        if (slider.collide_point(ev.pos[0], ev.pos[1])):
            self.zooming = True

    def on_touch_move(self, slider, ev):
        if (self.zooming):
            zoom = self.zoomSlider.value
            self.core.scale = zoom

    def on_touch_up(self, slider, ev):
        self.zooming = False

    def showStats(self, *args):
        classCounts = {}
        for classification in classesToColours:
            classCounts[classification] = 0
        for track in self.tracks:
            if track.getClassification():
                classCounts[track.getClassification()] += 1

        text = ""
        for classification in classCounts:
            text +=  "    %s : %s \n"%(classification,classCounts[classification])
        popup = Popup(title='Statistics',
            content=Label(text=text),
            size_hint=(None, None), size=(400, 400))
        popup.open()

    def setClass(self, classification):
        if (self.activeTrack):
            self.activeTrack.setClassification(classification)

    def setActive(self, track):
        if (self.activeTrack):
            self.activeTrack.setInactive()
        self.activeTrack = track
        track.setActive()
    def newPoint(self):
        if (self.activeTrack == None):
            return
        point = Point((width/2,height/2))
        if (self.activeTrack.addPoint(point, self.currentLayer)):
            self.getCurrentLayer().addPoint(point)
    def deletePoint(self):
        if (self.activeTrack == None):
            return
        point = self.activeTrack.getPointForLayer(self.currentLayer)
        if (point == None):
            return
        if not(self.activeTrack.deletePoint(self.currentLayer)):
            return 
        self.getCurrentLayer().deletePoint(point)
        if (self.activeTrack.getClassification() == None):
            self.tracks.remove(self.activeTrack)
            self.activeTrack = None
        

    def newTrack(self):
        track = Track(self.setActive)
        point = Point((width/2, height/2))
        track.addPoint(point, self.currentLayer)
        track.setActive()
        track.setClassification('unclassified')
        self.tracks.append(track)
        self.setActive(track)
        self.getCurrentLayer().addPoint(point)
    def getCurrentLayer(self):
        return self.layers[self.currentLayer]

    def jumpToUnclassified(self):
        for track in self.tracks:
            if track.getClassification() == 'unclassified':
                for i, layer in enumerate(self.layers):
                    if track.getPointForLayer(i):
                        self.setActive(track)
                        self.swapLayer(self.getCurrentLayer(), layer)
                        self.currentLayer = i
                        return
        popup = Popup(title='',
            content=Label(text="No unclassified tracks found!"),
            size_hint=(None, None), size=(400, 400))
        popup.open()
                        
            

    def moveUpLayer(self):
        if (self.currentLayer < (len(self.layers) - 1)):
            original = self.getCurrentLayer()
            self.currentLayer += 1
            new = self.getCurrentLayer()
            self.swapLayer(original, new)
    def moveDownLayer(self):
        if (self.currentLayer > 0):
            original = self.getCurrentLayer()
            self.currentLayer -= 1
            new = self.getCurrentLayer()
            self.swapLayer(original, new)

    def swapLayer(self, old, new):
        if (old == new):
            return
        self.imagelabel.text = new.getSource()
        self.core.add_widget(new.getContents())
        self.core.remove_widget(old.getContents())
        # current transform is layer * user
        layer = new.getTransform()
        transform = self.core.transform
        user = transform.multiply(layer.inverse())
        # put back to start
        self.core.apply_transform(self.core.transform_inv)
        # apply layer transformation
        self.core.apply_transform(old.getTransform())
        # reapply user transformation
        self.core.apply_transform(user)
    def on_key_down(self, instance, code, *args):
        if (code == 275):
            self.moveUpLayer()
        if (code == 276):
            self.moveDownLayer()
Esempio n. 4
0
class IDSGUI(App):
    def __init__(self):
        super(IDSGUI, self).__init__()
        self._camera = None

    def _led_toggle(self, val):
        if self._led_state == GPIO.LOW:
            self._led_state = GPIO.HIGH
            self._toggle.text = "LED ON"
        else:
            self._led_state = GPIO.LOW
            self._toggle.text = "LED OFF"
        GPIO.output(LED_Pin, self._led_state)

    def _start_count(self, val):
        pass
        # fake_bin = int((np.random.randn() * 100) + 320)
        # self._tracker_histogram.add_track(max(0, min(640, fake_bin)))
        # (x,y) = self._camera.get_roi_offset()
        # self._camera.set_roi_offset(x+50,y+50)

    def _toggle_object_detection(self, val):
        pass

    #     detecting = not self._camera.get_object_detection()
    #     self._camera.set_object_detection(detecting)
    #     if not detecting:
    #         self._object_detection.source = self.img_path('object_detection_off.png')
    #     else:
    #         self._object_detection.source = self.img_path('object_detection_on.png')

    def _change_exposure(self, instance, val):
        pass
        # self._camera.set_exposure(int(val))

    def _do_reset_scatter(self, val):
        # move the
        mat = Matrix().scale(10, 10, 10).translate(0, -150, 0)
        self._scatter.transform = mat

    def _exit_app(self, val):
        # self._camera.play = False
        # give it a 1/4 sec to shu down the camera
        sleep(0.25)
        App.get_running_app().stop()
        import sys
        sys.exit()

    def _update_histogram(self, val):
        pass
        # frame = self._camera.get_current_frame()
        # self._histogram.set_data(frame)

    def _update_fps(self, l):
        pass
        # self._fps.text = "FPS: %d" % self._camera.get_fps()
        # self._temp.text = "Temp: %s" % self._camera.get_temp()
        # self._exposure.text = "Exposure: %d" % self._camera.get_exposure()
        # self._centroid.text = "C: %d" % self._histogram.centroid

    def _update_roi(self, roi, roi2):
        pass
        # roi = self._roi_tracker.roi_Offset
        # self._camera.set_roi_offset(roi[0], roi[1])

    def img_path(self, image_name):
        return os.path.join(os.path.dirname(__file__), 'img', image_name)

    def init_GPIO(self):
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(LED_Pin, GPIO.OUT)
        self._led_state = GPIO.LOW
        GPIO.output(LED_Pin, self._led_state)

    def get_ip_address(self):
        try:
            import socket
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            s.connect(("8.8.8.8", 80))
            addr = s.getsockname()[0]
            s.close()
            return addr
        except:
            return "Error"

    def build(self):
        self.init_GPIO()

        layout = FloatLayout(size=(800, 480), pos=(0, 0))

        self._toggle = ToggleButton(text='LED OFF',
                                    size_hint=(0.2, 0.2),
                                    pos_hint={'pos': (0.8, 0)})

        self._snap = Button(text='COUNT',
                            size_hint=(0.2, 0.2),
                            pos_hint={'pos': (0.8, 0.2)})

        self._object_detection = ImageButton(
            size_hint=(0.1, 0.1),
            pos_hint={'pos': (0.7, 0.0)},
            source=self.img_path('object_detection_off.png'))

        self._reset_scatter = ImageButton(
            size_hint=(0.1, 0.1),
            pos_hint={'pos': (0.7, 0.1)},
            source=self.img_path('reset_scatter.png'))

        self._logo = Image(size_hint=(0.3, 0.2),
                           pos_hint={'pos': (-0.03, 0.84)},
                           source=self.img_path('ids.png'))

        self._exit = ImageButton(size_hint=(0.05, 0.05),
                                 pos_hint={'pos': (0.96, 0.95)},
                                 source=self.img_path('close-white.png'))

        red, white, kivy_blue = (1, 0, 0, 1), (1, 1, 1,
                                               1), (51. / 255, 164. / 255,
                                                    206. / 255, 1)

        self._fps = Label(text='FPS: 0',
                          size_hint=(0.1, 0.1),
                          pos_hint={'pos': (0.8, 0.9)},
                          color=red)
        self._temp = Label(text='Temp: 0',
                           size_hint=(0.1, 0.1),
                           pos_hint={'pos': (0.6, 0.9)},
                           color=white)

        dev_ip = self.get_ip_address()

        self._ip = Label(text='IP: %s' % dev_ip,
                         size_hint=(0.1, 0.1),
                         pos_hint={'pos': (0.4, 0.9)},
                         color=white)
        self._exposure = Label(text='Exposure: 0',
                               size_hint=(0.2, 0.1),
                               pos_hint={'pos': (0, 0)})

        self._centroid = Label(text='C:0',
                               size_hint=(0.1, 0.1),
                               pos_hint={'pos': (0.79, 0.83)},
                               color=white)

        self._exposure_slider = Slider(min=0,
                                       max=2500,
                                       value=1358,
                                       size_hint=(0.5, 0.1),
                                       pos_hint={'pos': (0.2, 0)})

        # self._camera = Camera2131(resolution=(1280,960),
        #                           fourcc="GREY",
        #                           capture_resolution=(3872, 2764),
        #                           capture_fourcc="Y16 ",
        #                           size_hint=(1,1),
        #                           pos_hint={'pos':(0,0)},
        #                           play=True, )

        # self._camera = CameraIDS(resolution=(640, 480),
        #                           fourcc="GREY",
        #                           capture_resolution=(640, 480),
        #                           capture_fourcc="GREY",
        #                           size_hint=(1,1),
        #                           pos_hint={'pos':(0,0)},
        #                           play=True)

        self._histogram = Histogram(size_hint=(0.2, 0.25),
                                    pos_hint={'pos': (0.8, 0.65)})

        self._tracker_histogram = TrackerHistogram(
            size_hint=(0.2, 0.25), pos_hint={'pos': (0.8, 0.4)})

        # self._roi_tracker = ROITracker(self._camera.resolution,
        #     size_hint=(0.2,0.25), pos_hint={'pos':(0.02,0.6)})
        # self._roi_tracker.bind(roi_Offset=self._update_roi)

        # self._demo.bind(on_press=self._show_demo_results)
        self._toggle.bind(on_press=self._led_toggle)
        self._snap.bind(on_press=self._start_count)
        self._exit.bind(on_press=self._exit_app)
        self._object_detection.bind(on_press=self._toggle_object_detection)
        self._exposure_slider.bind(value=self._change_exposure)
        self._reset_scatter.bind(on_press=self._do_reset_scatter)

        # self._camera.fbind('on_frame_complete',self._update_histogram)

        self._scatter = Scatter(
            size_hint=(None, None),
            size=(200, 200),
        )
        # self._scatter.add_widget(self._camera)
        # layoutInner = FloatLayout(size_hint=(0.8, 1), pos_hint={'x':0,'y':0})
        # layoutInner.add_widget(self._scatter)
        layout.add_widget(self._scatter)

        mat = Matrix().scale(10, 10, 10).translate(0, -150, 0)
        self._scatter.apply_transform(mat)
        layout.add_widget(self._histogram)
        layout.add_widget(self._tracker_histogram)
        layout.add_widget(self._snap)
        layout.add_widget(self._exit)
        layout.add_widget(self._exposure_slider)
        layout.add_widget(self._object_detection)
        layout.add_widget(self._reset_scatter)

        layout.add_widget(self._exposure)
        layout.add_widget(self._fps)
        layout.add_widget(self._temp)
        layout.add_widget(self._ip)
        Clock.schedule_interval(self._update_fps, 2)
        layout.add_widget(self._toggle)
        layout.add_widget(self._logo)
        # layout.add_widget(self._roi_tracker)
        self._is_updating = False
        return layout
Esempio n. 5
0
class DraggableImage(BoxLayout):
    def __init__(self, source, **kwargs):
        super().__init__(**kwargs)
        """
        Hierarchy
        """
        self.image = Image(source=source,
                           pos_hint={
                               "center_x": 0.5,
                               "center_y": 0.5
                           })

        self.container = Scatter()
        self.container.add_widget(self.image)

        self.add_widget(self.container)
        """
        Class properties
        """
        self.source = source
        self.scale_value = 1.0
        self.initial_alpha = self.image.color[3]
        self.initial_pos = None
        self.debug = False
        self.clickable = True
        self.touched = False
        self.mouse_pos = tuple()  # mouse position (frequently updated)
        """
        Some updates per drawing
        """
        Window.bind(mouse_pos=lambda w, p: setattr(self, 'mouse_pos', p))
        Window.bind(on_draw=self.fit_image)
        Window.bind(on_dropfile=self._on_file_drop)

    def fit_image(self, *args):
        self.image.size = self.size

    def _on_file_drop(self, window, file_path):
        print("Dropping file ...")
        if self.collide_point(*self.mouse_pos):
            filePath = file_path.decode("utf-8")
            if self.debug:
                print(file_path)
            self.image.source = filePath
            self.image.reload()

            self.source = filePath

    def on_touch_move(self, touch):
        if touch.button == "left" and self.clickable:
            """
            Call scatter method
            """
            self.container.on_touch_move(touch)

            self.clickable = True
            """
            Change image to "moving" state
            """
            self.image.color[3] = self.initial_alpha / 2
            self.image.reload()
        else:
            self.clickable = False

    def on_touch_up(self, touch):
        if self.initial_pos is None:
            self.initial_pos = self.pos

        if touch.button == "left":
            """
            Call scatter method
            """
            self.container.on_touch_up(touch)

            self.clickable = True
            """
            Change image/scatter to normal state
            """
            scale_matrix = Matrix().scale(1.0 / self.container.scale,
                                          1.0 / self.container.scale,
                                          1.0 / self.container.scale)
            self.container.apply_transform(scale_matrix)
            self.image.color[3] = self.initial_alpha
            self.image.reload()

            # TODO: error when resizing window
            self.container.pos = self.initial_pos

    def on_touch_down(self, touch):
        if self.initial_pos is None:
            self.initial_pos = self.pos

        touch.double_tap_time = 1
        if touch.is_double_tap and self.collide_point(*touch.pos):
            self.container.on_touch_down(touch)
            popup = ImagePopup(source=self.image.source)
            popup.open()
            return

        if touch.button == "left" and self.collide_point(*touch.pos):
            self.container.on_touch_down(touch)

            print("Touch ", self)
            """
            Change image to "clicked" state
            """
            scale_matrix = Matrix().scale(self.scale_value, self.scale_value,
                                          self.scale_value)
            self.container.apply_transform(scale_matrix)
            self.container.center = self.mouse_pos  # Fix the image to the position of the mouse

    def reload_image(self, source):
        self.image.source = source
        self.image.reload()

    def __eq__(self, other):
        return self is other