agent_host.addOptionalFloatArgument('epsilon', 'Exploration rate of the Q-learning agent.', 0.01) agent_host.addOptionalFloatArgument('gamma', 'Discount factor.', 1.0) agent_host.addOptionalFlag('load_model', 'Load initial model from model_file.') agent_host.addOptionalStringArgument('model_file', 'Path to the initial model file', '') agent_host.addOptionalFlag('debug', 'Turn on debugging.') malmoutils.parse_command_line(agent_host) # -- set up the python-side drawing -- # scale = 40 world_x = 6 world_y = 14 root = tk.Tk() root.wm_title("Q-table") canvas = tk.Canvas(root, width=world_x*scale, height=world_y*scale, borderwidth=0, highlightthickness=0, bg="black") canvas.grid() root.update() if agent_host.receivedArgument("test"): num_maps = 1 else: num_maps = 30000 for imap in range(num_maps): # -- set up the agent -- # actionSet = ["movenorth 1", "movesouth 1", "movewest 1", "moveeast 1"] agent = TabQAgent( actions=actionSet,
def __init__(self, master, width, height, background='white', font="-*-helvetica-medium-r-normal--10-*-*-*-*-*-*-*", **attr): """ @param master: the parent widget @param width: the initial width of the canvas @type width: C{int} @param height: the initial height of the canvas @type height: C{int} @param background: the background color @type background: C{str} @param font: the font used for the axis labels @type font: C{str} @param attr: widget attributes @keyword zoom: a flag that indicates whether interactive zooming (using the left mouse button) is enabled; the default is C{False} (no zoom) @type zoom: C{bool} @keyword select: enables the user to select a range along the x axis by dragging the mouse (with the left button pressed) in the area B{under} the x axis. If select is 0, no selection is possible. Otherwise the value of select must be a callable object that is called whenever the selection changes, with a single argument that can be C{None} (no selection) or a tuple containing two x values. """ self.zoom = 0 if attr.has_key('zoom'): self.zoom = attr['zoom'] del attr['zoom'] self.selectfn = None if attr.has_key('select'): self.selectfn = attr['select'] del attr['select'] apply(Tkinter.Frame.__init__, (self, master), attr) self.canvas = Tkinter.Canvas(self, width=width, height=height, background=background) self.canvas.pack(fill=Tkinter.BOTH, expand=Tkinter.YES) border_w = self.canvas.winfo_reqwidth() - \ int(self.canvas.cget('width')) border_h = self.canvas.winfo_reqheight() - \ int(self.canvas.cget('height')) self.border = (border_w, border_h) self.canvas.bind('<Configure>', self.reconfigure) if self.zoom or self.selectfn is not None: self.mouse_state = 0 self.canvas.bind('<Button-1>', self._mousePressed) self.canvas.bind('<B1-Motion>', self._mouseMotion) self.canvas.bind('<ButtonRelease-1>', self._mouseRelease) self.popup_menu = Tkinter.Menu(self.canvas, tearoff=0) self.label = None self.canvas.bind('<Button-2>', self._showValue) self.canvas.bind('<ButtonRelease-2>', self._hideValue) self.popup_menu.add_command(label='Auto Scale', command=self._autoScale) self.popup_menu.add_command(label='Run Xmgrace', command=self._xmgr) self.canvas.bind('<Button-3>', self._popupMenu) self._setsize() self.last_draw = None self.font = self._testFont(font) self.rubberband = None self.rectangle = None self.selected_range = None
t, dt = tnew, tnew - t for point in explode_points: for item in point: item.update(dt) cv.update() total_time += dt # 通过递归持续不断的在背景中添加新烟花 root.after(wait_time, simulate, cv) def close(*ignore): """停止模拟循环,关闭窗口""" global root root.quit() if __name__ == '__main__': root = tk.Tk() cv = tk.Canvas(root, height=600, width=600) # 自己选择一个好的图像背景填充画布 image = Image.open("tknv.jpg") photo = ImageTk.PhotoImage(image) cv.create_image(0, 0, image=photo, anchor='nw') cv.pack() root.protocol("WM_DELETE_WINDOW", close) root.after(100, simulate, cv) root.mainloop()
def __init__(self, root, options): """ web2pyDialog constructor """ root.title('web2py server') self.root = Tkinter.Toplevel(root) self.options = options self.scheduler_processes = {} self.menu = Tkinter.Menu(self.root) servermenu = Tkinter.Menu(self.menu, tearoff=0) httplog = os.path.join(self.options.folder, 'httpserver.log') iconphoto = 'web2py.gif' if os.path.exists(iconphoto): img = Tkinter.PhotoImage(file=iconphoto) self.root.tk.call('wm', 'iconphoto', self.root._w, img) # Building the Menu item = lambda: start_browser(httplog) servermenu.add_command(label='View httpserver.log', command=item) servermenu.add_command(label='Quit (pid:%i)' % os.getpid(), command=self.quit) self.menu.add_cascade(label='Server', menu=servermenu) self.pagesmenu = Tkinter.Menu(self.menu, tearoff=0) self.menu.add_cascade(label='Pages', menu=self.pagesmenu) #scheduler menu self.schedmenu = Tkinter.Menu(self.menu, tearoff=0) self.menu.add_cascade(label='Scheduler', menu=self.schedmenu) #start and register schedulers from options self.update_schedulers(start=True) helpmenu = Tkinter.Menu(self.menu, tearoff=0) # Home Page item = lambda: start_browser('http://www.web2py.com/') helpmenu.add_command(label='Home Page', command=item) # About item = lambda: tkMessageBox.showinfo('About web2py', ProgramInfo) helpmenu.add_command(label='About', command=item) self.menu.add_cascade(label='Info', menu=helpmenu) self.root.config(menu=self.menu) if options.taskbar: self.root.protocol('WM_DELETE_WINDOW', lambda: self.quit(True)) else: self.root.protocol('WM_DELETE_WINDOW', self.quit) sticky = Tkinter.NW # IP Tkinter.Label(self.root, text='Server IP:', justify=Tkinter.LEFT).grid(row=0, column=0, sticky=sticky) self.ips = {} self.selected_ip = Tkinter.StringVar() row = 0 ips = [('127.0.0.1', 'Local (IPv4)')] + \ ([('::1', 'Local (IPv6)')] if socket.has_ipv6 else []) + \ [(ip, 'Public') for ip in options.ips] + \ [('0.0.0.0', 'Public')] for ip, legend in ips: self.ips[ip] = Tkinter.Radiobutton( self.root, text='%s (%s)' % (legend, ip), variable=self.selected_ip, value=ip) self.ips[ip].grid(row=row, column=1, sticky=sticky) if row == 0: self.ips[ip].select() row += 1 shift = row # Port Tkinter.Label(self.root, text='Server Port:', justify=Tkinter.LEFT).grid(row=shift, column=0, sticky=sticky) self.port_number = Tkinter.Entry(self.root) self.port_number.insert(Tkinter.END, self.options.port) self.port_number.grid(row=shift, column=1, sticky=sticky) # Password Tkinter.Label(self.root, text='Choose Password:'******'*') self.password.bind('<Return>', lambda e: self.start()) self.password.focus_force() self.password.grid(row=shift + 1, column=1, sticky=sticky) # Prepare the canvas self.canvas = Tkinter.Canvas(self.root, width=300, height=100, bg='black') self.canvas.grid(row=shift + 2, column=0, columnspan=2) self.canvas.after(1000, self.update_canvas) # Prepare the frame frame = Tkinter.Frame(self.root) frame.grid(row=shift + 3, column=0, columnspan=2) # Start button self.button_start = Tkinter.Button(frame, text='start server', command=self.start) self.button_start.grid(row=0, column=0) # Stop button self.button_stop = Tkinter.Button(frame, text='stop server', command=self.stop) self.button_stop.grid(row=0, column=1) self.button_stop.configure(state='disabled') if options.taskbar: self.tb = contrib.taskbar_widget.TaskBarIcon() self.checkTaskBar() if options.password != '<ask>': self.password.insert(0, options.password) self.start() self.root.withdraw() else: self.tb = None
def __init__(self, logger): self.logger = logger self.drawcolors = ['white', 'black', 'red', 'yellow', 'blue', 'green'] root = Tkinter.Tk() root.title("ImageViewTk Example") #root.set_border_width(2) #root.connect("delete_event", lambda w, e: self.quit(w)) self.root = root #self.select = FileSelection.FileSelection() vbox = Tkinter.Frame(root, relief=Tkinter.RAISED, borderwidth=1) vbox.pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) canvas = Tkinter.Canvas(vbox, bg="grey", height=512, width=512) canvas.pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) fi = ImageViewCanvas(logger) fi.set_widget(canvas) #fi.set_redraw_lag(0.0) fi.enable_autocuts('on') fi.set_autocut_params('zscale') fi.enable_autozoom('on') fi.enable_draw(False) fi.set_callback('none-move', self.motion) fi.set_bg(0.2, 0.2, 0.2) fi.ui_setActive(True) fi.show_pan_mark(True) self.fitsimage = fi bd = fi.get_bindings() bd.enable_all(True) # canvas that we will draw on canvas = DrawingCanvas() canvas.enable_draw(True) canvas.set_drawtype('rectangle', color='lightblue') canvas.setSurface(fi) self.canvas = canvas # add canvas to view fi.add(canvas) canvas.ui_setActive(True) fi.configure(512, 512) hbox = Tkinter.Frame(root) hbox.pack(side=Tkinter.BOTTOM, fill=Tkinter.X, expand=0) self.readout = Tkinter.Label(root, text='') self.readout.pack(side=Tkinter.BOTTOM, fill=Tkinter.X, expand=0) self.drawtypes = fi.get_drawtypes() ## wdrawtype = ttk.Combobox(root, values=self.drawtypes, ## command=self.set_drawparams) ## index = self.drawtypes.index('ruler') ## wdrawtype.current(index) wdrawtype = Tkinter.Entry(hbox, width=12) wdrawtype.insert(0, 'rectangle') wdrawtype.bind("<Return>", self.set_drawparams) self.wdrawtype = wdrawtype # wdrawcolor = ttk.Combobox(root, values=self.drawcolors, # command=self.set_drawparams) # index = self.drawcolors.index('blue') # wdrawcolor.current(index) wdrawcolor = Tkinter.Entry(hbox, width=12) wdrawcolor.insert(0, 'blue') wdrawcolor.bind("<Return>", self.set_drawparams) self.wdrawcolor = wdrawcolor self.vfill = Tkinter.IntVar() wfill = Tkinter.Checkbutton(hbox, text="Fill", variable=self.vfill) self.wfill = wfill walpha = Tkinter.Entry(hbox, width=12) walpha.insert(0, '1.0') walpha.bind("<Return>", self.set_drawparams) self.walpha = walpha wclear = Tkinter.Button(hbox, text="Clear Canvas", command=self.clear_canvas) wopen = Tkinter.Button(hbox, text="Open File", command=self.open_file) wquit = Tkinter.Button(hbox, text="Quit", command=lambda: self.quit(root)) for w in (wquit, wclear, walpha, Tkinter.Label(hbox, text='Alpha:'), wfill, wdrawcolor, wdrawtype, wopen): w.pack(side=Tkinter.RIGHT)
def _build_maze(self): self.canvas = tk.Canvas( self, bg='white', #設定畫布大小(? height=MAZE_H * UNIT, width=MAZE_W * UNIT) # create grids for c in range(0, MAZE_W * UNIT, UNIT): x0, y0, x1, y1 = c, 0, c, MAZE_H * UNIT self.canvas.create_line(x0, y0, x1, y1) for r in range(0, MAZE_H * UNIT, UNIT): x0, y0, x1, y1 = 0, r, MAZE_W * UNIT, r self.canvas.create_line(x0, y0, x1, y1) # create origin origin = np.array([20, 20]) + np.array([0, UNIT * 3]) # hell hell1_center = origin + np.array([UNIT, 0]) self.hell1 = self.canvas.create_rectangle(hell1_center[0] - 15, hell1_center[1] - 15, hell1_center[0] + 15, hell1_center[1] + 15, fill='black') # hell hell2_center = origin + np.array([UNIT * 2, 0]) self.hell2 = self.canvas.create_rectangle(hell2_center[0] - 15, hell2_center[1] - 15, hell2_center[0] + 15, hell2_center[1] + 15, fill='black') # hell hell3_center = origin + np.array([UNIT * 3, 0]) self.hell3 = self.canvas.create_rectangle(hell3_center[0] - 15, hell3_center[1] - 15, hell3_center[0] + 15, hell3_center[1] + 15, fill='black') # hell hell4_center = origin + np.array([UNIT * 4, 0]) self.hell4 = self.canvas.create_rectangle(hell4_center[0] - 15, hell4_center[1] - 15, hell4_center[0] + 15, hell4_center[1] + 15, fill='black') # hell hell5_center = origin + np.array([UNIT * 5, 0]) self.hell5 = self.canvas.create_rectangle(hell5_center[0] - 15, hell5_center[1] - 15, hell5_center[0] + 15, hell5_center[1] + 15, fill='black') # hell hell6_center = origin + np.array([UNIT * 6, 0]) self.hell6 = self.canvas.create_rectangle(hell6_center[0] - 15, hell6_center[1] - 15, hell6_center[0] + 15, hell6_center[1] + 15, fill='black') # hell hell7_center = origin + np.array([UNIT * 7, 0]) self.hell7 = self.canvas.create_rectangle(hell7_center[0] - 15, hell7_center[1] - 15, hell7_center[0] + 15, hell7_center[1] + 15, fill='black') # hell hell8_center = origin + np.array([UNIT * 8, 0]) self.hell8 = self.canvas.create_rectangle(hell8_center[0] - 15, hell8_center[1] - 15, hell8_center[0] + 15, hell8_center[1] + 15, fill='black') # hell hell9_center = origin + np.array([UNIT * 9, 0]) self.hell9 = self.canvas.create_rectangle(hell9_center[0] - 15, hell9_center[1] - 15, hell9_center[0] + 15, hell9_center[1] + 15, fill='black') # hell hell10_center = origin + np.array([UNIT * 10, 0]) self.hell10 = self.canvas.create_rectangle(hell10_center[0] - 15, hell10_center[1] - 15, hell10_center[0] + 15, hell10_center[1] + 15, fill='black') # hell hell11_center = origin + np.array([UNIT * 0, UNIT * 1]) self.hell11 = self.canvas.create_rectangle(hell11_center[0] - 15, hell11_center[1] - 15, hell11_center[0] + 15, hell11_center[1] + 15, fill='black') # hell hell12_center = origin + np.array([UNIT * 11, UNIT * 1]) self.hell12 = self.canvas.create_rectangle(hell12_center[0] - 15, hell12_center[1] - 15, hell12_center[0] + 15, hell12_center[1] + 15, fill='black') # create oval oval_center = origin + np.array([UNIT * 11, 0]) self.oval = self.canvas.create_oval(oval_center[0] - 15, oval_center[1] - 15, oval_center[0] + 15, oval_center[1] + 15, fill='yellow') # create red rect self.rect = self.canvas.create_rectangle(origin[0] - 15, origin[1] - 15, origin[0] + 15, origin[1] + 15, fill='red') # pack all self.canvas.pack()
import Tkinter import time window = Tkinter.Tk() canvas = Tkinter.Canvas(window, height=800, width=1280) canvas.pack() dash = Tkinter.PhotoImage(file = "CenterCircle.gif") image = canvas.create_image(640,400, image=dash) for n in range(1,360): if n<181: arc = 240, 0, 1040, 800 canvas.create_arc(arc, start = 181-n, extent = n-1, outline = 'blue', width = 8, tag='greenarc') else: arc = 640, 400, 1040, 800 canvas.create_arc(arc, start = n-181, extent = 361-n, outline = 'blue', width = 8, tag='greenarc') canvas.update() #time.sleep(0.01) canvas.delete('greenarc') window.mainloop() #this holds the window open
def xGC_skew(seq, window=1000, zoom=100, r=300, px=100, py=100): """Calculate and plot normal and accumulated GC skew (GRAPHICS !!!).""" try: import Tkinter as tkinter # Python 2 except ImportError: import tkinter # Python 3 yscroll = tkinter.Scrollbar(orient=tkinter.VERTICAL) xscroll = tkinter.Scrollbar(orient=tkinter.HORIZONTAL) canvas = tkinter.Canvas(yscrollcommand=yscroll.set, xscrollcommand=xscroll.set, background="white") win = canvas.winfo_toplevel() win.geometry("700x700") yscroll.config(command=canvas.yview) xscroll.config(command=canvas.xview) yscroll.pack(side=tkinter.RIGHT, fill=tkinter.Y) xscroll.pack(side=tkinter.BOTTOM, fill=tkinter.X) canvas.pack(fill=tkinter.BOTH, side=tkinter.LEFT, expand=1) canvas.update() X0, Y0 = r + px, r + py x1, x2, y1, y2 = X0 - r, X0 + r, Y0 - r, Y0 + r ty = Y0 canvas.create_text(X0, ty, text="%s...%s (%d nt)" % (seq[:7], seq[-7:], len(seq))) ty += 20 canvas.create_text(X0, ty, text="GC %3.2f%%" % (GC(seq))) ty += 20 canvas.create_text(X0, ty, text="GC Skew", fill="blue") ty += 20 canvas.create_text(X0, ty, text="Accumulated GC Skew", fill="magenta") ty += 20 canvas.create_oval(x1, y1, x2, y2) acc = 0 start = 0 for gc in GC_skew(seq, window): r1 = r acc += gc # GC skew alpha = pi - (2 * pi * start) / len(seq) r2 = r1 - gc * zoom x1 = X0 + r1 * sin(alpha) y1 = Y0 + r1 * cos(alpha) x2 = X0 + r2 * sin(alpha) y2 = Y0 + r2 * cos(alpha) canvas.create_line(x1, y1, x2, y2, fill="blue") # accumulated GC skew r1 = r - 50 r2 = r1 - acc x1 = X0 + r1 * sin(alpha) y1 = Y0 + r1 * cos(alpha) x2 = X0 + r2 * sin(alpha) y2 = Y0 + r2 * cos(alpha) canvas.create_line(x1, y1, x2, y2, fill="magenta") canvas.update() start += window canvas.configure(scrollregion=canvas.bbox(tkinter.ALL))
###### # Create Controller ####### # Instantiate and place slider speed_slider = Tkinter.Scale(root, from_=20, to=1, variable=speed_intvar, label='speed') speed_slider.grid(row=1, column=0, sticky=Tkinter.W) # Create and place directions for the user text = Tkinter.Label(root, text='Drag slider \nto adjust\nspeed.') text.grid(row=0, column =0) ###### # Create View ####### # Create and place a canvas canvas = Tkinter.Canvas(root, width=600, height=600, background='#FFFFFF') canvas.grid(row=0, rowspan=2, column=1) # Create a circle on the canvas to match the initial model amount = 20 def rand8bit(): return random.randint(0,255) def randpos(): return random.randint(r, 600-r) circles = [] for i in range(amount):
break if flag3==1: result.config(text="BREAKAGE DETECTED") ima=images.replace('.jpg','res.jpg') cv2.imwrite(ima,img) pro_image(ima) def load_image(entry): pro_img.paste(Image.open("camo.jpg")) original_img.paste(Image.open(entry)) start_detection(entry) root.title("XXX PEACE KEEPER XXX") canvas = tk.Canvas(root,height=HEIGHT,width=WIDTH) canvas.pack() bg = Image.open("camo.jpg") background_image = ImageTk.PhotoImage(bg) background_label = tk.Label(root, image=background_image) background_label.place(relwidth=1, relheight=1) top_frame = tk.Frame(root,bg="#071F2D",bd=5) top_frame.place(relx=0.5,rely=0.03,relwidth=0.9,relheight=0.1,anchor='n') entry = tk.Entry(top_frame,font=("Courier", 20)) entry.place(relwidth=0.65,relheight=1) load = tk.Button(top_frame,font=("Courier", 20),text=" LOAD ",bg="#394344",command=lambda:load_image(entry.get())) load.place(relx=0.68,relwidth=0.32,relheight=1)
def _create_step2_widgets(self): self.current_step = 2 assert self.xcorr_ca is not None self.ROOT_FRAME_2 = tk.Frame(self) self.ROOT_FRAME_2.pack(fill=tk.BOTH, expand=1) upper_frame_2 = tk.LabelFrame(self.ROOT_FRAME_2, text="Station code: " + self.station_code) upper_frame_2.pack(anchor=tk.N, side=tk.TOP) coeff_widgets_frame_2 = tk.Frame(upper_frame_2) coeff_widgets_frame_2.pack(anchor=tk.NW, side=tk.TOP, padx=2, pady=2) coeff_widgets_label = tk.Label(coeff_widgets_frame_2, font=8, text="Tune coefficients to optimize clustering and filtering of outliers") coeff_widgets_label.pack(anchor=tk.W, side=tk.TOP, pady=2) coeff0_label = tk.LabelFrame(coeff_widgets_frame_2, text="Coefficient 0 (x-separation)") coeff0_label.pack(anchor=tk.W, side=tk.LEFT, padx=2) coeff0_spinbox = tk.Spinbox(coeff0_label, from_=0.0, to=100.0, increment=0.1, textvariable=self.cluster_coeff0) coeff0_spinbox.pack(padx=2, pady=2) coeff1_label = tk.LabelFrame(coeff_widgets_frame_2, text="Coefficient 1 (y-separation)") coeff1_label.pack(anchor=tk.W, side=tk.LEFT, padx=2) coeff1_spinbox = tk.Spinbox(coeff1_label, from_=0.0, to=100.0, increment=0.1, textvariable=self.cluster_coeff1) coeff1_spinbox.pack(padx=2, pady=2) coeff2_label = tk.LabelFrame(coeff_widgets_frame_2, text="Coefficient 2 (slope)") coeff2_label.pack(anchor=tk.W, side=tk.LEFT, padx=2) coeff2_spinbox = tk.Spinbox(coeff2_label, from_=0.0, to=100.0, increment=0.1, textvariable=self.cluster_coeff2) coeff2_spinbox.pack(padx=2, pady=2) control_buttons_frame_2 = tk.Frame(upper_frame_2) control_buttons_frame_2.pack(anchor=tk.NW, side=tk.TOP, padx=2, pady=2, fill=tk.X) self.next_button = tk.Button(control_buttons_frame_2) self.next_button['text'] = "Continue..." self.next_button['command'] = self._goto_step3 self.next_button.pack(anchor=tk.NW, side=tk.LEFT) self.quit_button = tk.Button(control_buttons_frame_2) self.quit_button['text'] = "Quit" self.quit_button['command'] = self._quit_app self.quit_button.pack(anchor=tk.SE, side=tk.RIGHT) lower_frame_2 = tk.LabelFrame(self.ROOT_FRAME_2, text="Clustering Result") lower_frame_2.pack(anchor=tk.N, side=tk.TOP) self.cluster_figure_canvas_2 = tk.Canvas(lower_frame_2) self.cluster_figure_canvas_2.pack(anchor=tk.N, side=tk.TOP, fill=tk.BOTH, expand=True, padx=4, pady=4) self._refresh_clustering_canvas() self.update() coeff0_spinbox['command'] = self._refresh_clustering_canvas coeff1_spinbox['command'] = self._refresh_clustering_canvas coeff2_spinbox['command'] = self._refresh_clustering_canvas coeff0_spinbox.bind('<FocusOut>', self._refresh_clustering_canvas) coeff0_spinbox.bind('<Return>', self._refresh_clustering_canvas) coeff1_spinbox.bind('<FocusOut>', self._refresh_clustering_canvas) coeff1_spinbox.bind('<Return>', self._refresh_clustering_canvas) coeff2_spinbox.bind('<FocusOut>', self._refresh_clustering_canvas) coeff2_spinbox.bind('<Return>', self._refresh_clustering_canvas)
def build_grid(self): """ construir los objetos necesarios """ self.canvas = tk.Canvas(self.window, bg='white', height=MAZE_H * UNIT, width=MAZE_W * UNIT) # grillar un tabla de UNIT * UNIT, iterar para ambos lados for c in range(0, MAZE_W * UNIT, UNIT): x0, y0, x1, y1 = c, 0, c, MAZE_W * UNIT self.canvas.create_line(x0, y0, x1, y1) for r in range(0, MAZE_H * UNIT, UNIT): x0, y0, x1, y1 = 0, r, MAZE_H * UNIT, r self.canvas.create_line(x0, y0, x1, y1) # punto de comienzo en el centro origin = np.array([int(UNIT / 2), int(UNIT / 2)]) # definir centro de la celda hell1_center = origin + np.array([UNIT * 2, UNIT]) # infierno 1 self.hell1 = self.canvas.create_rectangle(hell1_center[0] - 15, hell1_center[1] - 15, hell1_center[0] + 15, hell1_center[1] + 15, fill='black') # infierno 2 hell2_center = origin + np.array([UNIT, UNIT * 2]) self.hell2 = self.canvas.create_rectangle(hell2_center[0] - 15, hell2_center[1] - 15, hell2_center[0] + 15, hell2_center[1] + 15, fill='black') # infierno 3 hell3_center = origin + np.array([UNIT, UNIT * 5]) self.hell3 = self.canvas.create_rectangle(hell3_center[0] - 15, hell3_center[1] - 15, hell3_center[0] + 15, hell3_center[1] + 15, fill='black') # infierno 4 hell4_center = origin + np.array([UNIT * 8, UNIT * 5]) self.hell4 = self.canvas.create_rectangle(hell4_center[0] - 15, hell4_center[1] - 15, hell4_center[0] + 15, hell4_center[1] + 15, fill='black') # infierno 5 hell5_center = origin + np.array([UNIT * 9, UNIT * 2]) self.hell5 = self.canvas.create_rectangle(hell5_center[0] - 15, hell5_center[1] - 15, hell5_center[0] + 15, hell5_center[1] + 15, fill='black') # infierno 6 hell6_center = origin + np.array([UNIT * 10, UNIT * 10]) self.hell6 = self.canvas.create_rectangle(hell6_center[0] - 15, hell6_center[1] - 15, hell6_center[0] + 15, hell6_center[1] + 15, fill='black') # infierno 7 hell7_center = origin + np.array([UNIT * 6, UNIT * 8]) self.hell7 = self.canvas.create_rectangle(hell7_center[0] - 15, hell7_center[1] - 15, hell7_center[0] + 15, hell7_center[1] + 15, fill='black') # infierno 8 hell8_center = origin + np.array([UNIT * 5, UNIT * 8]) self.hell8 = self.canvas.create_rectangle(hell8_center[0] - 15, hell8_center[1] - 15, hell8_center[0] + 15, hell8_center[1] + 15, fill='black') # infierno 9 hell9_center = origin + np.array([UNIT * 3, UNIT * 3]) self.hell9 = self.canvas.create_rectangle(hell9_center[0] - 15, hell9_center[1] - 15, hell9_center[0] + 15, hell9_center[1] + 15, fill='black') # infierno 10 hell10_center = origin + np.array([UNIT * 3, UNIT * 3]) self.hell10 = self.canvas.create_rectangle(hell10_center[0] - 15, hell10_center[1] - 15, hell10_center[0] + 15, hell10_center[1] + 15, fill='black') # crear donde esta el oro oval_center1 = origin + UNIT * 4 self.oval1 = self.canvas.create_oval(oval_center1[0] - 15, oval_center1[1] - 15, oval_center1[0] + 15, oval_center1[1] + 15, fill='yellow') oval_center2 = origin + np.array([UNIT * 7, UNIT * 7]) self.oval2 = self.canvas.create_oval(oval_center2[0] - 15, oval_center2[1] - 15, oval_center2[0] + 15, oval_center2[1] + 15, fill='yellow') oval_center3 = origin + np.array([UNIT * 9, UNIT * 1]) self.oval3 = self.canvas.create_oval(oval_center3[0] - 15, oval_center3[1] - 15, oval_center3[0] + 15, oval_center3[1] + 15, fill='yellow') # crear el rectangulo del agente self.rect = self.canvas.create_rectangle(origin[0] - 15, origin[1] - 15, origin[0] + 15, origin[1] + 15, fill='green') # tomar todos con método pack de canvas self.canvas.pack()
def fillInUI(self, parent): parent.columnconfigure(0, pad=2) parent.columnconfigure(1, pad=2) import itertools row = itertools.count() self.showBackbone = BackboneOption(parent, row.next(), 'Show backbone as', 'ribbon', None) self.showSide = SideOption(parent, row.next(), 'Show side (sugar/base) as', 'fill/slab', self._showSideCB) self.showOrientation = BooleanOption(parent, row.next(), 'Show base orientation', default.ORIENT, None) import Tix self.nb = Tix.NoteBook(parent) self.nb.grid(row=row.next(), column=0, columnspan=2, sticky=Tk.EW, padx=2) # ladder page self.nb.add("ladder", label="Ladder Options") f = self.nb.page("ladder") if Tk.TkVersion >= 8.5: parent.tk.call('grid', 'anchor', f._w, Tk.N) prow = itertools.count() self.skipNonBase = BooleanOption(f, prow.next(), 'Ignore non-base H-bonds', default.IGNORE, None) self.showStubs = BooleanOption(f, prow.next(), 'Show stubs', default.STUBS, None) self.rungRadius = FloatOption(f, prow.next(), 'Rung radius', default.RADIUS, None) self.rungRadius.min = 0.0 self.useExisting = BooleanOption(f, prow.next(), 'Using existing H-bonds', default.USE_EXISTING, self._useExistingCB) from FindHBond.gui import RelaxParams self.relaxParams = RelaxParams(f, None, colorOptions=False) #self.relaxParams.relaxConstraints = False self.relaxParams.grid(row=prow.next(), columnspan=2, sticky='nsew', padx=2) # slab page self.nb.add("slab", label="Slab Options") f = self.nb.page("slab") if Tk.TkVersion >= 8.5: parent.tk.call('grid', 'anchor', f._w, Tk.N) prow = itertools.count() self.thickness = FloatOption(f, prow.next(), 'Thickness', default.THICKNESS, None) self.thickness.min = 0.01 self.shape = ShapeOption(f, prow.next(), 'Slab object', default.SHAPE, None) self.hideBases = BooleanOption(f, prow.next(), 'Hide base atoms', default.HIDE, None) self.showGlycosidic = BooleanOption(f, prow.next(), 'Separate glycosidic bond', default.GLYCOSIDIC, None) self.nb.add("style", label="Slab Style", raisecmd=self.map) # style page f = self.nb.page("style") if Tk.TkVersion >= 8.5: f.tk.call('grid', 'anchor', f._w, Tk.N) info = NA.findStyle(self.currentStyle) from chimera.preferences import saveui f2 = Tk.Frame(f) self.saveui = saveui.SaveUI(f2, self) f2.grid(row=prow.next(), column=0, columnspan=2, sticky=Tk.EW, padx=2, pady=2) self.anchor = AnchorOption(f, prow.next(), 'Anchor', info[NA.ANCHOR], self._drawStyle) f2 = Pmw.Group(f, tag_text=NA.PURINE.title()) f2.grid(row=prow.next(), column=0, columnspan=2, sticky=Tk.EW, padx=2) f2 = f2.interior() f2.columnconfigure(0, weight=1, pad=2, uniform='a') f2.columnconfigure(1, weight=1, uniform='a') f2.columnconfigure(2, weight=1) self.purine_canvas = Tk.Canvas(f2, width=1, height=1) #, #borderwidth=2, relief=Tk.RIDGE) r = prow.next() self.purine_canvas.grid(row=r, column=0, rowspan=3, sticky=Tk.NSEW, padx=2, pady=2) corners = info[NA.PURINE] self.puLL = Float2Option(f2, prow.next(), 'Lower left', corners[0], self._drawStyle, startCol=1) self.puUR = Float2Option(f2, prow.next(), 'Upper right', corners[1], self._drawStyle, startCol=1) f3 = Pmw.Group(f, tag_text="%s, %s" % (NA.PYRIMIDINE.title(), NA.PSEUDO_PYRIMIDINE.title())) r = prow.next() f3.grid(row=r, column=0, columnspan=2, sticky=Tk.EW, padx=2) f3 = f3.interior() f3.columnconfigure(0, weight=1, pad=2, uniform='a') f3.columnconfigure(1, weight=1, uniform='a') f3.columnconfigure(2, weight=1) self.pyrimidine_canvas = Tk.Canvas(f3, width=1, height=1) #, #borderwidth=2, relief=Tk.RIDGE) r = prow.next() self.pyrimidine_canvas.grid(row=r, column=0, rowspan=3, sticky=Tk.NSEW, padx=2, pady=2) corners = info[NA.PYRIMIDINE] self.pyLL = Float2Option(f3, prow.next(), 'Lower left', corners[0], self._drawStyle, startCol=1) self.pyUR = Float2Option(f3, prow.next(), 'Upper right', corners[1], self._drawStyle, startCol=1) self.restrict = Tk.IntVar(parent) self.restrict.set(1) cb = Tk.Checkbutton(parent, variable=self.restrict, text="Restrict OK/Apply to current selection, if any") cb.grid(row=row.next(), columnspan=2) parent.pack(ipady=2) self._showSideCB() chimera.triggers.addHandler(NA.TRIGGER_SLAB_STYLES, self._updateStyles, None)
def __init__(self): # Variable for showing the "ruler" to false self.ViewOffsets = False # Variable used to track the width and height of a character # Narrow = 8 bits # Wide = 16 bits self.charwidth = 8 self.charheight = 19 # Variable for tracking the margin size (both Vertical and Horizontal) of the canvas # attempting to draw outside of this margin will not be rendered on the canvas self.margins = 2 # Variable for tracking this Tk Widget's root widget self.root = Tkinter.Tk() # Set the Title bar of the widget self.root.title("UEFI Glyph Creator") # Calculate the height/width of each square in a glyph # if the resolution is low, then set a minimum of 20 self.smallestsquare = self.root.winfo_screenheight() / 70 if self.smallestsquare < 20: self.smallestsquare = 20 # Set the current square size based on the smallest square self.square = self.smallestsquare # Create a Menu, and configure the root widget to use it menubar = Tkinter.Menu(self.root, tearoff=0) self.root.config(menu=menubar) # Add an Edit Menu to the menu bar EditMenu = Tkinter.Menu(menubar, tearoff=0) EditMenu.add_command(label="Increase Size", command=self.IncreaseSize) EditMenu.add_command(label="Decrease Size", command=self.DecreaseSize) EditMenu.add_checkbutton(label="Show Offsets", variable=self.ViewOffsets, command=self.SwitchShowOffsets) EditMenu.add_command(label="Clear", command=self.Clear) menubar.add_cascade(label="Edit", menu=EditMenu) # Add an Options menu to the menu bar OptionsMenu = Tkinter.Menu(menubar, tearoff=0) OptionsMenu.add_checkbutton(label="WideChar", variable=self.charwidth, command=self.SwitchToWideChar) OptionsMenu.add_command(label="Copy To Clipboard", command=self.CopyBufferToClipBoard) OptionsMenu.add_command(label="Import from ClipBoard", command=self.ImportClipBoardToBuffer) menubar.add_cascade(label="Options", menu=OptionsMenu) # Add a Help menu to the menu bar HelpMenu = Tkinter.Menu(menubar, tearoff=0) HelpMenu.add_command(label="About", command=self.About) menubar.add_cascade(label="Help", menu=HelpMenu) # Create a Canvas widget and add it to the root Widget self.canvas = Tkinter.Canvas(self.root, bg="white") self.canvas.pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) # Bind the left mouse button click to function Clicked self.root.bind('<Button-1>', self.Clicked) # Bind keypad + and the plus keys to the IncreaseSize function self.root.bind('<KP_Add>', self.IncreaseSize) self.root.bind('<plus>', self.IncreaseSize) # Bind keypad - and the minus keys to the DecreaseSize function self.root.bind('<KP_Subtract>', self.DecreaseSize) self.root.bind('<minus>', self.DecreaseSize) # Initialize the Canvas area with the Glyph Information self.InitializeCanvas() # Create a status bar that show the current Width and Height self.StatusBar = Tkinter.Label(self.root, text="", bd=1, relief=Tkinter.GROOVE, anchor=Tkinter.W) self.StatusBar.config(text="Width = %d Height = %d " % (self.charwidth, self.charheight)) self.StatusBar.pack(side=Tkinter.TOP, fill=Tkinter.X) # Start the Widget self.root.mainloop()
root.bind('<Alt-Key-x>', callback) root.bind('<Button2-Motion>', drag) box.bind('<<ListboxSelect>>', selected) box.bind('b', wrap(swap, box)) prog = ttk.Progressbar(frame, orient='horizontal', length=500, mode='determinate', maximum=5, value=0) prog.grid(column=0, row=6) # prog.bind('<Double-Button-1>', wrap(step, prog)) prog.bind('<Button-1>', wrap(start, prog)) prog.bind('<Double-Button-1>', wrap(stop, prog)) canvas = tkinter.Canvas(frame, width=500, height=500) canvas.grid(row=5, column=0) canvas.create_line(10, 10, 490, 490) canpoint = [0, 0] canvas.bind('<Button-1>', (lambda *args: begin_lines(canvas, canpoint, *args))) canvas.bind('<Button1-Motion>', (lambda *args: draw_line(canvas, canpoint, *args))) try: label.configure(image=pim) except: traceback.print_exc() do = False if do:
class TkinterEvent(object): x_root = 0 y_root = 0 x = 0 y = 0 widget = tk.Canvas()
radialPixPerDeg = float(self.endRad - self.begRad) / (self.endAng - self.begAng) radPix = self.begRad + (radialPixPerDeg * (ang - self.begAng)) adjAng = (ang * self.angScale) + self.angOff xPos = self.xctr + (radPix * RO.MathUtil.cosd(adjAng)) yPos = self.yctr - (radPix * RO.MathUtil.sind(adjAng)) return (xPos, yPos) if __name__ == '__main__': from RO.Wdg.PythonTk import PythonTk root = PythonTk() cnv = Tkinter.Canvas(root, width=201, height=201) cnv.pack() ctrPlus(cnv, 80, 80, 10, 5) ctrPlus(cnv, 100, 80, 10, 5, 5) ctrX(cnv, 80, 100, 10, 5) ctrX(cnv, 100, 100, 10, 5, 5) ctrCircle(cnv, 80, 120, 10, 1) ctrCircle(cnv, 100, 120, 10, 5) ctrCircle(cnv, 120, 80, 10) ctrPlus(cnv, 120, 80, 10, holeRad=5) ctrX(cnv, 120, 80, 10, holeRad=5) ctrCircle(cnv, 120, 100, 10, width=5) ctrPlus(cnv, 120, 100, 10, holeRad=5, width=5) ctrX(cnv, 120, 100, 10, holeRad=5, width=5)
def __init__(self, master, board): self.__margin = 20 self.__tile_size = 40 self.__canvas_width = None self.__canvas_height = None self.__robot_images = {} self.__target_images = {} self.__solution_images = [] self.__direction_images = [] self.__entered = set() self.__slots = {} self.__highlights = {} self.__targets = {} self.__moves = {} self.__moves_short = {} self.__robots = {} self.__barriers = {} self.__tiles = [] self.__canvas_width = board.size * self.__tile_size + 2 * self.__margin self.__canvas_height = ( 1 + board.size) * self.__tile_size + 3 * self.__margin self.__canvas = Tkinter.Canvas(master, width=self.__canvas_width, height=self.__canvas_height) self.__canvas.pack() colors = ['green', 'red', 'blue', 'yellow'] shapes = ['moon', 'sun', 'star', 'saturn'] directions = [('north', 0, -1), ("east", 1, 0), ('south', 0, 1), ('west', -1, 0)] for orientation in ['left', 'right']: path = 'img/tile_{orientation}.gif'.format(orientation=orientation) self.__tiles.append(Tkinter.PhotoImage(file=path)) for direction in ['north', 'west']: path = 'img/wall_{direction}.gif'.format(direction=direction) self.__barriers[direction] = (Tkinter.PhotoImage(file=path), -6, -6) for color in colors: path = 'img/robot_{color}.gif'.format(color=color) self.__robots[color] = Tkinter.PhotoImage(file=path) for shape in shapes: path = "img/{shape}_{color}.gif".format(shape=shape, color=color) self.__targets[(color, shape)] = Tkinter.PhotoImage(file=path) for (direction, dx, dy) in directions: path = "img/arrow_{color}_{direction}.gif".format( color=color, direction=direction) self.__moves[(color, dx, dy)] = Tkinter.PhotoImage(file=path) path = "img/move_{color}_{direction}.gif".format( color=color, direction=direction) self.__moves_short[(color, dx, dy)] = Tkinter.PhotoImage(file=path) for x in range(0, board.size): for y in range(0, board.size): self.__canvas.create_image( self.__margin + self.__tile_size * x, self.__margin + self.__tile_size * y, anchor=Tkinter.NW, image=self.__tiles[(x + y) % len(self.__tiles)]) for (t, m, x, y) in board.targets: self.__target_images[(x, y)] = self.__canvas.create_image( self.__margin + self.__tile_size * x, self.__margin + self.__tile_size * y, anchor=Tkinter.NW, image=self.__targets[(t, m)]) self.__canvas.itemconfig(self.__target_images[(x, y)], state=Tkinter.HIDDEN) for (r, (x, y)) in board.pos.items(): self.__robot_images[r] = self.__canvas.create_image( self.__margin + self.__tile_size * x, self.__margin + self.__tile_size * y, anchor=Tkinter.NW, image=self.__robots[r]) for (d, x, y) in board.barriers: (img, dx, dy) = self.__barriers[d] self.__canvas.create_image( self.__margin + self.__tile_size * x + dx, self.__margin + self.__tile_size * y + dy, anchor=Tkinter.NW, image=img) self.__solve_button = self.__canvas.create_text( board.size * self.__tile_size / 2 + self.__margin, (0.5 + board.size) * self.__tile_size + 2 * self.__margin, text="Solve!", activefill="blue", state=Tkinter.HIDDEN) self.__solving_text = self.__canvas.create_text( board.size * self.__tile_size / 2 + self.__margin, (0.5 + board.size) * self.__tile_size + 2 * self.__margin, text="Solving...", state=Tkinter.HIDDEN) self.__canvas.bind('<Motion>', self.__mouse_move_event) self.__canvas.bind('<Button-1>', self.__mouse_click_event)
# Uses vector math to compute the new velocities after the collision has commenced. '''https://en.wikipedia.org/wiki/Elastic_collision#Two-dimensional_collision_with_two_moving_objects''' v1f = scalar_product(COLLISION_LOSS, subtract_vectors(v1, scalar_product(float(dot_product(subtract_vectors(v1,v2),subtract_vectors(x1,x2)))/float(square_sum(subtract_vectors(x1,x2))), subtract_vectors(x1,x2)))) v2f = subtract_vectors(add_vectors(v1,v2),v1f) # Conservation of momentum return [v1f, v2f] ''' Tkinter Canvas ''' root = TK.Tk() root.wm_title('MiniPool') canvas = TK.Canvas(root, width=DIMENSIONS[0], height=DIMENSIONS[1], background='#FFFFFF') canvas.grid(row=0, column=0, columnspan=4) speed_intvar = TK.IntVar() speed_intvar.set(0) direction_intvar = TK.IntVar() direction_intvar.set(360) # Buttons and sliders start_button = TK.Button(root, text='New Game', command=new_game) start_button.grid(row=1, column=0) shoot_button = TK.Button(root, text='Shoot', command=shoot, state=TK.ACTIVE, disabledforeground='#000000') shoot_button.grid(row=1, column=3) direction_slider = TK.Scale(root, from_=0, to=720, orient=TK.HORIZONTAL, length = 760, variable=direction_intvar, label='Direction', command=adjust_trajectory, showvalue=0) direction_slider.grid(row=1, column=1)
x += d * (0.5 - random.random()) * 0.25 y += d * (0.5 - random.random()) * 0.25 x += x0 y += y0 dots.append(Point(x, y)) dots.append(Point(x1, y1)) return dots if __name__ == "__main__": root = tk.Tk() root.title("Tree") gw, gh = 800, 600 canvas = tk.Canvas( root, width=gw, height=gh, ) canvas.pack() tree = Tree(root, canvas, Point(gw / 2, gh - 20), Point(gw / 2, gh * 0.2), branches=2, depth=8) root.bind("n", lambda evt: tree.new()) root.bind("=", lambda evt: tree.chgDepth(0)) root.bind("w", lambda evt: tree.chgDepth(1)) root.bind("s", lambda evt: tree.chgDepth(-1)) root.bind("a", lambda evt: tree.chgBranch(1)) root.bind("d", lambda evt: tree.chgBranch(-1))
def __init__(self, root, options): """ web2pyDialog constructor """ import Tkinter import tkMessageBox bg_color = 'white' root.withdraw() self.root = Tkinter.Toplevel(root, bg=bg_color) self.root.resizable(0, 0) self.root.title(ProgramName) self.options = options self.scheduler_processes = {} self.menu = Tkinter.Menu(self.root) servermenu = Tkinter.Menu(self.menu, tearoff=0) httplog = os.path.join(self.options.folder, self.options.log_filename) iconphoto = os.path.join('extras', 'icons', 'web2py.gif') if os.path.exists(iconphoto): img = Tkinter.PhotoImage(file=iconphoto) self.root.tk.call('wm', 'iconphoto', self.root._w, img) # Building the Menu item = lambda: start_browser(httplog) servermenu.add_command(label='View httpserver.log', command=item) servermenu.add_command(label='Quit (pid:%i)' % os.getpid(), command=self.quit) self.menu.add_cascade(label='Server', menu=servermenu) self.pagesmenu = Tkinter.Menu(self.menu, tearoff=0) self.menu.add_cascade(label='Pages', menu=self.pagesmenu) #scheduler menu self.schedmenu = Tkinter.Menu(self.menu, tearoff=0) self.menu.add_cascade(label='Scheduler', menu=self.schedmenu) #start and register schedulers from options self.update_schedulers(start=True) helpmenu = Tkinter.Menu(self.menu, tearoff=0) # Home Page item = lambda: start_browser('http://www.web2py.com/') helpmenu.add_command(label='Home Page', command=item) # About item = lambda: tkMessageBox.showinfo('About web2py', ProgramInfo) helpmenu.add_command(label='About', command=item) self.menu.add_cascade(label='Info', menu=helpmenu) self.root.config(menu=self.menu) if options.taskbar: self.root.protocol('WM_DELETE_WINDOW', lambda: self.quit(True)) else: self.root.protocol('WM_DELETE_WINDOW', self.quit) sticky = Tkinter.NW # Prepare the logo area self.logoarea = Tkinter.Canvas(self.root, background=bg_color, width=300, height=300) self.logoarea.grid(row=0, column=0, columnspan=4, sticky=sticky) self.logoarea.after(1000, self.update_canvas) logo = os.path.join('extras', 'icons', 'splashlogo.gif') if os.path.exists(logo): img = Tkinter.PhotoImage(file=logo) pnl = Tkinter.Label(self.logoarea, image=img, background=bg_color, bd=0) pnl.pack(side='top', fill='both', expand='yes') # Prevent garbage collection of img pnl.image = img # Prepare the banner area self.bannerarea = Tkinter.Canvas(self.root, bg=bg_color, width=300, height=300) self.bannerarea.grid(row=1, column=1, columnspan=2, sticky=sticky) Tkinter.Label(self.bannerarea, anchor=Tkinter.N, text=str(ProgramVersion + "\n" + ProgramAuthor), font=('Helvetica', 11), justify=Tkinter.CENTER, foreground='#195866', background=bg_color, height=3).pack(side='top', fill='both', expand='yes') self.bannerarea.after(1000, self.update_canvas) # IP Tkinter.Label(self.root, text='Server IP:', bg=bg_color, justify=Tkinter.RIGHT).grid(row=4, column=1, sticky=sticky) self.ips = {} self.selected_ip = Tkinter.StringVar() row = 4 ips = [('127.0.0.1', 'Local (IPv4)')] + \ ([('::1', 'Local (IPv6)')] if socket.has_ipv6 else []) + \ [(ip, 'Public') for ip in options.ips] + \ [('0.0.0.0', 'Public')] for ip, legend in ips: self.ips[ip] = Tkinter.Radiobutton( self.root, bg=bg_color, highlightthickness=0, selectcolor='light grey', width=30, anchor=Tkinter.W, text='%s (%s)' % (legend, ip), justify=Tkinter.LEFT, variable=self.selected_ip, value=ip) self.ips[ip].grid(row=row, column=2, sticky=sticky) if row == 4: self.ips[ip].select() row += 1 shift = row # Port Tkinter.Label(self.root, text='Server Port:', bg=bg_color, justify=Tkinter.RIGHT).grid(row=shift, column=1, pady=10, sticky=sticky) self.port_number = Tkinter.Entry(self.root) self.port_number.insert(Tkinter.END, self.options.port) self.port_number.grid(row=shift, column=2, sticky=sticky, pady=10) # Password Tkinter.Label(self.root, text='Choose Password:'******'*') self.password.bind('<Return>', lambda e: self.start()) self.password.focus_force() self.password.grid(row=shift + 1, column=2, sticky=sticky) # Prepare the canvas self.canvas = Tkinter.Canvas(self.root, width=400, height=100, bg='black') self.canvas.grid(row=shift + 2, column=1, columnspan=2, pady=5, sticky=sticky) self.canvas.after(1000, self.update_canvas) # Prepare the frame frame = Tkinter.Frame(self.root) frame.grid(row=shift + 3, column=1, columnspan=2, pady=5, sticky=sticky) # Start button self.button_start = Tkinter.Button(frame, text='start server', command=self.start) self.button_start.grid(row=0, column=0, sticky=sticky) # Stop button self.button_stop = Tkinter.Button(frame, text='stop server', command=self.stop) self.button_stop.grid(row=0, column=1, sticky=sticky) self.button_stop.configure(state='disabled') if options.taskbar: import gluon.contrib.taskbar_widget self.tb = gluon.contrib.taskbar_widget.TaskBarIcon() self.checkTaskBar() if options.password != '<ask>': self.password.insert(0, options.password) self.start() self.root.withdraw() else: self.tb = None
def __init__(self, master=None, label=None, minval=0.0, maxval=100.0, incr=None, init=None, width=150, height=20, withValue=1, immediate=1, left=10, right=10 , labelformat = '%4.2f', cursortype='float', lookup=None): CallbackFunctions.__init__(self) self.frame = Tkinter.Frame(master) self.lastx=0 self.immediate = immediate self.labelformat = labelformat self.cursortype = cursortype if not label: label = '' #'slider' fnt='-*-helvetica-medium-r-narrow-*-*-120-*-*-*-*-*-*' self.label = Tkinter.Label(self.frame, text=label, font=fnt) self.label.pack(side=Tkinter.LEFT) if withValue: height = max(30, height) self.withValue = withValue self.draw = Tkinter.Canvas(self.frame, width=width, height=height, relief=Tkinter.SUNKEN) self.width = width self.height = height self.left = left self.right = width-right # MS May 1st add support for discrete set of values self.lookup = lookup # can be set to a list of values indexed by # int(value) if lookup is not None: # force min and max to provide proper indices minval = 0.0 maxval = len(lookup)-1 incr = 1 self.max=maxval self.min=minval self._ComputeCst() self.incr = incr self.incrCanvas = None if incr: self.incrCanvas = round(incr*self.cst) if withValue: m = self.height / 2 else: m = int(self.height * 0.75) self.middle = m self.draw.create_line( self.left, m, self.right, m, width=2, fill='black') y = m-10 # 10 is the cursor's height l = self.left self.cursor = self.draw.create_polygon( l, m, l+5, y, l-5, y, l, m, fill='blue', tag='cursor') if withValue: y = self.middle+10 self.valueLabel = self.draw.create_text( l, y, text= str(minval), font=fnt, tag='cursor') self.draw.pack(side = Tkinter.RIGHT) if init is None: init = self.min if self.lookup: init = self.lookup.index(init) self.Set(init) Tkinter.Widget.bind(self.draw, "<1>", self.MoveCursor) Tkinter.Widget.bind(self.draw, "<B1-Motion>", self.MoveCursor) if not immediate: Tkinter.Widget.bind(self.draw, "<ButtonRelease-1>", self.MouseUp)
g.SetRandomNodePosition() # create the window object for painting the graph on root = tk.Tk() # make it cover the entire screen w, h = root.winfo_screenwidth(), root.winfo_screenheight() root.overrideredirect(1) root.geometry("%dx%d+0+0" % (w, h)) c_width = w - border * 2 c_height = h - border * 2 root.title("Force directed layout of graphs (by Mathias Bader) - version 0.1") c = tk.Canvas(root, width=c_width + 2 * border, height=c_height + 2 * border, bg='white') # left-click c.bind("<Button-1>", event_button1_pressed) c.bind("<B1-Motion>", event_button1_motion) c.bind("<ButtonRelease-1>", event_button1_released) # right-click c.bind("<Button-3>", event_button3_pressed) c.bind("<B3-Motion>", event_button3_motion) c.bind("<ButtonRelease-3>", event_button3_released) # keyboard key c.bind("<Key>", key_pressed) c.pack() c.focus_set() g.paintGraph()
def initUI(self): ################################################################### # Create a Hamster joystick window which contains # 1. a canvas widget where "sensor readings" are displayed # 2. a square representing Hamster # 3. 4 canvas items to display floor sensors and prox sensors # 4. a button for exit, i.e., a call to stopProg(), given in this class # 5. listen to key press and key release when focus is on this window ################################################################### # canvas calculation canvas_width = 1280 / 2 canvas_height = 720 / 2 # robot calculation robot_side = 100 robot_center_x = canvas_width / 2 robot_center_y = canvas_height / 2 robot_x1 = robot_center_x - robot_side / 2 robot_y1 = robot_center_y - robot_side / 2 robot_x2 = robot_center_x + robot_side / 2 robot_y2 = robot_center_y + robot_side / 2 # floor left calculation floor_side = 10 floorl_x1 = robot_x1 floorl_y1 = robot_y1 floorl_x2 = robot_x1 + floor_side floorl_y2 = robot_y1 + floor_side # floor right calculation floorr_x1 = robot_x1 + robot_side - floor_side floorr_y1 = robot_y1 floorr_x2 = floorr_x1 + floor_side floorr_y2 = floorr_y1 + floor_side # prox calculation prox_l_x = floorl_x1 prox_l_y = floorl_y1 prox_r_x = floorr_x2 prox_r_y = floorr_y2 - floor_side self.exit = tk.Button(self.root, text='Exit', commands=self.stopProg()) self.exit.pack(side='left') # init everything self.root.title("Hamster") self.root.geometry("1280x720+0+0") self.floor_l_id = tk.Label(self.root, text="FloorLeft: N/A") self.floor_l_id.pack() self.floor_r_id = tk.Label(self.root, text="FloorRight: N/A") self.floor_r_id.pack() self.prox_l_id = tk.Label(self.root, text="ProxLeft: N/A") self.prox_l_id.pack() self.prox_r_id = tk.Label(self.root, text="ProxRight: N/A") self.prox_r_id.pack() self.canvas = tk.Canvas(self.root, width=canvas_width, height=canvas_height, bg="white") self.canvas_robot_id = self.canvas.create_rectangle(robot_x1, robot_y1, robot_x2, robot_y2, fill="gold") self.canvas_floorl_id = self.canvas.create_rectangle(floorl_x1, floorl_y1, floorl_x2, floorl_y2, fill="black") self.canvas_floorr_id = self.canvas.create_rectangle(floorr_x1, floorr_y1, floorr_x2, floorr_y2, fill="black") self.canvas_proxl_id = self.canvas.create_line(prox_l_x, prox_l_y, prox_l_x, prox_l_y, fill="black", width=4) self.canvas_proxr_id = self.canvas.create_line(prox_r_x, prox_r_y, prox_r_x, prox_r_y, fill="black", width=4) self.canvas.pack() # add key listeners self.root.bind('<KeyPress>', self.keydown) self.root.bind('<KeyRelease>', self.keyup)
def __init__(self): # Retrieve params: self._frequency = rospy.get_param('~frequency', 0.0) self._scale = rospy.get_param('~scale', 1.0) self._holonomic = rospy.get_param('~holonomic', False) # Create twist publisher: self._pub_cmd = rospy.Publisher('mouse_vel', Twist, queue_size=100) # Initialize twist components to zero: self._v_x = 0.0 self._v_y = 0.0 self._w = 0.0 # Initialize mouse position (x, y) to None (unknown); it's initialized # when the mouse button is pressed on the _start callback that handles # that event: self._x = None self._y = None # Create window: self._root = Tkinter.Tk() self._root.title('Mouse Teleop') # Make window non-resizable: self._root.resizable(0, 0) # Create canvas: self._canvas = Tkinter.Canvas(self._root, bg='white') # Create canvas objects: self._canvas.create_arc(0, 0, 0, 0, fill='red', outline='red', width=1, style=Tkinter.PIESLICE, start=90.0, tag='w') self._canvas.create_line(0, 0, 0, 0, fill='red', width=4, tag='v_x') if self._holonomic: self._canvas.create_line(0, 0, 0, 0, fill='blue', width=4, tag='v_y') # Create canvas text objects: self._text_v_x = Tkinter.StringVar() if self._holonomic: self._text_v_y = Tkinter.StringVar() self._text_w = Tkinter.StringVar() self._label_v_x = Tkinter.Label(self._root, anchor=Tkinter.W, textvariable=self._text_v_x) if self._holonomic: self._label_v_y = Tkinter.Label(self._root, anchor=Tkinter.W, textvariable=self._text_v_y) self._label_w = Tkinter.Label(self._root, anchor=Tkinter.W, textvariable=self._text_w) if self._holonomic: self._text_v_x.set('v_x = %0.2f m/s' % self._v_x) self._text_v_y.set('v_y = %0.2f m/s' % self._v_y) self._text_w.set('w = %0.2f deg/s' % self._w) else: self._text_v_x.set('v = %0.2f m/s' % self._v_x) self._text_w.set('w = %0.2f deg/s' % self._w) self._label_v_x.pack() if self._holonomic: self._label_v_y.pack() self._label_w.pack() # Bind event handlers: self._canvas.bind('<Button-1>', self._start) self._canvas.bind('<ButtonRelease-1>', self._release) self._canvas.bind('<Configure>', self._configure) if self._holonomic: self._canvas.bind('<B1-Motion>', self._mouse_motion_linear) self._canvas.bind('<Shift-B1-Motion>', self._mouse_motion_angular) self._root.bind('<Shift_L>', self._change_to_motion_angular) self._root.bind('<KeyRelease-Shift_L>', self._change_to_motion_linear) else: self._canvas.bind('<B1-Motion>', self._mouse_motion_angular) self._canvas.pack() # If frequency is positive, use synchronous publishing mode: if self._frequency > 0.0: # Create timer for the given frequency to publish the twist: period = rospy.Duration(1.0 / self._frequency) self._timer = rospy.Timer(period, self._publish_twist) # Start window event manager main loop: self._root.mainloop()
Tkinter GUI Application Development Hotshot """ import Tkinter root = Tkinter.Tk() #pie chart def prop(n): return 360.0 * n / 1000 Tkinter.Label(root, text='Pie Chart').pack() c = Tkinter.Canvas(width=154, height=154) c.pack() c.create_arc((2, 2, 152, 152), fill="#FAF402", outline="#FAF402", start=prop(0), extent=prop(200)) c.create_arc((2, 2, 152, 152), fill="#00AC36", outline="#00AC36", start=prop(200), extent=prop(400)) c.create_arc((2, 2, 152, 152), fill="#7A0871", outline="#7A0871",
def __init__(self, parent, width=8,height=8, position=[0,0], options={}, *args, **kwargs): tk.Frame.__init__(self, parent, *args, **kwargs) # set root of frame self.root = parent self.root.title("Environment") self.root.resizable(0,0) # assign svg-reader, allows reading in svg-figures self.reader = SVGReader() # set constants # conversion of meter to pixels, required for plotting self.meter_to_pixel = options['meter_to_pixel'] if 'meter_to_pixel' in options else 50 self.n_cells = options['n_cells'] if 'n_cells' in options else [20, 20] # [horizontal, vertical] # make environment frame and size it self.frame_width_px = int(width*self.meter_to_pixel) self.frame_height_px = int(height*self.meter_to_pixel) self.frame_width_m = width self.frame_height_m = height # top left corner point of the frame [px] self.position = [pos * self.meter_to_pixel for pos in position] self.canvas = tk.Canvas(self.root, width=self.frame_width_px, height=self.frame_height_px, borderwidth=0, highlightthickness=0) self.canvas.configure(cursor="tcross") self.canvas.grid(row=0,columnspan=3) # round up sizes, such that frame width is guaranteed to be reached self.cell_width_px = int(np.ceil(self.frame_width_px*1./self.n_cells[0])) self.cell_height_px = int(np.ceil(self.frame_height_px*1./self.n_cells[1])) self.rows = self.n_cells[0] self.columns = self.n_cells[1] self.draw_grid() # draw grid in canvas self.obstacles = [] # list to hold all obstacles self.clicked_positions = [] # list to hold all clicked positions self.canvas.bind("<Button-1>", self.make_obstacle) # left mouse button makes obstacle self.canvas.bind("<Button-3>", self.get_position) # right mouse button gives start and goal position # Add buttons ready_button = tk.Button(self.root, text="Ready", fg="green", command=self.build_environment) ready_button.grid(row=2, column=0) quit_button = tk.Button(self.root, text="Quit", fg="red", command=self.canvas.quit) quit_button.grid(row=3, column=0) remove_button = tk.Button(self.root, text="Remove", fg="black", command=self.remove_last_obstacle) remove_button.grid(row=4, column=0) load_button = tk.Button(self.root, text="Load", fg="black", command=self.load_environment) load_button.grid(row=5, column=0) load_svg_button = tk.Button(self.root, text="Load SVG", fg="black", command=self.load_svg) load_svg_button.grid(row=6, column=0) self.save_env = tk.BooleanVar(value=False) label_save = tk.Checkbutton(self.root, text="Save [yes/no]", variable=self.save_env) label_save.grid(row=7,column=0) # indicate cell size self.cell_size_label = tk.Label(self.root, text='Cell size: ' + str(np.round(self.frame_width_m*1./self.n_cells[0],3)) + 'x' + str(np.round(self.frame_height_m*1./self.n_cells[0],3)) + ' [m]') self.cell_size_label.grid(row=1, column=1) # indicate clicked position # self.clickedPos = tk.StringVar() # labelClickedPos = tk.Label(self, text="Clicked position [x,y]") # labelClickedPosEntry = tk.Entry(self, bd =0, textvariable=self.clickedPos) # labelClickedPos.pack() # labelClickedPosEntry.pack() # select obstacle shape (rectangle or circle) self.shape = tk.StringVar() self.circle_button = tk.Radiobutton(self.root, text="Circle", variable=self.shape, value='circle') self.circle_button.grid(row=2, column=2) self.rectangle_button = tk.Radiobutton(self.root, text="Rectangle", variable=self.shape, value='rectangle') self.rectangle_button.grid(row=3,column=2) # select obstacle size self.width = tk.DoubleVar() label_width = tk.Label(self.root, text="Width [m]") label_width_entry = tk.Entry(self.root, bd =0, textvariable=self.width) label_width.grid(row=2,column=1) label_width_entry.grid(row=3,column=1) self.height = tk.DoubleVar() label_height = tk.Label(self.root, text="Height [m]") label_height_entry = tk.Entry(self.root, bd =0, textvariable=self.height) label_height.grid(row=4,column=1) label_height_entry.grid(row=5,column=1) self.radius = tk.DoubleVar() label_radius = tk.Label(self.root, text="Radius [m]") label_radius_entry = tk.Entry(self.root, bd =0, textvariable=self.radius) label_radius.grid(row=6,column=1) label_radius_entry.grid(row=7,column=1) # select obstacle velocity self.vel_x = tk.DoubleVar(value=0.0) label_velx = tk.Label(self.root, text="x-velocity [m/s]") label_velx_entry = tk.Entry(self.root, bd =0, textvariable=self.vel_x) label_velx.grid(row=4,column=2) label_velx_entry.grid(row=5,column=2) self.vel_y = tk.DoubleVar(value=0.0) label_vely = tk.Label(self.root, text="y-velocity [m/s]") label_vely_entry = tk.Entry(self.root, bd =0, textvariable=self.vel_y) label_vely.grid(row=6,column=2) label_vely_entry.grid(row=7,column=2) # select if moving obstacle should bounce off other obstacles or off the walls self.bounce = tk.BooleanVar(value=False) label_bounce = tk.Checkbutton(self.root, text="Bounce [yes/no]", variable=self.bounce) label_bounce.grid(row=8,column=2) # add scrollbars self.hbar=tk.Scrollbar(self.root,orient=tk.HORIZONTAL) self.hbar.grid(row=9, column = 0) self.hbar.config(command=self.canvas.xview) self.vbar=tk.Scrollbar(self.root,orient=tk.VERTICAL) self.vbar.grid(row=0, column = 3) self.vbar.config(command=self.canvas.yview) self.canvas.config(width=1000, height=600) # limit canvas size such that it fits on screen self.canvas.config(xscrollcommand=self.hbar.set, yscrollcommand=self.vbar.set)
def initUI(self): self.parent.title("Cryo Shield") self.grid(row=0, column=0) self.tCernox = Tk.StringVar() self.tCernox.set("153.52 K") self.pollLongAB = Tk.IntVar() self.pollLongCERNOX = Tk.IntVar() self.whichDataSet = 0 #ITEMS - First specify all the items! title = Tk.Label(self.parent, text="DNP Insert CryoShield", font="TkHeadingFont 16", foreground="#000000") ### ALLEN BRADLEY abDataFrame = Tk.LabelFrame(self.parent, bd=1, text="Allen-Bradley", width=15) self.fig = Figure(figsize=(8, 3.5)) self.ax1 = self.fig.add_axes([0.1, 0.1, 0.8, 0.8]) self.ax1.set_ylabel("AB1") self.ax1.set_xlabel("Time (s)") self.ax1.grid(False) self.ax1.set_xlim([self.pOAB.xlimL, self.pOAB.xlimU]) self.ax1.set_ylim([self.pOAB.ylimL, self.pOAB.ylimU]) self.canvas = FigureCanvasTkAgg(self.fig, master=abDataFrame) plotOptionButtonAB = Tk.Button( abDataFrame, text="Plot Options", command=lambda: self.changePlotOptionsAB(self.pOAB, only="AB")) longTermSignalAB = Tk.Checkbutton(abDataFrame, text=" Long term", variable=self.pollLongAB, command=self.readCryoShield) #use the frame colour to match the plot colour for a given resistor! levelCanvas = Tk.Canvas(abDataFrame, width=400, height=50) levelCanvas.create_rectangle(30, 10, 120, 40, outline="#f00", fill="#acf") levelCanvas.create_rectangle(150, 10, 240, 40, outline="#f0f", fill="#acf") levelCanvas.create_rectangle(270, 10, 370, 40, outline="#00f", fill="#acf") #Cernox Frame cernoxFrame = Tk.LabelFrame(self.parent, bd=1, text="Cernox", width=15) #this contains the temperature plot and goes into a second canvas self.fig2 = Figure(figsize=(8, 3.5)) self.ax2 = self.fig2.add_axes([0.1, 0.1, 0.8, 0.8]) self.ax2.set_ylabel("T (K)") self.ax2.set_xlabel("Time (h)") self.ax2.grid(False) self.canvas2 = FigureCanvasTkAgg(self.fig2, master=cernoxFrame) self.ax2.set_xlim([self.pOCERNOX.xlimL, self.pOCERNOX.xlimU]) self.ax2.set_ylim([self.pOCERNOX.ylimL, self.pOCERNOX.ylimU]) plotOptionButtonCERNOX = Tk.Button( cernoxFrame, text="Plot Options", command=lambda: self.changePlotOptionsCERNOX(self.pOCERNOX, only="CERNOX")) temperatureFrame = Tk.Frame(cernoxFrame, width=400, height=50, background="#dddddd") tCernoxLabel = Tk.Label(temperatureFrame, width=12, text="Temperature:", anchor=Tk.W, foreground="#0000CC", font="TkIconFont 15") tCernoxValue = Tk.Label(temperatureFrame, textvariable=self.tCernox, anchor=Tk.W, foreground="#0000CC", font="TkIconFont 15") longTermSignalCERNOX = Tk.Checkbutton(cernoxFrame, text=" Long term", variable=self.pollLongCERNOX, command=self.readCryoShield) tReadButton = Tk.Button(self.parent, text="Read", command=lambda: self.readCryoShield(only="")) self.var = Tk.IntVar() autoUpdateButton = Tk.Checkbutton( self.parent, text="Auto Poll", variable=self.var, command=lambda: self.autoPoll(self.var.get())) #autoPollButton.var = self.doAutoPoll cernoxFrame.columnconfigure(2, minsize=400) cernoxFrame.rowconfigure(1, minsize=40) #LAYOUT - Now arrange the layout title.grid(row=0, column=0, padx=2, pady=2, sticky=Tk.W + Tk.E) abDataFrame.grid(row=1, column=0, padx=2, pady=2, sticky=Tk.W + Tk.E) self.canvas.get_tk_widget().grid(row=0, column=0, columnspan=3, sticky=Tk.W + Tk.E + Tk.N + Tk.S) plotOptionButtonAB.grid(row=1, column=0, padx=2, pady=2, sticky=Tk.E) longTermSignalAB.grid(row=1, column=1, padx=2, pady=2, sticky=Tk.E) levelCanvas.grid(row=1, column=2, sticky=Tk.E) cernoxFrame.grid(row=2, column=0, padx=2, pady=2, sticky=Tk.E) self.canvas2.get_tk_widget().grid(row=0, column=0, columnspan=3, sticky=Tk.W + Tk.E + Tk.N + Tk.S) plotOptionButtonCERNOX.grid(row=1, column=0, padx=2, pady=2, sticky=Tk.E) longTermSignalCERNOX.grid(row=1, column=1, padx=2, pady=2, sticky=Tk.E) temperatureFrame.grid(row=1, column=2, padx=2, pady=2) tCernoxValue.pack(side=Tk.RIGHT) tCernoxLabel.pack(side=Tk.RIGHT) tReadButton.grid(row=3, column=0, padx=2, pady=2, sticky=Tk.E) autoUpdateButton.grid(row=5, column=0, padx=2, pady=2, sticky=Tk.E) #self.canvas2.get_tk_widget().grid(row = 1, column = 0, columnspan = 4, sticky = Tk.W + Tk.E + Tk.N + Tk.S) tReadButton.focus_set() print "Tk widget obtained and gridded"
if __name__ == "__main__": win = gui.Tk() print(gui.TclVersion) win.geometry("+0+0") SEQ_FONT = gui_font.Font(size=32, weight='bold') TRANSPORT_FONT = gui_font.Font(size=20, weight='bold') CONFIG_FONT = gui_font.Font(size=14, weight='bold') LEGEND_FONT = gui_font.Font(size=12, slant='italic') YASS_SMALL_FONT = gui_font.Font(size=22, slant='italic') win.title("Y A S S ! Yet Another Step Sequencer") win.bind("<Escape>", quitProperly) canvas = gui.Canvas(win, width=WIDTH * PPI * DRAW_SCALE, height=HEIGHT * PPI * DRAW_SCALE, bg=DRAW_BACKCOLOR) canvas.grid() drawRectangle(canvas, WIDTH / 2.0, HEIGHT / 2.0, WIDTH, HEIGHT) drawStepLeds(canvas) drawTransportKeys(canvas) drawSequenceKeys(canvas) drawGlobalKeys(canvas) drawRightKeys(canvas) drawDisplay(canvas) drawEncoder(canvas) drawLine2(canvas) drawLine3(canvas) drawBigYass(canvas) drawSmallYass(canvas)
def createWidgets(self): utils_cl = Common_Utils() sql_path = '../sql_scripts/' cnx = mysql.connector.connect(user=credential_list[0], password=credential_list[1], host=credential_list[2], database=credential_list[3], get_warnings=True, buffered=True) cursor = cnx.cursor() cursor_high = cnx.cursor() # returns list [ [0] readable list of 'stop_mysqlid : trunc stop_name', [1] integer stop_mysqlid ] # this list is the stops that can serve as a map center sql_phrase = utils_cl.read_sql_script(sql_path + 'select_current_map_starts.sql') cursor_high.execute(sql_phrase) ln = cursor_high.fetchone() temp_log_path = u'../data/temp_log_drawmaps.log' write = sys.stdout.write # loops through all of the 'starts' in the 'best_times' table while ln: starting_loc = ln[1] try: starting_loc = int(starting_loc) # want start to be persistent, separate persistent variable starting_saved = starting_loc except: print ln[0] sys.exit('Starting location wasn''t an integer - exiting') # x_dim and y_dim are size of map in pixels, or are supposed to be x_dim = 1024 y_dim = 1024 # x_ctr and y_ctr are center points on map, or are supposed to be x_ctr = int(round(( x_dim / 2 ) + (x_dim * .175))) y_ctr = int(round(( y_dim / 2 ) + (y_dim * .175))) # quit button, if you need it self.quitButton = tk.Button(self, text='Quit', command=self.quit) self.quitButton.grid() can = tk.Canvas(self, height=str(y_dim) + 'p', width=str(x_dim) + 'p', bg='#fff') # returns [0] maximim travel time for all trips from the starting_loc # for purposes of getting the scale right sql_phrase = "SELECT MAX(total_time) FROM mbta_data.mbta_map_best_times WHERE start_mysqlid = %(starting_loc)s GROUP BY start_mysqlid" cursor.execute(sql_phrase, {u'starting_loc' : starting_saved}) max_time = cursor.fetchone()[0] # defensive programming - make sure the cursor is reset cursor.fetchall() # this is the central query # returns the list of best times with their attributes # the query itself determines the total travel time and compass direction # that work all is done in sql sql_phrase = utils_cl.read_sql_script(sql_path + 'populate_map_points_from_start.sql') # returns list with the following index locations: # [0] dest_mysqlid, [1] total_time (seconds), [2] trip_count, [3] transp_mode, [4] route_mysqlid, # [5] route_name, [6] dest_name, [7] route_color, [8]compass, [9]trip_leg, # [10] start_loc, [11] prev_stop_mysqlid, [12]immed_prev_stop cursor.execute(sql_phrase, {u'starting_loc' : starting_loc}) line = cursor.fetchone() # overall structure of script: # makes calculatons in section below and stores them in a dictionary # does this for two reasons (1) want entirely to draw the lines first, then the station points on top # (2) line drawing requires reference to a dictionary of the locations of the previous stops # so need both complete dictionaries before drawing lines # initial values point_dict = {} prev_stops = {} max_time_route = {} rail_dest_list = [] route_mysqlid = -1 dest_name = '' # reads through query of stops, total times while line: # belt-and-suspenders: stop if no more lines of query if line == [] or line == None or not line: break # use named local variables in place of index locations # to make code manipularions easier to read dest_mysqlid = line[0] leng = line[1] total_min = (line[1]) /60 # converts output time in seconds to minutes trip_count = line[2] transp_mode = line[3] route_mysqlid = line[4] route_name = line[5] dest_name = line[6] color = line[7] comp = line[8] trip_leg = line[9] prev_stop_mysqlid = line[11] immed_prev_stop = line[12] # converts count into ratio, with 2512 being the most trips for any one origin/dest pair # probably would be more correct to run query with MAX(count) if trip_count != None: trip_ratio = line[2] / 2512 # gave multipliers for heavy rail service # otherwise bus dots are overwhelming/dominant if transp_mode == 1: trip_ratio = trip_ratio * 1.7 if transp_mode == 2: trip_ratio = trip_ratio * 40 else: # avoids potential errors nonetype and div by 0 errors trip_ratio = .01 # convert total time in seconds into distance from origin on map if leng != 0: leng = (x_ctr) * scale_coef( ( leng / max_time ) ) # convert compass direction into radians if comp == None: comp = 0 comp = (comp * math.pi) / 180 #convert to radians # caluclate points on map for stop x_point = ( math.sin(comp) * leng ) + x_ctr y_point = -1 * ( math.cos(comp) * leng ) + y_ctr # use white color for stops reached by walking if color != None: color = '#' + str(color) else: color = '#fff' if color.upper() == '#FFFF7C': color = '#E7D450' # update dictionary of *previous* stops # coordinates and colors of previous stops may be used in some situations # where it is desired to draw the route that *departs* from the station # rather than the one that arrives if prev_stop_mysqlid not in prev_stops: prev_stops.update({prev_stop_mysqlid : dest_mysqlid}) # if stop already in list, only update if the new route is bigger/better than old route # or is not walking or bus else: if ( (point_dict[prev_stops[prev_stop_mysqlid]]['trip_ratio'] < trip_ratio and (point_dict[prev_stops[prev_stop_mysqlid]]['transp_mode'] in [None, 3] or transp_mode not in [None, 3])) or (point_dict[prev_stops[prev_stop_mysqlid]]['transp_mode'] in [None, 3] and transp_mode not in [None, 3]) ): prev_stops.update({prev_stop_mysqlid : dest_mysqlid}) if transp_mode != None: if route_mysqlid not in max_time_route: max_time_route.update({route_mysqlid : {'min' : leng, 'max' : leng}}) else: if leng > max_time_route[route_mysqlid]['max']: max_time_route[route_mysqlid].update({'max' : leng}) if leng < max_time_route[route_mysqlid]['min']: max_time_route[route_mysqlid].update({'min' : leng}) if transp_mode != 3: rail_dest_list.append(dest_mysqlid) # dictionary of all destinations and point/other info point_dict.update( { dest_mysqlid : { 'x_point' : x_point, 'y_point' : y_point, 'total_min' : total_min, 'trip_count' : trip_count, 'route_mysqlid' : route_mysqlid, 'route_name' : route_name, 'immed_prev_stop' : immed_prev_stop, 'trip_ratio' : trip_ratio, 'color' : color, 'transp_mode' : transp_mode, 'prev_stop_mysqlid' : prev_stop_mysqlid, 'comp' : comp, 'leng' : leng, 'dest_name' : dest_name } }) line = cursor.fetchone() # draw background square; covers entire canvas can.create_rectangle(0,0,x_ctr * 2.5, y_ctr * 2.5, fill='#fff', outline='#fff') # get name of origin stop sql_phrase = "SELECT stop_name FROM mbta_data.sched_stops WHERE mysql_id = %(starting_loc)s" cursor.execute(sql_phrase, {u'starting_loc' : starting_saved}) start_name = cursor.fetchone()[0] cursor.fetchall() txt = start_name trunc_loc = txt.find(u' - ') if trunc_loc != -1: txt = txt[:trunc_loc] trunc_loc = txt.find(u'Station') if trunc_loc != -1 and u'south station' not in txt.lower() and u'north station' not in txt.lower(): txt = txt[:trunc_loc] can.create_text(x_ctr, y_ctr - 16, text = txt, font = ('UnBom', -48), fill = '#A3A3A3', anchor = 's' ) # add legends fl = tk.PhotoImage(file='../legend.ppm') can.create_image((x_ctr * 2) - 18, (y_ctr * 2) - 20, anchor=tk.SE, image=fl, state=tk.NORMAL) fl_2 = tk.PhotoImage(file='../legend_2.ppm') can.create_image( 36, (y_ctr * 2) - 56, anchor=tk.SW, image=fl_2, state=tk.NORMAL) # draw the reference circles circle_time_mins = [15, 30, 60] for i in range(0, len(circle_time_mins), 1): leng = (x_ctr) * scale_coef( ( ( circle_time_mins[i] * 60 ) / max_time ) ) can.create_oval(x_ctr - leng , y_ctr - leng, x_ctr + leng, y_ctr + leng, fill = '', outline = '#A3A3A3', width = 5) can.create_text(x_ctr, y_ctr - leng, text = str(circle_time_mins[i]) + 'min.', anchor = 's', font = ('UnBom', -24), fill = '#A3A3A3') can.create_text(x_ctr, y_ctr + leng + 2, text = str(circle_time_mins[i]) + 'min.', anchor = 'n', font = ('UnBom', -24), fill = '#A3A3A3') # this loop is run after dictionaries are completely full # draws the maps using data stored earlier # draw all of the lines first # first so that they do not interfere with dots for i in range(1, len(point_dict.keys()), 1): immed_prev_stop = None if (point_dict[point_dict.keys()[i]]['route_mysqlid'] not in [0, None] and point_dict[point_dict.keys()[i]]['immed_prev_stop'] != None and point_dict[point_dict.keys()[i]]['immed_prev_stop'] in point_dict and (point_dict[point_dict.keys()[i]]['transp_mode'] == point_dict[point_dict[point_dict.keys()[i]]['immed_prev_stop']]['transp_mode'])): immed_prev_stop = point_dict[point_dict.keys()[i]]['immed_prev_stop'] elif (point_dict[point_dict.keys()[i]]['route_mysqlid'] not in [0, None] and point_dict[point_dict.keys()[i]]['immed_prev_stop'] != None): sql_phrase = utils_cl.read_sql_script(sql_path + 'select_traceback_route.sql') immed_prev_stop = point_dict[point_dict.keys()[i]]['immed_prev_stop'] transp_mode = point_dict[point_dict.keys()[i]]['transp_mode'] transp_mode_2 = None sql_data = ({ 'origin_mysqlid' : point_dict[point_dict.keys()[i]]['prev_stop_mysqlid'], 'immed_prev_mysqlid' : immed_prev_stop, 'start_mysqlid' : starting_saved }) count = 0 if (not (immed_prev_stop in rail_dest_list and transp_mode == transp_mode_2 ) and not (immed_prev_stop == point_dict[point_dict.keys()[i]]['prev_stop_mysqlid']) and not (count >= 100)): trip_mode = [-1, -2, -3] count_2 = 0 while (trip_mode[0] != trip_mode[1] and point_dict[point_dict.keys()[i]]['prev_stop_mysqlid'] != trip_mode[2] and point_dict[point_dict.keys()[i]]['prev_stop_mysqlid'] != immed_prev_stop and count_2 <= 30): cursor.execute(sql_phrase, sql_data) sql_catchbasin = cursor.fetchone() #one step earlier immed_prev_stop #[0]a.immed_prev_stop, [1]a.dest_route_type, #[2]b.immed_prev_route_type, [3]b.dest_mysqlid, [4]b.total_time, #[5]a.origin_mysqlid cursor.fetchall() # defensive programming if sql_catchbasin != None: if sql_catchbasin[0] != None: immed_prev_stop = sql_catchbasin[0] else: immed_prev_stop = point_dict[point_dict.keys()[i]]['prev_stop_mysqlid'] trip_mode = [sql_catchbasin[1], sql_catchbasin[2], sql_catchbasin[3]] else: immed_prev_stop = None sql_data.update({'immed_prev_mysqlid' : immed_prev_stop}) count_2 += 1 if sql_catchbasin != None: if immed_prev_stop in point_dict: if sql_catchbasin[0] != None: transp_mode_2 = point_dict[immed_prev_stop]['transp_mode'] else: transp_mode_2 = transp_mode else: immed_prev_stop = None count += 1 # only trace to first stop on route # if the traced-to stop is same type of stop, update dictionary if immed_prev_stop != None and immed_prev_stop in point_dict: if immed_prev_stop not in prev_stops: prev_stops.update({immed_prev_stop : point_dict.keys()[i]}) elif (point_dict[prev_stops[immed_prev_stop]]['transp_mode'] in [None, 3] and point_dict[point_dict.keys()[i]]['transp_mode'] not in [None, 3]): prev_stops.update({immed_prev_stop : point_dict.keys()[i]}) point_dict[point_dict.keys()[i]]['immed_prev_stop'] = immed_prev_stop elif point_dict[point_dict.keys()[i]]['route_mysqlid'] not in [0, None]: immed_prev_stop = point_dict[point_dict.keys()[i]]['prev_stop_mysqlid'] else: immed_prev_stop = None if immed_prev_stop != None and immed_prev_stop in point_dict: higher_comp = max(point_dict[point_dict.keys()[i]]['comp'], point_dict[immed_prev_stop]['comp']) x_point = round(point_dict[immed_prev_stop]['x_point'],0) y_point = round(point_dict[immed_prev_stop]['y_point'],0) if math.pow(abs(x_point - x_ctr),3) + math.pow(abs(y_point - y_ctr),3) >= 3: prev_comp = point_dict[immed_prev_stop]['comp'] cur_comp = point_dict[point_dict.keys()[i]]['comp'] if prev_comp < cur_comp: compass_delta = ( cur_comp - prev_comp ) elif prev_comp > cur_comp: compass_delta = ( (2 * math.pi) - prev_comp + cur_comp ) else: compass_delta = 0 if compass_delta > math.pi: compass_delta = ( (-2 * math.pi) + compass_delta ) leng_delta = point_dict[point_dict.keys()[i]]['leng'] - point_dict[immed_prev_stop]['leng'] comp = point_dict[immed_prev_stop]['comp'] leng = point_dict[immed_prev_stop]['leng'] num_segments = int(abs(math.ceil(compass_delta / .0628))) line_width = str(5 * (point_dict[point_dict.keys()[i]]['trip_ratio']) + 1) + 'p' if num_segments != 0: leng_seg = leng_delta / num_segments comp_seg = compass_delta / num_segments for k in range(1, num_segments, 1): x_last = x_point y_last = y_point leng = leng + leng_seg comp = comp + comp_seg x_point = ( math.sin(comp) * leng ) + x_ctr y_point = -1 * ( math.cos(comp) * leng ) + y_ctr can.create_line(x_last, y_last, x_point, y_point, fill = point_dict[point_dict.keys()[i]]['color'], width = line_width) can.create_line(x_point, y_point, point_dict[point_dict.keys()[i]]['x_point'], point_dict[point_dict.keys()[i]]['y_point'], fill = point_dict[point_dict.keys()[i]]['color'], width = line_width) # draw all of the stop points # draws on top of the lines for i in range(0, len(point_dict.keys()), 1): for z in range(0, 2, 1): color = '#fff' if z == 0 and point_dict[point_dict.keys()[i]]['transp_mode'] not in [None]: color = point_dict[point_dict.keys()[i]]['color'] trip_ratio = point_dict[point_dict.keys()[i]]['trip_ratio'] transp_mode = point_dict[point_dict.keys()[i]]['transp_mode'] route_name = point_dict[point_dict.keys()[i]]['route_name'] route_mysqlid = point_dict[point_dict.keys()[i]]['route_mysqlid'] leng = point_dict[point_dict.keys()[i]]['leng'] if z == 1 and point_dict.keys()[i] in prev_stops: if (point_dict[point_dict.keys()[i]]['transp_mode'] in [None, 3] and point_dict[prev_stops[point_dict.keys()[i]]]['transp_mode'] not in [None, 3]): color = point_dict[prev_stops[point_dict.keys()[i]]]['color'] trip_ratio = point_dict[prev_stops[point_dict.keys()[i]]]['trip_ratio'] transp_mode = point_dict[prev_stops[point_dict.keys()[i]]]['transp_mode'] route_name = point_dict[prev_stops[point_dict.keys()[i]]]['route_name'] route_mysqlid = point_dict[prev_stops[point_dict.keys()[i]]]['route_mysqlid'] leng = point_dict[prev_stops[point_dict.keys()[i]]]['leng'] if color != '#fff': x1 = point_dict[point_dict.keys()[i]]['x_point'] - 18 * trip_ratio x2 = point_dict[point_dict.keys()[i]]['x_point'] + 18 * trip_ratio y1 = point_dict[point_dict.keys()[i]]['y_point'] - 18 * trip_ratio y2 = point_dict[point_dict.keys()[i]]['y_point'] + 18 * trip_ratio # draw stop labels, changing the anchor location based on the map sector if 1==1: if point_dict[point_dict.keys()[i]]['y_point'] >= y_ctr: anchor_loc = 'n' y_anchor = y2 ln_loc = [7,0] else: anchor_loc = 's' y_anchor = y1 ln_loc = [0,-7] if point_dict[point_dict.keys()[i]]['x_point'] >= x_ctr : anchor_loc += 'w' else: anchor_loc += 'e' txt = point_dict[point_dict.keys()[i]]['dest_name'] # truncates annoying little extras on stop names trunc_loc = txt.find(u' - ') if trunc_loc != -1: txt = txt[:trunc_loc] trunc_loc = txt.find(u'Station') if trunc_loc != -1: txt = txt[:trunc_loc] # station name and trip time txt = txt + ' (' + str(int(round(point_dict[point_dict.keys()[i]]['total_min'],0))) + '\')' if color.upper() == '#FFFF7C': color_out = '#FCF344' else: color_out = color if transp_mode != 3: can.create_text( point_dict[point_dict.keys()[i]]['x_point'], y_anchor, text = txt, font = ('UnBom', int(round((trip_ratio)) * -10) - 9 ), fill = color, anchor = anchor_loc ) elif route_mysqlid in max_time_route: if leng >= max_time_route[route_mysqlid]['max'] or leng <= max_time_route[route_mysqlid]['min']: font_obj = tkFont.Font(family='UnBom', size=-10) slice_loc = route_name.find(u' ') can.create_text( point_dict[point_dict.keys()[i]]['x_point'], y_anchor + ln_loc[0], text = route_name[:slice_loc], font = font_obj, fill = color_out, anchor = anchor_loc ) can.create_text( point_dict[point_dict.keys()[i]]['x_point'], y_anchor + ln_loc[1], text = route_name[(slice_loc + 1):], font = font_obj, fill = color_out, anchor = anchor_loc ) if color.upper() == '#FFFF7C': color_out = '#FCF344' color = '#FCF344' else: color_out = color can.create_oval( x1 , y1, x2, y2, fill = color, outline = color_out ) # center/start circle can.create_oval(x_ctr -12 , y_ctr - 12, x_ctr + 12, y_ctr + 12, fill='#808080') can.create_text(24, 48, text = 'Travel times from:', anchor = 'nw', font = ('Segui UI Bold', -24, 'bold'), fill = '#A3A3A3') can.create_text(32, 74, text = str(start_name), anchor = 'nw', font = ('Segui UI Bold', int(round(-0.07 * x_dim)), 'bold'), fill = '#A3A3A3') can.create_text(24, 130, text = 'Time from origin in minutes.', anchor = 'nw', font = ('Segui UI Bold', -24, 'bold'), fill = '#A3A3A3') can.grid() can.update() file_name = str(start_name).lower() spc_chars = ' \\/()\'\":;&|' for qq in range(0, len(spc_chars), 1): file_name = file_name.replace(spc_chars[qq], '_') file_name += "_travel_times" ps_path = "../data/ps/" png_path = "../data/png/" can.postscript(file=ps_path + str(file_name) + ".ps", height= str(y_dim) + 'p', width = str(x_dim) + 'p') cmd = 'convert -density 220 ' + ps_path + file_name + '.ps ' + png_path + file_name + '.png' os.system(cmd) with open(temp_log_path,'a') as __f__: __f__.write(u'\n' + unicode(file_name) + u'.png') can = None ln = cursor_high.fetchone() cursor.close() cursor_high.close() cnx.close()