def main():
    global drawing_area

    root = Tk()
    root.title("Drawer")
    drawing_area = Canvas(root, width=300, height=300, bg="white")

    # Binding Events to the canvas
    drawing_area.bind("<B1-Motion>", drag)
    drawing_area.bind("<ButtonRelease-1>", drag_end)
    drawing_area.pack()

    # Buttons
    # Quit Button
    b1 = Button(root, text="Quit")
    b1.pack()
    b1.bind("<Button-1>", quit)

    # Clear Button
    b2 = Button(root, text="Clear")
    b2.pack()
    b2.bind("<Button-1>", clear)

    # Save Button
    b3 = Button(root, text="Save")
    b3.pack()
    b3.bind("<Button-1>", save)
    root.mainloop()
 def __init__(self):
     Tk.__init__(self)
     self.title("Speed Reader")
     main_frame = MainFrame(master=self)
     self.grid_columnconfigure(0, weight=1)
     self.grid_rowconfigure(0, weight=1)
     main_frame.grid(padx=50, pady=50, sticky=(N, S, E, W))
Example #3
0
class New_Doc():

	def __init__(self):
		self.master = Tk()
		Label(self.master, text="Square_size:").grid(row=0)
		Label(self.master, text="Number of Squares Horizonal").grid(row=1)
		Label(self.master, text="Number of Squares Vertical").grid(row=2)
		self.e1 = Entry(self.master)
		self.e2 = Entry(self.master)
		self.e3 = Entry(self.master)
		self.e1.grid(row=0, column=1)
		self.e2.grid(row=1, column=1)
		self.e3.grid(row=2, column=1)
		Tkinter.Button(self.master, text='OK', 
				command = self.show_entry_fields).grid(row=3,
				column = 0, 
				sticky = W, 
				pady = 4)
		Tkinter.Button(self.master, text='Cancel', 
				command = self.master.destroy).grid(row=3, 
				column = 1, 
				sticky = W, 
				pady = 4)
		mainloop()

	def show_entry_fields(self):
		puzzle = Square_Puzzle(int(self.e1.get()), int(self.e2.get()), int(self.e3.get()))
		self.master.destroy()
		Edit_Doc(puzzle)
Example #4
0
File: cfg.py Project: gijs/nltk
def demo():
    from nltk import Nonterminal, parse_cfg
    nonterminals = 'S VP NP PP P N Name V Det'
    (S, VP, NP, PP, P, N, Name, V, Det) = [Nonterminal(s)
                                           for s in nonterminals.split()]
    
    grammar = parse_cfg("""
    S -> NP VP
    PP -> P NP
    NP -> Det N
    NP -> NP PP
    VP -> V NP
    VP -> VP PP
    Det -> 'a'
    Det -> 'the'
    Det -> 'my'
    NP -> 'I'
    N -> 'dog'
    N -> 'man'
    N -> 'park'
    N -> 'statue'
    V -> 'saw'
    P -> 'in'
    P -> 'up'
    P -> 'over'
    P -> 'with'
    """)

    def cb(grammar): print grammar
    top = Tk()
    editor = CFGEditor(top, grammar, cb)
    Label(top, text='\nTesting CFG Editor\n').pack()
    Button(top, text='Quit', command=top.destroy).pack()
    top.mainloop()
Example #5
0
def main():
    tk = Tk()

    menuBar = Pmw.MainMenuBar(tk)

    def command():
        print('Pressed')

    menuBar.addmenu('File', 'File')

    menuBar.addmenuitem(
        'File', 'command', 'Close',
        command=command,
        label='Close'
    )

    insertmenuitem(
        menuBar,
        'File', 'command', 'Open',
        command=command,
        index=0,
        label='Open'
    )

    tk.configure(menu=menuBar)

    tk.mainloop()
Example #6
0
def main(posts = Search.FrontPage()):
	
	#main window
	root = Tk()
	root.geometry("600x300+300+300")
	app = GUI(root,posts)
	root.mainloop()
Example #7
0
def gain_focus():
    t = Tk()
    t.destroy()
    find_cmd_str = 'ps -o command | grep "%s"'%__file__
    find_results = Popen(find_cmd_str, shell=True, stdout=PIPE).stdout.read()
    py_path = search('(.*Python\.app)', find_results).groups()[0]
    Popen(['open',py_path])
Example #8
0
def main(): 
    queue = Queue.Queue()
    parent = Tk()
    musicplayer1 = musicplayer.MusicPlayer()    
    gui = Example(parent, queue, musicplayer1)
    #client.endApplication()
    parent.mainloop()  
 def __init__(self):
     #Creating main window. And initializing components
     Tk.__init__(self)
     f = Frame(self, width=400, height=200)
     f.pack(expand=True)
     #Blank labels are added to make window alignment  better
     Label(f,text="").grid(row=0)
     #Blank labels are added to make window alignment  better
     Label(f,text="  ").grid(row=1,column=0)
     #Add label fileName
     Label(f,text="File Name").grid(row=1,column=1)
     #Adding text box
     self.textbox1=Entry(f,width=20)
     self.textbox1.grid(row=1,column=2)
     #Adding file Browse button. Set its even handler as openFileBrowser()
     Button(f,text="Choose File",command=self.openFileBrowser).grid(row=1,column=3)
     #Blank labels are added to make window alignment  better
     Label(f,text="  ").grid(row=1,column=4)
     #Blank labels are added to make window alignment  better
     Label(f,text="").grid(row=2)
     #Adding Summarize button. Set its even handler as summarize()
     Button(f,text="Summarize",command=self.summarize).grid(row=3,column=2)
     #Adding frame to window
     f.pack_propagate(0)
     #Set window title
     self.title("Auto Text Summarizer")
     self.mainloop()
def main():

	root=Tk()
	root.geometry("250x150+300+300")
	app=GUI(root)
	app.mainloop()
	pass
Example #11
0
    def directions_window():
        directions_window = Tk()
        directions_window.title("How To Operate The Board")

        label = Label(directions_window, text="Left Click to pick a piece \n Right Click to place the piece", height=20,
                      width=50)
        label.pack()
Example #12
0
 def main():
     global self, root
   
     root = Tk()
     root.geometry("800x800+0+0")
     self = at_graph(root)
     self.pack(fill=BOTH, expand=1)
Example #13
0
def test_tabs():
    a = Tk()
    n = Notebook( a, TOP )

    # uses the Notebook's frame
    f1 = Frame( n() )
    b1 = Button( f1, text="Ignore me" )
    e1 = Entry( f1 )
    # pack your widgets before adding the frame 
    # to the Notebook (but not the frame itself)!
    b1.pack( fill=BOTH, expand=1 )
    e1.pack( fill=BOTH, expand=1 )

    # keeps the reference to the radiobutton (optional)
    x1 = n.add_screen( f1, "Tab 1" )

    f2 = Frame( n() )
    # this button destroys the 1st screen radiobutton
    b2 = Button( f2, text='Remove Tab 1', command=lambda:x1.destroy() )
    b3 = Button( f2, text='Beep...', command=lambda:Tk.bell( a ) )
    b2.pack( fill=BOTH, expand=1 )
    b3.pack( fill=BOTH, expand=1 )

    f3 = Frame( n() )


    n.add_screen( f2, "Tab 2" )
    n.add_screen( f3, "Minimize" )
    a.mainloop()
Example #14
0
class ColonistGame(object):
    def __init__(self):
        pass

    def initialize_game(self):
        #initialize model instances
        print "initialize game"
        self.model_instance = GameModel()
        for colonist in self.model_instance.colonistlist:
            print colonist.get_name()

        self.root = Tk()
        self.app = GameScreen(self.root, game_instance)
        self.root.mainloop()
        self.app.update_screen()

    def next_turn(self):
        """
        Model update
        """
        self.model_instance.resolve_turn_phase()

        """
        Screen update
        """
        self.app.update_screen()

        print "Next turn"
Example #15
0
class DataViewDialog:
	"""Manages the windows and initialization for creating a box to display the entire
	   data set at once."""

##### Initialization ####################################################################

	def __init__( self, filename, data ):
		"""Initializes the data view window."""
		self.root = Tk()
		self.root.title(filename)
		self.root.geometry('1024x768')
		
		# Create the scrollbar UI widgets
		scrollbarY = tk.Scrollbar(self.root)
		scrollbarY.pack(side=tk.RIGHT, fill=tk.Y)
		scrollbarX = tk.Scrollbar(self.root, orient=tk.HORIZONTAL)
		scrollbarX.pack(side=tk.BOTTOM, fill=tk.X)

		# Adds the text object to the window and makes it un-editable.
		w = tk.Text(self.root, wrap=tk.NONE, yscrollcommand=scrollbarY.set, xscrollcommand=scrollbarX.set, font='courier 12 bold')
		w.insert(tk.INSERT, data)
		w.config( state=tk.DISABLED )
		w.pack( expand=1, fill=tk.BOTH) 
		
		# Activate the scrollbars for their respective views.
		scrollbarY.config(command=w.yview)
		scrollbarX.config(command=w.xview)
Example #16
0
class TK_Framework(object):
    def __init__(self):
        self.root = Tk()

        # list of open windows
        self.windows = {'main':self.root}

        # setup the overall style of the gui
        self.style = Style()
        self.style.theme_use('clam')

    def get_window(self,name):
        return self.windows[name]

    def create_window(self, name):
        self.windows[name] = Toplevel()
    
    
    @staticmethod
    def open_file(init_dir):
        filename = askopenfilename(initialdir=init_dir)
        return filename

    def hide_root(self):
        """Hides the root window"""
        self.root.withdraw()

    def get_root(self):
        return self.root
Example #17
0
 def run(self):
     """
     Runs the music stand.
     
     This method will not return until the application exits.
     """
     
     callbacks = dict(song_loaded=self._start_song,
         song_stopped=self._abort_song, song_restarted=self._restart_song)
     
     self._capturer.start() # also starts the listener
     self._matcher.start()
     
     try:
         self._running = True
         
         root = Tk()
         self._display = Display(root, callbacks, self._debug)
         
         # run the Tkinter event loop
         root.mainloop()
     except KeyboardInterrupt:
         print
     finally:
         self._running = False
         self._matcher.shutdown()
         self._capturer.stop() # similarly, also stops the listener
Example #18
0
class WelcomeDialog:
	"""Manages the window and initialization for creating a the V.I.O.L.A.S. welcome
	   box."""

##### Initialization ####################################################################

	def __init__( self ):
		"""Initializes the welcome window."""
		self.root = Tk()
		self.root.title('Welcome')
		self.root.geometry('515x350')
		w = tk.Message(self.root, anchor='center',
					text=	"			   Welcome to V.I.O.L.A.S.!\n\n" + 
							"		Visual Information Observation, Logging and Analysis System\n\n" +
							"  Key Features Include:\n\n" +
							"	*Ability to Read in any CSV File\n" +
							"	*Made to Order Graphical Representations\n" +
							"	*Quick and Easy Statistical Computation\n\n" +
							"  How to Use V.I.O.L.A.S:\n\n" +
							"	*Step 1: Under the file menu, use Open to import any csv file. The\n" + 
							"		data will be presented in an easy to read format in the\n" + 
							"		terminal.\n\n" +
							"	*Step 2: Under the graphs menu, one can create either a histogram, a\n" +
							"		scatterplot (4D,3D,2D), or a box plot. Each type of graphical\n" +
							"		representation takes user input in order to create the graph.\n\n" +
							"	*Step 3: Under the calculations menu, one can calculate the mean,\n" +
							"		median, mode, standard deviation, and the range depending on \n" +
							"		the user's wants. \n\n" +
							"	*Step 4: Have fun and immerse yourself in the wonders of \n" +
							"		graphical analysis that this program has to offer!\n\n",
						background='blue', foreground='white', border=0, width=550, font='courier 12 bold')
		w.pack()
def main():

    root = Tk()
    root.geometry("500x350+300+300")
    app = Example(root)
    
    root.mainloop()
Example #20
0
    def __init__(self, input):
        Tk.__init__(self)
        self.input = input

        if sys.platform == "win32":
            self.iconbitmap(bitmap=settings.mainicon)
        else:
            img = ImageTk.PhotoImage(master=self, file=settings.mainicon)
            self.tk.call('wm', 'iconphoto', self._w, img)
        self.resizable(width=FALSE, height=FALSE)

        self.end = None
        self.serialized = dict()

        self.title('Download.am')

        self.ok_element = None
        self.cancel_element = None

        self.bind('<Return>', lambda event: self.unbound_ok())
        self.bind('<Escape>', lambda event: self.unbound_cancel())
        if input.close_aborts:
            self.protocol("WM_DELETE_WINDOW", self.unbound_cancel)
        else:
            self.protocol("WM_DELETE_WINDOW", self.destroy)

        ctx = Context(self, self, input.elements)
        ctx.frame.pack()

        self.wm_attributes("-topmost", 1)
        self.focus_force()
Example #21
0
def points():
    cikis = Tk()
    cikis.title('Puan durumu')
    Label(cikis, text='                 Puan Durumu                 ').pack(pady=15)
    Label(cikis, text='YEŞİL:' + str(greenPoints)).pack(pady=15)
    Label(cikis, text='YELLOW:' + str(yellowPoints)).pack(pady=15)
    Button(cikis, text="EXIT", command=cikis.destroy).pack(side=BOTTOM)
class ABC(Frame):

    def __init__(self,parent=None):
        Frame.__init__(self,parent)
        self.parent = parent
        self.pack() # Pack.config(self)  # same as self.pack()
        ABC.make_widgets(self)
        Button(self, text='Pop1', command=self.dialog1).pack()
        enable = {'ID1050': 0, 'ID1106': 0, 'ID1104': 0, 'ID1102': 0}
        for machine in enable:
            enable[machine] = Variable()
            l = Checkbutton(self, text=machine, variable=enable[machine])
            l.pack()

        self.pack()


    def make_widgets(self):
        self.root = Tk()
        self.root.title("Simple Prog")

    def dialog1(self):
        ans = Dialog(self,
                     title   = 'Title!',
                     text    = 'text'
                               'and text "quotation".',
                     bitmap  = 'questhead',
                     default = 0, strings = ('Yes', 'No', 'Cancel'))
Example #23
0
File: Pinball.py Project: MLDL/rlpy
def run_pinballview(width, height, configuration):
    """

        Changed from original Pierre-Luc Bacon implementation to reflect
        the visualization changes in the PinballView Class.

    """
    width, height = float(width), float(height)
    master = Tk()
    master.title('RLPY Pinball')
    screen = Canvas(master, width=500.0, height=500.0)
    screen.configure(background='LightGray')
    screen.pack()

    environment = PinballModel(configuration)
    environment_view = PinballView(screen, width, height, environment)

    actions = [
        PinballModel.ACC_X,
        PinballModel.DEC_Y,
        PinballModel.DEC_X,
        PinballModel.ACC_Y,
        PinballModel.ACC_NONE]
    done = False
    while not done:
        user_action = np.random.choice(actions)
        environment_view.blit()
        if environment.episode_ended():
            done = True
        if environment.take_action(user_action) == environment.END_EPISODE:
            done = True

        environment_view.blit()
        screen.update()
Example #24
0
    def interactive_ask_diff(self, code, tmpfn, reffn, testid):
        from os import environ
        if 'UNITTEST_INTERACTIVE' not in environ:
            return False

        from Tkinter import Tk, Label, LEFT, RIGHT, BOTTOM, Button
        from PIL import Image, ImageTk

        self.retval = False

        root = Tk()

        def do_close():
            root.destroy()

        def do_yes():
            self.retval = True
            do_close()

        phototmp = ImageTk.PhotoImage(Image.open(tmpfn))
        photoref = ImageTk.PhotoImage(Image.open(reffn))
        Label(root, text='The test %s\nhave generated an different'
              'image as the reference one..' % testid).pack()
        Label(root, text='Which one is good ?').pack()
        Label(root, text=code, justify=LEFT).pack(side=RIGHT)
        Label(root, image=phototmp).pack(side=RIGHT)
        Label(root, image=photoref).pack(side=LEFT)
        Button(root, text='Use the new image -->',
               command=do_yes).pack(side=BOTTOM)
        Button(root, text='<-- Use the reference',
               command=do_close).pack(side=BOTTOM)
        root.mainloop()

        return self.retval
class TestBase(unittest.TestCase):

    def setUp(self):
        self.root = Tk()

    def tearDown(self):
        self.root.destroy()
Example #26
0
def main():
    app = "netconvert"
    appOptions = parse_help(app)
    # appOptions = []
    root = Tk()
    app = Launcher(root, app, appOptions)
    root.mainloop()
Example #27
0
    def interactive_ask_ref(self, code, imagefn, testid):
        from os import environ
        if 'UNITTEST_INTERACTIVE' not in environ:
            return True

        from Tkinter import Tk, Label, LEFT, RIGHT, BOTTOM, Button
        from PIL import Image, ImageTk

        self.retval = False

        root = Tk()

        def do_close():
            root.destroy()

        def do_yes():
            self.retval = True
            do_close()

        image = Image.open(imagefn)
        photo = ImageTk.PhotoImage(image)
        Label(root, text='The test %s\nhave no reference.' % testid).pack()
        Label(root, text='Use this image as a reference ?').pack()
        Label(root, text=code, justify=LEFT).pack(side=RIGHT)
        Label(root, image=photo).pack(side=LEFT)
        Button(root, text='Use as reference', command=do_yes).pack(side=BOTTOM)
        Button(root, text='Discard', command=do_close).pack(side=BOTTOM)
        root.mainloop()

        return self.retval
def checkExit():
    root = Tk()
    root.geometry("200x90+300+300")
    app = Escape(root)
    root.mainloop()
    result = app.getStatus()
    return result
Example #29
0
File: drt.py Project: gijs/nltk
    def __init__(self, drs, size_canvas=True, canvas=None):
        """
        :param drs: C{AbstractDrs}, The DRS to be drawn
        :param size_canvas: bool, True if the canvas size should be the exact size of the DRS
        :param canvas: C{Canvas} The canvas on which to draw the DRS.  If none is given, create a new canvas. 
        """
        master = None
        if not canvas:
            master = Tk()
            master.title("DRT")
    
            font = Font(family='helvetica', size=12)
            
            if size_canvas:
                canvas = Canvas(master, width=0, height=0)
                canvas.font = font
                self.canvas = canvas
                (right, bottom) = self._visit(drs, self.OUTERSPACE, self.TOPSPACE)
                
                width = max(right+self.OUTERSPACE, 100)
                height = bottom+self.OUTERSPACE
                canvas = Canvas(master, width=width, height=height)#, bg='white')
            else:
                canvas = Canvas(master, width=300, height=300)
                
            canvas.pack()
            canvas.font = font

        self.canvas = canvas
        self.drs = drs
        self.master = master
Example #30
0
    def __init__(self):

        Tk.__init__(self)

        self.geometry('%dx%d+500+500' % (WIDTH,HEIGHT))
        self.title('GooMPy')

        self.canvas = Canvas(self, width=WIDTH, height=HEIGHT)

        self.canvas.pack()

        self.bind("<Key>", self.check_quit)
        self.bind('<B1-Motion>', self.drag)
        self.bind('<Button-1>', self.click)

        self.label = Label(self.canvas)

        self.radiogroup = Frame(self.canvas)
        self.radiovar = IntVar()
        self.maptypes = ['OSM', 'GoogleSatellite', 'Satellite']
        self.add_radio_button('OSM',  0)
        self.add_radio_button('GoogleSatellite', 1)
        self.add_radio_button('Satellite',    2)

        self.zoom_in_button  = self.add_zoom_button('+', +1)
        self.zoom_out_button = self.add_zoom_button('-', -1)

        self.zoomlevel = ZOOM

        maptype_index = 0
        self.radiovar.set(maptype_index)

        self.goompy = GooMPy(WIDTH, HEIGHT, LATITUDE, LONGITUDE, ZOOM, MAPTYPE)

        self.restart()
Example #31
0
 def __init__(self):
     Tk.__init__(self)
Example #32
0
class WSGui(threading.Thread):  #Word Suggester GUI
    '''
    Creates the GUI when initialized, and allows the word displayed in the
    box to update. The GUI will always be "in-front" of other application
    windows, so that it will always be visible.
    '''
    def __init__(self,
                 bg,
                 corner,
                 dcm,
                 fontsize,
                 txtcolor,
                 Q,
                 height=2,
                 width=40):
        threading.Thread.__init__(self)
        self.root = Tk()

        self.dcm = dcm
        self.q = Q
        self.fg = txtcolor

        # Convert corner string into appropriate newGeometry value for
        # root.geometry(). This functionality is Windows OS specific.
        if corner == "topright":
            newGeometry = "-1+1"
        elif corner == "topleft":
            newGeometry = "+1+1"
        elif corner == "bottomright":
            newGeometry = "-1-1"
        elif corner == "bottomleft":
            newGeometry = "+1-1"
        else:
            raise ValueError("GUI corner string has unrecognized value.")

        # Set the window to always be visible, but be non-interactable
        self.root.wm_attributes("-topmost", 1)
        self.root.overrideredirect(1)

        # Create the variable to store the text to display
        self.textvar = StringVar()

        # Create the label widget to pack into the root window
        self.label = Label(self.root,
                           anchor=CENTER,
                           background=bg,
                           fg=self.fg,
                           font=('', fontsize),
                           textvariable=self.textvar,
                           height=height,
                           width=width)
        self.label.pack(expand=0, fill=None)

        # Place the window where specified by the corner parameter
        self.root.geometry(newGeometry)

        if self.dcm == True:
            self.root.withdraw()

    def run(self):
        self.root.after(1000, self.poll)
        self.root.mainloop()

    def poll(self):
        try:
            word = self.q.get(block=True)
        except Queue.Empty:
            print "THIS SHOULDN'T HAPPEN. CRY DEEPLY THAT I CODED NO REAL \
EXCEPTION HANDLING."

        while not self.q.empty():
            word = self.q.get()
        if type(word) is str:
            if self.dcm == False:
                self.update_word(word)
        elif type(word) is list:
            options_list = word
            self.update_config(options_list)
        elif word == 1:
            self.flash_color()
        elif word == 0:
            self.end()
            return
        if self.dcm != True:
            self.root.after(100, self.poll)
        else:
            self.root.after(2000, self.poll)

    def update_word(self, word):
        #updates the text displayed, changing it to the word string passed in
        self.textvar.set(word)
        self._update_idle()

    def update_config(self, options_l):
        GUI_size, GUI_corner, GUI_bg, GUI_txtcolor, GUI_fontsize, DCM, p_s, spc, p_n = options_l
        if GUI_size == "small":
            GUI_height = 1
            GUI_width = 20
        elif GUI_size == "normal":
            GUI_height = 2
            GUI_width = 40
        elif GUI_size == "large":
            GUI_height = 3
            GUI_width = 60

        if GUI_corner == "topright":
            newGeometry = "-1+1"
        elif GUI_corner == "topleft":
            newGeometry = "+1+1"
        elif GUI_corner == "bottomright":
            newGeometry = "-1-1"
        elif GUI_corner == "bottomleft":
            newGeometry = "+1-1"

        if GUI_fontsize == "small":
            fontsize = 15
        elif GUI_fontsize == "normal":
            fontsize = 25
        elif GUI_fontsize == "large":
            fontsize = 35

        if DCM == True:
            if self.dcm != DCM:
                self.root.withdraw()
        elif DCM == False:
            if self.dcm != DCM:
                self.root.deiconify()
        self.dcm = DCM

        self.fg = GUI_txtcolor

        self.label.config(bg=GUI_bg,
                          fg=self.fg,
                          font=('', fontsize),
                          height=GUI_height,
                          width=GUI_width)

        self.root.geometry(newGeometry)

    def flash_color(self, color="blue", color_opt="black"):
        ''' Sets the text to the color, passed in as a string. '''
        if self.fg != color:
            self.label.config(fg=color)
        else:
            self.label.config(fg=color_opt)
        self._update_idle()
        self.root.after(100, self._reset_color)

    def end(self):
        try:
            self.root.destroy()
        except Exception as e:
            print(e)
            print "ROOT DID NOT DESTROY"

    def _update_idle(self):
        self.root.update_idletasks()

    def _reset_color(self):
        self.label.config(fg=self.fg)
Example #33
0
    yellow = "blue"
    red = "cyan"
    white = "black"
    black = "white"
else:
    grey = "light slate grey"
    green = "green"
    yellow = "yellow"
    red = "red"
    white = "white"
    black = "black"

c_height = 476  #the border lines are approx 2px
c_width = 316  #316

root = Tk()
root.config(width=(c_width - 45), height=c_height, bg=black)
if not testMode:
    root.config(cursor="none")
    root.attributes("-fullscreen",
                    True)  #if not in test mode switch to fullscreen

textFont = tkFont.Font(family="Helvetica", size=36, weight="bold")

# Declare Variables
measuredItems = [
    "RPM", "Water TMP", "Oil Temp", "Oil Press", "EGT", "Fuel Flow",
    "Fuel(left)", "Voltage"
]
errorBoxItems = ["TEMP", "PRESS", "FUEL", "POWER", "ERROR"]
errorBoxItemsColor = ["red", "green", "green", "yellow", "green"]
Example #34
0
    def copia_entrambe(self):
        """
        Copy descr. and query sql into clipboard
        """
        the_tk = Tk()
        the_tk.withdraw()
        the_tk.clipboard_clear()
        the_tk.clipboard_append(self.testo_descriz)
        the_tk.clipboard_append('\n\n-----\n\n')
        the_tk.clipboard_append(self.testo_query)
        the_tk.update()
        the_tk.destroy()

        self.tedDescriz.selectAll()
        self.tedQuerySql.selectAll()

        self.labInfoDone.setText('Copiate descriz. e query negli appunti')
Example #35
0
    def copia_query(self):
        """
        Copy query sql into clipboard
        """
        the_tk = Tk()
        the_tk.withdraw()
        the_tk.clipboard_clear()
        the_tk.clipboard_append(self.testo_query)
        the_tk.update()
        the_tk.destroy()

        self.tedQuerySql.selectAll()
        self.labInfoDone.setText('Copiata query sql negli appunti')
Example #36
0
    def copia_descriz(self):
        """
        Copy descr. into clipboard
        """
        the_tk = Tk()
        the_tk.withdraw()
        the_tk.clipboard_clear()
        the_tk.clipboard_append(self.testo_descriz)
        the_tk.update()
        the_tk.destroy()

        self.tedDescriz.selectAll()
        self.labInfoDone.setText('Copiata descriz. negli appunti')
Example #37
0
class fenetre_mac:

    def __init__(self, resu1, resu2, mac):
        from Calc_essai.outils_ihm import MacWindowFrame
        from Tkinter import Tk, Frame, StringVar, Entry, Label, Button

        self.resu1 = resu1
        self.resu2 = resu2
        self.mac = mac
        self.root = Tk()

        nom1 = resu1.nom
        nom2 = resu2.nom
        titre = "MAC pour la base " + nom1 + " et " + nom2
        size = (20, 300)

        # la fenetre de MAC
        mac_win = MacWindowFrame(self.root, titre, nom1, nom2, size)
        mac_win.grid(row=0, column=0)

        self.freq1 = get_modes(resu1)
        self.freq2 = get_modes(resu2)
        # la variable NUMERIQUE qui contient ces memes listes. On remplit
        # ces valeurs quand on ferme la fenetre
        self.l1 = None
        self.l2 = None
        # la variable GRAPHIQUE qui donne le contenu des listes
        self.var_l1 = StringVar()
        self.var_l2 = StringVar()

        mac_win.set_modes(self.freq1, self.freq2, self.mac)

        # Une deuxieme fentre, dans laquelle on peut modifier l'appariement des
        # modes
        f = Frame(self.root)
        f.grid(row=1, column=0, sticky='news')
        f.columnconfigure(0, weight=1)
        f.columnconfigure(1, weight=4)

        Label(f, text="Liste de mode 1").grid(row=0, column=0, sticky='e')
        # l1 = Entry(f, textvariable=self.var_l1 )
        Label(f, textvariable=self.var_l1).grid(row=0, column=1, sticky='w')
        # l1.grid(row=0,column=1,sticky='ew')#,columnspan=3)
        Label(f, text="Liste de mode 2").grid(row=1, column=0, sticky='e')
        l2 = Entry(f, textvariable=self.var_l2)
        l2.grid(row=1, column=1, sticky='ew')  # ,columnspan=3)
        close = Button(f, text='Fermer', command=self.close_win)

        close.grid(row=2, column=1, sticky='e')

        self.set_default_pair()

        self.root.mainloop()

    def get_pair(self):
        """rend une double liste donnant les appariements de modes"""
        return [self.var_l1.get(), self.var_l2.get()]

    def set_pair(self, liste):
        """affiche une liste d'appariement donnee"""
        self.var_l1.set(liste[0])
        self.var_l2.set(liste[1])

    def set_default_pair(self):
        """ affiche la liste d'appariement par defaut. Le nombre de modes
            correspond au plus petit nombre de modes entre resu1 et resu2"""
        nb_mod = min(len(self.freq1), len(self.freq2))
        self.var_l1.set(range(1, nb_mod + 1))
        self.var_l2.set(range(1, nb_mod + 1))

    def close_win(self):
        self.l1 = self.var_l1.get()
        self.l2 = self.var_l2.get()
        self.root.quit()

    def get_list(self):
        exec('l1=' + self.l1)
        exec('l2=' + self.l2)
        return l1, l2
Example #38
0
                    self.msg.set('该URL 不存在 JSONP劫持 漏洞。')
            except :
                self.result.config(fg='red')
                self.msg.set('网络资源请求失败,请确保已经接入互联网和网址的有效性!')













root=Tk()
root.title('JSONP漏洞检测工具 by WD(WX:13503941314)  Topsec V2 ')
root.geometry('700x500+100+100')

app=App(root)
root.mainloop()






if __name__ == '__main__':
    pass
Example #39
0
            text='Battery level:\n{} %'.format(data.percentage))

    def publish_pos(self):
        #publishing the position of the target position in pixels
        if not rospy.is_shutdown():
            p = Point()
            p.x = pos_x
            p.y = pos_y
            p.z = 0
            self.gui_target_pub.publish(p)
            self.rate.sleep()
            rospy.loginfo("New Gui target published (%d, %d)", pos_x, pos_y)


## sizing the gui window and initialising
ImageFile.LOAD_TRUNCATED_IMAGES = True
root = Tk()
root.geometry('1700x850')

gui = DroneGUI(root)
gui.update_image()

col_count, row_count = root.grid_size()
for col in xrange(col_count):
    root.grid_columnconfigure(col, minsize=40)

for row in xrange(row_count):
    root.grid_rowconfigure(row, minsize=20)

root.mainloop()
Example #40
0
def clip(self):
    locale.setlocale(locale.LC_ALL, '')
    r = Tk()
    r.withdraw()
    r.clipboard_clear()
    r.clipboard_append(locale.format("%.1f", distance / mpc2kpc, grouping=False) + '\t' + locale.format("%.0f", vinf, grouping=False) + '\t' + locale.format("%.2f", rc, grouping=False) + '\t' + locale.format("%.2f", p0, grouping=False) + '\t' + locale.format("%.2E", M, grouping=False))
    r.update() # now it stays on the clipboard after the window is closed
    r.destroy()
Example #41
0
    def destroy(self):
        self.interior.destroy()
        
    def item_ID(self, index):
        return self.interior.get_children()[index]

if __name__ == '__main__':
    try:
        from Tkinter import Tk
        import tkMessageBox as messagebox
    except ImportError:
        from tkinter import Tk
        from tkinter import messagebox

    root = Tk()
    
    def on_select(data):
        print("called command when row is selected")
        print(data)
        print("\n")
        
    def show_info(msg):
        messagebox.showinfo("Table Data", msg)

    mc = Multicolumn_Listbox(root, ["column one","column two", "column three"], stripped_rows = ("white","#f2f2f2"), command=on_select, cell_anchor="center")
    mc.interior.pack()
    
    mc.insert_row([1,2,3])
    show_info("mc.insert_row([1,2,3])")
    
Example #42
0
class zfitwin(tkinter.Tk):
    
    """ The basic class of the widget """

    def __init__(self,parent, startfile=None, z_start=0.0):
        
        """ My constructor """
        
        self.tk = Tk()

        #set min and preferred size of main gui
        self.minwinwidth=300
        self.minwinheight=300
        screen_width = self.winfo_screenwidth()
        screen_height = self.winfo_screenheight()
        self.preferwinwidth=int(screen_width*0.8)
        self.preferwinheight=int(screen_height*0.8)
        self.minsize(width=self.minwinwidth, height=self.minwinheight)
        self.geometry("{}x{}".format(self.preferwinwidth,self.preferwinheight))
        
        #tweak the aspect ratio of the menu and data gui
        self.menuaspect=[1,0.24]     #Ruari 24/05 fixes bug where different resolutions cause the menu to be cut off 
        self.dataaspect=[1,1-0.24]     #Ruari 24/05 fixes bug where different resolutions cause the menu to be cut off 
        self.dpi=80

        #find exect dir
        self.execdir=__file__.split('zfit.py')[0]
        if(len(self.execdir)==0):
            self.execdir='./'
            
        #Fiddle with font
        default_font = tkfont.nametofont("TkDefaultFont")
        scalefont = int(screen_height/1080.0*14)
        default_font.configure(size=scalefont)

        #init gui frame
        self.initialize(startfile, z_start)

    def initialize(self, startfile, z_start):
        """ This init the basic gui """ 
        
        #create a menu frame
        self.menuframe=tkinter.Frame(self,width=int(self.preferwinwidth*self.menuaspect[0]),
                                     height=int(self.preferwinheight*self.menuaspect[1]))
        self.menuframe.grid_propagate(0)
        self.menuframe.grid()

        #create a data frame
        self.dataframe=tkinter.Frame(self,width=int(self.preferwinwidth*self.dataaspect[0]), 
                                     height=int(self.preferwinheight*self.dataaspect[1]))
        self.dataframe.grid_propagate(0)
        self.dataframe.grid()

        #stick the 2D image in a separate window
        self.imgframe=tkinter.Toplevel(width=600,height=600)
        
        #update for later use of units 
        self.update()

        #now initialise the menu frame
        self.init_menuframe()
        #now initialise the data frame
        self.init_dataframe(startfile)
        
        #If zstart exists show the lines automatically
        if z_start != 0.0: 
            self.displaylines()
            self.shwlinstate.set(1)
            self.redshiftline.set("{}".format(z_start))

    def init_menuframe(self):

        """ This init the menu specific part """ 
        
        #exit button
        self.menu_exit = tkinter.Button(self.menuframe,text=u"EXIT",command=self.OnExit)
        self.menu_exit.grid(column=0,row=0)

      
        #save button
        self.menu_save = tkinter.Button(self.menuframe,text=u"Save",command=self.OnSave)
        self.menu_save.grid(column=0,row=1)

        #choice of spectra
        self.menu_select = tkinter.Button(self.menuframe,text=u"Open Spectrum",
                                          command=self.SelectFile)
        self.menu_select.grid(column=0,row=2)
        
        #current spectrum
        self.currspec=tkinter.StringVar()
        self.currspec.set('Spect: Demo')
        self.current=tkinter.Label(self.menuframe,textvariable = self.currspec)
        self.current.grid(column=0,row=3)

        self.mouse_position=tkinter.StringVar()
        self.mouse_position.set('Mouse:(None,None)')
        self.mouse_position_w=tkinter.Label(self.menuframe,textvariable = self.mouse_position)
        self.mouse_position_w.grid(column=0,row=4,columnspan=3)

        #Message window
        self.generic_message=tkinter.StringVar()
        self.generic_message.set('zfit-> Ready to go!')
        self.generic_message_w=tkinter.Label(self.menuframe,textvariable = self.generic_message)
        self.generic_message_w.grid(column=5,row=3,columnspan=3)

        #line control stuff
        self.init_linecontrol()

        #templates control stuff 
        self.init_templcontrol()


    def init_dataframe(self, startfile):

        """ This init the data specific part """ 

        #Work out the geometry of the different data parts

        #canvas for spectrum ... 
        self.pltspec_width=self.dataframe.winfo_width()
        self.pltspec_height=int(self.dataframe.winfo_height()*0.6)
    
        #canvas for twod spec
        self.twodspc_width=self.dataframe.winfo_width()
        self.twodspc_height=int((self.dataframe.winfo_height()-self.pltspec_height)*0.6)

        #canvas for twod err
        self.twoderr_width=self.dataframe.winfo_width()
        self.twoderr_height=int((self.dataframe.winfo_height()-self.pltspec_height)*0.5)
        
        #work out dimensions for twod image
        self.twodimg_width=self.imgframe.winfo_width()
        self.twodimg_height=self.imgframe.winfo_height()

        #now open with default spectrum and plot
        #self.filename=os.path.abspath(self.execdir)+"/test_spectrum.fits" RUari Jul 17 17
        if startfile==None:
            self.filename=os.path.abspath(self.execdir)+"/test_spectrum.fits"
        else:
            self.filename=startfile
            self.currspec.set('Spect: '+startfile)
        self.fits=fits.open(self.filename) 
       
        #unpack
        self.fitwav1d=self.fits[2].data
        self.fitspe1d=self.fits[0].data
        self.fitspe1d_original=np.copy(self.fitspe1d)
        self.fiterr1d=self.fits[1].data
        self.fitspe2d=self.fits[4].data
        self.fiterr2d=self.fits[5].data
        self.fitimg=self.fits[6].data
        
        #load sky model and normalise to source flux
        skyspe=fits.open('{}/templates/sky/SKY_SPECTRUM_0001.fits'.format(self.execdir))
        skycnt=fits.open('{}/templates/sky/SKY_CONTINUUM_0001.fits'.format(self.execdir))
        #compute continuum subtracted sky model 
        self.wavesky=np.array(skyspe[1].data['LAMBDA'])
        cont_resampled=interp1d(skycnt[1].data['LAMBDA'],skycnt[1].data['FLUX'],bounds_error=False,fill_value=0)(skyspe[1].data['LAMBDA'])
        self.fluxsky=np.array(skyspe[1].data['DATA'])-cont_resampled
        self.fluxsky=self.fluxsky/np.max(self.fluxsky)*0.5*np.max(self.fitspe1d)

        self.drawdata()

        #set tmpfitxcorr to None to avoid error or later init
        self.tmpfitxcorr=None
        #set smoothwindow
        self.smooth=3
        

    def init_linecontrol(self):
        
        """ This controls operation with emission lines """

        #just say what it is 
        linelabel=tkinter.Label(self.menuframe,text = "Emission lines")
        linelabel.grid(column=1,row=0,columnspan=2)

        #drop down menu to select emission lines
        llab = tkinter.Label(self.menuframe, text="Select Lines: ")
        llab.grid(column=1,row=1)
        self.linelist = tkinter.StringVar(self.menuframe)
        self.linelist.set("gal_vac") # default value
        self.lineselect = tkinter.OptionMenu(self.menuframe, self.linelist,"gal_vac","gal_air","lbg","lls","tell")
        self.lineselect.grid(column=2,row=1)
        #set the linelist in trace state
        self.linelist.trace("w",self.displaylines)

        #line redshift window 
        zlab = tkinter.Label(self.menuframe, text="z = ")
        zlab.grid(column=1,row=2)
        self.redshiftline = tkinter.StringVar()
        self.redlinecntr = tkinter.Entry(self.menuframe,textvariable=self.redshiftline)
        self.redlinecntr.grid(column=2,row=2)
        self.redshiftline.set("0.0000")
        #set the redshift in a trace state
        self.redshiftline.trace("w",self.displaylines)

        #display lines
        self.shwlinstate=tkinter.IntVar()
        self.lineshow = tkinter.Checkbutton(self.menuframe, text="Show Lines",
                                            variable=self.shwlinstate,command=self.displaylines)
        self.lineshow.grid(column=1,row=3)
        
        #fit lines
        self.line_fit = tkinter.Button(self.menuframe,text=u"FitLines",command=self.fitlines)
        self.line_fit.grid(column=2,row=3)
      
    def init_templcontrol(self):

        """ Control the options for template fitting """
        
        #just say what it is 
        templabel=tkinter.Label(self.menuframe,text = "Templates")
        templabel.grid(column=3,row=0,columnspan=4)

        #drop down menu to select template family 
        llab = tkinter.Label(self.menuframe, text="Pick template: ")
        llab.grid(column=3,row=1)
        self.tempgroup= tkinter.StringVar(self.menuframe)
        self.tempgroup.set("Select")
        self.tempselect = tkinter.OptionMenu(self.menuframe,self.tempgroup,"kinney","lbgs","sdss")
        self.tempselect.grid(column=4,row=1)
        self.tempgroup.trace("w",self.loadtemplate)

        #just say what it is 
        self.currenttemplate=tkinter.StringVar(self.menuframe)
        self.currenttemplate.set("Current: None")
        self.tempchoice=tkinter.Label(self.menuframe,textvariable = self.currenttemplate)
        self.tempchoice.grid(column=5,row=1,columnspan=2)

        #D not use trace for template, as these are expensive to compute 
        #template redshift window 
        zlab = tkinter.Label(self.menuframe, text="z = ")
        zlab.grid(column=3,row=2)
        self.redshifttemp = tkinter.StringVar()
        self.redtempcntr = tkinter.Entry(self.menuframe,textvariable=self.redshifttemp)
        self.redtempcntr.grid(column=4,row=2)
        self.redshifttemp.set("0.0000")
         
        #rmag window
        rmg = tkinter.Label(self.menuframe, text="flux = ")
        rmg.grid(column=3,row=3)
        self.magtemp = tkinter.StringVar()
        self.magtemcntr = tkinter.Entry(self.menuframe,textvariable=self.magtemp)
        self.magtemcntr.grid(column=4,row=3)
        self.magtemp.set("1.00")
    
        #display template
        self.shwtempstate=tkinter.IntVar()
        self.tempshow = tkinter.Button(self.menuframe,text="Show Template",command=self.displaytemplate)
        self.tempshow.grid(column=3,row=4)
        self.temphide = tkinter.Button(self.menuframe,text="Hide Template",command=self.hidetemplate)
        self.temphide.grid(column=4,row=4)
       
        #fit template
        self.template_fit = tkinter.Button(self.menuframe,text=u"FitTemplate",command=self.fittemplate)
        self.template_fit.grid(column=5,row=2)

        #toggle sky      
        self.shwskystate=tkinter.IntVar()
        self.template_sky=tkinter.Button(self.menuframe,text=u"Sky On/Off",command=self.togglesky)
        self.template_sky.grid(column=5,row=4)

    
    def OnExit(self):
        """ Quit all on exit """
        self.fits.close()
        self.quit()
        self.destroy()

    def OnSave(self):
        """ Save screen """
        print('Placeholder')


    def SelectFile(self):
        """ Select and open file as one wishes """
        #select file 
        self.filename=filedialog.askopenfilename(initialdir='./')
        #update name
        self.currspec.set("Spec: "+self.filename.split("/")[-1])
        
        #close old and reopen
        self.fits.close()
        self.fits=fits.open(self.filename)
        
        #unpack
        self.fitwav1d=self.fits[2].data
        self.fitspe1d=self.fits[0].data
        self.fitspe1d_original=np.copy(self.fits[0].data)
        self.fiterr1d=self.fits[1].data
        self.fitspe2d=self.fits[4].data
        self.fiterr2d=self.fits[5].data
        self.fitimg=self.fits[6].data

        #redraw
        self.drawdata(refresh=True)
        
    def drawdata(self,refresh=False):
        
        """
        Once the spectrum is set, populate the data part of the gui
        
        refresh -> True, wipe all canvas before redrawing
  
        """
        
        if(refresh):
            #now destroy all data canvas 
            self.twodimagePlot.get_tk_widget().destroy()
            self.spectrumPlot.get_tk_widget().destroy()
            self.twodspcPlot.get_tk_widget().destroy()
            self.twoderrPlot.get_tk_widget().destroy()

        #refresh 2D image
        self.init_twodimage()

        #refresh the spectrum
        self.init_spectrum()

        #refresh 2D spec
        self.init_twodspec()
        
        #refresh 2D err
        self.init_twoderr()
        

    def init_twodimage(self):

        """ Draw the 2D image """

        #create properties for this plot
        self.twodimagePlot_prop={}
        
        #figure staff
        self.twodimagePlot_prop["figure"] = Figure(figsize=(self.twodimg_width/self.dpi,self.twodimg_height/self.dpi),
                                                   dpi=self.dpi)
        self.twodimagePlot_prop["axis"] = self.twodimagePlot_prop["figure"].add_subplot(111)
 
        #call plotting routine
        self.update_twodimage()
     
        #send it to canvas - connect event 
        self.twodimagePlot = FigureCanvasTkAgg(self.twodimagePlot_prop["figure"],master=self.imgframe)
        #Draw is required in matplotlib > 2.2, show is kept for legacy only
        try:  
           self.twodimagePlot.draw()
        except:
           self.twodimagePlot.show()
        #need to set tight layout after showing 
        self.twodimagePlot_prop["figure"].tight_layout()
        #enable event on click
        self.twodimagePlot.mpl_connect("button_press_event", self.pressbutton)
        self.twodimagePlot.mpl_connect("key_press_event", self.presskey)

        self.twodimagePlot.get_tk_widget().grid()

    def update_twodimage(self,update=False):
        
        """
        Code that updates the 2D image
        Update = True, redraw
                
        """
        self.twodimagePlot_prop["image"] =self.twodimagePlot_prop["axis"].imshow(self.fitimg,origin='lower',aspect='auto')
        self.twodimagePlot_prop["image"].set_cmap('hot')
        #self.twodimagePlot_prop["axis"].set_xlabel('Pix')
        #self.twodimagePlot_prop["axis"].set_ylabel('Pix')

        
    def init_spectrum(self):

        """ Draw the spectrum """
        
        #create properties for this plot
        self.spectrumPlot_prop={}
        self.spectrumPlot_prop["xmin"]=np.min(np.nan_to_num(self.fitwav1d))
        self.spectrumPlot_prop["xmax"]=np.max(np.nan_to_num(self.fitwav1d))
        self.spectrumPlot_prop["ymin"]=np.min(np.nan_to_num(self.fitspe1d))
        self.spectrumPlot_prop["ymax"]=np.max(np.nan_to_num(self.fitspe1d))

        #figure stuff
        self.spectrumPlot_prop["figure"]= Figure(figsize=(0.99*self.pltspec_width/self.dpi,0.96*self.pltspec_height/self.dpi),
                                                 dpi=self.dpi)
        self.spectrumPlot_prop["axis"]= self.spectrumPlot_prop["figure"].add_subplot(111)

        #call plotting routine
        self.update_spectrum()
        #send it to canvas
        self.spectrumPlot = FigureCanvasTkAgg(self.spectrumPlot_prop["figure"],master=self.dataframe)
        try:
           self.spectrumPlot.draw()
        except:
           self.spectrumPlot.show()
        #enable event on click
        self.spectrumPlot_prop["figure"].tight_layout()
        self.spectrumPlot.mpl_connect("button_press_event", self.pressbutton)
        self.spectrumPlot.mpl_connect("motion_notify_event", self.movemouse)
        self.spectrumPlot.mpl_connect("key_press_event", self.presskey)
        self.spectrumPlot.get_tk_widget().grid(column=0,row=0)

    def update_spectrum(self,update=False):
        
        """

        Code that updates the spectrum
        
        Update = True, redraw

        """
        if(update):
            self.spectrumPlot_prop["axis"].cla()
            
        #plot main data
        self.spectrumPlot_prop["axis"].step(self.fitwav1d,self.fitspe1d,where='mid')
        self.spectrumPlot_prop["axis"].step(self.fitwav1d,self.fiterr1d,color='red',\
                                            linestyle='--',zorder=1,where='mid')
        self.spectrumPlot_prop["axis"].set_xlim(self.spectrumPlot_prop["xmin"],self.spectrumPlot_prop["xmax"])
        self.spectrumPlot_prop["axis"].set_ylim(self.spectrumPlot_prop["ymin"],self.spectrumPlot_prop["ymax"])
        self.spectrumPlot_prop["axis"].set_xlabel('Wavelength')
        #self.spectrumPlot_prop["axis"].set_ylabel('Flux')

        #if needed plot sky
        if(self.shwskystate.get()):
            self.spectrumPlot_prop["axis"].step(self.wavesky,self.fluxsky,where='mid',color='black')

        #if needed, plot lines
        if(self.shwlinstate.get()):
             #set redshift
            try:
                redsh=float(self.redshiftline.get())
            except:
                redsh=0.0
            #loop over lines and draw
            for lw,lnam in self.infoline:
                #find the obs wave
                lwplot=lw*(1+redsh)
                if((lwplot > self.spectrumPlot_prop["xmin"]) & (lwplot < self.spectrumPlot_prop["xmax"])):
                    self.spectrumPlot_prop["axis"].axvline(lwplot, color='grey', linestyle='--')
                    self.spectrumPlot_prop["axis"].text(lwplot,self.spectrumPlot_prop["ymax"],lnam,
                                                        verticalalignment='top',rotation=90,fontsize=12)
  
        #if needed, plot template
        if(self.shwtempstate.get()):
            self.spectrumPlot_prop["axis"].plot(self.fitwav1d,self.templatedata_current,color='black',zorder=3)
                  
        #plot zero line
        self.spectrumPlot_prop["axis"].plot([self.spectrumPlot_prop["xmin"],self.spectrumPlot_prop["xmax"]],
                                            [0,0],color='green',zorder=2,linestyle=':')


        #finally draw
        if(update):
            self.spectrumPlot.draw()
    

    def init_twodspec(self):

        """ Draw the 2D spectrum """

        #create properties for this plot
        self.twodspcPlot_prop={}

        #figure staff
        self.twodspcPlot_prop["figure"]= Figure(figsize=(0.99*self.twodspc_width/self.dpi,0.96*self.twodspc_height/self.dpi),
                                                dpi=self.dpi)
        self.twodspcPlot_prop["axis"] = self.twodspcPlot_prop["figure"].add_subplot(111)

        #call plotting routine
        self.update_twodspec()
    
        #send it to canvas
        self.twodspcPlot = FigureCanvasTkAgg(self.twodspcPlot_prop["figure"],master=self.dataframe)
        try:
           self.twodspcPlot.draw()
        except:
          self.twodspcPlot.show()  
        #enable event on click
        self.twodspcPlot_prop["figure"].tight_layout()
        self.twodspcPlot.mpl_connect("button_press_event", self.pressbutton)
        self.twodspcPlot.mpl_connect("key_press_event", self.presskey)
        self.twodspcPlot.mpl_connect("motion_notify_event", self.movemouse)

        self.twodspcPlot.get_tk_widget().grid(column=0,row=1,sticky='NW')
        
    def wavemap(self,x,pos):
    
        """ Utility to map the pixel in 2D image to wavelegth """
        
        #wavelength mapper 
        index=np.arange(0,len(self.fitwav1d))
        wave=np.interp(x,index,self.fitwav1d)
        'The two args are the value and tick position'
        return "%.1f" % wave
    
    def inv_wavemap(self,x):
    
        """ Utility to map wavelegth to pixel in 2D mage """
        
        #wavelength mapper 
        index=np.arange(0,len(self.fitwav1d))
        pix=np.interp(x,self.fitwav1d,index,left=0,right=len(self.fitwav1d))
        return  pix

    def update_twodspec(self,update=False):
        
        """

        Code that updates the 2D spectrum
        
        Update = True, redraw

        """
        
        if(update):
            self.twodspcPlot_prop["axis"].cla()
    
        self.twodspcPlot_prop["image"]=self.twodspcPlot_prop["axis"].imshow(np.rot90(self.fitspe2d),origin='lower',aspect='auto')
        self.twodspcPlot_prop["image"].set_cmap('hot')
       
        
        #control level
        medianlevel=np.median(np.nan_to_num(self.fitspe2d))
        stdlevel=np.std(np.nan_to_num(self.fitspe2d))
        self.twodspcPlot_prop["image"].set_clim(medianlevel-3.*stdlevel,medianlevel+3*stdlevel)

        #wave mapper
        self.twodspcPlot_prop["axis"].xaxis.set_major_formatter(matplotlib.ticker.FuncFormatter(self.wavemap))
        
        #now set X axis as in 1d spectrum
        xpixmin=self.inv_wavemap(self.spectrumPlot_prop["xmin"])
        xpixmax=self.inv_wavemap(self.spectrumPlot_prop["xmax"])
        
        #force minimum maximum
        if(xpixmin == xpixmax):
            xpixmin = xpixmax-1
        if(xpixmax == 0):
            xpixmax = 1

        self.twodspcPlot_prop["axis"].set_xlim(xpixmin,xpixmax)
        self.twodspcPlot_prop["axis"].set_xlabel('Wavelength')

        if(update):
            self.twodspcPlot.draw()
    

    def init_twoderr(self):

        """ Draw the 2D error """

        #create properties for this plot
        self.twoderrPlot_prop={}
        
        #figure staff
        #self.twoderr.grid(column=1,row=2,sticky='NW')
        self.twoderrPlot_prop['figure'] = Figure(figsize=(0.99*self.twoderr_width/self.dpi,0.96*self.twoderr_height/self.dpi),
                                                 dpi=self.dpi)
        self.twoderrPlot_prop['axis'] = self.twoderrPlot_prop['figure'].add_subplot(111)
        
        #call plotting routine
        self.update_twoderr()
    
        #send it to canvas
        self.twoderrPlot = FigureCanvasTkAgg(self.twoderrPlot_prop['figure'],master=self.dataframe)
        try:
           self.twoderrPlot.draw()
        except:
           self.twoderrPlot.show()
        #enable event on click
        self.twoderrPlot_prop['figure'].tight_layout()
        self.twoderrPlot.mpl_connect("button_press_event", self.pressbutton)
        self.twoderrPlot.mpl_connect("key_press_event", self.presskey)
        self.twoderrPlot.mpl_connect("motion_notify_event", self.movemouse)
        self.twoderrPlot.get_tk_widget().grid(column=0,row=2,sticky='NW')


    def update_twoderr(self,update=False):
        
        """

        Code that updates the 2D error
        
        Update = True, redraw

        """

        if(update):
            self.twoderrPlot_prop["axis"].cla()
        
        self.twoderrPlot_prop['image'] =self.twoderrPlot_prop['axis'].imshow(np.rot90(self.fiterr2d),origin='lower',aspect='auto')
        self.twoderrPlot_prop['image'].set_cmap('hot')
        

        #control level
        medianlevel=np.median(np.nan_to_num(self.fiterr2d))
        stdlevel=np.std(np.nan_to_num(self.fiterr2d))
        self.twoderrPlot_prop["image"].set_clim(medianlevel-3.*stdlevel,medianlevel+3*stdlevel)


        #wave mapper
        self.twoderrPlot_prop["axis"].xaxis.set_major_formatter(matplotlib.ticker.FuncFormatter(self.wavemap))
        
        #now set X axis as in 1d spectrum
        xpixmin=self.inv_wavemap(self.spectrumPlot_prop["xmin"])
        xpixmax=self.inv_wavemap(self.spectrumPlot_prop["xmax"])
        
        #force minimum maximum
        if(xpixmin == xpixmax):
            xpixmin = xpixmax-1
        if(xpixmax == 0):
            xpixmax = 1

        self.twoderrPlot_prop["axis"].set_xlim(xpixmin,xpixmax)
        self.twoderrPlot_prop["axis"].set_xlabel('Wavelength')

        if(update):
            self.twoderrPlot.draw()


    def displaylines(self,*args):

        """ Display the line list by refreshing plot in update state """
 
        #first parse the line lists
        linefile=self.execdir+"/lines/"+self.linelist.get()+".lst"
        self.infoline = Table.read(linefile, format='ascii.basic')
        #self.infoline=np.loadtxt(linefile, dtype={'names': ('wave', 'tag'),
        #                                          'formats': ('f4', 'S4')})
        
        #refresh plot
        self.update_spectrum(update=True)
    
    def loadtemplate(self,*args):
        
        """ Load template from disk and preselect some
            useful default                   
        """

        #if so, start dialogue to pick the desired template
        self.picktemplate=filedialog.askopenfilename(initialdir='{}/templates/{}'.format(self.execdir,self.tempgroup.get()))
        #set current template 
        self.currenttemplate.set("Current: "+self.picktemplate.split("/")[-1])
        
        #load current template
        if('sdss' in self.tempgroup.get()):
            #load fits
            fitstemp=fits.open(self.picktemplate)
            #grab flux
            self.templatedata={'flux':fitstemp[0].data[0,:]}
            #cosntruct wave
            waveinx=np.arange(0,len(self.templatedata['flux']),1)
            wavevac=10**(waveinx*1.*fitstemp[0].header['COEFF1']+1.*fitstemp[0].header['COEFF0'])
            ##go to air
            #self.templatedata['wave']= wavevac/(1.0+2.735182e-4+131.4182/wavevac**2+2.76249e8/wavevac**4)
            #remain in vac 
            self.templatedata['wave']= wavevac
        else:
            #load text
            #self.templatedata=np.loadtxt(self.picktemplate, dtype={'names': ('wave', 'flux'),
            #                                                       'formats': ('f10', 'f10')},usecols=(0,1))
            self.templatedata = Table.read(self.picktemplate, format='ascii.basic')
            
        #set sensible pick in redshift and adjust data as needed
        if('lbg' in self.tempgroup.get()):
            self.redshifttemp.set("3.000")
        elif('kinney' in self.tempgroup.get()):
            self.templatedata['flux']=self.templatedata['flux']/1e-14
        elif('sdss' in self.tempgroup.get()):
            self.templatedata['flux']=self.templatedata['flux']*100.
        else:
            self.redshifttemp.set("0.000")
                
    def displaytemplate(self,*args):

        """ Compute and display template """
        self.shwtempstate.set(1)

        #compute template given current values
        self.adapttemplate()
                        
        #refresh plot
        self.update_spectrum(update=True)

    def hidetemplate(self,*args):

        """ Hide template """
        self.shwtempstate.set(0)
        #refresh plot
        self.update_spectrum(update=True)

    def adapttemplate(self):
        
        """ Interpolate a template over the data """

        #redshift factor 
        redhfactor=(1+float(self.redshifttemp.get()))
   
        #now construct interpolation 
        thisw=self.templatedata['wave']*redhfactor
        thisf=self.templatedata['flux']
        intflx = interp1d(thisw,thisf,kind='linear',bounds_error=False,fill_value=0.0)
        #apply normalisation
        self.templatedata_current=intflx(self.fitwav1d)*float(self.magtemp.get())
    
    def togglesky(self,*args):

        """ Switch on/off sky """
        if(self.shwskystate.get()):
            self.shwskystate.set(0)
        else:
            self.shwskystate.set(1)
        
        #refresh plot
        self.update_spectrum(update=True)


    def fitlines(self):

        """ Fit the line list """

        #loop over lines inside spectrum 
        #lounch a new window
        self.lnfit=tkinter.Toplevel(self.tk)
        
        #add a display
        fig=Figure(figsize=(self.preferwinwidth/self.dpi,self.preferwinheight/self.dpi),dpi=self.dpi)
                 
        #pick z
        try:
            redsh=float(self.redshiftline.get())
        except:
            redsh=0.0
            
        lines_good_wave_rest=[]
        lines_good_wave_obs=[]
        lines_good_name=[]

        for lw,lnam in self.infoline:
            lwplot=lw*(1+redsh)
            if((lwplot > min(self.fitwav1d)+8) & (lwplot < max(self.fitwav1d)-8)):
                
                #do a boxchart in 6A bin to see if line exists 
                inside=np.where((self.fitwav1d > lwplot-4)& (self.fitwav1d < lwplot+4))
                continuum=np.where(((self.fitwav1d > lwplot-20)& (self.fitwav1d < lwplot-10)) |
                                   ((self.fitwav1d > lwplot+10)& (self.fitwav1d < lwplot+20)))
                clevel=np.median(self.fitspe1d[continuum])
                flux=np.sum((self.fitspe1d[inside]-clevel))
                noise=np.sqrt(np.sum(self.fiterr1d[inside]**2))
                
                #cut in SN
                if(flux/noise > 2):
                    
                    #stash 
                    lines_good_wave_rest.append(lw)
                    lines_good_wave_obs.append(lwplot)
                    lines_good_name.append(lnam)
                    

        #generate a 4x? grid of plots
        nlines=len(lines_good_wave_rest)
        ncol=4
        nraw=int(nlines/ncol)
        if(nlines%ncol > 0):
            nraw=nraw+1
        
        czall=[]

        #loop on good stuff for fits
        for ii in range(nlines):

            #select region to fit
            fitwindow=np.where((self.fitwav1d > lines_good_wave_obs[ii]-10) & (self.fitwav1d < lines_good_wave_obs[ii]+10))
            continuum=np.where(((self.fitwav1d > lines_good_wave_obs[ii]-20)& (self.fitwav1d < lines_good_wave_obs[ii]-10)) |
                               ((self.fitwav1d > lines_good_wave_obs[ii]+10)& (self.fitwav1d < lines_good_wave_obs[ii]+20)))
            clevel=np.median(self.fitspe1d[continuum])
            p0=np.array([10.,1.*float(lines_good_wave_obs[ii]),2.,0.])

            #fit a Gaussian 
            yval=np.nan_to_num(self.fitspe1d[fitwindow]-clevel)
            yerr=np.nan_to_num(self.fiterr1d[fitwindow]*1.)
            xval=np.nan_to_num(self.fitwav1d[fitwindow]*1.)
            popt,pcov=curve_fit(self.gauss,xval,yval,p0=p0, sigma=yerr)
            perr = np.sqrt(np.diag(pcov))
            #eval fit 
            xg=np.arange(min(xval)-2,max(xval)+2,0.2)
            fitg=self.gauss(xg,*popt)

            #grab fits
            czfit=popt[1]/lines_good_wave_rest[ii]-1.
            czfiterr=perr[1]/lines_good_wave_rest[ii]
            czall.append(czfit)

            #display
            ax = fig.add_subplot(nraw,ncol,ii+1)
            ax.plot(xval,yval)
            ax.plot(xval,yerr,color='red',linestyle="--",zorder=1)
            ax.plot(xg,fitg,color='black',linestyle=":")
            ax.set_title("{0}{1} z = {2:.6} +/- {3:.5}".format(lines_good_name[ii],int(lines_good_wave_rest[ii]),czfit,czfiterr))

        #send message to user  and reset redshift 
        bestz=np.median(np.array(czall))
        bestez=np.std(np.array(czall))
        self.generic_message.set(r'zfit-> Best fit is {:6.5f}+/-{:6.5f}'.format(bestz,bestez))
        self.redshiftline.set(bestz)

        #send figure to canvas
        self.linefitplot = FigureCanvasTkAgg(fig,master=self.lnfit)
        try:
           self.linefitplot.draw()
        except:
           self.linefitplot.show()
        #fig.tight_layout()
        self.linefitplot.get_tk_widget().grid()
 
    def fittemplate(self):

        """ Fit the template  """

        #init the template correlation 
        realdata={'wave':self.fitwav1d,'flux':self.fitspe1d,'error':self.fiterr1d}
        
        ##Testing sequence
        #realdata={'wave':self.templatedata['wave']*(1+0.4329),'flux':self.templatedata['flux'], 
        #          'error':self.templatedata['flux']}
        
        print('Computing correlation... be patient!')
            
        #find the wavelength range covering the min/max extent 
        absmin=np.min([np.min(self.templatedata['wave']),np.min(realdata['wave'])])
        absmax=np.max([np.max(self.templatedata['wave']),np.max(realdata['wave'])])

        #resample in log 
        deltal=5e-4
        lnwave=np.arange(np.log(absmin),np.log(absmax),deltal)
        
        #resample with spline (s controls the smoothing)
        x=np.nan_to_num(self.templatedata['wave'])
        y=np.nan_to_num(self.templatedata['flux'])
        resamp_templ=interpolate.splrep(np.log(x),y,s=0)
        x=np.nan_to_num(realdata['wave'])
        y=np.nan_to_num(realdata['flux'])
        resamp_real=interpolate.splrep(np.log(x),y,s=0)
       
        #put everything on the same array - zero padding the extrapolation
        flux_templ=interpolate.splev(lnwave,resamp_templ,der=0,ext=1)
        flux_real=interpolate.splev(lnwave,resamp_real,der=0,ext=1)

        #masking strong sky lines
        mask=np.where((lnwave > np.log(5569.)) & (lnwave < np.log(5584.)))
        flux_real[mask]=0
        mask=np.where((lnwave > np.log(6292.)) & (lnwave < np.log(6308.)))
        flux_real[mask]=0
        mask=np.where((lnwave > np.log(6356.)) & (lnwave < np.log(6369.)))
        flux_real[mask]=0
        mask=np.where((lnwave > 8.6752) & (lnwave < 8.6860))
        flux_real[mask]=0
        mask=np.where((lnwave > 8.8274) & (lnwave < 8.8525))
        flux_real[mask]=0
        mask=np.where((lnwave > 8.8862) & (lnwave < np.log(12000.)))
        flux_real[mask]=0

        #correlate 
        xcorr=np.correlate(flux_real,flux_templ,mode='full')

        #find the peak in the second half in units of redshift
        indxmax=np.argmax(xcorr)-len(xcorr)/2
        peakz=np.exp(indxmax*deltal)-1
        #print peakz
        
        #find the reshift axis
        indxarr=np.arange(0,len(lnwave),1)
        self.xcorr_redax=np.exp(indxarr*deltal)-1
        self.xcorr_xcorr=xcorr[len(xcorr)/2:]
        self.xcorr_redshift=peakz

        #set the redshift in template window
        self.redshifttemp.set("{}".format(self.xcorr_redshift))

        #trigger display options 
        #lounch a new window
        self.tmlfit=tkinter.Toplevel(self.tk)
        
        #add xcorr to display
        #create properties for this plot
        self.tmpfitxcorr_prop={}
        self.tmpfitxcorr_prop["xmin"]=np.min(np.nan_to_num(self.xcorr_redax))
        self.tmpfitxcorr_prop["xmax"]=np.max(np.nan_to_num(self.xcorr_redax))
        self.tmpfitxcorr_prop["ymin"]=np.min(np.nan_to_num(self.xcorr_xcorr))
        self.tmpfitxcorr_prop["ymax"]=np.max(np.nan_to_num(self.xcorr_xcorr))


        self.tmpfitxcorr_prop["figure"]=Figure(figsize=(self.preferwinwidth/self.dpi*0.75,self.preferwinheight/self.dpi*0.75),dpi=self.dpi)
        self.tmpfitxcorr_prop["axis"]= self.tmpfitxcorr_prop["figure"].add_subplot(111)

        #call plotting routine
        self.update_xcorrplot()
   
        #send it to canvas
        self.tmpfitxcorr = FigureCanvasTkAgg(self.tmpfitxcorr_prop["figure"],master=self.tmlfit)
        self.tmpfitxcorr.show()
        #enable event on click
        self.tmpfitxcorr_prop["figure"].tight_layout()
        self.tmpfitxcorr.mpl_connect("button_press_event", self.pressbutton)
        self.tmpfitxcorr.mpl_connect("key_press_event", self.presskey)
        self.tmpfitxcorr.get_tk_widget().grid(column=0,row=0)

        
    def update_xcorrplot(self,update=False):

        """ Update plot for xcorrplot """

        if(update):
            self.tmpfitxcorr_prop["axis"].cla()
            
        #plot main data
        self.tmpfitxcorr_prop["axis"].plot(self.xcorr_redax,self.xcorr_xcorr)
        self.tmpfitxcorr_prop["axis"].axvline(self.xcorr_redshift, color='grey', linestyle='--')
        self.tmpfitxcorr_prop["axis"].set_xlim(self.tmpfitxcorr_prop["xmin"],self.tmpfitxcorr_prop["xmax"])
        self.tmpfitxcorr_prop["axis"].set_ylim(self.tmpfitxcorr_prop["ymin"],self.tmpfitxcorr_prop["ymax"])
        self.tmpfitxcorr_prop["axis"].set_xlabel('Redshift')
        self.tmpfitxcorr_prop["axis"].set_ylabel('XCORR')

        #finally draw
        if(update):
            self.tmpfitxcorr.draw()
    

    def movemouse(self,event):
        
        """ Do stuff when  mouse moves """
        if(event.canvas == self.spectrumPlot): 
            self.mouse_position.set('Mouse:({},{})'.format(event.xdata,event.ydata))
        elif(event.canvas == self.twodspcPlot):
            try:
                self.mouse_position.set('Mouse:({},{})'.format(self.wavemap(event.xdata,0.0),event.ydata))
            except:
                self.mouse_position.set('Mouse:(None,None)')
        elif(event.canvas == self.twoderrPlot):
            try:
                self.mouse_position.set('Mouse:({},{})'.format(self.wavemap(event.xdata,0.0),event.ydata))
            except:
                self.mouse_position.set('Mouse:(None,None)')
                
        
    def pressbutton(self,event):
        
        """ Do stuff when data plot is pressed with mouse """

        #this is how to redirect events
        if(event.canvas == self.twoderrPlot): 
            #set focus
            self.twoderrPlot.get_tk_widget().focus_set()
        if(event.canvas == self.twodspcPlot): 
            #set focus
            self.twodspcPlot.get_tk_widget().focus_set()
        if(event.canvas == self.twodimagePlot): 
            #set focus
            self.twodimagePlot.get_tk_widget().focus_set()
        if(event.canvas == self.spectrumPlot): 
            #set focus
            self.spectrumPlot.get_tk_widget().focus_set()
            #for right click, trigger line selector
            if(event.button == 3):
                self.lineselectorwidget(event)
        if(event.canvas == self.tmpfitxcorr): 
            #set focus
            self.tmpfitxcorr.get_tk_widget().focus_set()

    def presskey(self,event):
        
        """ Do stuff when data plot is pressed with key """

        #quit on q
        if(event.key == "q"):
            self.OnExit()

        #keyboard event when focus on spectrum
        if(event.canvas == self.spectrumPlot): 
            self.spetrumPlot_events(event)
            
        #keyboard event when focus on xcorr
        if(event.canvas == self.tmpfitxcorr): 
            self.tmpfitxcorr_events(event)
 
    def tmpfitxcorr_events(self,event):

        """ Handle events of xcorr plot """
        
        

        #set bottom plot
        if(event.key == "b"):
            self.tmpfitxcorr_prop["ymin"]=event.ydata
            self.update_xcorrplot(update=True)
            #set top plot
        if(event.key == "t"):
            self.tmpfitxcorr_prop["ymax"]=event.ydata
            self.update_xcorrplot(update=True)
            #set left plot
        if(event.key == "l"):
            self.tmpfitxcorr_prop["xmin"]=event.xdata
            self.update_xcorrplot(update=True)
         #set right plot
        if(event.key == "r"):
            self.tmpfitxcorr_prop["xmax"]=event.xdata
            self.update_xcorrplot(update=True)
         #zoom in
        if(event.key == "i"):
             #find the current width in x
            currentwidth=self.tmpfitxcorr_prop["xmax"]-self.tmpfitxcorr_prop["xmin"]
             #zoom in by factor of 2
            currentwidth=currentwidth*0.5
             #zoom around selected wave
            self.tmpfitxcorr_prop["xmin"]=event.xdata-currentwidth/2.
            self.tmpfitxcorr_prop["xmax"]=event.xdata+currentwidth/2.
            self.update_xcorrplot(update=True)
         #zoom out
        if(event.key == "o"):
             #find the current width in x
            currentwidth=self.tmpfitxcorr_prop["xmax"]-self.tmpfitxcorr_prop["xmin"]
             #zoom out by factor of 2
            currentwidth=currentwidth*2
             #zoom around selected wave
            self.tmpfitxcorr_prop["xmin"]=event.xdata-currentwidth/2.
            self.tmpfitxcorr_prop["xmax"]=event.xdata+currentwidth/2.
            self.update_xcorrplot(update=True)
    
         #pan left 
        if(event.key == "["):
             #find the current width in x
            currentwidth=self.tmpfitxcorr_prop["xmax"]-self.tmpfitxcorr_prop["xmin"]
             #pan left
            self.tmpfitxcorr_prop["xmin"]=self.tmpfitxcorr_prop["xmin"]-currentwidth/2
            self.tmpfitxcorr_prop["xmax"]=self.tmpfitxcorr_prop["xmax"]-currentwidth/2
            self.update_xcorrplot(update=True)
  
         #pan right 
        if(event.key == "]"):
             #find the current width in x
            currentwidth=self.tmpfitxcorr_prop["xmax"]-self.tmpfitxcorr_prop["xmin"]
             #pan right
            self.tmpfitxcorr_prop["xmin"]=self.tmpfitxcorr_prop["xmin"]+currentwidth/2
            self.tmpfitxcorr_prop["xmax"]=self.tmpfitxcorr_prop["xmax"]+currentwidth/2
            self.update_xcorrplot(update=True)
         #set reset plot
        if(event.key == "W"):
            self.tmpfitxcorr_prop["xmin"]=np.min(np.nan_to_num(self.xcorr_redax))
            self.tmpfitxcorr_prop["xmax"]=np.max(np.nan_to_num(self.xcorr_redax))
            self.tmpfitxcorr_prop["ymin"]=np.min(np.nan_to_num(self.xcorr_xcorr))
            self.tmpfitxcorr_prop["ymax"]=np.max(np.nan_to_num(self.xcorr_xcorr))
            self.update_xcorrplot(update=True)
            
        #mark new redshift
        if(event.key == "z"):
            #update relevent info
            self.xcorr_redshift=event.xdata
            self.redshifttemp.set("{}".format(self.xcorr_redshift))
            #refresh plot
            self.update_xcorrplot(update=True)
            #display template
            self.displaytemplate()


    def spetrumPlot_events(self,event):
    
         """" Handle events of spectrum plot """
         
          #set bottom plot
         if(event.key == "b"):
             self.spectrumPlot_prop["ymin"]=event.ydata
             self.update_spectrum(update=True)
            #set top plot
         if(event.key == "t"):
             self.spectrumPlot_prop["ymax"]=event.ydata
             self.update_spectrum(update=True)
            #set left plot
         if(event.key == "l"):
             self.spectrumPlot_prop["xmin"]=event.xdata
             self.update_spectrum(update=True)
             #update 2d spectra accordingly
             self.update_twodspec(update=True)
             self.update_twoderr(update=True)
         #set right plot
         if(event.key == "r"):
             self.spectrumPlot_prop["xmax"]=event.xdata
             self.update_spectrum(update=True)
             #update 2d spectra accordingly
             self.update_twodspec(update=True)             
             self.update_twoderr(update=True)        
         #zoom in
         if(event.key == "i"):
             #find the current width in x
             currentwidth=self.spectrumPlot_prop["xmax"]-self.spectrumPlot_prop["xmin"]
             #zoom in by factor of 2
             currentwidth=currentwidth*0.5
             #zoom around selected wave
             self.spectrumPlot_prop["xmin"]=event.xdata-currentwidth/2.
             self.spectrumPlot_prop["xmax"]=event.xdata+currentwidth/2.
             self.update_spectrum(update=True)
             #update 2d spectra accordingly
             self.update_twodspec(update=True)
             self.update_twoderr(update=True)              
         #zoom out
         if(event.key == "o"):
             #find the current width in x
             currentwidth=self.spectrumPlot_prop["xmax"]-self.spectrumPlot_prop["xmin"]
             #zoom out by factor of 2
             currentwidth=currentwidth*2
             #zoom around selected wave
             self.spectrumPlot_prop["xmin"]=event.xdata-currentwidth/2.
             self.spectrumPlot_prop["xmax"]=event.xdata+currentwidth/2.
             self.update_spectrum(update=True)
             #update 2d spectra accordingly
             self.update_twodspec(update=True)
             self.update_twoderr(update=True)

         #pan left 
         if(event.key == "["):
             #find the current width in x
             currentwidth=self.spectrumPlot_prop["xmax"]-self.spectrumPlot_prop["xmin"]
             #pan left
             self.spectrumPlot_prop["xmin"]=self.spectrumPlot_prop["xmin"]-currentwidth/2
             self.spectrumPlot_prop["xmax"]=self.spectrumPlot_prop["xmax"]-currentwidth/2
             self.update_spectrum(update=True)
             #update 2d spectra accordingly
             self.update_twodspec(update=True)
             self.update_twoderr(update=True)


         #pan right 
         if(event.key == "]"):
             #find the current width in x
             currentwidth=self.spectrumPlot_prop["xmax"]-self.spectrumPlot_prop["xmin"]
             #pan right
             self.spectrumPlot_prop["xmin"]=self.spectrumPlot_prop["xmin"]+currentwidth/2
             self.spectrumPlot_prop["xmax"]=self.spectrumPlot_prop["xmax"]+currentwidth/2
             self.update_spectrum(update=True)
             #update 2d spectra accordingly
             self.update_twodspec(update=True)
             self.update_twoderr(update=True)
         #set reset plot
         if(event.key == "W"):
             self.spectrumPlot_prop["xmin"]=np.min(np.nan_to_num(self.fitwav1d))
             self.spectrumPlot_prop["xmax"]=np.max(np.nan_to_num(self.fitwav1d))
             self.spectrumPlot_prop["ymin"]=np.min(np.nan_to_num(self.fitspe1d))
             self.spectrumPlot_prop["ymax"]=np.max(np.nan_to_num(self.fitspe1d))
             self.update_spectrum(update=True)
             #update 2d spectra accordingly
             self.update_twodspec(update=True)
             self.update_twoderr(update=True)
        #smooth plot
         if(event.key == "S"):
             self.fitspe1d=signal.medfilt(self.fitspe1d,self.smooth)
             self.smooth=self.smooth+2
             self.update_spectrum(update=True)
            
        #unsmooth smooth 
         if(event.key == "U"):
             self.fitspe1d=self.fitspe1d_original
             self.smooth=3
             self.update_spectrum(update=True)

         
    def lineselectorwidget(self,event):
        """  Control what happens when right-click on 1D spectrum 
        
             - trigger construction of line list selector
        
        """

        #refresh lines as needed
        self.displaylines()

        #lounch a new window
        self.lnsel=tkinter.Toplevel(self.tk)
     
        #pick z
        try:
            redsh=float(self.redshiftline.get())
        except:
            redsh=0.0
            
        #create line buttons for those visibles
        self.wlineselect = tkinter.DoubleVar()
        self.wlinepos = event.xdata
        i=0
        for lw,lnam in self.infoline:
            lwplot=lw*(1+redsh)
            tkinter.Radiobutton(self.lnsel, text=lnam+"{}".format(int(lw)), 
                                variable=self.wlineselect, value=lw,
                                command=self.pickedline).grid(row = i%30, column = i/30, sticky = "NWSE")
            i=i+1

        self.tk.wait_window(self.lnsel)

    def pickedline(self):
        
        """ If one pick a line, find redshift """

        #find the redshift
        redshift=self.wlinepos/self.wlineselect.get()-1

        #set it - auto trigger refresh 
        self.shwlinstate.set(1)        
        self.redshiftline.set("{}".format(redshift))

        #destroy window
        self.lnsel.destroy()
        
    def gauss(self,x, *p):
        """ Gaussian model for line fit """
        
        A, mu, sigma, zero = p
        gg=A*np.exp(-1.*(x-mu)*(x-mu)/(2.*sigma*sigma))+zero
        
        return gg
 def onCancel(self):
     if self.threads == 0:
         Tk().quit()
     else:
         showinfo(self.title,
                  'Cannot exit: %d threads running' % self.threads)
Example #44
0
import Tkinter
from Tkinter import Tk

top = Tk()
top.minsize(200, 200)
top.mainloop()
Example #45
0
    def size(self):
        return self.lists[0].size()

    def see(self, index):
        for l in self.lists:
            l.see(index)

    def selection_anchor(self, index):
        for l in self.lists:
            l.selection_anchor(index)

    def selection_clear(self, first, last=None):
        for l in self.lists:
            l.selection_clear(first, last)

    def selection_includes(self, index):
        return self.lists[0].selection_includes(index)

    def selection_set(self, first, last=None):
        for l in self.lists:
            l.selection_set(first, last)


if __name__ == '__main__':
    tk = Tk()
    Label(tk, text='MultiListbox').pack()
    mlb = MultiListbox(tk, (('Subject', 40), ('Sender', 20), ('Date', 10)))
    for i in range(1000):
        mlb.insert(END, ('Important Message: %d' % i, 'John Doe', '10/10/%04d' % (1900 + i)))
    mlb.pack(expand=YES, fill=BOTH)
    tk.mainloop()
Example #46
0
class ContinuousTMPViewer(object):
    def __init__(self,
                 suction_height,
                 regions,
                 tl_x=0,
                 tl_y=0,
                 width=400,
                 height=200,
                 title='Grid',
                 background=BACKGROUND_COLOR):
        self.tk = Tk()
        # tk.geometry('%dx%d+%d+%d'%(width, height, 100, 0))
        self.tk.withdraw()
        self.top = Toplevel(self.tk)
        self.top.wm_title(title)
        self.top.protocol('WM_DELETE_WINDOW', self.top.destroy)

        self.suction_height = suction_height
        self.regions = regions
        self.width = width
        self.height = height
        self.canvas = Canvas(self.top,
                             width=self.width,
                             height=self.height,
                             background=background)
        self.canvas.pack()
        # self.center()
        self.move_frame(tl_x, tl_y)

        min_x = min(x1 for x1, _ in regions.values())
        max_x = max(x2 for _, x2 in regions.values())
        max_width = max_x - min_x
        self.dist_to_pixel = (self.width - 2 * PIXEL_BUFFER
                              ) / max_width  # Maintains aspect ratio
        self.dist_width = self.width / self.dist_to_pixel
        self.dist_height = self.height / self.dist_to_pixel
        self.ground_height = self.height - self.dist_to_pixel * ENV_HEIGHT
        self.robot_dist = self.dist_height / 2.

        self.dynamic = []
        self.static = []
        self.draw_environment()

    def center(self):
        self.top.update_idletasks()
        w = self.top.winfo_screenwidth()
        h = self.top.winfo_screenheight()
        size = tuple(
            int(_) for _ in self.top.geometry().split('+')[0].split('x'))
        x = w / 2 - size[0] / 2
        y = h / 2 - size[1] / 2
        self.top.geometry("%dx%d+%d+%d" % (size + (x, y)))

    def move_frame(self, x, y):
        self.top.update_idletasks()
        size = tuple(
            int(_) for _ in self.top.geometry().split('+')[0].split('x'))
        self.top.geometry("%dx%d+%d+%d" % (size + (x, y)))

    def scale_x(self, x):  # x \in [-self.dist_width/2, self.dist_width/2]
        return self.width / 2. + self.dist_to_pixel * x

    def scale_y(self, y):  # y \in [0, self.dist_height]
        return self.ground_height - self.dist_to_pixel * y

    def draw_block(self, x, y, width, height, name='', color='blue'):
        self.dynamic.extend([
            self.canvas.create_rectangle(self.scale_x(x - width / 2.),
                                         self.scale_y(y),
                                         self.scale_x(x + width / 2.),
                                         self.scale_y(y + height),
                                         fill=color,
                                         outline='black',
                                         width=2),
            self.canvas.create_text(self.scale_x(x),
                                    self.scale_y(y + height / 2),
                                    text=name),
        ])

    # def draw_holding(self, x, width, height, color='blue'):
    #     self.holding = self.canvas.create_rectangle(self.scale_x(x - width / 2.),
    #                                                 self.scale_y(self.robot_dist - SUCTION_HEIGHT / 2 - height),
    #                                                 self.scale_x(x + width / 2.),
    #                                                 self.scale_y(self.robot_dist - SUCTION_HEIGHT / 2),
    #                                                 fill=color, outline='black', width=2)

    def draw_region(self, region, name=''):
        x1, x2 = map(self.scale_x, region)
        y1, y2 = self.ground_height, self.height
        color = COLOR_FROM_NAME.get(name, name)
        self.static.extend([
            self.canvas.create_rectangle(x1,
                                         y1,
                                         x2,
                                         y2,
                                         fill=color,
                                         outline='black',
                                         width=2),
            self.canvas.create_text((x1 + x2) / 2, (y1 + y2) / 2, text=name),
        ])

    def draw_environment(self):
        # TODO: automatically draw in order
        self.static = []
        for name, region in sorted(self.regions.items(),
                                   key=lambda pair: get_width(pair[1]),
                                   reverse=True):
            self.draw_region(region, name=name)

    def draw_robot(
        self,
        x,
        y,
        name='',
        color='yellow'
    ):  # TODO - could also visualize as top grasps instead of side grasps
        #y = self.robot_dist
        self.dynamic.extend([
            self.canvas.create_rectangle(
                self.scale_x(x - SUCTION_WIDTH / 2.),
                self.scale_y(y - self.suction_height / 2.),
                self.scale_x(x + SUCTION_WIDTH / 2.),
                self.scale_y(y + self.suction_height / 2.),
                fill=color,
                outline='black',
                width=2),
            self.canvas.create_text(self.scale_x(x),
                                    self.scale_y(y),
                                    text=name),
            self.canvas.create_rectangle(
                self.scale_x(x - STEM_WIDTH / 2.),
                self.scale_y(y + self.suction_height / 2.),
                self.scale_x(x + STEM_WIDTH / 2.),
                self.scale_y(y + self.suction_height / 2. + STEM_HEIGHT),
                fill=color,
                outline='black',
                width=2),
        ])

    def clear_state(self):
        for part in self.dynamic:
            self.canvas.delete(part)
        self.dynamic = []

    def clear_all(self):
        self.canvas.delete('all')

    def save(self, filename):
        # TODO: screen recording based on location like I did before
        # TODO: only works on windows
        # self.canvas.postscript(file='%s.ps'%filename, colormode='color')
        #from PIL import ImageGrab
        try:
            import pyscreenshot as ImageGrab
        except ImportError:
            print('Unable to load pyscreenshot')
            return None
        # TODO: screenshot is in the wrong place
        x, y = self.top.winfo_x(), 2 * self.top.winfo_y()
        width, height = self.top.winfo_width(), self.top.winfo_height(
        )  # winfo_width, winfo_reqheight
        path = filename + '.png'
        print('Saved', path)
        ImageGrab.grab((x, y, x + width, y + height)).save(path)
        return path
Example #47
0
def show_error(err):
    root = Tk()
    root.title('Error')
    try:
        root.call('wm', 'iconphoto', root._w, PhotoImage(file='ico.png'))
    except Exception:
        print 'Error loading icon'
    root.geometry('200x100+100+100')
    root.overrideredirect(True)

    Label(root, text=err).place(x=0, y=0, height=50, relwidth=1.0)

    Button(root, text='Ok', command=lambda: exit(root)).place(x=60,
                                                              y=60,
                                                              height=30,
                                                              width=80)

    root.mainloop()
Example #48
0
			if c == '(':
				paren += 1
			elif c == ')':
				paren -= 1
				#if paren < 0:

		if paren != 0:
			print "LINE", lnum, ": SYNTAX ERROR 01"
			print line
			return
		if incomplete:
			print "LINE", lnum, ": SYNTAX ERROR 02"
			print line
			return"""

root = Tk()
root.withdraw()


def readfile(pfile):
    global lines

    lines = pfile.readlines()  #[l[:-1] for l in pfile.readlines()]


#	print lines


def interpret():
    #keep track of values
Example #49
0
class ContinuousTMPViewer(object):
    def __init__(self,
                 env_region,
                 regions=[],
                 tl_x=0,
                 tl_y=0,
                 width=500,
                 height=250,
                 title='Grid',
                 background='tan'):
        self.tk = Tk()

        self.tk.withdraw()
        self.top = Toplevel(self.tk)
        self.top.wm_title(title)
        self.top.protocol('WM_DELETE_WINDOW', self.top.destroy)

        self.env_region = env_region
        self.regions = regions
        self.tl_x = tl_x
        self.tl_y = tl_y
        self.width = width
        self.height = height
        self.canvas = Canvas(self.top,
                             width=self.width,
                             height=self.height,
                             background=background)
        self.canvas.pack()

        self.move_frame(self.tl_x, self.tl_y)

        self.dist_to_pixel = (self.width -
                              2 * PIXEL_BUFFER) / (self.env_region.w)
        self.dist_width = self.width / self.dist_to_pixel
        self.dist_height = self.height / self.dist_to_pixel
        self.ground_height = self.height - self.dist_to_pixel * ENV_HEIGHT
        self.robot_dist = self.dist_height / 2.

        self.robot = []
        self.blocks = []
        self.holding = None
        self.draw_environment()

    def center(self):
        self.top.update_idletasks()
        w = self.top.winfo_screenwidth()
        h = self.top.winfo_screenheight()
        size = tuple(
            int(_) for _ in self.top.geometry().split('+')[0].split('x'))
        x = w / 2 - size[0] / 2
        y = h / 2 - size[1] / 2
        self.top.geometry("%dx%d+%d+%d" % (size + (x, y)))

    def move_frame(self, x, y):
        self.top.update_idletasks()
        size = tuple(
            int(_) for _ in self.top.geometry().split('+')[0].split('x'))
        self.top.geometry("%dx%d+%d+%d" % (size + (x, y)))

    def t_x(self, x):
        return self.dist_to_pixel * (x + self.dist_width / 2.)

    def t_y(self, y):
        return self.ground_height - self.dist_to_pixel * y

    def draw_block(self, block, x):
        self.blocks.append(
            self.canvas.create_rectangle(self.t_x(x - block.w / 2.),
                                         self.t_y(0),
                                         self.t_x(x + block.w / 2.),
                                         self.t_y(block.h),
                                         fill=block.color,
                                         outline='black',
                                         width=2))

    def draw_holding(self, block, x):
        self.holding = self.canvas.create_rectangle(
            self.t_x(x - block.w / 2.),
            self.t_y(self.robot_dist - SUCTION_HEIGHT / 2 - block.h),
            self.t_x(x + block.w / 2.),
            self.t_y(self.robot_dist - SUCTION_HEIGHT / 2),
            fill=block.color,
            outline='black',
            width=2)

    def draw_region(self, region):
        self.environment.append(
            self.canvas.create_rectangle(self.t_x(region.x - region.w / 2.),
                                         self.ground_height,
                                         self.t_x(region.x + region.w / 2.),
                                         self.height,
                                         fill='red',
                                         outline='black',
                                         width=2))

    def draw_environment(self, table_color='lightgrey', bin_color='grey'):
        self.environment = [
            self.canvas.create_rectangle(self.t_x(-self.env_region.w / 2),
                                         self.ground_height,
                                         self.t_x(self.env_region.w / 2),
                                         self.height,
                                         fill=table_color,
                                         outline='black',
                                         width=2)
        ]
        for region in self.regions:
            self.draw_region(region)

    def draw_robot(self, x, color='yellow'):
        self.robot = [
            self.canvas.create_rectangle(
                self.t_x(x - SUCTION_WIDTH / 2.),
                self.t_y(self.robot_dist - SUCTION_HEIGHT / 2.),
                self.t_x(x + SUCTION_WIDTH / 2.),
                self.t_y(self.robot_dist + SUCTION_HEIGHT / 2.),
                fill=color,
                outline='black',
                width=2),
            self.canvas.create_rectangle(
                self.t_x(x - STEM_WIDTH / 2.),
                self.t_y(self.robot_dist + SUCTION_HEIGHT / 2.),
                self.t_x(x + STEM_WIDTH / 2.),
                self.t_y(self.robot_dist + SUCTION_HEIGHT / 2. + STEM_HEIGHT),
                fill=color,
                outline='black',
                width=2),
        ]

    def clear_state(self):
        for block in self.blocks:
            self.canvas.delete(block)
        for part in self.robot:
            self.canvas.delete(part)
        if self.holding is not None:
            self.canvas.delete(self.holding)

    def clear_all(self):
        self.canvas.delete('all')

    def save(self, filename):

        from PIL import ImageGrab
        ImageGrab.grab((0, 0, self.width, self.height)).save(filename + '.jpg')
Example #50
0
def main():
    print "main"
    root = Tk()
    env = Environment(root)
    root.geometry("500x200+300+300")
    root.mainloop()
 def setUpClass(cls):
     requires('gui')
     from Tkinter import Tk, Text
     cls.Text = Text
     cls.root = Tk()
Example #52
0
from Tkinter import Tk, Label, Entry, Button
from tkMessageBox import showinfo

my_app = Tk(className='coba-coba')

L1 = Label(my_app, text="DATA DIRI", font=("Times New Roman", 20))
L1.grid(row=0, column=1)
L2 = Label(my_app, text="nama")
L2.grid(row=1, column=0)
E2 = Entry(my_app)
E2.grid(row=1, column=1)
L3 = Label(my_app, text="nim ")
L3.grid(row=2, column=0)
E3 = Entry(my_app)
E3.grid(row=2, column=1)
L4 = Label(my_app, text="buku favorit ")
L4.grid(row=3, column=0)
E4 = Entry(my_app)
E4.grid(row=3, column=1)
L5 = Label(my_app, text="idola ")
L5.grid(row=4, column=0)
E5 = Entry(my_app)
E5.grid(row=4, column=1)
L6 = Label(my_app, text="motto ")
L6.grid(row=5, column=0)
E6 = Entry(my_app)
E6.grid(row=5, column=1)


def quit():
    my_app.destroy()
 def setUpClass(cls):
     requires('gui')
     cls.root = Tk()
     _initializeTkVariantTests(cls.root)
Example #54
0
# -*- coding: utf8 -*-
from Tkinter import Tk
r = Tk()
r.withdraw()
r.clipboard_clear()
r.clipboard_append('两两相忘')
r.update()  # now it stays on the clipboard after the window is closed
r.destroy()
Example #55
0
try:
    from Tkinter import Tk
except ImportError:
    from tkinter import Tk

from idlelib.TreeWidget import ScrolledCanvas, FileTreeItem, TreeNode
import os

root = Tk()
root.title("Test TreeWidget")

sc = ScrolledCanvas(root, bg="white", highlightthickness=0, takefocus=1)
sc.frame.pack(expand=1, fill="both", side="left")

item = FileTreeItem(os.getcwd())
node = TreeNode(sc.canvas, None, item)
node.expand()

root.mainloop()
# INPUTS
# -------------------------------------------------

dir_path = os.path.abspath(os.path.dirname(__file__))

# Name base folder
base = 'iPhone Files'
# base = 'test II'

src_dir = dir_path + os.sep + base + os.sep

# Get path to iPhone photo files
Files = glob.glob(src_dir + '*' + os.sep + '*.jpg*')
if Files == []:
    # Get path from user
    Tk().withdraw(
    )  # we don't want a full GUI, so keep the root window from appearing
    filename = askdirectory(
        initialdir="/",
        title=
        "I can't find your iPhone photos. \nPlease show me where you keep them?"
    )  # show an "Open" dialog box and return the path to the selected file
    src_dir = str(filename)
    src_dir = src_dir.replace('/', '\\')
    base = src_dir[find_last(src_dir, '\\') + 1:]

# Check that destination directories exist and create if not
if not os.path.exists(dir_path + os.sep + base + "- Copy" + os.sep):
    os.makedirs(dir_path + os.sep + base + "- Copy" + os.sep)
copy_dir = dir_path + os.sep + base + "- Copy" + os.sep
if not os.path.exists(dir_path + os.sep + base + "- Timestamped" + os.sep):
    os.makedirs(dir_path + os.sep + base + "- Timestamped" + os.sep)
Example #57
0
 def __init__(self):
     self.root = Tk()
     self.show()
Example #58
0
def rmshadows(humfile, sonpath, win, shadowmask, doplot, dissim, correl,
              contrast, energy, mn):
    '''
    Remove dark shadows in scans caused by shallows, shorelines, and attenuation of acoustics with distance
    Manual or automated processing options available
    Works on the radiometrically corrected outputs of the correct module

    Syntax
    ----------
    [] = PyHum.rmshadows(humfile, sonpath, win, shadowmask, doplot)

    Parameters
    ----------
    humfile : str
       path to the .DAT file
    sonpath : str
       path where the *.SON files are
    win : int, *optional* [Default=100]
       window size (pixels) for the automated shadow removal algorithm
    shadowmask : int, *optional* [Default=0]
       1 = do manual shadow masking, otherwise do automatic shadow masking
    doplot : int, *optional* [Default=1]
       1 = make plots, otherwise do not

    Returns
    -------
    sonpath+base+'_data_star_la.dat': memory-mapped file
        contains the starboard scan with water column removed and 
        radiometrically corrected, and shadows removed

    sonpath+base+'_data_port_la.dat': memory-mapped file
        contains the portside scan with water column removed and
        radiometrically corrected, and shadows removed

    '''

    # prompt user to supply file if no input file given
    if not humfile:
        print('An input file is required!!!!!!')
        Tk().withdraw(
        )  # we don't want a full GUI, so keep the root window from appearing
        humfile = askopenfilename(filetypes=[("DAT files", "*.DAT")])

    # prompt user to supply directory if no input sonpath is given
    if not sonpath:
        print('A *.SON directory is required!!!!!!')
        Tk().withdraw(
        )  # we don't want a full GUI, so keep the root window from appearing
        sonpath = askdirectory()

    # print given arguments to screen and convert data type where necessary
    if humfile:
        print('Input file is %s' % (humfile))

    if sonpath:
        print('Sonar file path is %s' % (sonpath))

    if win:
        win = np.asarray(win, int)
        print('Window is %s square pixels' % (str(win)))

    if shadowmask:
        shadowmask = np.asarray(shadowmask, int)
        if shadowmask == 1:
            print('Shadow masking is manual')
        else:
            print('Shadow masking is auto')

    if doplot:
        doplot = int(doplot)
        if doplot == 0:
            print("Plots will not be made")

    if dissim:
        dissim = np.asarray(dissim, int)
        print('Threshold dissimilarity (shadow is <) is %s' % (str(dissim)))

    if correl:
        correl = np.asarray(correl, int)
        print('Threshold correlation (shadow is <) is %s' % (str(correl)))

    if contrast:
        contrast = np.asarray(contrast, int)
        print('Threshold contrast (shadow is <) is %s' % (str(contrast)))

    if energy:
        energy = np.asarray(energy, int)
        print('Threshold energy (shadow is >) is %s' % (str(energy)))

    if mn:
        mn = np.asarray(mn, int)
        print('Threshold mean intensity (shadow is <) is %s' % (str(mn)))

    # start timer
    if os.name == 'posix':  # true if linux/mac or cygwin on windows
        start = time.time()
    else:  # windows
        start = time.clock()

    # if son path name supplied has no separator at end, put one on
    if sonpath[-1] != os.sep:
        sonpath = sonpath + os.sep

    base = humfile.split('.DAT')  # get base of file name for output
    base = base[0].split(os.sep)[-1]

    base = humutils.strip_base(base)

    meta = loadmat(os.path.normpath(os.path.join(sonpath, base + 'meta.mat')))

    # load memory mapped scans
    shape_port = np.squeeze(meta['shape_port'])
    if shape_port != '':
        #port_fp = np.memmap(sonpath+base+'_data_port_la.dat', dtype='float32', mode='r', shape=tuple(shape_port))
        with open(
                os.path.normpath(
                    os.path.join(sonpath, base + '_data_port_la.dat')),
                'r') as ff:
            port_fp = np.memmap(ff,
                                dtype='float32',
                                mode='r',
                                shape=tuple(shape_port))

    shape_star = np.squeeze(meta['shape_star'])
    if shape_star != '':
        #star_fp = np.memmap(sonpath+base+'_data_star_la.dat', dtype='float32', mode='r', shape=tuple(shape_star))
        with open(
                os.path.normpath(
                    os.path.join(sonpath, base + '_data_star_la.dat')),
                'r') as ff:
            star_fp = np.memmap(ff,
                                dtype='float32',
                                mode='r',
                                shape=tuple(shape_star))

    dist_m = np.squeeze(meta['dist_m'])
    ft = 1 / (meta['pix_m'])
    extent = shape_star[1]

    if shadowmask == 1:  #manual

        Zt = []
        if len(np.shape(star_fp)) > 2:
            for p in range(len(star_fp)):
                raw_input(
                    "Shore picking " + str(p + 1) + " of " +
                    str(len(star_fp)) +
                    " (starboard), are you ready? 60 seconds. Press Enter to continue..."
                )
                shoreline_star = {}
                fig = plt.figure()
                ax = plt.gca()
                ax.imshow(star_fp[p], cmap='gray')  #, origin = 'upper') #im =
                plt.axis('normal')
                plt.axis('tight')
                pts1 = plt.ginput(
                    n=300,
                    timeout=75)  # it will wait for 200 clicks or 75 seconds
                x1 = map(lambda x: x[0],
                         pts1)  # map applies the function passed as
                y1 = map(lambda x: x[1],
                         pts1)  # first parameter to each element of pts
                shoreline_star = np.interp(np.r_[:np.shape(star_fp[p])[1]], x1,
                                           y1)
                plt.close()
                del fig

                star_mg = star_fp[p].copy()

                shoreline_star = np.asarray(shoreline_star, 'int')
                # shift proportionally depending on where the bed is
                for k in range(np.shape(star_mg)[1]):
                    star_mg[shoreline_star[k]:, k] = np.nan

                del shoreline_star

                Zt.append(star_mg)

        else:

            raw_input(
                "Shore picking " + str(len(star_fp)) + " of " +
                str(len(star_fp)) +
                " (starboard), are you ready? 60 seconds. Press Enter to continue..."
            )
            shoreline_star = {}
            fig = plt.figure()
            ax = plt.gca()
            ax.imshow(star_fp, cmap='gray')  #, origin = 'upper') #im =
            plt.axis('normal')
            plt.axis('tight')
            pts1 = plt.ginput(
                n=300, timeout=75)  # it will wait for 200 clicks or 75 seconds
            x1 = map(lambda x: x[0],
                     pts1)  # map applies the function passed as
            y1 = map(lambda x: x[1],
                     pts1)  # first parameter to each element of pts
            shoreline_star = np.interp(np.r_[:np.shape(star_fp)[1]], x1, y1)
            plt.close()
            del fig

            star_mg = star_fp.copy()

            shoreline_star = np.asarray(shoreline_star, 'int')
            # shift proportionally depending on where the bed is
            for k in range(np.shape(star_mg)[1]):
                star_mg[shoreline_star[k]:, k] = np.nan

            del shoreline_star

            Zt.append(star_mg)

        ## create memory mapped file for Z
        #p = np.memmap(sonpath+base+'_data_star_la.dat', dtype='float32', mode='w+', shape=np.shape(Zt))
        #fp[:] = Zt[:]
        #del fp

        Zt = np.squeeze(Zt)

        # create memory mapped file for Zs
        #fp = np.memmap(sonpath+base+'_data_star_lar.dat', dtype='float32', mode='w+', shape=np.shape(Zs))
        with open(
                os.path.normpath(
                    os.path.join(sonpath, base + '_data_star_lar.dat')),
                'w+') as ff:
            fp = np.memmap(ff, dtype='float32', mode='w+', shape=np.shape(Zt))
        fp[:] = Zt[:]
        del fp
        del Zt

        #shutil.move(os.path.normpath(os.path.join(sonpath,base+'_data_star_lar.dat')), os.path.normpath(os.path.join(sonpath,base+'_data_star_la.dat')))

        Zt = []
        if len(np.shape(star_fp)) > 2:
            for p in range(len(port_fp)):

                raw_input(
                    "Shore picking " + str(p + 1) + " of " +
                    str(len(port_fp)) +
                    " (port), are you ready? 60 seconds. Press Enter to continue..."
                )
                shoreline_port = {}
                fig = plt.figure()
                ax = plt.gca()
                ax.imshow(port_fp[p], cmap='gray')  #, origin = 'upper') #im =
                plt.axis('normal')
                plt.axis('tight')
                pts1 = plt.ginput(
                    n=300,
                    timeout=75)  # it will wait for 200 clicks or 75 seconds
                x1 = map(lambda x: x[0],
                         pts1)  # map applies the function passed as
                y1 = map(lambda x: x[1],
                         pts1)  # first parameter to each element of pts
                shoreline_port = np.interp(np.r_[:np.shape(port_fp[p])[1]], x1,
                                           y1)
                plt.close()
                del fig

                port_mg = port_fp[p].copy()

                shoreline_port = np.asarray(shoreline_port, 'int')
                # shift proportionally depending on where the bed is
                for k in range(np.shape(port_mg)[1]):
                    port_mg[shoreline_port[k]:, k] = np.nan

                del shoreline_port

                Zt.append(port_mg)

        else:

            raw_input(
                "Shore picking " + str(len(port_fp)) + " of " +
                str(len(port_fp)) +
                " (port), are you ready? 60 seconds. Press Enter to continue..."
            )
            shoreline_port = {}
            fig = plt.figure()
            ax = plt.gca()
            ax.imshow(port_fp, cmap='gray')  #, origin = 'upper') #im =
            plt.axis('normal')
            plt.axis('tight')
            pts1 = plt.ginput(
                n=300, timeout=75)  # it will wait for 200 clicks or 75 seconds
            x1 = map(lambda x: x[0],
                     pts1)  # map applies the function passed as
            y1 = map(lambda x: x[1],
                     pts1)  # first parameter to each element of pts
            shoreline_port = np.interp(np.r_[:np.shape(port_fp)[1]], x1, y1)
            plt.close()
            del fig

            port_mg = port_fp.copy()

            shoreline_port = np.asarray(shoreline_port, 'int')
            # shift proportionally depending on where the bed is
            for k in range(np.shape(port_mg)[1]):
                port_mg[shoreline_port[k]:, k] = np.nan

            del shoreline_port

            Zt.append(port_mg)

        Zt = np.squeeze(Zt)
        ## create memory mapped file for Z
        #fp = np.memmap(sonpath+base+'_data_port_la.dat', dtype='float32', mode='w+', shape=np.shape(Zt))
        #fp[:] = Zt[:]
        #del fp

        # create memory mapped file for Zp
        #fp = np.memmap(sonpath+base+'_data_port_lar.dat', dtype='float32', mode='w+', shape=np.shape(Zp))
        with open(
                os.path.normpath(
                    os.path.join(sonpath, base + '_data_port_lar.dat')),
                'w+') as ff:
            fp = np.memmap(ff, dtype='float32', mode='w+', shape=np.shape(Zt))
        fp[:] = Zt[:]
        del fp
        del Zt

        #shutil.move(os.path.normpath(os.path.join(sonpath,base+'_data_port_lar.dat')), os.path.normpath(os.path.join(sonpath,base+'_data_port_la.dat')))

    else:  #auto

        Zs = []
        Zp = []
        if len(np.shape(star_fp)) > 2:
            for p in range(len(star_fp)):
                merge = np.vstack((np.flipud(port_fp[p]), star_fp[p]))
                merge = np.asarray(merge, 'float64')

                merge_mask = np.vstack((np.flipud(port_fp[p]), star_fp[p]))

                merge[merge_mask == 0] = 0
                del merge_mask

                mask = np.asarray(merge != 0,
                                  'int8')  # only 8bit precision needed

                merge[np.isnan(merge)] = 0

                #Z,ind = humutils.sliding_window(merge,(win,win),(win/2,win/2))
                Z, ind = humutils.sliding_window(merge, (win, win), (win, win))

                #zmean = np.reshape(zmean, ( ind[0], ind[1] ) )
                Ny, Nx = np.shape(merge)
                #zmean[np.isnan(zmean)] = 0

                try:  #parallel processing with all available cores
                    w = Parallel(n_jobs=-1, verbose=0)(delayed(parallel_me)(
                        Z[k], dissim, correl, contrast, energy, mn)
                                                       for k in range(len(Z)))
                except:  #fall back to serial
                    w = Parallel(n_jobs=1, verbose=0)(delayed(parallel_me)(
                        Z[k], dissim, correl, contrast, energy, mn)
                                                      for k in range(len(Z)))

                zmean = np.reshape(w, (ind[0], ind[1]))
                del w

                M = humutils.im_resize(zmean, Nx, Ny)
                M[mask == 0] = 0
                del zmean

                bw = M > 0.5
                del M

                # erode and dilate to remove splotches of no data
                bw2 = binary_dilation(binary_erosion(bw,
                                                     structure=np.ones(
                                                         (3, 3))),
                                      structure=np.ones((13, 13)))
                #bw2 = binary_dilation(binary_erosion(bw,structure=np.ones((win/4,win/4))), structure=np.ones((win/4,win/4)))
                ##bw2 = binary_erosion(bw,structure=np.ones((win*2,win*2)))

                ## fill holes
                bw2 = binary_fill_holes(bw2, structure=np.ones(
                    (win, win))).astype(int)
                merge2 = grey_erosion(merge, structure=np.ones((win, win)))

                #del bw
                #bw2 = np.asarray(bw2!=0,'int8') # we only need 8 bit precision

                bw2 = np.asarray(bw != 0,
                                 'int8')  # we only need 8 bit precision
                del bw

                merge[bw2 == 1] = 0  #blank out bad data
                merge[merge2 == np.min(merge2)] = 0  #blank out bad data
                del merge2

                ## do plots of merged scans
                if doplot == 1:

                    Zdist = dist_m[shape_port[-1] * p:shape_port[-1] * (p + 1)]

                    fig = plt.figure()
                    plt.imshow(merge,
                               cmap='gray',
                               extent=[
                                   min(Zdist),
                                   max(Zdist), -extent * (1 / ft),
                                   extent * (1 / ft)
                               ])
                    plt.ylabel('Range (m)'), plt.xlabel(
                        'Distance along track (m)')

                    plt.axis('normal')
                    plt.axis('tight')
                    custom_save(sonpath,
                                'merge_corrected_rmshadow_scan' + str(p))
                    del fig

                Zp.append(np.flipud(merge[:shape_port[1], :]))
                Zs.append(merge[shape_port[1]:, :])
                del merge, bw2

        else:

            merge = np.vstack((np.flipud(port_fp), star_fp))
            merge = np.asarray(merge, 'float64')

            merge_mask = np.vstack((np.flipud(port_fp), star_fp))

            merge[merge_mask == 0] = 0
            del merge_mask

            mask = np.asarray(merge != 0, 'int8')  # only 8bit precision needed

            merge[np.isnan(merge)] = 0

            #Z,ind = humutils.sliding_window(merge,(win,win),(win/2,win/2))
            Z, ind = humutils.sliding_window(merge, (win, win), (win, win))

            #zmean = np.reshape(zmean, ( ind[0], ind[1] ) )
            Ny, Nx = np.shape(merge)
            #zmean[np.isnan(zmean)] = 0

            try:  #parallel processing with all available cores
                w = Parallel(n_jobs=-1, verbose=0)(delayed(parallel_me)(
                    Z[k], dissim, correl, contrast, energy, mn)
                                                   for k in range(len(Z)))
            except:  #fall back to serial
                w = Parallel(n_jobs=1, verbose=0)(delayed(parallel_me)(
                    Z[k], dissim, correl, contrast, energy, mn)
                                                  for k in range(len(Z)))

            zmean = np.reshape(w, (ind[0], ind[1]))
            del w

            M = humutils.im_resize(zmean, Nx, Ny)
            M[mask == 0] = 0
            del zmean

            bw = M > 0.5
            del M

            # erode and dilate to remove splotches of no data
            bw2 = binary_dilation(binary_erosion(bw, structure=np.ones(
                (3, 3))),
                                  structure=np.ones((13, 13)))
            #bw2 = binary_dilation(binary_erosion(bw,structure=np.ones((win/4,win/4))), structure=np.ones((win/4,win/4)))
            ##bw2 = binary_erosion(bw,structure=np.ones((win*2,win*2)))

            ## fill holes
            bw2 = binary_fill_holes(bw2, structure=np.ones(
                (win, win))).astype(int)
            merge2 = grey_erosion(merge, structure=np.ones((win, win)))

            #del bw
            #bw2 = np.asarray(bw2!=0,'int8') # we only need 8 bit precision

            bw2 = np.asarray(bw != 0, 'int8')  # we only need 8 bit precision
            del bw

            merge[bw2 == 1] = 0  #blank out bad data
            merge[merge2 == np.min(merge2)] = 0  #blank out bad data
            del merge2

            # erode and dilate to remove splotches of no data
            #bw2 = binary_dilation(binary_erosion(bw,structure=np.ones((3,3))), structure=np.ones((13,13)))
            #bw2 = binary_dilation(binary_erosion(bw,structure=np.ones((win,win))), structure=np.ones((win*2,win*2)))
            #bw2 = binary_erosion(bw,structure=np.ones((win,win)))

            # fill holes
            #bw2 = binary_fill_holes(bw2, structure=np.ones((3,3))).astype(int)
            #del bw
            #bw2 = np.asarray(bw2!=0,'int8') # we only need 8 bit precision

            #merge[bw2==1] = 0 #blank out bad data

            ## do plots of merged scans
            if doplot == 1:

                Zdist = dist_m
                fig = plt.figure()
                plt.imshow(merge,
                           cmap='gray',
                           extent=[
                               min(Zdist),
                               max(Zdist), -extent * (1 / ft),
                               extent * (1 / ft)
                           ])
                plt.ylabel('Range (m)'), plt.xlabel('Distance along track (m)')

                plt.axis('normal')
                plt.axis('tight')
                custom_save(sonpath, 'merge_corrected_rmshadow_scan' + str(0))
                del fig

            Zp.append(np.flipud(merge[:shape_port[0], :]))
            Zs.append(merge[shape_port[0]:, :])
            del merge, bw2

        Zp = np.squeeze(Zp)
        Zs = np.squeeze(Zs)
        # create memory mapped file for Zp
        #fp = np.memmap(sonpath+base+'_data_port_lar.dat', dtype='float32', mode='w+', shape=np.shape(Zp))
        #with open(sonpath+base+'_data_port_lar.dat', 'w+') as f:
        with open(
                os.path.normpath(
                    os.path.join(sonpath, base + '_data_port_lar.dat')),
                'w+') as ff:
            fp = np.memmap(ff, dtype='float32', mode='w+', shape=np.shape(Zp))
        fp[:] = Zp[:]
        del fp
        del Zp

        #shutil.move(sonpath+base+'_data_port_lar.dat', sonpath+base+'_data_port_la.dat')
        #shutil.move(os.path.normpath(os.path.join(sonpath,base+'_data_port_lar.dat')), os.path.normpath(os.path.join(sonpath,base+'_data_port_la.dat')))

        # create memory mapped file for Zs
        #fp = np.memmap(sonpath+base+'_data_star_lar.dat', dtype='float32', mode='w+', shape=np.shape(Zs))
        #with open(sonpath+base+'_data_star_lar.dat', 'w+') as f:
        with open(
                os.path.normpath(
                    os.path.join(sonpath, base + '_data_star_lar.dat')),
                'w+') as ff:
            fp = np.memmap(ff, dtype='float32', mode='w+', shape=np.shape(Zs))
        fp[:] = Zs[:]
        del fp
        del Zs

        #shutil.move(sonpath+base+'_data_star_lar.dat', sonpath+base+'_data_star_la.dat')
        #shutil.move(os.path.normpath(os.path.join(sonpath,base+'_data_star_lar.dat')), os.path.normpath(os.path.join(sonpath,base+'_data_star_la.dat')))

    if os.name == 'posix':  # true if linux/mac
        elapsed = (time.time() - start)
    else:  # windows
        elapsed = (time.clock() - start)
    print("Processing took " + str(elapsed) + "seconds to analyse")

    print("Done!")
    print("===================================================")
Example #59
0
class ReversiView:
    '''
    Creates window with the reversi board and controls the game using gui.
    '''
    def __init__(self, boardSize=8, w=850, h=410):
        '''
        :param w: width of the window
        :param h: height of the window
        '''
        self.root = Tk()
        self.boardSize = boardSize
        self.stone_board = [-1] * self.boardSize
        for row in range(self.boardSize):
            self.stone_board[row] = [-1] * self.boardSize
        self.w = w
        self.h = h
        self.offx = 5
        self.offy = 5
        self.gridw = 410
        self.gridh = 410
        self.gridspacing = 50
        self.ovalDiamPart = 0.8
        self.colors = ["blue", "red"]
        self.root.title("Reversi")

        self.interactive_player_ids = []
        self.interactivePlayers = []

        self.interractivePlayerName = 'Interactive'
        self.possiblePlayers = {
            self.interractivePlayerName: -1,
        }
        self.wrong_move = False
        ws = self.root.winfo_screenwidth()
        hs = self.root.winfo_screenheight()
        x = (ws / 2) - (self.w / 2)
        y = (hs / 2) - (self.h / 2)

        self.root.geometry('%dx%d+%d+%d' % (self.w, self.h, x, y))
        self.draw_game_grid()
        self.draw_game_info_grid()

        self.game_state = GameState.STOPPED

    def set_game(self, game):
        '''
        Sets the game to the GUI.
        '''
        self.game = game

    def set_board(self, board):
        '''
        Sets the game board to the GUI.
        '''
        self.board = board

    def draw_stone(self, x, y, color):
        '''
        Draw stone on position [x,y] in gui
        :param x: x coordinate of the stone
        :param y: y coordinate of the stone
        :param color: 0 for blue, 1 fro red
        '''
        x_coord = (self.gridspacing *
                   x) + (1.0 - self.ovalDiamPart) * self.gridspacing
        y_coord = (self.gridspacing *
                   y) + (1.0 - self.ovalDiamPart) * self.gridspacing
        diameter = self.ovalDiamPart * self.gridspacing
        self.clear_stone(x, y)
        self.stone_board[x][y] = self.grid.create_oval(x_coord,
                                                       y_coord,
                                                       x_coord + diameter,
                                                       y_coord + diameter,
                                                       fill=self.colors[color])

    def clear_stone(self, x, y):
        '''
        Delete stone on position [x,y] from the gui
        :param x: x coordinate of the stone
        :param y: y coordinate of the stone
        '''
        if self.stone_board[x][y] != -1:
            self.grid.delete(self.stone_board[x][y])
            self.stone_board[x][y] = -1

    def draw_game_info_grid(self):
        '''
        Draw control and inform part of game to right side of the window.
        '''
        self.info = Canvas(self.root,
                           height=self.h - self.gridh,
                           width=self.w - self.gridw)
        self.info.pack(side="left")

        label_stones = Label(self.info,
                             text="Current stones:",
                             font=("Helvetica", 10))
        label_stones.grid(row=1, column=0)
        label_max_time = Label(self.info,
                               text="Max time:",
                               font=("Helvetica", 10))
        label_max_time.grid(row=2, column=0)

        label_scale = Label(self.info,
                            text='Game speed [ms]:',
                            font=("Helvetica", 10),
                            foreground='black')
        label_scale.grid(row=5, column=0)

        helv36 = font.Font(family="helvetica", size=16, weight='bold')
        self.scale_var = IntVar()
        scale = Scale(self.info,
                      variable=self.scale_var,
                      command=self.sleep_time_change_handler,
                      from_=0,
                      to=1000,
                      resolution=10,
                      width="15",
                      orient=HORIZONTAL,
                      length="225")
        scale.set(200)
        scale.grid(row=5, column=1, columnspan=3)

        self.button = Button(self.info,
                             text="Play",
                             width="20",
                             height="2",
                             command=self.play_button_click_handler)
        self.button['font'] = helv36
        self.button.grid(row=6, column=0, columnspan=4)

        # labels for num stones, max time of move, etc
        self.label_player_stones = [-1, -1]
        self.label_player_max_time = [-1, -1]
        self.labels_inform = [-1, -1]
        self.labels_player_name = [-1, -1]
        self.option_menus = [-1, -1]
        self.option_menus_vars = [-1, -1]

        for i in range(2):
            self.label_player_stones[i] = Label(self.info,
                                                text='2',
                                                font=("Helvetica", 10),
                                                foreground=self.colors[i])
            self.label_player_stones[i].grid(row=1,
                                             column=2 * (i + 1) - 1,
                                             columnspan=2)

            self.label_player_max_time[i] = Label(self.info,
                                                  text="%.2f [ms]" % 0.0,
                                                  font=("Helvetica", 10),
                                                  foreground=self.colors[i])
            self.label_player_max_time[i].grid(row=2,
                                               column=2 * (i + 1) - 1,
                                               columnspan=2)

            self.labels_inform[i] = Label(self.info,
                                          text='',
                                          font=("Helvetica", 10),
                                          foreground='black')
            self.labels_inform[i].grid(row=i + 3, column=0, columnspan=4)

            self.labels_player_name[i] = Label(self.info,
                                               text="Player%d:" % (i),
                                               font=("Helvetica", 12),
                                               foreground=self.colors[i])
            self.labels_player_name[i].grid(row=0, column=2 * i)

            self.option_menus_vars[i] = StringVar(self.root)
            self.option_menus_vars[i].set(self.interractivePlayerName)
            self.option_menus[i] = OptionMenu(self.info,
                                              self.option_menus_vars[i],
                                              *self.possiblePlayers)
            self.option_menus[i].grid(row=0, column=2 * i + 1)

    def draw_game_grid(self):
        '''
        Draw empty 8x8 grid on the left side of the window.
        '''
        self.grid = Canvas(self.root,
                           bg="white",
                           height=self.gridh,
                           width=self.gridw)
        self.grid.bind("<Button 1>", self.place_stone_click_handler)
        gridsize = self.boardSize
        offy = self.offy
        offx = self.offx
        w = self.gridw
        h = self.gridh
        spacing = self.gridspacing
        # line around
        self.grid.create_line(offx, offy, offx, h - offy, w - offx, h - offy,
                              w - offx, offy, offx, offx)

        for x in range(0, gridsize):
            for y in range(0, gridsize):
                arrayText = '[' + str(y) + ',' + str(x) + ']'
                self.grid.create_text(offx + (spacing * x) + spacing / 2,
                                      offy + (spacing * y) + spacing / 2,
                                      text=arrayText)
        # line rows
        for rowy in range(offy + spacing, h - offy, spacing):
            self.grid.create_line(offx, rowy, w - offx, rowy)

        # line columns
        for colx in range(offx + spacing, w - offx, spacing):
            self.grid.create_line(colx, offy, colx, h - offy)

        self.grid.pack(side="left")

    def sleep_time_change_handler(self, event):
        '''
        Called after scale value change, updates the wait time between moves.
        :param event: slider change event
        '''
        self.game.sleep_time_ms = self.scale_var.get()

    def play_button_click_handler(self):
        '''
        Button listener for Play/Pause/RePlay etc.
        On button click prints slider value and start game.
        '''

        # set the players from dropdown menu if game is stopped
        if self.game_state == GameState.STOPPED:
            print("game_state " + str(self.game_state))
            self.interactive_player_ids = []
            for i in range(2):
                print(self.option_menus_vars[i].get())
                if self.option_menus_vars[i].get(
                ) == self.interractivePlayerName:
                    self.interactive_player_ids.append(i)

                    if i == 0:
                        self.game.player1.name = self.interractivePlayerName
                    else:
                        self.game.player2.name = self.interractivePlayerName

                else:
                    if i == 0:
                        player_class = self.possiblePlayers[
                            self.option_menus_vars[i].get()]
                        self.game.player1 = player_class(
                            self.game.player1_color, self.game.player2_color)

                    else:
                        player_class = self.possiblePlayers[
                            self.option_menus_vars[i].get()]
                        self.game.player2 = player_class(
                            self.game.player2_color, self.game.player1_color)

                    self.game.clear_game()
            self.game.current_player = self.game.player1
            self.game.current_player_color = self.game.player1_color
            print('player1 ' + str(self.game.player1_color))
            print('player2 ' + str(self.game.player2_color))

        #play game or start game if interactive
        if len(self.interactive_player_ids) != 0:
            if self.game_state == GameState.STOPPED:
                if not self.board.can_play(self.game.current_player,
                                           self.game.current_player_color):
                    self.game.clear_game()
                    self.button['text'] = 'Play'
                else:
                    self.game_state = GameState.RUNNING
                    self.button['text'] = 'RePlay'
                    print('can play ', self.interactive_player_ids)
                    inform_str = 'Player%d plays' % (
                        self.interactive_player_ids[0])
                    self.inform(inform_str, 'green')
                    if len(self.interactive_player_ids
                           ) == 1 and self.interactive_player_ids[0] == 1:
                        self.game.play_game(self.interactive_player_ids[0])

            else:
                self.game_state = GameState.STOPPED
                self.button['text'] = 'Play'
                self.game.clear_game()
                # self.game.play_game(self.interactivePlayerId)
        else:
            if self.game_state == GameState.STOPPED or self.game_state == GameState.PAUSED:
                print('start')
                print('player1 ' + str(self.game.player1_color))
                print('player2 ' + str(self.game.player2_color))
                self.button['text'] = 'Pause'
                self.game.sleepTimeMS = self.scale_var.get()
                if self.game_state == GameState.STOPPED:
                    self.game.clear_game()
                self.game.pause(False)
                self.game_state = GameState.RUNNING
                print('player1 ' + str(self.game.player1_color))
                print('player2 ' + str(self.game.player2_color))
                self.game.play_game()
                print('game exited')
                if self.board.can_play(self.game.current_player,
                                       self.game.current_player_color
                                       ) and not self.wrong_move:
                    print('set pause state')
                    self.button['text'] = 'Continue'
                    self.game_state = GameState.PAUSED
                else:
                    print('set stopped state')
                    self.button['text'] = 'RePlay'
                    self.game_state = GameState.STOPPED
                    # self.game.clear_game()

            elif self.game_state == GameState.RUNNING:
                print('pause')
                self.game_state = GameState.PAUSED
                self.game.pause(True)

    def add_players(self, players):
        '''
        Adds possible players to the gui.
        :param players: array of players to add.
        '''
        for player_name in players.keys():
            self.possiblePlayers[player_name] = players[player_name]

        for i in range(2):
            self.info.delete(self.option_menus[i])
            self.option_menus[i] = OptionMenu(self.info,
                                              self.option_menus_vars[i],
                                              *self.possiblePlayers)
            self.option_menus[i].grid(row=0, column=2 * i + 1)
        self.root.update()

    def print_score(self):
        '''
        Set number of stones for both players.
        '''
        stones = self.board.get_score()
        self.print_player_num_stones(0, stones[0])
        self.print_player_num_stones(1, stones[1])

    def print_num_stones(self, stones):
        '''
        Set number of stones for both players.
        :param stones: array of player number of stones
        '''
        self.print_player_num_stones(0, stones[0])
        self.print_player_num_stones(1, stones[1])

    def print_player_num_stones(self, playerID, stones):
        '''
        Set player number of stones.
        :param playerID: 0 for player 1, 1 for player 2
        :param maxTime: maximal time of player
        '''
        self.label_player_stones[playerID]['text'] = str(stones)
        self.root.update()

    def print_move_max_times(self, maxTimesMS):
        '''
        Print maximal times for both players to the gui.
        :param max_times_ms: array of max time needed for move.
        '''
        self.print_player_move_max_time(0, maxTimesMS[0])
        self.print_player_move_max_time(1, maxTimesMS[1])

    def print_player_move_max_time(self, playerID, maxTime):
        '''
        Set player maximal time.
        :param playerID: 0 for player 1, 1 for player 2
        :param maxTime: maximal time of player
        '''
        self.label_player_max_time[playerID]['text'] = '%.2f [ms]' % maxTime
        self.root.update()

    def print_board_state(self):
        '''
        Show the state of the board in gui.
        '''
        # self.board.print_board()
        for y in range(self.board.board_size):
            for x in range(self.board.board_size):
                if self.board.board[y][x] == -1:
                    self.clear_stone(x, y)
                else:
                    self.draw_stone(x, y, self.board.board[y][x])
        self.root.update()

    def place_stone_click_handler(self, event):
        '''
        For interactive player places stone to mouse click position. 
        :param event: mouse click event
        '''
        if self.game_state != GameState.STOPPED and len(
                self.interactive_player_ids
        ) >= 1 and self.game.current_player_color in self.interactive_player_ids:
            pos_move = [
                int((event.y - self.offy) / self.gridspacing),
                int((event.x - self.offx) / self.gridspacing)
            ]
            #print(type(pos_move))
            #print(type(pos_move[0]))
            #print(type(pos_move[1]))
            if self.board.is_correct_move(pos_move, self.game.current_player,
                                          self.game.current_player_color):
                # print('correct move',pos_move)
                # self.inform('correct move to %d %d'%(pos_move[0],pos_move[1]), 'green')
                # self.board.pla
                next_player_id = self.game.play_move(pos_move)
                self.print_board_state()
                self.print_score()
                self.print_move_max_times(self.game.max_times_ms)
                inform_str = 'Player%d plays' % (
                    self.game.current_player_color)
                self.inform(inform_str, 'green')
                if len(self.interactive_player_ids) == 1:
                    self.game.play_game(self.interactive_player_ids[0])
                if next_player_id == -1:
                    self.game_state = GameState.STOPPED
                    self.button['text'] = 'RePlay'
                    self.game.print_final_info()
            else:
                print('incorrect move', pos_move)
                self.inform(
                    'incorrect move to %d %d' % (pos_move[0], pos_move[1]),
                    'red')

    def inform(self, text_strs, color_str):
        '''
        Show inform text in gui.
        :param text_strs: string or string array of size 2 that is shown in gui
        :param color_str: color of shown text_strs
        '''
        inform_str_all = ['', '']
        if not isinstance(text_strs, list):
            inform_str_all[0] = text_strs
        else:
            inform_str_all = text_strs
        # print(inform_str_all)
        for i in range(2):
            self.labels_inform[i]['text'] = inform_str_all[i]
            self.labels_inform[i]['foreground'] = color_str
        self.root.update()
Example #60
0
def main():
    root = Tk()
    ex = Walking(root)
    root.geometry("200x250+300+300")
    root.mainloop()