Example #1
0
class Setup:
    def __init__(self, source):
        self.source = source
        self.files = source.setup_list
        self.main_window = source.main_window
        self.dbs = source.dbs
        self.admin = source.admin
        self.pointer = 0
        self.sentinel = len(self.files)
        self.line_status = False
        self.draw_status = False
        self.status = False 
        self.analysis = None

        # init setup ui
        init_address(self.main_window)

        # enable address button
        self.main_window.setup_address_btn.setEnabled(True)
        
        # signals
        # connect setup save button
        self.main_window.connect(self.main_window.setup_save_btn, \
            SIGNAL("clicked()"), self.save_setup)
        self.main_window.setup_save_btn.setEnabled(True)
        # connect address button
        self.main_window.connect(self.main_window.setup_address_btn, \
            SIGNAL("clicked()"), self.click_address_btn)
        # setup play button
        self.main_window.connect(self.main_window.setup_play_btn, \
            SIGNAL("clicked()"), self.click_setup_play_btn)
        # setup pause button
        self.main_window.connect(self.main_window.setup_pause_btn, \
            SIGNAL("clicked()"), self.click_setup_pause_btn)
        # setup background button
        self.main_window.connect(self.main_window.setup_bg_btn, \
            SIGNAL("clicked()"), self.click_setup_bg_btn)
        # setup reset button
        self.main_window.connect(self.main_window.setup_reset_btn, \
            SIGNAL("clicked()"), self.click_reset_btn)
        # setup draw button
        self.main_window.connect(self.main_window.setup_draw_btn, \
            SIGNAL("clicked()"), self.click_draw_btn)
        # setup line button
        self.main_window.connect(self.main_window.setup_line_btn, \
            SIGNAL("clicked()"), self.click_line_btn)

        # setup frame mousePressEvent overide
        self.main_window.setup_frame.mousePressEvent = \
            self.setup_frame_click

    def get_data(self):
        if self.source.media == "file":
            print("Gathering video properties")
            self.path = self.file
            self.metadata = get_metadata(self.file)
            self.base_name = get_base_name(self.file)
            self.fps = get_fps(self.metadata)
            self.duration = get_duration(self.metadata)
            self.resolution = get_resolution(self.metadata)
            self.format = get_format(self.metadata)
        if self.source.media == "camera":
            self.base_name = self.source.base_name 
            self.path = self.source.path 
            self.metadata = None
            self.fps = None
            self.duration = None
            self.resolution = None
            self.format = None

    def valid_setup(self):
        rv = True
        message = ''
        # address
        if self.address_window.valid_address():
            print("Creating address for video in db")
            self.address_window.create_address()
            self.address = self.address_window.address
        else:
            message = message + "Address is incomplete!\n"
            rv = False
        # background
        if self.background.path is None:
            message = message + "Background image is None!\n"
            rv = False
        # polygon
        if self.polygon.no_of_points <= 3:
            message = message + "Polygon is not yet set!\n"
            rv = False
        if rv is False:
            print(message)
            self.dialog = DialogWindow("Setup", message)
        return rv

    def save_db(self):
        file = self.base_name
        path = self.path
        background = self.background.path
        fps = self.fps
        duration = None
        created_time = None
        admin_id = self.admin.id
        address_id = self.address.id

        video = Video(file, path, background, \
            fps, duration, created_time, admin_id, \
            address_id)
        
        self.video = video 
        print("Creating video in db", video)
        s = self.dbs
        s.add(video)
        s.commit()

        # save polygon after acquiring video 
        self.polygon.save_db()

    def start_analysis(self):
        print("Nothing to setup!")
        self.dialog = DialogWindow("Setup", "Setup is finished!")
        self.status = False
        print("Start analysis here")
        self.analysis = Analysis(self.source, self)
        self.source.analysis = self.analysis

    def save_setup(self):
        print("Clicked save setup button")
        if self.valid_setup():
            self.save_db()
            if self.status == True:
                if self.source.media == 'file':
                    self.sequencer()
                if self.source.media == 'camera':
                   self.start_analysis() 

    def click_address_btn(self):
        self.address_window.ui.show()

    def populate_setup(self):
        self.main_window.name_lbl.setText(self.base_name)
        self.main_window.fps_lbl.setText(self.fps)
        self.main_window.duration_lbl.setText(self.duration)
        self.main_window.resolution_lbl.setText(self.resolution)
        self.main_window.format_lbl.setText(self.format)
        self.main_window.statusbar.showMessage("Path: %s" % self.path)

    def open(self):
        self.source.base_name = get_base_file(self.file) 
        # background folder
        directory = 'backgrounds/' + self.source.base_name
        create_dir(directory) 
        init_setup_new(self.main_window)
        self.source.setup_frames = cv2.VideoCapture(self.file)
        self.get_data()
        self.populate_setup()
        self.address_window = AddressWindow(self, self.main_window)
        self.polygon = Polygon(self, self.source)
        self.draw_status = False
        self.play = Play(self.source, self)
        self.play.run_setup()
        self.background = Background(self.source)

    def sequencer(self):
        init_setup(self.main_window)
        if self.pointer != len(self.files):
            self.status = True
            self.file = self.files[self.pointer]
            self.path = self.file
            self.open()
            self.pointer += 1
        else:
            self.start_analysis()

    def camera(self):
        print("Camera in setup")
        # background folder
        directory = 'backgrounds/' + self.source.base_name
        create_dir(directory) 
        self.status = True
        init_setup_new(self.main_window)
        self.source.setup_frames = cv2.VideoCapture(config['camera'])
        self.get_data()
        self.populate_setup()
        self.address_window = AddressWindow(self, self.main_window)
        self.polygon = Polygon(self, self.source)
        self.draw_status = False
        self.play = Play(self.source, self)
        self.play.run_setup()
        self.background = Background(self.source)

    def click_setup_play_btn(self):
        print("Clicked setup play button!")
        self.play.setup_status = True
        self.play.setup_timer.start()
        self.main_window.setup_pause_btn.setEnabled(True)
        self.main_window.setup_play_btn.setEnabled(False)

    def click_setup_pause_btn(self):
        print("Clicked setup pause button!")
        self.play.setup_status = False 
        self.play.setup_timer.stop()
        self.main_window.setup_pause_btn.setEnabled(False)
        self.main_window.setup_play_btn.setEnabled(True)

    def click_setup_bg_btn(self):
        print("Clicked capture background button")
        self.background.capture_frame()

    def click_draw_btn(self):
        print("Clicked draw button")
        self.line_status = False
        self.draw_status = True
        if self.play.setup_status == False:
            self.play.run_setup_pause()
        self.main_window.setup_draw_btn.setEnabled(False)
        self.main_window.setup_line_btn.setEnabled(True)
        # get area of polygon
        area = self.polygon.compute_area()
        self.main_window.area_lbl.setText(str(self.polygon.area))

    def click_line_btn(self):
        print("Clicked line button")
        self.line_status = True 
        self.draw_status = False 
        if self.play.setup_status == False:
            self.play.run_setup_pause()
        self.main_window.setup_line_btn.setEnabled(False)
        self.main_window.setup_draw_btn.setEnabled(True)
        self.main_window.area_lbl.setText("") 

    def click_reset_btn(self):
        print("Clicked reset button")
        self.polygon.reset()
        if self.play.setup_status == False:
            self.play.run_setup_reset()
        self.main_window.setup_reset_btn.setEnabled(False)
        self.main_window.setup_line_btn.setEnabled(False)
        self.main_window.setup_draw_btn.setEnabled(False)
        self.line_status = False 
        self.draw_status = False

    def setup_frame_click(self, event):
        if self.play.setup_status == True:
            print("Pause the source before assigning coordinates")
        else:
            print("Clicked setup frame") 
            x = event.pos().x()
            y = event.pos().y()
            print(x, y)
            print(event.pos())
            point = (x, y)
            self.polygon.append(point)
            self.polygon.get_no_points()
            if self.polygon.no_of_points > 0:
                self.main_window.setup_reset_btn.setEnabled(True)
            if self.polygon.no_of_points > 1:
                self.line_status = True
            if self.polygon.no_of_points > 2:
                self.main_window.setup_draw_btn.setEnabled(True)
            self.play.run_setup_pause()

    def get_video(self):
        return self.video

    def load_video(self, video_id):
        load = False
        s = self.dbs
        result = s.query(Video).filter(Video.id == video_id)
        if result.count() == 1:
            video = result.first() 
            load = True
        elif result.count() > 1:
            print("Found more than 1 match in database!")
        else:
            print("No match found in database!")
        if load == True: 
            self.path = video.path
            self.base_name = video.name 
            self.fps = str(video.fps) 
            self.duration = video.duration
            # address
            self.address_window = AddressWindow(self, self.main_window)
            self.address_window.get_address(video.address_id)
            # polygon
            self.polygon = Polygon(self, self.source)
            self.polygon.get_points(video.id)
            self.polygon.compute_area()
            area = self.polygon.area
            self.main_window.area_lbl.setText(str(abs(area)))
            self.metadata = get_metadata(self.path)
            self.duration = get_duration(self.metadata)
            self.resolution = get_resolution(self.metadata)
            self.format = get_format(self.metadata)
            # load in setup
            self.populate_setup()