Пример #1
0
def timed_messagebox(title, message):
    messagebox = Toplevel()
    messagebox.title(title)
    m = Message(messagebox, text=message, padx=100, pady=100)
    m.config(font=('TkDefaultFont', 20))
    m.pack()
    messagebox.after(3000, messagebox.destroy)
Пример #2
0
def inventory():
    inv_pop = Toplevel()
    inv_pop.geometry("400x300")
    inv_pop.title("Your Backpack")
    scroll = Scrollbar(inv_pop)
    scroll.pack(side=RIGHT, fill=Y)
    if not Player.inventory:
        Text_ = Text(inv_pop, bg="#837373", fg="#d9d9d9", yscrollcommand=scroll.set, relief="flat")
        Text_.insert(INSERT, "Nothing in here yet...")
    else:
        Text_ = Text(inv_pop, bg="#837373", fg="#d9d9d9", yscrollcommand=scroll.set, relief="flat")
        Text_.insert(INSERT, Player.get_inventory())
    Text_.pack(expand=True)
    if OS == "Windows":
        Text_.config(font=("Times", 12))
    scroll.config(command=Text_.yview)
    Text_.config(state=DISABLED)

    def update():
        if Everything.inventory_uptodate is False:
            Text_.config(state=NORMAL)
            Text_.delete("1.0", END)
            if Player.get_inventory():
                Text_.insert(INSERT, Player.get_inventory())
            else:
                Text_.insert(INSERT, "Nothing in here yet...")
            Text_.config(state=DISABLED)
            Everything.inventory_uptodate = True
            Text_.see("end")
        inv_pop.after(500, update)

    inv_pop.after(1000, update)
Пример #3
0
    def upload():
        file_path_list = filedialog.askopenfilenames(
            initialdir="/",
            title='Upload single or multiple .pdf and/or .docx files')
        if len(file_path_list) != 0:
            window_width = 200
            window_height = 100
            screen_width = root.winfo_screenwidth()
            screen_height = root.winfo_screenheight()
            x = (screen_width / 2) - (window_width / 2)
            y = (screen_height / 2) - (window_height / 2)
            popup_loading = Toplevel()
            popup_loading.geometry(
                f'{window_width}x{window_height}+{int(x)}+{int(y)}')

            info = Label(popup_loading, text="Loading...")
            info.pack(fill='x', padx=15, pady=15)

            for file in file_path_list:
                name, extension = os.path.splitext(file)
                if extension == '.pdf':
                    upload_pdf(file)
                elif extension == '.docx':
                    upload_docx(file)
                else:
                    upload_un_files(file)
            popup_loading.after(5000, lambda: popup_loading.destroy())
Пример #4
0
    def showProcessInfoWindow(cls, destroyTime, title, message):

        infoWindow = Toplevel()
        infoWindow.title(title)
        infoWindow.geometry("%dx%d+%d+%d" % (300, 100, 100, 100))
        Message(infoWindow, text=message, padx=20, pady=20, width=200).pack()
        infoWindow.after(destroyTime, infoWindow.destroy)
Пример #5
0
 def show_tmp_message(message):
     '''
     Displays a temporary message that is destroyed after 5 seconds
     '''
     top = Toplevel()
     top.title('Welcome')
     Message(top, text=message, padx=20, pady=20).pack()
     top.after(5000, top.destroy)
Пример #6
0
 def load_model_waiting_win(self, waiting_win: tk.Toplevel,
                            load_thread: td.Thread):
     if load_thread.is_alive():
         waiting_win.after(
             100,
             lambda: self.load_model_waiting_win(waiting_win, load_thread))
     else:
         waiting_win.pb.stop()
         waiting_win.destroy()
Пример #7
0
    def rightCWindow(shit, editor, count=0):
        #---------search function-------------
        count = 0
        framess = Toplevel()
        #framess = tkinter.Frame(popup)

        searchbox = tkinter.Entry(framess)
        searchbox.grid()

        #check = tkinter.Frame(popup)

        tkinter.intvar = count

        linelabel = tkinter.Label(framess,
                                  text='Navigate with index from index')
        linelabel.grid()
        nelabel = tkinter.Label(framess, text='Find Text')
        nelabel.grid()
        Cvalue = tkinter.Entry(framess)
        Cvalue.focus()
        Cvalue.grid()
        framess.after(500, lambda: framess.focus_force())
        searchbox.after(700, lambda: searchbox.focus_force())
        Cvalue.insert('end', str(count))
        label = tkinter.Label(framess, text='jump to line')
        label.grid()
        thecount = lambda: navigation.count(Cvalue)
        butts2 = tkinter.Button(framess,
                                foreground='blue',
                                text='+',
                                command=thecount)

        butts2.grid()
        tempfunc = lambda: controlers.searched(
            widget=searchbox, editor=editor, butts=Cvalue, linelabel=linelabel)
        butts = tkinter.Button(framess,
                               foreground='blue',
                               text='search',
                               width=40,
                               command=tempfunc)

        butts.grid()

        removeit = lambda: editor.tag_remove('highlight', '1.0', 'end')
        clearbutts = tkinter.Button(framess,
                                    width=40,
                                    foreground='blue',
                                    text='clear',
                                    command=removeit)
        clearbutts.grid()
Пример #8
0
def alertWindow(text="", fg="orange", font="Courier 14 bold"):
    wind = Toplevel(root)  # new window
    wind.geometry("320x120")  # set resolution
    wind.overrideredirect(1)  # make window borderless

    # add text to window
    Label(wind,
          text=text,
          fg=fg,
          font=font,
          height=6,
          wraplength=300,
          justify=CENTER).place(x=160, y=60, anchor=CENTER)

    wind.after(3000, wind.destroy)  # exit window after 3 seconds
Пример #9
0
    def new_popup(self):
        pos = self._get_free_slot()
        if pos is None:
            return
        msg = self.communicator.get_message()
        new_window = Toplevel(self.parent)

        app = MessagePopup(
            parent=new_window,
            position=pos,
            color=msg.color,
            title=msg.title,
            text=msg.text,
            background=self._get_background(msg.color)
        )

        self.slots[pos] = app
        new_window.after(self.popup_show_time, app.quit)
        new_window.after(self.popup_show_time + 500, lambda: self._clear_slot(pos))

        self.update_counter_window()
class CreateToolTip(object):
    '''
    create a tooltip for a given widget
    '''
    def __init__(self, widget, text='widget info'):
        self.widget = widget
        self.text = text
        self.widget.bind("<Enter>", self.enter)
        self.widget.bind("<Leave>", self.close)
        self.ready = 0

    def close(self, event=None):
        if hasattr(self, 'tw'):
            self.tw.destroy()
            self.ready = 0
        else:
            self.ready = 0

    def enter(self, event=None):
        def makeWidget():
            self.tw = Toplevel(self.widget)

            def construct():
                # Leaves only the label and removes the app window
                self.tw.wm_overrideredirect(True)
                # Places the tool-tip window close to the mouse pointer position
                x = y = 0
                x, y, cx, cy = self.widget.bbox("insert")
                x += self.widget.winfo_rootx() + 25
                y += self.widget.winfo_rooty() + 20
                self.tw.wm_geometry("+%d+%d" % (x, y))
                # changes the transparency of the tootip
                self.tw.wm_attributes("-alpha", 0.9)
                # puts a label inside the Toplevel widget
                self.label = tk.Label(self.tw,
                                      text=self.text,
                                      justify='left',
                                      background='white',
                                      relief='solid',
                                      borderwidth=1,
                                      font=("TkDefautlFont", "8", "normal"))
                self.label.pack(padx=0, pady=0)

            threading.Thread(target=self.tw.after(3000, construct())).start()

        def wait(delay):
            t = threading.Thread(target=time.sleep(delay))
            t.start()
            self.ready = 1

        #wait(3)
        makeWidget()
Пример #11
0
def character():
    char_pop = Toplevel()
    char_pop.geometry("400x200")
    char_pop.title("You")
    if Player.ready is False:
        Text_ = Label(char_pop, anchor=W, justify="left", text="All so blurry...\n"
                                                               "Who.. am I?...\n"
                                                               "I need some water...")
    else:
        Text_ = Label(char_pop, anchor=W, justify="left", text=Player.pond())
    Text_.grid(row=0, column=0)
    if OS == "Windows":
        Text_.config(font=("Times", 12))

    def update():
        if Player.ready is False:
            Text_.config(text="All so blurry...\nWho.. am I?...\nI need some water...")
        elif Everything.character_uptodate is False:
            Text_.config(text=Player.pond())
            Everything.character_uptodate = True
        char_pop.after(500, update)

    char_pop.after(1000, update)
Пример #12
0
def nameHandler(name, message):
    '''Takes a string name and character, provides an interface for correcting
    the illegal name, returns a new legal string name.'''

    #todo: create a proper validate method

    def destroy(*args):
        root.destroy()

    root = Toplevel()
    root.title('Bad Name')
    root.resizable(False, False)
    root.after(100, root.focus_force) #todo: temp?

    mainFrame = ttk.Frame(root, padding=MAIN_PAD)
    mainFrame.grid(column=0, row=0, sticky='nwes')

    newname = StringVar(value=name)

    nameEntry = ttk.Entry(mainFrame, textvariable=newname)
    nameEntry.grid(row=1, sticky='we')

    ttk.Label(mainFrame, text=message).grid(row=0)

    for child in mainFrame.winfo_children():
        child.grid(padx=5, pady=5)

    nameEntry.after(100, nameEntry.focus) #todo: temp?
    root.bind('<Return>', destroy)

    root.wait_window()

    #todo: disable the ability to close the window instead? add abort option?
    if len(newname.get()) < 1:
        return nameHandler(name, message)
    else:
        return newname.get()
Пример #13
0
def map_():
    Map_pop = Toplevel()
    Map_pop.geometry("400x400")
    Map_pop.title("Your Map")
    Map_pop.config(bg="#CABB92")
    m = World.make_map()
    yscroll = Scrollbar(Map_pop)
    xscroll = Scrollbar(Map_pop, orient="horizontal")
    yscroll.pack(side=RIGHT, fill=Y)
    xscroll.pack(side=BOTTOM, fill=X)
    Text_ = Text(Map_pop, bg="#CABB92", fg="black", relief="flat", highlightbackground="#CABB92",
                 font=("DejaVu Sans Mono", 14), yscrollcommand=yscroll.set, xscrollcommand=xscroll.set, wrap=NONE)
    Text_.insert("1.0", m)
    Text_.pack(expand=False)
    yscroll.config(command=Text_.yview)
    xscroll.config(command=Text_.xview)
    Text_.config(state=DISABLED)

    def update():
        if Everything.map_uptodate is False:
            scrollposx = Text_.xview()
            scrollposy = Text_.yview()
            scrollposx = str(scrollposx)[1:-1].split(", ")
            scrollposy = str(scrollposy)[1:-1].split(", ")
            Text_.config(state=NORMAL)
            x = World.make_map()
            Text_.delete("1.0", END)
            Text_.insert("1.0", x)
            # the code below is for keeping the map
            # focus to where you scrolled it
            Text_.yview_moveto(float(scrollposy[0]))
            Text_.xview_moveto(float(scrollposx[0]))
            Text_.config(state=DISABLED)
            Everything.map_uptodate = True
        Map_pop.after(500, update)
    Map_pop.after(100, update)
Пример #14
0
class TakePicture:
    def __init__(self):
        """ Initialize application which uses OpenCV + Tkinter. It displays
            a video stream in a Tkinter window and stores current snapshot on disk """
        print('Initializing TakePicture...')
        # capture video frames, 0 is your default video camera
        self.capture = cv2.VideoCapture(0)
        self.current_image = None  # current image from the camera

        self.root = Toplevel()  # initialize second window
        self.root.title("Photo Booth")  # set window title
        # self.destructor function gets fired when the window is closed
        self.root.protocol('WM_DELETE_WINDOW', self.destructor)

        self.panel = ttk.Label(self.root)  # initialize image panel
        self.panel.grid(column=0,
                        row=0,
                        columnspan=2,
                        rowspan=1,
                        padx=10,
                        pady=10)
        # take picture button
        take_image_btn = ttk.Button(self.root,
                                    text="Cheese!",
                                    command=self.take_snapshot)
        take_image_btn.grid(column=0, row=2, pady=5)
        # exit / cancel
        cancel_btn = ttk.Button(self.root,
                                text="Exit",
                                command=self.destructor)
        cancel_btn.grid(column=1, row=2, pady=5)

        # start a self.video_loop that constantly pools the video sensor
        # for the most recently read frame
        self.video_loop()

    def video_loop(self):
        """ Get frame from the video stream and show it in Tkinter """
        ret, frame = self.capture.read()  # read frame from video stream
        if ret:  # frame captured without any errors
            # convert colors from BGR to RGB
            cv2image = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            self.current_image = Image.fromarray(
                cv2image)  # convert image for PIL
            # convert image for tkinter
            imgtk = ImageTk.PhotoImage(image=self.current_image)
            self.panel.imgtk = imgtk  # anchor imgtk so it does not be deleted by garbage-collector
            self.panel.config(image=imgtk)  # show the image
        # call the same function after 30 milliseconds
        self.root.after(30, self.video_loop)

    def take_snapshot(self):
        """ Take snapshot and save it to the file """
        sleep(1)  # add some effect to indicate that picture been taken
        pathlib.Path('images/').mkdir(
            exist_ok=True)  # check if images dir exists, if not create
        image_name = 'face.jpg'  # construct filename
        path_to_save = 'images/{}'.format(image_name)  # where to save image
        self.current_image.save(path_to_save)  # save image as jpeg file
        print("[INFO] saving image: {}".format(image_name))

    def destructor(self):
        """ Destroy the second window object and release all resources """
        print("[INFO] closing TakePicture...")
        self.root.destroy()
        self.capture.release()  # release web camera
        cv2.destroyAllWindows()  # it is not mandatory in this application
Пример #15
0
class Overlay(threading.Thread):
    def __init__(self,
                 width, height,
                 xpos, ypos,
                 bgcolor, fgcolor,
                 fontsize, opacity,
                 messages, close):
        threading.Thread.__init__(self, daemon=True)

        self.width = width
        self.height = height
        self.xpos = xpos
        self.ypos = ypos
        self.bgcolor = bgcolor
        self.fgcolor = fgcolor
        self.fontsize = fontsize
        self.opacity = opacity
        self.messages = messages
        self.close = close

        username_colors = [
            '#0000ff',
            '#ff7f50',
            '#1e90ff',
            '#00ff7f',
            '#9acd32',
            '#00ff00',
            '#ff4500',
            '#ff0000',
            '#daa520',
            '#ff69b4',
            '#5f9ea0',
            '#2e8b57',
            '#d2691e',
            '#8a2be2',
            '#b22222',
        ]
        self.color_for = defaultdict(lambda: random.choice(username_colors))
        self.start()
        self.images = []

    def die(self):
        self.images = None
        self.close.put('killme')
        self.root.quit()

    def run(self):
        self.root = MyRoot()
        self.root.lower()
        self.root.iconify()
        self.root.title('poetato overlay')
        self.root.protocol('WM_DELETE_WINDOW', self.die)

        self.app = Toplevel(self.root)
        self.app.geometry("%dx%d+%d+%d" % (self.width, self.height,
                                           self.xpos, self.ypos))
        self.app.resizable(width=False, height=False)
        self.app.overrideredirect(1)
        self.app.minsize(width=self.width, height=self.height)
        self.app.maxsize(width=self.width, height=self.height)
        self.app.attributes(
            '-alpha', self.opacity,
            '-topmost', True,
            '-disabled', True,
        )

        self.text = Text(self.app,
                         bg=self.bgcolor, fg=self.fgcolor,
                         wrap='word', state='disabled')
        self.text.configure(font=('Helvetica', self.fontsize, 'bold'))
        self.text.pack()
        self.app.lift()

        # tell Windows(tm) to allow clicks to pass through our overlay.
        hWindow = pywintypes.HANDLE(int(self.root.frame(), 16))
        exStyle = (win32con.WS_EX_LAYERED |
                   win32con.WS_EX_TRANSPARENT |
                   win32con.WS_EX_NOACTIVATE)
        win32api.SetWindowLong(hWindow, win32con.GWL_EXSTYLE, exStyle)

        self.app.after(100, self.update)
        self.app.mainloop()

    def update(self):
        if self.messages.empty():
            self.app.after(100, self.update)
            return
        msg = self.messages.get_nowait()

        self.text['state'] = 'normal'

        if self.text.index('end-1c') != '1.0':
            self.text.insert('end', '\n')

        self.text.insert('end', "{0}: ".format(msg.display_name))
        emote_insertions = {}
        for eid, pos in msg.emotes.items():
            for p in pos:
                emote_insertions[p[0]] = (msg.localemotes[eid], p[1]+1)

        cur_pos = 0
        for i in sorted(emote_insertions.keys()):
            if cur_pos < i:
                self.text.insert('end', msg.message[cur_pos:i])
            img = PhotoImage(file=emote_insertions[i][0])
            self.text.image_create('end', image=img)

            # tkinter *needs* us to save a reference to a displayed image :(
            self.images.append(img)
            cur_pos = emote_insertions[i][1]
        if cur_pos < len(msg.message):
            self.text.insert('end', msg.message[cur_pos:])

        color = self.color_for[msg.display_name]
        self.text.tag_config(msg.display_name, foreground=color, relief=RAISED)
        self.text.tag_add(msg.display_name, 'end-1l', 'end-1l wordend')

        self.text.see('end')
        self.text['state'] = 'disabled'
        self.app.after(100, self.update)
Пример #16
0
class ImportFromDialog:
    def __init__(self, master, uf):
        self.master = master
        self.uf = uf 
        self.top = Toplevel(self.master)
        self.top.title('Import keys from old device')
        self.top.geometry('+350+350')
        ImportFromDialog.path = ''  # static member variable
        # default values for padding and sticky
        padyD = 5
        padxD = 5      
        
        # Layout                       
        self.lblPW = Label(self.top, text='Enter passphrase to decrypte Files')
        self.lblPW.grid(row=0, columnspan=3, sticky=W, pady=padyD, padx=padxD) 
        
        self.etyPw = Entry(self.top)
        self.etyPw.grid(row=1, columnspan=3, sticky=W+E, pady=padyD, padx=padxD) 
        
        self.lblPath = Label(self.top, text='Import files from transport medium (e.g. USB-Stick):')
        self.lblPath.grid(row=2, columnspan=3, sticky=W+S, pady=padyD, padx=padxD) 
        
        self.lblPathDisplay = Label(self.top, text=ImportFromDialog.path)
        self.lblPathDisplay.grid(row=3, columnspan=3, sticky=W+N, pady=padyD, padx=padxD) 
        
        self.btnCancle = Button(self.top, text='Cancle', command=self.cancle, width=16)
        self.btnCancle.grid(row=4, sticky=W, pady=padyD, padx=padxD) 

        self.btnPath = Button(self.top, text='Select path',command=self.change_path, width=16)
        self.btnPath.grid(row=4, column=1, sticky=W+E, pady=padyD, padx=padxD) 
        
        self.btnOK = Button(self.top, text='OK',command=self.submit, width=16)
        self.btnOK.grid(row=4, column=2, sticky=E, pady=padyD, padx=padxD) 
        
        self.update()
        
    # check display loop
    def update(self):
        self.lblPathDisplay.config(text=ImportFromDialog.path, font='Helvetica 8 bold')
        self.top.after(500, self.update) # call update() again after 500ms
        
    def change_path(self):
        ImportFromDialog.path = filedialog.askdirectory()
        self.top.lift(aboveThis=self.master)  # lift the toplevel above master window again
        
    def cancle(self):
        self.top.destroy() 
        
    def submit(self):
        pw = self.etyPw.get()
        
        # input check
        if len(pw) == 0:
            raise ExceptionMsg('No password provided', self.top, self.master)
        elif len(ImportFromDialog.path) == 0:
            raise ExceptionMsg('No path selected', self.top, self.master)
        else:                
            try:
                # password verification happens as decryption with aes throws invalid tag exeption
                # if one of the elements (none, key, ...) is wrong. 
                # if key is wrong its a password problem, thus catch the InvalidTag Exception
                self.uf.decrypt_private_keys(pw, ImportFromDialog.path)
                self.uf.import_other_files(ImportFromDialog.path)
                self.top.destroy() 
                messagebox.showinfo('successfull', 'Data successfuly importetd')                
            except FileNotFoundError as error:
                raise ExceptionMsg(error, self.top, self.master)                
            except InvalidTag:
                raise ExceptionMsg('The password is wrong', self.top, self.master)
Пример #17
0
class ExportToDialog:
    def __init__(self, master, uf):
        self.master = master
        self.uf = uf
        self.top = Toplevel(self.master)
        self.top.title('Export keys for new device')
        self.top.geometry('+350+350')
        ExportToDialog.path = ''  # static member variable, ramains on new button click as priviously selected
        # default values for padding and sticky
        padyD = 5
        padxD = 5      
        
        # Layout                
        self.lblPW = Label(self.top, text='Enter passphrase (Needed later on new device. Thus remember!')
        self.lblPW.grid(row=0, columnspan=3, sticky=W, pady=padyD, padx=padxD) 
        
        self.etyPw = Entry(self.top)
        self.etyPw.grid(row=1, columnspan=3, sticky=W+E, pady=padyD, padx=padxD) 
        
        self.lblPwCheck = Label(self.top, text='')
        self.lblPwCheck.grid(row=2, columnspan=3, sticky=W, pady=padyD, padx=padxD) 
        
        self.lblPath = Label(self.top, text='Save Encrypted files to transport medium (e.g. USB-Stick):')
        self.lblPath.grid(row=3, columnspan=3, sticky=W+S, pady=padyD, padx=padxD) 
        
        self.lblPathDisplay = Label(self.top, text=ExportToDialog.path)
        self.lblPathDisplay.grid(row=4, columnspan=3, sticky=W+N, pady=padyD, padx=padxD) 
        
        self.btnCancle = Button(self.top, text='Cancle', command=self.cancle, width=16)
        self.btnCancle.grid(row=5, sticky=W, pady=padyD, padx=padxD) 

        self.btnPath = Button(self.top, text='Select path',command=self.change_path, width=16)
        self.btnPath.grid(row=5, column=1, sticky=W+E, pady=padyD, padx=padxD) 
        
        self.btnOK = Button(self.top, text='OK',command=self.submit, width=16)
        self.btnOK.grid(row=5, column=2, sticky=E, pady=padyD, padx=padxD) 
        
        self.update()
        
    # check display loop
    def update(self):
        if len(self.etyPw.get()) > 0:  # avoid errors when nothing entered yet
            text, color = self.uf.pw_checker(self.etyPw.get())
            self.lblPwCheck.config(text=text, foreground = color)
        self.lblPathDisplay.config(text=ExportToDialog.path, font='Helvetica 8 bold')
        self.top.after(500, self.update) # call update() again after 500ms
        
    def change_path(self):
        ExportToDialog.path = filedialog.askdirectory()
        self.top.lift(aboveThis=self.master)  # lift the toplevel above master window again
        
    def cancle(self):
        self.top.destroy() 
        
    def submit(self):
        pw = self.etyPw.get()
        
        # input check
        if len(pw) == 0:
            raise ExceptionMsg('No password provided', self.top, self.master)
        elif len(ExportToDialog.path) == 0:
            raise ExceptionMsg('No path selected', self.top, self.master)
        else:  
            try:
                self.uf.encrypt_private_keys(pw, ExportToDialog.path)
                self.uf.export_other_files(ExportToDialog.path)
                self.top.destroy()   
                messagebox.showinfo('successfull', 'Data successfuly exportet to ' + self.path)
            except FileNotFoundError as error:
                raise ExceptionMsg(error, self.top, self.master)                   
class App(object):
    
    def __init__(self, bulk_processing=False, show_logging=True, gpu_id=None, instance_id=None, config_file=None, input_folder=None, file=None):
        
        self.root = Tk()
        self.bulk_processing = bulk_processing        
        self.show_logging = show_logging
        self.cam = None
        self.cam_id = 0
        self.input_source = None
        self.source_changed = False
        self.opencv_thread = None
        self.window = None
        self.tracker = None
        
        if self.bulk_processing:  
            
            workspace.GlobalInit(['caffe2', '--caffe2_log_level=0'])
            self.input_source = file
            self.load_config_file(config_file)            
            self.app_gpu = gpu_id
            self.app_save_det_result_path = input_folder
            self.app_save_tracking_result_path = input_folder
            self.setup_logging(__name__)                       
            self.logger = logging.getLogger(__name__)
        
        else:   
            self.v_1: IntVar = IntVar()        
            self.v_2: IntVar = IntVar()        
            self.v_3: IntVar = IntVar()
            self.v_4: IntVar = IntVar()
            self.v_5: IntVar = IntVar()
            self.v_detector_to_use: StringVar = StringVar()
            self.v_tracker_to_use: StringVar = StringVar()
            self.v_detectron_model: StringVar = StringVar()
            self.v_chainer_model: StringVar = StringVar()           
            
    
            self.chainercv_models = ['yolo_v2', 'yolo_v3', 'yolo_v2_tiny', 
                                   'ssd300', 'ssd512', 
                                   'fasterrcnnvgg16', 'fasterrcnnfpnresnet50', 'fasterrcnnfpnresnet101']
            
            self.detectron_models = ['e2emaskrcnnR101FPN2x', 'e2efasterrcnnR101FPN2x', 'use config file settings']
            
            self.trackers = ['deep_sort', 'sort']
            
            self.detectors = ['detectron', 'chainer']
            
            self.load_config_file('config.ini')
            
            self.logger = logging.getLogger(__name__)
        
    def run(self):
        self.main_window = main_window.MainWindow(self)        
        self.root.mainloop()
        cv2.destroyAllWindows()
        sys.exit()
        
    def ask_for_options(self):
        self.config_window = config_window.ConfigWindow(self)

    def open_webcam(self):
        if self.cam_id is not None:
            self.input_source = self.cam_id
            self.source_changed = True
            self.start_video()

    def open_video(self):
        options = {}
        options['title'] = "Choose video"

        filename = askopenfilename(**options)

        if filename:
            self.input_source = filename
            self.source_changed = True
            self.start_video()  
    
    def start_bulk(self):
           
        self.start_video()
        self.root.mainloop()
        sys.exit()
        
    def start_video(self):        
        
        if self.opencv_thread is None:            
            self.source_changed = False
            self.opencv_thread = Thread(target=self.run_opencv_thread)
            self.opencv_thread.daemon = True
            self.opencv_thread.start()  
            
        if self.show_logging is True:
            self.show_logging_window()

    def run_opencv_thread(self):
        
        if self.app_display is True:
            cv2.namedWindow('source')
        
        self.start_processing()

        cv2.destroyAllWindows()
        self.opencv_thread = None

    def start_processing(self):
        
        if self.input_source is not None:

            file_stream = FileVideoStream(self.input_source, queue_size=self.app_imutils_queue_size).start()
            
            time.sleep(0.001)            
            detector = self.initializeDetector()
            self.tracker = self.initializeTracker()
            self.setDataset()
                
            fps = FPS().start()
            
            frame_id = 0
            all_boxes = {}
            tracking_boxes = []

            while (not self.source_changed) and file_stream.running(): 
                
                time.sleep(0.001)
                
                try:
                        
                    self.image = file_stream.read()
                
                    if frame_id % self.app_process_every_nth_frame == 0:                            
                                           
                        if(self.image is not None):

                            vis = self.image.copy()                            
                            cls_boxes = None 
                            cls_segms = None 
                            cls_keyps = None 
                            timers = defaultdict(Timer)
                            t = time.time()
                            fps.update()
                            fps.stop()
                            
                            self.logger.info('Processing file {}'.format(self.input_source))
                            self.logger.info('Processing frame {}'.format(frame_id))
                            
                            fps_text = "FPS " + "{:.2f}".format(fps.fps())
                            self.logger.info('FPS: ' + fps_text)        
                            
                            if self.app_do_detection and not self.source_changed:
                                
                                cls_boxes, cls_segms, cls_keyps = self.infer(vis, timers, detector)     
                                                                                                
                                all_boxes[frame_id] = cls_boxes
                                
                                self.logger.info('Inference time: {:.3f}s'.format(time.time() - t))          
                                
                                for k, v in timers.items():
                                    self.logger.info(' | {}: {:.3f}s'.format(k, v.average_time))
                                if frame_id == 0:
                                    self.logger.info(
                                        ' \ Note: inference on the first image will be slower than the '
                                        'rest (caches and auto-tuning need to warm up)'
                                    )            
                                fps_text = "FPS " + "{:.2f}".format(fps.fps())
                                self.logger.info('FPS: ' + fps_text)
            
                                                            
                                if self.app_display_det_result_img:
                                    if frame_id % self.app_display_det_every_nth_frame == 0 :                                        
                                        vis = self.visualize_det(vis, cls_boxes, fps_text, 
                                                                 segms=cls_segms, keypoints=cls_keyps)
      
            
                                if self.app_save_det_result_img:
                                    if not self.app_display_det_result_img:
                                        ret = self.visualize_det(vis, cls_boxes, fps_text, 
                                                                 segms=cls_segms, keypoints=cls_keyps)
                                        self.save_det_result_img(ret, frame_id)
                                    else:
                                        self.save_det_result_img(vis, frame_id)
                                    
                            if self.app_do_tracking and not App.is_list_empty(cls_boxes) and not self.source_changed:
                                
                                t = time.time()
                                tmp_tracking_boxes = self.track(self.image.copy(), cls_boxes, frame_id, timers)
                                                                
                                self.logger.info('Tracking time (incl. feature generation): {:.3f}s'.format(time.time() - t))

                                if self.app_display_tracking_result_img:
                                    if frame_id % self.app_display_tracking_every_nth_frame == 0 :                              
                                        vis = self.visualize_tracking(vis, tmp_tracking_boxes, fps_text)                                       
                                        
                                                                
                                if self.app_save_tracking_result_img:
                                    if not self.app_display_tracking_result_img:
                                        ret = self.visualize_tracking(vis, tmp_tracking_boxes, fps_text)
                                        self.save_tracking_result_img(ret, frame_id)
                                    else:
                                        self.save_tracking_result_img(vis, frame_id)
                                
                                tracking_boxes = self.extend_result_boxes(frame_id, tracking_boxes, tmp_tracking_boxes)
                                                                
                            if self.app_display:
                                cv2.imshow('source', vis)  
                                ch = 0xFF & cv2.waitKey(1)
                                if ch == 27:
                                    break
         
                            self.logger.info('Total time frame {}: {:.3f}s'.format(frame_id, time.time() - t))                            
                                
                            frame_id += 1                              

                except Exception:
                    print(sys.exc_info()[0] + sys.exc_info()[1])     
                    #continue
            
            if self.app_save_det_result_boxes:                                
                self.save_det_result_boxes(all_boxes)    
                self.logger.info('Wrote detections to: {}'.format(os.path.abspath(self.app_save_det_result_path)))
                
            if self.app_save_tracking_result_boxes:                                
                self.save_tracking_result_boxes(list(tracking_boxes))
                self.logger.info('Wrote tracks to: {}'.format(os.path.abspath(self.app_save_tracking_result_path)))
                
            file_stream.stop()
            self.source_changed = False
            
            if not self.bulk_processing:
                self.start_processing()
            else:
                self.root.quit()
            

    def initializeDetector(self):
                
        if self.app_detector_to_use == 'chainer':
                        
            return detector_chainercv.Detector(self.app_gpu, 
                                               self.chainer_model, 
                                               self.chainer_ms_thresh, 
                                               self.chainer_score_thresh)
            
        elif self.app_detector_to_use == 'detectron':
            
            cfg.immutable(False)
            
            if self.detectron_model == 'e2emaskrcnnR101FPN2x':
                detectron_cfg_tmp = 'Detectron/configs/12_2017_baselines/e2e_mask_rcnn_R-101-FPN_2x.yaml'
                detectron_wts_tmp = (str(self.detectron_download_cache) + '/35861858/12_2017_baselines/'
                                    'e2e_mask_rcnn_R-101-FPN_2x.yaml.02_32_51.SgT4y1cO/output/train/'
                                    'coco_2014_train:coco_2014_valminusminival/generalized_rcnn/model_final.pkl')
                                    
            elif self.detectron_model == 'e2efasterrcnnR101FPN2x':
                detectron_cfg_tmp = 'Detectron/configs/12_2017_baselines/e2e_faster_rcnn_R-101-FPN_2x.yaml'
                detectron_wts_tmp = (str(self.detectron_download_cache) + '/35857952/12_2017_baselines/'
                                    'e2e_faster_rcnn_R-101-FPN_2x.yaml.01_39_49.JPwJDh92/output/train/'
                                    'coco_2014_train:coco_2014_valminusminival/generalized_rcnn/model_final.pkl')
            else:
                detectron_cfg_tmp = self.detectron_cfg
                detectron_wts_tmp = self.detectron_wts
                
            merge_cfg_from_file(detectron_cfg_tmp)
            cfg.NUM_GPUS = 1
            cfg.DOWNLOAD_CACHE = self.detectron_download_cache                    
            cfg.TEST.NMS = self.detectron_nms_thresh
            cfg.TEST.DETECTIONS_PER_IM = self.detectron_detections_per_im
            cfg.TEST.PROPOSAL_LIMIT = self.detectron_proposal_limit
            cfg.TEST.RPN_NMS_THRESH = self.detectron_rpn_nms_thresh
            cfg.TEST.SCORE_THRESH = self.detectron_score_thresh
            weights = cache_url(detectron_wts_tmp, cfg.DOWNLOAD_CACHE)
            assert_and_infer_cfg()
            _merge_a_into_b(cfg, infer_engine.cfg)
            
            return infer_engine.initialize_model_from_cfg(weights, self.app_gpu)
                    
    def infer(self, image, timers, detector):
        
        cls_boxes = None 
        cls_segms = None 
        cls_keyps = None
        
        if self.app_detector_to_use == 'chainer':
            
            timers['chainer_detect'].tic()
            bboxes, labels, scores = detector.predict(image)
            timers['chainer_detect'].toc()
            cls_boxes = App.transform_to_detectron(bboxes, labels, scores)
            
        elif self.app_detector_to_use == 'detectron':
                                                        
            with c2_utils.NamedCudaScope(self.app_gpu):
                cls_boxes, cls_segms, cls_keyps = infer_engine.im_detect_all(
                    detector, image, None, timers=timers
                )
        
        return cls_boxes, cls_segms, cls_keyps
    
    def visualize_det(self, vis, cls_boxes, fps_text, segms=None, keypoints=None):
                                
        offsetX = 20
        offsetY = 20
        text_width = 100
        text_height = 10
        
        vis = detectron_visualizator.vis_one_image_opencv(vis, cls_boxes, segms=segms, keypoints=keypoints, 
                                                          thresh=self.app_vis_thresh,
                                                          kp_thresh=self.detectron_kp_thresh, 
                                                          show_box=True, 
                                                          dataset=self.dataset, 
                                                          show_class=True)
        
        #(text_width, text_height) = cv2.getTextSize(fps_text, fontScale=cv2.FONT_HERSHEY_SIMPLEX, thickness=1)
        cv2.rectangle(vis, 
                      (offsetX - 2, offsetY - text_height - 2), 
                      (offsetX + 2 + text_width, offsetY + 2), 
                      (0, 0, 0), cv2.FILLED)
        cv2.putText(vis, fps_text, (offsetX, offsetY),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255))
        
        return vis     

    def save_det_result_img(self, vis, frame_id):
        
        try:   
            head, tail = os.path.split(self.input_source)   
            filename = os.path.splitext(tail)[0]                  
            cv2.imwrite(head + '/' + filename + '_' + str(frame_id) + '.png',vis)
            
        except Exception:

            e = sys.exc_info()[0]
            messagebox.showinfo("Error saving detection images", e)
            raise

    def save_det_result_boxes(self, all_boxes):
            
        try:
            target_lines = []
                   
            for frame_id, cls_boxes in all_boxes.items():
                for cls_idx in range(1, len(cls_boxes)):
                    
                    dataset = self.dataset.classes
                    
                    for dets in cls_boxes[cls_idx]:
                        
                        line = [frame_id + 1, '-1', round(dets[0], 1), round(dets[1], 1), 
                                round(dets[2] - dets[0], 1), round(dets[3] - dets[1], 1), 
                                round(dets[4] * 100, 1), dataset[cls_idx], '-1', '-1', '-1']
                        target_lines.append(line)
                                
            target_lines.sort(key=lambda x: x[0])
            
            head, tail = os.path.split(self.input_source)   
            filename = os.path.splitext(tail)[0]                  
            
            with open(head + '/' + filename + '_detections.csv', 'w+') as txtfile:
                wr = csv.writer(txtfile, lineterminator='\n')
                for val in target_lines:
                    wr.writerow(val)
                    
        except Exception:

            e = sys.exc_info()[0]
            messagebox.showinfo("Error saving detection images", e)
            raise
           
    def initializeTracker(self):
        
        if self.app_tracker_to_use == 'deep_sort':
            
            return tracker_deep_sort.DeepSortTracker(self.deep_sort_feature_model, 
                                                     self.deep_sort_max_cosine_distance, 
                                                     self.deep_sort_nn_budget, 
                                                     self.deep_sort_per_process_gpu_mem_fraction,
                                                     self.app_gpu)
            
        elif self.app_tracker_to_use == 'sort':
            
            return tracker_sort.Sort()
    
    def track(self, vis, cls_boxes, frame_id, timers):
        
        result = None
        cls_boxes = [np.append(item, i) for i, sublist in enumerate(cls_boxes) for item in sublist]
        cls_boxes = np.asarray(cls_boxes)
        
        if self.app_tracker_to_use == 'deep_sort':
            timers['deep_sort'].tic()
            result = self.tracker.track(vis, cls_boxes, frame_id, 
                                        self.deep_sort_min_detection_height, 
                                        self.deep_sort_min_confidence, 
                                        self.deep_sort_nms_max_overlap)
            timers['deep_sort'].toc()
            
        elif self.app_tracker_to_use == 'sort':
            timers['sort'].tic()
            cls_boxes[:,2:4] += cls_boxes[:,0:2]
            result = self.tracker.update(cls_boxes)
            timers['sort'].toc()             
         
        return result
        
    def visualize_tracking(self, vis, tracking_boxes, fps_text):
                
        offsetX = 20
        offsetY = 20
        text_width = 100
        text_height = 10        
            
        if self.app_tracker_to_use == 'deep_sort':        
            
            vis = self.tracker.draw_trackers(vis, tracking_boxes, 
                                             self.dataset.classes, 
                                             self.deep_sort_min_confidence)
            
        if self.app_tracker_to_use == 'sort':           
            
            vis = self.tracker.draw_trackers(vis, tracking_boxes)
        
        cv2.rectangle(vis, 
                      (offsetX - 2, offsetY - text_height - 2), 
                      (offsetX + 2 + text_width, offsetY + 2), 
                      (0, 0, 0), cv2.FILLED)
        cv2.putText(vis, fps_text, (offsetX, offsetY),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255))
        
        return vis   
        
    def save_tracking_result_img(self, vis, frame_id):
        
        try:
                                
            cv2.imwrite(self.app_save_tracking_result_path + 
                        '/tracking_res_img_' + str(frame_id) + 
                        '.png',vis)
            
            head, tail = os.path.split(self.input_source)   
            filename = os.path.splitext(tail)[0]                  
            cv2.imwrite(head + '/' + filename + '_tracking_' + str(frame_id) + '.png',vis)
            
        except Exception:

            e = sys.exc_info()[0]
            messagebox.showinfo("Error saving tracking images", e)
            raise
        
    def save_tracking_result_boxes(self, tracking_boxes):                        
        
        try:
            tracking_boxes.sort(key = lambda x: (x[0], x[1]))
            
            head, tail = os.path.split(self.input_source)   
            filename = os.path.splitext(tail)[0]                  
            
            with open(head + '/' + filename + '_tracks.csv', 'w+') as txtfile:
                
                wr = csv.writer(txtfile, lineterminator='\n')
                
                for val in tracking_boxes:
                    
                    if self.app_tracker_to_use == 'deep_sort':            
                        val = [val[0] + 1, val[1], round(val[2], 2), round(val[3], 2), 
                               round(val[4], 2), round(val[5], 2), round(val[6], 1), -1, -1, -1]
                        
                    if self.app_tracker_to_use == 'sort':
                        val = [val[0] + 1, int(val[5]), round(val[1], 1), 
                               round(val[2], 1), round(val[3], 1), round(val[4], 1)]
                        
                    wr.writerow(val)
                    
        except Exception:

            e = sys.exc_info()[0]
            messagebox.showinfo("Error saving tracking boxes", e)
            raise
    
    def extend_result_boxes(self, frame_id, tracking_boxes, tmp_tracking_boxes):
        
        if self.app_tracker_to_use == 'deep_sort':            
            conf_tracks = self.tracker.get_confirmed_tracks(frame_id)
            tracking_boxes.extend(conf_tracks)
            self.logger.info('Tracks in image: {} tracks'.format(len(conf_tracks)))
            
        elif self.app_tracker_to_use == 'sort':                                    
            self.logger.info('Tracks in image: {} tracks'.format(len(tmp_tracking_boxes)))
            for index, obj in enumerate(tmp_tracking_boxes):
                tracking_boxes.extend([[frame_id, obj[0], obj[1], obj[2], obj[3], obj[4]]])
                
        return tracking_boxes
    
    def setDataset(self):
        
        if self.app_detector_to_use == 'detectron':
            self.dataset = App.get_coco_dataset()
            
        elif self.app_detector_to_use == 'chainer' and (
                self.chainer_model == 'fasterrcnnfpnresnet50' or 
                self.chainer_model == 'fasterrcnnfpnresnet101'):
            self.dataset = App.get_coco_dataset(False)
            
        else:
            self.dataset = App.get_voc_dataset()
            
    def load_config_file(self, configfile=None):
        
        try:
        
            self.config = configparser.ConfigParser()
            self.config.sections()
            
            if configfile is None:
                
                options = {}
                options['title'] = "Choose config file"
                options['filetypes'] = [('Config file', '.ini')]
                options['defaultextension'] = "ini"
        
                filename = askopenfilename(**options)
        
                if filename:
                    configfile = filename
                    
            if configfile is not None:
            
                self.config.read(configfile)
                
                self.app_display = eval(self.config['App']['display'])
                self.app_gpu = int(self.config['App']['gpu'])    
                self.app_save_det_result_img = eval(self.config['App']['save_det_result_img'])
                self.app_save_det_result_boxes = eval(self.config['App']['save_det_result_boxes'])    
                self.app_save_det_result_path = self.config['App']['save_det_result_path']   
                self.app_save_tracking_result_img = eval(self.config['App']['save_tracking_result_img'])
                self.app_save_tracking_result_boxes = eval(self.config['App']['save_tracking_result_boxes'])
                self.app_save_tracking_result_path = self.config['App']['save_tracking_result_path']        
                self.app_display_det_result_img = eval(self.config['App']['display_det_result_img'])
                self.app_display_det_every_nth_frame = eval(self.config['App']['display_det_every_nth_frame'])
                self.app_process_every_nth_frame = eval(self.config['App']['process_every_nth_frame'])
                self.app_display_tracking_result_img = eval(self.config['App']['display_tracking_result_img'])
                self.app_display_tracking_every_nth_frame = eval(self.config['App']['display_tracking_every_nth_frame'])
                self.app_detector_to_use = self.config['App']['detector_to_use']
                self.app_tracker_to_use = self.config['App']['tracker_to_use']
                self.app_vis_thresh = float(self.config['App']['vis_thresh'])
                self.app_config_file = self.config['App']['config_file']
                self.app_do_detection = eval(self.config['App']['do_detection'])
                self.app_do_tracking = eval(self.config['App']['do_tracking'])
                self.app_imutils_queue_size = int(self.config['App']['imutils_queue_size'])
                self.cam_id = int(self.config['App']['web_cam'])
                
                self.detectron_model = self.config['Detectron']['model']
                self.detectron_cfg = self.config['Detectron']['cfg']
                self.detectron_wts = self.config['Detectron']['wts']
                self.detectron_kp_thresh = float(self.config['Detectron']['kp_thresh'])
                self.detectron_nms_thresh = float(self.config['Detectron']['nms_thresh'])
                self.detectron_download_cache = self.config['Detectron']['download_cache']
                self.detectron_detections_per_im = int(self.config['Detectron']['detections_per_im'])
                self.detectron_proposal_limit = int(self.config['Detectron']['proposal_limit'])
                self.detectron_rpn_nms_thresh = float(self.config['Detectron']['rpn_nms_thresh'])
                self.detectron_score_thresh = float(self.config['Detectron']['score_thresh'])
                
                self.deep_sort_min_confidence = float(self.config['deep_sort']['min_confidence'])
                self.deep_sort_nn_budget = int(self.config['deep_sort']['nn_budget'])
                self.deep_sort_max_cosine_distance = float(self.config['deep_sort']['max_cosine_distance'])
                self.deep_sort_nms_max_overlap = float(self.config['deep_sort']['nms_max_overlap'])
                self.deep_sort_min_detection_height = int(self.config['deep_sort']['min_detection_height'])
                self.deep_sort_per_process_gpu_mem_fraction = float(self.config['deep_sort']['per_process_gpu_mem_fraction'])
                
                self.deep_sort_feature_model = self.config['deep_sort_features']['model']
                
                self.chainer_model = self.config['chainer']['model']
                self.chainer_ms_thresh = float(self.config['chainer']['ms_thresh'])
                self.chainer_score_thresh = float(self.config['chainer']['score_thresh'])
                
                if self.opencv_thread is not None:
                        self.source_changed = True
                
                if not self.bulk_processing:
                    self.update_main_gui()
                
        except Exception:

            e = sys.exc_info()[0]
            messagebox.showinfo("Error loading file", e)
            raise
    
    def save_config_file(self, configfile=None):
        
        try:
        
            self.config['App'] = {'display': self.app_display,
                             'gpu': self.app_gpu,
                             'save_det_result_img': self.app_save_det_result_img,
                             'save_det_result_boxes': self.app_save_det_result_boxes,
                             'save_det_result_path': self.app_save_det_result_path,                             
                             'save_tracking_result_img': self.app_save_tracking_result_img,
                             'save_tracking_result_boxes': self.app_save_tracking_result_boxes,
                             'save_tracking_result_path': self.app_save_tracking_result_path,
                             'display_det_result_img': self.app_display_det_result_img,
                             'display_det_every_nth_frame': self.app_display_det_every_nth_frame,
                             'display_tracking_result_img': self.app_display_tracking_result_img,
                             'display_tracking_every_nth_frame': self.app_display_tracking_every_nth_frame,
                             'detector_to_use': self.app_detector_to_use,
                             'tracker_to_use': self.app_tracker_to_use,
                             'vis_thresh': self.app_vis_thresh,
                             'config_file': self.app_config_file,
                             'process_every_nth_frame': self.app_process_every_nth_frame,
                             'do_detection': self.app_do_detection,
                             'do_tracking': self.app_do_tracking,
                             'imutils_queue_size': self.app_imutils_queue_size,
                             'web_cam': self.cam_id}
            
            self.config['Detectron'] = {
                             'model': self.detectron_model,
                             'cfg': self.detectron_cfg,
                             'wts': self.detectron_wts,
                             'kp_thresh': self.detectron_kp_thresh,
                             'nms_thresh': self.detectron_nms_thresh,
                             'download_cache': self.detectron_download_cache,
                             'detections_per_im': self.detectron_detections_per_im,
                             'proposal_limit': self.detectron_proposal_limit,
                             'rpn_nms_thresh': self.detectron_rpn_nms_thresh,
                             'score_thresh': self.detectron_score_thresh}
            self.config['deep_sort'] = {'min_confidence': self.deep_sort_min_confidence,
                             'nn_budget': self.deep_sort_nn_budget,
                             'max_cosine_distance': self.deep_sort_max_cosine_distance,
                             'nms_max_overlap': self.deep_sort_nms_max_overlap,
                             'min_detection_height': self.deep_sort_min_detection_height,
                             'per_process_gpu_mem_fraction': self.deep_sort_per_process_gpu_mem_fraction
                             }
            self.config['deep_sort_features'] = {'model': self.deep_sort_feature_model}
            self.config['chainercv'] = {'model': self.chainer_model,
                             'ms_thresh': self.chainer_ms_thresh,
                             'score_thresh': self.chainer_score_thresh}
                            
            options = {}
            options['filetypes'] = [('Config file', '.ini')]
            options['defaultextension'] = "ini"
            options['initialfile'] = "config.ini"
            options['title'] = "Where to save?"
    
            configfile = asksaveasfilename(**options)
    
            if configfile:

                with open(configfile, 'w') as configfile:
                        self.config.write(configfile)
    
        except Exception:

            e = sys.exc_info()[0]
            messagebox.showinfo("Error saving file", e)
            raise
                   
    def trans_img_chainer(img):
        buf = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        dst = np.asanyarray(buf, dtype=np.uint8).transpose(2, 0, 1)
        return dst
    
    def transform_to_detectron(bbox, label, score):
        #Detectron: all_boxes[cls][image] = N x 5 array with columns (x1, y1, x2, y2, score)
        label_names = voc_bbox_label_names        
        cls_boxes = [[] for _ in range(len(label_names))]
        
        if label is not None and not len(bbox) == len(label):
            raise ValueError('The length of label must be same as that of bbox')
        if score is not None and not len(bbox) == len(score):
            raise ValueError('The length of score must be same as that of bbox')
    
        if label is not None:
            order = np.argsort(label)
            
            bbox = np.array(bbox[0])
            score = np.array(score[0])
            label = np.array(label[0])
            
            bbox = bbox[order]
            score = score[order]
            label = label[order]
            
            if len(bbox) == 0:
                return
            
            tmp_label = None
            for i, bb in enumerate(bbox[0]):
                if tmp_label is None or tmp_label != label[0][i]:
                    tmp_label = label[0][i]
                cls_boxes[tmp_label].append([bb[1], bb[0], bb[3], bb[2], score[0][i]])
                
                 
        return cls_boxes
    
    def get_coco_dataset(incl_background=True):
        ds = AttrDict()
        classes = [
            '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',
            'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
            'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',
            'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack',
            'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee', 'skis',
            'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove',
            'skateboard', 'surfboard', 'tennis racket', 'bottle', 'wine glass',
            'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich',
            'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake',
            'chair', 'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
            'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
            'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
            'scissors', 'teddy bear', 'hair drier', 'toothbrush'
        ]
        if incl_background:
            ds.classes = {i: name for i, name in enumerate(classes)}
        else:
            ds.classes = {i: name for i, name in enumerate(classes[1:])}        
        return ds
    
    def get_voc_dataset():
        ds = AttrDict()
    
        classes = [
            'aeroplane', 'bicycle', 'bird', 'boat', 'bottle',
            'bus', 'car', 'cat', 'chair', 'cow', 'diningtable',
            'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa',
            'train', 'tvmonitor'
        ]
        ds.classes = {i: name for i, name in enumerate(classes)}
        return ds
    
    def is_list_empty(inList):
        if isinstance(inList, list):
            return all( map(App.is_list_empty, inList) )
        return False    

        
    def on_closing(self):
        if messagebox.askokcancel("Quit", "Do you want to quit?"):
            if self.cam is not None:
                self.cam.release()
            
            sys.exit()
    
    def set_detector_to_use(self, event=None):
        if event is not None:
            self.app_detector_to_use = str(event.widget.get())
            if self.opencv_thread is not None:
                self.source_changed = True
    
    def set_tracker_to_use(self, event=None):
        if event is not None:
            self.app_tracker_to_use = str(event.widget.get())
            if self.opencv_thread is not None:
                self.source_changed = True
    
    def set_detectron_model(self, event=None):
        if event is not None:
            self.detectron_model = str(event.widget.get())
            if self.opencv_thread is not None:
                self.source_changed = True
    
    def set_chainercv_model(self, event=None):
        if event is not None:
            self.chainer_model = str(event.widget.get())
            if self.opencv_thread is not None:
                self.source_changed = True
            
    def set_display_det_result_img(self):
        self.app_display_det_result_img = bool(self.v_1.get())
            
    def set_display_tracking_result_img(self):
        self.app_display_tracking_result_img = bool(self.v_4.get())
    
    def set_do_tracking(self):
        self.app_do_tracking = bool(self.v_5.get())        
            
    def set_save_det_result_img(self):
        self.app_save_det_result_img = bool(self.v_2.get())
            
    def set_save_tracking_result_img(self):
        self.app_save_tracking_result_img = bool(self.v_3.get())

    def update_main_gui(self):
                
        self.v_1.set(self.app_display_det_result_img)
        self.v_2.set(self.app_save_det_result_img)
        self.v_4.set(self.app_display_tracking_result_img)
        self.v_3.set(self.app_save_tracking_result_img)
        self.v_5.set(self.app_do_tracking)
        
        self.v_detector_to_use.set(self.app_detector_to_use)
        self.v_tracker_to_use.set(self.app_tracker_to_use)
        self.v_detectron_model.set(self.detectron_model)
        self.v_chainer_model.set(self.chainer_model)        
        
        self.root.update()
    
    def show_logging_window(self):
        
        if self.window is not None:
            self.window.destroy()
        
        if self.bulk_processing:            
            self.window = self.root
        else:
            self.window = Toplevel(self.root)
        
        self.window.wm_title("Process/GPU: " + str(self.app_gpu))
        self.window.resizable(width=True, height=True)
        self.window.attributes('-topmost', True)
                
        self.scrolled_text = tkst.ScrolledText(self.window, state='disabled', height=24)
        self.scrolled_text.grid(row=0, column=0, sticky=(N, S, W, E))
        self.scrolled_text.configure(font='TkFixedFont')
        self.scrolled_text.tag_config('INFO', foreground='black')
        self.scrolled_text.tag_config('DEBUG', foreground='gray')
        self.scrolled_text.tag_config('WARNING', foreground='orange')
        self.scrolled_text.tag_config('ERROR', foreground='red')
        self.scrolled_text.tag_config('CRITICAL', foreground='red', underline=1)
        self.log_queue = queue.Queue()
        self.queue_handler = LoggingQueueHandler(self.log_queue)
        formatter = logging.Formatter('%(asctime)s: %(message)s')
        self.queue_handler.setFormatter(formatter)
        self.logger.addHandler(self.queue_handler)
        self.window.after(100, self.poll_log_queue)
    
    def display_logging(self, record):        
        msg = self.queue_handler.format(record)
        self.scrolled_text.configure(state='normal')
        self.scrolled_text.insert(END, msg + '\n', record.levelname)
        self.scrolled_text.configure(state='disabled')
        self.scrolled_text.yview(END)

    def poll_log_queue(self):        
        while True:
            try:
                record = self.log_queue.get(block=False)
            except queue.Empty:
                break
            else:
                self.display_logging(record)
        self.window.after(1000, self.poll_log_queue)
        
    def setup_logging(self, name):        
        FORMAT = '%(levelname)s %(filename)s:%(lineno)4d: %(message)s'
        # Manually clear root loggers to prevent any module that may have called
        # logging.basicConfig() from blocking our logging setup
        logging.root.handlers = []
        logging.basicConfig(level=logging.INFO, format=FORMAT, stream=sys.stdout)
        logger = logging.getLogger(name)
        return logger
Пример #19
0
class Flasher:
    def __init__(self):
        # create parent widget that'll live through the whole program
        self.root = Tk()
        self.root.withdraw()

        # menubar modification for macOS (to remove the default bloated Tkinter menu)
        menubar = Menu(self.root)
        appmenu = Menu(menubar, name='apple')
        menubar.add_cascade(menu=appmenu)
        appmenu.add_command(label='About VPFlasher')  # inactive for now
        appmenu.add_separator()
        self.root['menu'] = menubar

        # initialized variables go here
        self.ring_has_timed_out = False
        self.call_status = "WAITING"
        self.ring_timeout = 0
        self.session_timeout = 0

        # bind callbacks to events
        self.root.bind("<<RingingOn>>", self.ringing_triggered)
        self.root.bind("<<RingingOff>>", self.ringing_terminated)
        self.root.bind("<<SessionOn>>", self.call_in_session)
        self.root.bind("<<SessionOff>>", self.session_terminated)

        # start "main program here"
        self.waiting_for_payload_in_thread()

        self.root.mainloop()

###### BEGINNING OF PAYLOAD PROCESSING ######

    def connecting_payload(self):
        # return the readable string in a matched raw payload
        while True:
            # exit the program if main thread is terminated
            if not main_thread().is_alive():
                sys.exit(1)
            # reset the payload processing if ringing timed out
            if self.call_status == "RINGING" and time() >= self.ring_timeout:
                self.ring_has_timed_out = True
                return
            frame = sniff(
                count=1,
                filter=
                '(tcp and dst port 5066) and (tcp[13] == 16 or tcp[13] == 24)',
                timeout=1)
            print("connecting_payload():", frame)  # UNCOMMENT FOR DEBUG
            if len(frame) > 0:
                if frame[0].haslayer('Raw'):
                    try:
                        return frame[0].getlayer('Raw').load.decode("utf-8")
                    except UnicodeDecodeError:
                        return

    def has_session_keepalive_packet(self):
        # return the readable string in a matched raw payload
        sleep(
            0.5
        )  # reduce processing load on CPU due to excessive matched frames traversing
        frame = sniff(count=1, filter='udp and ip[2:2] = 200', timeout=1)
        if len(frame) > 0:
            print("Session keepalive found at", time())  # UNCOMMENT FOR DEBUG
            return True
        else:
            return False

    def payload_found(self, payload, *payload_search_string):
        # return True if all strings in parameter are found in the payload
        try:
            if all(substring in payload
                   for substring in payload_search_string):
                return True
        except TypeError:
            # return False when the connection payload functions return NoneType
            return False

    def waiting_for_payload_in_thread(self):
        self.wait_thread = Thread(target=self.waiting_for_payload)
        self.wait_thread.start()

    def waiting_for_payload(self):
        self.call_status = "WAITING"
        while self.call_status == "WAITING":  ### THIS IS THE ACTUAL START OF THE PROGRAM
            self.next_payload = self.connecting_payload()

            # set to 'RINGING' status
            if self.payload_found(self.next_payload, "SIP/2.0 180 Ringing"):
                print("It's ringing!")  # UNCOMMENT FOR DEBUG
                self.call_status = "RINGING"
                self.ringing()

    def ringing(self):
        self.call_status = "RINGING"
        self.root.event_generate("<<RingingOn>>")
        self.ring_timeout = time() + 30
        self.ring_has_timed_out = False

        while self.call_status == "RINGING":
            # collect potential next matched payload
            self.next_payload = self.connecting_payload()

            # branch out to 'connected'
            # 'CSeq: 2' = Convo, 'CSeq: 1' = Sorenson, and 'CSeq: 102' = Purple/ZVRS
            if (self.payload_found(self.next_payload, "SIP/2.0 200 OK",
                                   "CSeq: 2 INVITE")
                    or self.payload_found(self.next_payload, "SIP/2.0 200 OK",
                                          "CSeq: 1 INVITE")
                    or self.payload_found(self.next_payload, "SIP/2.0 200 OK",
                                          "CSeq: 102 INVITE")):
                print("You're now connected!")  # UNCOMMENT FOR DEBUG
                self.root.event_generate("<<RingingOff>>")
                self.in_call()
                break

            # branch out to 'cancelled'. This applies to calls not being timely answered too.
            # 'CSeq: 2' = Convo, 'CSeq: 1' = Sorenson, and 'CSeq: 102' = Purple/ZVRS
            elif (self.payload_found(self.next_payload, "SIP/2.0 200 OK",
                                     "CSeq: 2 CANCEL")
                  or self.payload_found(self.next_payload, "SIP/2.0 200 OK",
                                        "CSeq: 1 CANCEL")
                  or self.payload_found(
                      self.next_payload, "SIP/2.0 200 OK",
                      "CSeq: 102 CANCEL")) or self.ring_has_timed_out:
                print("The call has been cancelled before you can answer."
                      )  # UNCOMMENT FOR DEBUG
                self.call_status = "WAITING"
                self.root.event_generate("<<RingingOff>>")
                break

            # branch out to 'busy'
            elif self.payload_found(self.next_payload,
                                    "SIP/2.0 486 Busy Here"):
                print("Okay! We see you're busy. :) ")  # UNCOMMENT FOR DEBUG
                self.call_status = "WAITING"
                self.root.event_generate("<<RingingOff>>")
                break

            elif self.payload_found(self.connecting_payload(),
                                    "SIP/2.0 180 Ringing"):
                # ring for new inbound call in case of network disconnection and reconnection while ringing
                self.root.event_generate("<<RingingOff>>")
                self.ringing()

    def in_call(self):
        # process "keep-alive" payload in while loop. If not, call session has timed out
        self.call_status = "IN_CALL"
        self.root.event_generate("<<SessionOn>>")
        print("Call session has begun at", time())  # UNCOMMENT FOR DEBUG

        self.session_timeout = time() + 1

        while self.call_status == "IN_CALL":
            # just process the sniff() function in connected_payload() as it appears an UDP packet
            # with IP header total length of exactly 200 bytes may be very unique to RTP traffic

            # exit the program if main thread is terminated
            if not main_thread().is_alive():
                sys.exit(1)

            # resume to listen for new incoming call if session terminated
            if time() >= self.session_timeout:
                print("Call session has timed out at ",
                      time())  # UNCOMMENT FOR DEBUG
                self.call_status = "WAITING"

            # extend timeout value as long as there exists a keepalive packet
            if self.has_session_keepalive_packet():
                self.session_timeout = time() + 1

        self.root.event_generate("<<SessionOff>>")

###### END OF PAYLOAD PROCESSING ######
#
###### BEGINNING OF GUI BUILDING ######

    def create_flasher_ui(self):
        self.flash_widget = Toplevel(master=self.root)
        self.flash_widget.title("")
        self.flash_widget_width = self.flash_widget.winfo_screenwidth()
        self.flash_widget_height = self.flash_widget.winfo_screenheight()
        self.flash_widget.wm_resizable(width=False, height=False)
        # self.flash_widget.configure(background='#76B53E') # green flashing widget
        self.flash_widget.configure(background='Blue')  # blue flashing widget
        self.flash_widget.attributes('-alpha', 0.7)
        self.flash_widget.geometry("0x0+0+0")
        self.flash_widget.protocol("WM_DELETE_WINDOW", self.terminate_program)

    def flashing_widget(self):
        self.flash_widget.after(
            100, self.flash_widget.geometry,
            "{0}x{1}+0+0".format(self.flash_widget_width,
                                 self.flash_widget_height))
        self.flash_widget.after(200, self.flash_widget.geometry, "0x0+0+0")
        self.flash_widget.after(300, self.flashing_widget)

    def create_in_call_ui(self):
        self.in_call_widget = Toplevel(master=self.root)
        self.in_call_widget.title("CALL IN SESSION")
        self.in_call_widget.attributes('-alpha', 0.8)
        self.in_call_widget_width = int(
            self.in_call_widget.winfo_screenwidth() / 4.5)
        self.in_call_widget_height = int(
            self.in_call_widget.winfo_screenheight() / 4)
        self.in_call_widget.geometry("{0}x{1}+0+0".format(
            self.in_call_widget_width, self.in_call_widget_height))
        self.in_call_widget.wm_resizable(width=False, height=False)
        self.in_call_widget.protocol("WM_DELETE_WINDOW",
                                     self.terminate_program)

        # create a label inside the widget
        self.in_call_text = Label(self.in_call_widget, text="CALL IN SESSION")
        self.in_call_text.configure(
            font=("TkDefaultFont", 20, "bold"),
            foreground="white",
            background="red",
        )
        self.in_call_text.pack(fill=BOTH, expand=1)

###### END OF GUI BUILDING ######
#
###### BEGINNING OF EVENT BINDING ######

    def ringing_triggered(self, event):
        self.create_flasher_ui()
        self.flashing_widget()

    def ringing_terminated(self, event):
        self.flash_widget.destroy()

    def call_in_session(self, event):
        self.create_in_call_ui()

    def session_terminated(self, event):
        self.in_call_widget.destroy()

###### END OF EVENT BINDING ######
#
###### BEGINNING OF MISCELLANEOUS FUNCTIONS ######

    def terminate_program(self):
        sys.exit(1)
Пример #20
0
class GUI(object):
    def __init__(self):
        self.root = tkinter.Tk()
        self.root.title("区块链价格预测系统")
        self.root.geometry('370x370')
        self.dataGet_button = tkinter.Button(self.root,
                                             command=self.dataGet,
                                             text='最新数据',
                                             width=25,
                                             height=3)
        self.dataAnalysis_button = tkinter.Button(self.root,
                                                  command=self.dataAnalysis,
                                                  text='分析数据',
                                                  width=25,
                                                  height=3)
        self.PricePredict_button = tkinter.Button(self.root,
                                                  command=self.Predict,
                                                  text='价格预测',
                                                  width=25,
                                                  height=3)

    def GuiArrang(self):
        self.dataGet_button.place(x=100, y=50)
        self.dataAnalysis_button.place(x=100, y=120)
        self.PricePredict_button.place(x=100, y=190)

    def dataGet(self):
        self.top = Toplevel()
        self.top.title = ('数据获取')
        self.top.geometry('600x700')
        tmp = None

        def arrang():
            currency1Chosen.place(x=60, y=20)
            currency1Chosen.current(0)
            currency2Chosen.place(x=280, y=20)
            currency2Chosen.current(0)
            label_to.place(x=220, y=20)
            Submit_button.place(x=400, y=20)
            Drawing_button.place(x=500, y=20)
            self.tree.column("a", width=125, anchor="center")
            self.tree.column("b", width=100, anchor="center")
            self.tree.column("c", width=100, anchor="center")
            self.tree.column("d", width=100, anchor="center")
            self.tree.column("e", width=100, anchor="center")
            self.tree.heading("a", text="订单时间")
            self.tree.heading("b", text="买卖类型")
            self.tree.heading("c", text="币种单价")
            self.tree.heading("d", text="成交币种数量")
            self.tree.heading("e", text="订单总额")
            self.tree.place(x=38, y=80)
            vbar.place(x=695, y=30, height=550)

        def dataCrawl():
            rootUrl = 'https://data.gateio.co/api2/1/tradeHistory/'
            currency1.get()
            url = rootUrl + currency1.get() + '_' + currency2.get()
            browsers = requests.get(url).json()
            items = None
            if (browsers["result"] == "true"):
                items = browsers["data"]
            else:
                messagebox.showinfo(title='error', message='Please Retry')
            for _ in map(self.tree.delete, self.tree.get_children("")):
                pass
            for item in items:
                self.tree.insert("",
                                 "end",
                                 values=(item["date"], item["type"],
                                         item["rate"], item["amount"],
                                         item["total"]))
            Drawing_button['state'] = 'active'

        def dataDrawing():
            messagebox.showinfo(title='Waiting~', message='I am drawing!')

        currency1 = tkinter.StringVar()
        currency2 = tkinter.StringVar()
        currency1Chosen = ttk.Combobox(self.top,
                                       width=12,
                                       textvariable=currency1)
        currency1Chosen['values'] = ('eth', 'btc')
        label_to = tkinter.Label(self.top, text='to')
        currency2Chosen = ttk.Combobox(self.top,
                                       width=12,
                                       textvariable=currency2)
        currency2Chosen['values'] = ('usdt', 'cnyx')
        Submit_button = tkinter.Button(self.top,
                                       command=dataCrawl,
                                       text='开始抓取')
        Drawing_button = tkinter.Button(self.top,
                                        command=dataDrawing,
                                        text='绘制图表',
                                        state='disabled')
        self.tree = ttk.Treeview(self.top,
                                 show="headings",
                                 height=28,
                                 columns=("a", "b", "c", "d", "e"))
        vbar = ttk.Scrollbar(self.tree,
                             orient='vertical',
                             command=self.tree.yview)
        self.tree.configure(yscrollcommand=vbar.set)
        arrang()

    def Predict(self):
        self.top = Toplevel()
        self.top.title = ('数据获取')
        self.top.geometry('600x400')
        ave_price_show = tkinter.StringVar()
        origin_price_data_show = tkinter.StringVar()
        predicted_price_show = tkinter.StringVar()
        self.i = 0

        def price_predict():
            url = 'https://data.gateio.co/api2/1/tradeHistory/btc_usdt'
            data = []
            load_btc_data(url, data)
            data_process(data)
            origin_price_data = copy.deepcopy(np.array(data).T[1])
            # 对数据归一化
            new_btc_data, max, min = data_nornalization(data)
            new_btc_data = np.array(new_btc_data).reshape((1, 80, 4))
            ave_price = origin_price_data.mean()
            # 预测价格
            result = predict(new_btc_data)
            predicted_price = result[0][0] * (max[1] - min[1]) + min[1]
            ave_price_show.set('最新80笔交易的平均价格:' + str(ave_price))
            origin_price_data_show.set('当前最新价格:' + str(origin_price_data[-1]))
            predicted_price_show.set('预测的下一次交易的价格:' + str(predicted_price))
            print('最新80笔交易的平均价格:{}'.format(ave_price))
            print('当前最新价格:{}'.format(origin_price_data[-1]))
            print('预测的下一次交易的价格:{}'.format(predicted_price))
            # 可视化
            l1 = range(1, len(origin_price_data) + 1)
            plt.figure()
            plt.plot(l1, origin_price_data, 'b-', color='blue')
            l2 = [80, 81]
            predict_data = [origin_price_data[-1], predicted_price]
            plt.plot(l2, predict_data, 'b-o', color='red')
            image_name = 'predict\predicted_price' + str(self.i) + '.png'
            self.i += 1
            plt.savefig(image_name)
            image = self.Png_To_Gif(image_name)
            self.imgLabel.config(image=image)
            self.imgLabel.image = image
            self.top.update_idletasks()
            self.top.after(100)

        B = tkinter.Button(self.top, text='预测下一次交易的价格', command=price_predict)
        B.pack()
        l_ave_price = tkinter.Label(self.top, textvariable=ave_price_show)
        l_origin_price_data = tkinter.Label(
            self.top, textvariable=origin_price_data_show)
        l_predicted_price = tkinter.Label(self.top,
                                          textvariable=predicted_price_show)
        self.imgLabel = tkinter.Label(self.top)
        l_ave_price.pack()
        l_origin_price_data.pack()
        l_predicted_price.pack()
        self.imgLabel.pack()

    def Png_To_Gif(self, image_name):
        image = Image.open(image_name)
        (x, y) = image.size
        x_s = int(x / 2)
        y_s = int(y / 2)
        image = image.resize((x_s, y_s), Image.ANTIALIAS)
        image = ImageTk.PhotoImage(image)
        return image

    def dataAnalysis(self):
        self.top = Toplevel()
        self.top.title = ('数据分析')
        self.top.geometry('700x700')
        canvas = tkinter.Canvas(self.top,
                                width=800,
                                height=800,
                                scrollregion=(0, 0, 1400, 1400))  # 创建canvas
        canvas.place(x=0, y=0)  # 放置canvas的位置
        frame = tkinter.Frame(canvas, width=1400,
                              height=1400)  # 把frame放在canvas里
        frame.place(x=0, y=0)  # frame的长宽,和canvas差不多的
        vbar = tkinter.Scrollbar(canvas, orient='vertical')  # 竖直滚动条
        vbar.place(x=680, width=20, height=700)
        vbar.configure(command=canvas.yview)
        canvas.config(yscrollcommand=vbar.set)  # 设置
        image1 = self.Png_To_Gif('data_analyse\\all_trade_all.png')
        image2 = self.Png_To_Gif('data_analyse\\all_trade_big_volume.png')
        image3 = self.Png_To_Gif('data_analyse\\buy_all.png')
        image4 = self.Png_To_Gif('data_analyse\\buy_big_colume.png')
        image5 = self.Png_To_Gif('data_analyse\\sell_all.png')
        image6 = self.Png_To_Gif('data_analyse\\sell_big_volume.png')
        image7 = self.Png_To_Gif('data_analyse\\list1.png')
        image8 = self.Png_To_Gif('data_analyse\\list2.png')
        self.img_label1 = tkinter.Label(frame, image=image1)
        self.img_label2 = tkinter.Label(frame, image=image2)
        self.img_label3 = tkinter.Label(frame, image=image3)
        self.img_label4 = tkinter.Label(frame, image=image4)
        self.img_label5 = tkinter.Label(frame, image=image5)
        self.img_label6 = tkinter.Label(frame, image=image6)
        self.img_label7 = tkinter.Label(frame, image=image7)
        self.img_label8 = tkinter.Label(frame, image=image8)
        self.img_label1.image = image1
        self.img_label2.image = image2
        self.img_label3.image = image3
        self.img_label4.image = image4
        self.img_label5.image = image5
        self.img_label6.image = image6
        self.img_label7.image = image7
        self.img_label8.image = image8
        self.img_label1.place(x=0, y=0)
        self.img_label2.place(x=350, y=0)
        self.img_label3.place(x=0, y=250)
        self.img_label4.place(x=350, y=250)
        self.img_label5.place(x=0, y=500)
        self.img_label6.place(x=350, y=500)
        self.img_label7.place(x=0, y=750)
        self.img_label8.place(x=0, y=860)
        text = '从上面的六个图和两个价格差的对比表格可以明显看出:\n' \
               '在所有交易中,所有交易平均的价格差方差为75.5788,而大额交易的价格差方差为78.9996,由此可以看出大额交易使得价格的变化波动加剧,但总体来说对价格的变化并不是很明显,交易后比交易前价格平均上升0.20左右。但对买入和卖出的交易分别分析。可以发现,大额交易对价格有非常明显的影响。\n' \
               '在买入交易中,平均的价格差方差为151.0677而大额交易前后的价格差方差达到了163.9778。可见在买入交易中,大额交易前后价格的波动加剧。而在价格差平均值方面,所有买入的交易前后价格差基本没变化,而在大额交易后,价格上升了0.31。由此可以发现:\n' \
               '大额买入显著提升了比特币的价格。\n' \
               '在卖出交易中,平均的价格差方差为155.8411而大额交易前后的价格差方差达到了166.9491。可见在卖出交易中,大额交易前后价格的波动加剧。而在价格差平均值方面,两者的价格差也基本持平。\n' \
               '最终我们得出结论: 大额交易使得交易价格的波动加剧,而大额交易对价格的影响主要体现在买入交易中,大额买入显著提升了比特币的价格。\n'
        label1 = tkinter.Label(frame,
                               text=text,
                               width=800,
                               height=30,
                               wraplength=600,
                               justify='left',
                               anchor='nw')
        label1.place(x=0, y=980)
        canvas.create_window((700, 700), window=frame)
Пример #21
0
def report_webcam_csv(csv_name,
                      confidence,
                      model_checkpoint='models',
                      classifier='models/your_model.pkl',
                      video_file=None,
                      output_file=None):
    start_1 = time.time()
    global lst_student
    lst_student = []
    time_per_student = []

    # Set fps
    frame_interval = 3  # Number of frames after which to run face detection
    fps_display_interval = 5  # seconds
    frame_rate = 0
    frame_count = 0

    if video_file is not None:
        video_capture = cv2.VideoCapture(video_file)
    else:
        # Use internal camera
        video_capture = cv2.VideoCapture(0)
    ret, frame = video_capture.read()
    width = frame.shape[1]
    height = frame.shape[0]
    if output_file is not None:
        video_format = cv2.VideoWriter_fourcc(*'XVID')
        out = cv2.VideoWriter(output_file, video_format, 20, (width, height))
    face_recognition = Recognition(model_checkpoint, classifier)
    start_time = time.time()
    colors = np.random.uniform(0, 255, size=(1, 3))
    while True:
        # Capture frame-by-frame
        ret, frame = video_capture.read()
        image_1 = create_blank_image(500, height)

        if (frame_count % frame_interval) == 0:
            faces = face_recognition.identify(frame)
            for i in range(len(colors), len(faces)):
                colors = np.append(colors,
                                   np.random.uniform(150, 255, size=(1, 3)),
                                   axis=0)
            # Check our current fps
            end_time = time.time()
            if (end_time - start_time) > fps_display_interval:
                frame_rate = int(frame_count / (end_time - start_time))
                start_time = time.time()
                frame_count = 0

        add_overlays_webcam_report(frame,
                                   faces,
                                   frame_rate,
                                   colors,
                                   confidence=confidence)

        frame_count += 1

        # Want to save?
        if len(faces) == 1:
            if faces[0].prob > confidence:
                if faces[0].name not in lst_student:
                    start_rp = time.time()
                    top_resp = Toplevel()
                    top_resp.after(3000, top_resp.destroy)
                    #print(faces[0].name)
                    #print(type(faces[0].name)): string
                    #response = messagebox.askyesno("Face detected", faces[0].name + "\n" + "Want to save?")
                    response = messagebox.askyesno("Face detected",
                                                   faces[0].name,
                                                   parent=top_resp,
                                                   default="yes")
                    if response:
                        top_resp.destroy()
                        lst_student.append(faces[0].name)
                        add_to_csv(faces[0].name, csv_name)
                        end_rp = time.time()
                        print("Time per student:", end_rp - start_rp)
                        time_per_student.append(end_rp - start_rp)

        if len(lst_student) >= 1:
            if len(lst_student) > 5:
                add_to_blank_frame(image_1,
                                   list(enumerate(lst_student, start=1))[-5:])
            else:
                add_to_blank_frame(image_1,
                                   list(enumerate(lst_student, start=1)))

        if video_file is not None:
            frame75 = rescale_frame(frame, percent=75)
            cv2.imshow('Video', frame75)
        else:
            final = cv2.hconcat([frame, image_1])
            #cv2.imshow('Video', frame)
            cv2.imshow('Video', final)
        if output_file is not None:
            out.write(frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    # When everything is done, release the capture
    if output_file is not None:
        out.release()
    video_capture.release()
    cv2.destroyAllWindows()
    end_1 = time.time()
    print("Time per student:", time_per_student)
    print('Total Execute time:', end_1 - start_1)
Пример #22
0
class MainWindow:
    def __init__(self, rally_configuration, server_conn, running_as_exe):
        self.running_as_exe = running_as_exe
        self.subprocess_communicator = SubProcessCommunicator(server_conn)
        self.subprocess_communicator.start()
        self.server_connection = server_conn
        # server_conn.report_lost_connection = self.on_lost_connection
        # server_conn.message_receiver = self.on_message_received
        self.rally_configuration = rally_configuration
        self.sub_processes = SubProcesses(self.subprocess_communicator, self.rally_configuration, self.running_as_exe, self.server_connection.temporary_config_file)
        self.positions_map = {"Utanför bussen": 0,
                              "Förare": 1,
                              "Kartläsare": 2,
                              "Fram höger": 3,
                              "Mitten vänster": 4,
                              "Protokollförare": 5,
                              "Mitten höger": 6,
                              "Bak vänster": 7,
                              "Bak mitten": 8,
                              "Bak höger": 9}
        self.all_positions = ["Utanför bussen",
                              "Förare",
                              "Kartläsare",
                              "Fram höger",
                              "Mitten vänster",
                              "Protokollförare",
                              "Mitten höger",
                              "Bak vänster",
                              "Bak mitten",
                              "Bak höger"]
        self.main_window = None
        self.combo_select_seating = None
        self.placing_label = None
        self.placing_button = None
        self.rebus_button = None
        self.seats = []
        self.messages_text = None
        self.minibus_img = None

        self.layout()

        self.server_connection.start_client_loop(self.on_lost_connection, self.on_message_received, self.subprocess_communicator)

    def run(self):
        self.main_window.mainloop()
        if self.main_window is not None:
            self.main_window.destroy()

    def layout(self):
        self.main_window = Toplevel()
        #self.main_window.withdraw()
        self.main_window.title(self.rally_configuration.title)

        self.minibus_img = ImageTk.PhotoImage(Image.open("minibus.png"))
        w2 = self.minibus_img.width()
        h2 = self.minibus_img.height()

        f_bus = Frame(self.main_window, width=w2, height=480)
        background_label2 = Label(f_bus, image=self.minibus_img)
        # background_label2.place(x=0, y=0, relwidth=1, relheight=1)
        background_label2.grid(row=0, column=0, sticky=N)
        f_bus.grid(row=0, column=0, sticky=N)

        f_placing = Frame(f_bus)
        self.placing_label = Label(f_placing, text="Välj plats i bussen:")
        self.placing_label.grid(row=0, column=0)
        self.combo_select_seating = Combobox(f_placing, values=self.all_positions)
        self.combo_select_seating.current(0)
        self.combo_select_seating.grid(row=1, column=0)
        self.combo_select_seating.bind("<<ComboboxSelected>>", self.on_placing_cb_changed)
        f_placing.grid(row=1, column=0, sticky=N)

        self.placing_button = Button(f_placing, command=self.on_select_placing, text="Aktivera vald plats i bussen")
        self.placing_button.grid(row=2, column=0)
        self.rebus_button = Button(f_placing, command=self.on_search_for_rebus, text="Leta efter rebuskontroll här")
        self.rebus_button.grid(row=3, column=0)

        seat1 = Label(background_label2, text="")
        seat1.place(x=35, y=130)
        seat2 = Label(background_label2, text="")
        seat2.place(x=75, y=150)
        seat3 = Label(background_label2, text="")
        seat3.place(x=110, y=170)

        seat4 = Label(background_label2, text="")
        seat4.place(x=35, y=195)
        seat5 = Label(background_label2, text="")
        seat5.place(x=75, y=215)
        seat6 = Label(background_label2, text="")
        seat6.place(x=110, y=235)

        seat7 = Label(background_label2, text="")
        seat7.place(x=35, y=270)
        seat8 = Label(background_label2, text="")
        seat8.place(x=75, y=290)
        seat9 = Label(background_label2, text="")
        seat9.place(x=110, y=310)

        self.seats = [None, seat1, seat2, seat3, seat4, seat5, seat6, seat7, seat8, seat9]

        self.messages_text = Text(self.main_window, height=40, width=45)
        self.messages_text.grid(row=0, column=1)

        self.main_window.protocol("WM_DELETE_WINDOW", self.close_main_window)

        self.main_window.after(1, self.update_main_gui)

    def on_placing_cb_changed(self, data):
        position_value = self.positions_map[self.combo_select_seating.get()]
        #global server_connection
        client_to_server = clientprotocol_pb2.ClientToServer()
        client_to_server.select_seat.SetInParent()
        client_to_server.select_seat.user_id = self.server_connection.status_information.user_id
        client_to_server.select_seat.seat_index = position_value
        # print("Send message")
        self.server_connection.send_message_to_server(client_to_server)

    def on_select_placing(self):
        self.sub_processes.stop_processes()
        self.sub_processes.start_processes(self.server_connection.status_information.get_my_seat())

    def on_search_for_rebus(self):
        client_to_server = clientprotocol_pb2.ClientToServer()
        client_to_server.search_for_rebus.SetInParent()
        client_to_server.search_for_rebus.dummy = 0;
        self.server_connection.send_message_to_server(client_to_server)
        self.rebus_button["text"] = "Letar efter rebus"
        self.rebus_button["state"] = "disabled"

    def update_main_gui(self):
        speed = self.server_connection.get_current_speed()
        locked = speed != 0
        state = "normal"
        if locked:
            state = "disabled"
            self.placing_label["text"] = "Bussen står inte stilla"
        else:
            self.placing_label["text"] = "Välj plats i bussen:"
        if self.server_connection.status_information.looking_for_rebus:
            self.rebus_button["text"] = "Letar efter rebuskontroll"
            self.rebus_button["state"] = "disabled"
        else:
            self.rebus_button["text"] = "Leta efter rebuskontroll här"
            self.rebus_button["state"] = state
        self.combo_select_seating["state"] = state

        for i in range(1, 10):
            self.seats[i]["text"] = self.server_connection.status_information.seating[i].name

        self.main_window.after(1000, self.update_main_gui)

    def on_message_received(self, bc_message):
        # global messages_text
        if bc_message.HasField("date_time"):
            self.messages_text.insert(END, bc_message.date_time + "\n")
        if bc_message.HasField("message"):
            self.messages_text.insert(END, bc_message.message + "\n\n")
        self.messages_text.yview_pickplace("end")
        self.main_window.bell()

    def close_main_window(self):
        self.sub_processes.stop_processes()
        self.server_connection.stop()
        if self.main_window is not None:
            self.main_window.quit()
        self.main_window = None

    def on_lost_connection(self):
        if self.main_window is not None:
            try:
                messagebox.showerror("Förlorad koppling", "Förlorade kopplingen till servern", parent=self.main_window)
            except:
                pass
        self.close_main_window()
Пример #23
0
class Timer:
	def __init__(self,pump,rate_vol_pairs,times,master,units):
		
		self.root = Toplevel(master)
		#Check file path and make directories
		self.path = "C:\\Users\\dkhlab\\Documents\\Experiments"+"\\"+time.asctime().replace(":","-")
		
		self.pump = pump
		self.units = units
		self.times = times
		self.rate_vol_pairs =rate_vol_pairs
		self.pump.sendRun(self.rate_vol_pairs,units)
		self.root.geometry("400x200")
		self.start_time = time.time()
		self.on = True
		self.elapsed_time = 0 
		self.root
		self.pause_time = 0
		self.resume_time = None
		self.m = 0
		self.s = 0
		self.count = 0       
		self.label = Label(self.root,text="", font=("Helvetica 35 bold"))
		q=Button(self.root , text='Close Window', command=self.root.destroy)
		pb=Button(self.root , text='Pause Experiment', command=self.Pause)
		rb = Button(self.root , text='Resume Experiment', command=self.Resume)
		self.label.place(x=160,y=10)
		pb.place(x=25,y=100)
		rb.place(x=150,y=100)
		q.place(x=300,y=100)
		os.mkdir(self.path)
		self.vid = Video(self.path)
		self.Update()
		self.root.mainloop()
	
	#Updates the displayed timer
	def Update(self,timePaused=0):
		
		if self.on:
			self.elapsed_time =  time.time() - self.start_time - timePaused
			t = self.elapsed_time
			self.m = int(t/60)
			self.s = round(t%60)
			if round(t) in self.times:
				#takePic(self.path,self.count)
				self.count += 1
			if self.s <10:
				txt = f"{self.m}:0{self.s}"
			else:
				txt = f"{self.m}:{self.s}"
			self.label.configure(text=txt)
			self.root.after(1000,self.Update)
	
	#Pauses Timer
	def Pause(self):
		self.on = False
		self.pause_time = time.time()
		self.pump.Pause()
		self.vid.pause()
	#Resumes Timer
	def Resume(self):
		
		if self.on is False:
			self.on = True
			timePaused = time.time()- self.pause_time
			self.Update(timePaused)
			self.pump.Resume()
			self.vid.play()