class canvasInterface(interfaceScreen):
def __init__(self,master,width,height):
interfaceScreen.__init__(self)
self.canvas = Canvas(master, width=width, height=height,bg='white')
self.canvas.grid(row=0,column=1)
"""
---------------Interfaz con objeto dibujante---------------------
"""
def deleteFromCanvas(self,id):
self.canvas.delete(id)
pass
def create_rectangle(self,x1, y1, x2, y2,*arg,**kargs):
return self.canvas.create_rectangle(x1, y1, x2, y2,*arg,**kargs)
pass
def create_line(self,x1, y1, x2, y2, *args,**kwargs):
return self.canvas.create_line(x1, y1, x2, y2, *args,**kwargs)
def create_text(self,x1, y1,*args,**kargs):
return self.canvas.create_text(x1, y1,*args,**kargs)
def scan_mark(self,x,y):
self.canvas.scan_mark(x, y)
def scan_dragto(self,x, y, *args,**kwargs):
self.canvas.scan_dragto(x, y, *args,**kwargs)
def winfo_height(self):
return self.canvas.winfo_height()
def winfo_width(self):
return self.canvas.winfo_width()
class Example(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.x0=[x*0.1 for x in range(10, 15)]
self.y0=[0 for x in range(10, 15)]
#self.tet1 = [i for i in range(90)]
#self.tet2 = [i for i in range(45, 135)]
self.tet1_con = 0
self.tet2_con = 0
self.count1 = 0
self.count2 = 0
self.sign1 = 1
self.sign2 = -1
self.parent = parent
self.initUI()
self.parent.after(0, self.animation)
def initUI(self):
self.parent.title("Arm")
self.pack(fill=BOTH, expand=1)
self.canvas = Canvas(self)
#self.canvas.create_line(0, 0, 200, 100+self.count, width=arm_width)
line = Line(self.canvas, points['1'], (800/2, 400))
arms.append(line)
line = Line(self.canvas, 90-(points['2']-points['1']), line.cor1)
arms.append(line)
self.canvas.pack(fill=BOTH, expand=1)
def animation(self):
self.canvas.delete("all")
#self.canvas.create_line(0, 0, 200, 100+self.count, width=arm_width)
'''if points['1'] > 90 and self.sign1 == 1:
self.sign1 = -1
elif points['1'] == 45 and self.sign1 == -1:
self.sign1 = 1
if points['2'] > 135 and self.sign2 == 1:
self.sign2 = -1
elif points['2'] == 90 and self.sign2 == -1:
self.sign2 = 1
points['2']+=self.sign2
points['1']+=self.sign1'''
if self.count1 >= len(self.x0) and self.sign1 == 1:
self.sign1 = -1
if self.count1 <= 0 and self.sign1 == -1:
self.sign1 = 1
self.count1+=self.sign1
tet1, tet2 = getAngles(self.x0[self.count1-1], self.y0[self.count1-1])
print tet1, tet2
line = arms[0].draw(tet1)
arms[1].draw(90-(tet2+tet1), line, 'red')
#line = arms[0].draw(points['1'])
#arms[1].draw(90-(points['2']-points['1']), line)
self.canvas.update()
#self.count +=1
self.parent.after(50, self.animation)
class Visualizer(object):
def __init__(self, toplevel, **kwargs):
self.toplevel = toplevel
self.canvas = Canvas(
self.toplevel, width=600, height=400, background='black'
)
self.canvas.pack()
self._playing_lines = {}
def add_point(self, phrase, point, color):
if point in self._playing_lines:
self.remove_point(phrase, point)
if point.type == 'Rest':
return
if point not in phrase.points:
return
px,py, px2,py2 = phrase.get_line(point)
self._playing_lines[point] = self.canvas.create_line(
px,py, px2,py2, fill=color
)
def remove_point(self, phrase, point):
if point not in self._playing_lines:
return
self.canvas.delete(self._playing_lines[point])
del self._playing_lines[point]
class CoordsCanvas(object):
def __init__(self, parent, **kwargs):
self._canvas = Canvas(parent, **kwargs)
self._canvas.pack(fill=BOTH, expand=YES)
self._canvas.bind("<Double-Button-1>", self.on_double_click)
self._canvas.bind("<Shift-Button-1>", self.on_shift_button_click)
self._canvas.bind("<Control-Button-1>", self.on_ctrl_button_click)
self._canvas.bind("<Alt-Button-1>", self.on_alt_button_click)
self._canvas.bind("<Option-Button-1>", self.on_alt_button_click)
self._canvas.bind("<Double-Button-1>", self.on_double_click)
self._canvas.bind("<ButtonPress-1>", self.on_button_press)
self._canvas.bind("<ButtonRelease-1>", self.on_button_release)
self._event_receiver = None
self._dragger = Dragger()
def on_double_click(self, _):
if hasattr(self._event_receiver, 'zoom_in'):
self._event_receiver.zoom_in()
def on_shift_button_click(self, _):
if hasattr(self._event_receiver, 'zoom_out'):
self._event_receiver.zoom_out()
def on_ctrl_button_click(self, event):
if hasattr(self._event_receiver, 'add'):
self._event_receiver.add(event.x, event.y)
def on_alt_button_click(self, event):
if hasattr(self._event_receiver, 'remove'):
self._event_receiver.remove(event.x, event.y)
def on_button_press(self, event):
self._dragger.start(event.x, event.y)
def on_button_release(self, event):
if hasattr(self._event_receiver, 'move'):
self._dragger.drag_to(
event.x, event.y,
self._event_receiver.move)
def create_circle(self, x, y, r, **kwargs):
return self._canvas.create_oval(x-r, y-r, x+r, y+r, **kwargs)
def create_text(self, x, y, **kwargs):
return self._canvas.create_text(x, y, **kwargs)
def get_width(self):
return self._canvas.winfo_reqwidth()
def get_height(self):
return self._canvas.winfo_reqheight()
def set_event_receiver(self, receiver):
self._event_receiver = receiver
def destroy(self, item):
self._canvas.delete(item)
def destroy_all(self):
self._canvas.delete("all")
class CanvasFrame(Frame):
def initializeCanvas(self):
self.canvas = Canvas(self.master, width=200, height=100)
self.canvas.pack()
self.pack()
def setup_timer(self):
self.x = 10
self.y = 10
self.timer_tick()
def timer_tick(self):
self.canvas.delete('all')
self.canvas.create_line(self.x, self.y, 50, 50)
self.x = self.x + 1
self.y = self.y + 2
print 'in loop'
print self.x
print self.y
self.master.after(1000, self.timer_tick)
def __init__(self):
Frame.__init__(self, Tk())
self.pack()
self.initializeCanvas()
self.setup_timer()
class CanvasFrame(Frame):
def __initialize_canvas(self):
self.__canvas = Canvas(self.master,
width=Constants.DEFAULT_FRAME_WIDTH() + 120,
height=Constants.DEFAULT_FRAME_HEIGHT())
self.__canvas.pack()
self.pack()
def __setup_timer(self):
RefreshTimer(self.master, 10, self)
MonsterTimer(self.master, 1000)
def __setup_handlers(self):
ArrowHandler(self.master)
KeyMovementHandler(self.master)
MouseClickHandler(self.master)
def refresh(self):
self.__canvas.delete('all')
BoardPrinter.print_board(self.__canvas)
SelectPrinter.print_selected(self.__canvas)
TurnMenuPrinter.print_turn_menu(self.__canvas)
def __init__(self):
Frame.__init__(self, Tk())
self.pack()
self.__initialize_canvas()
self.__setup_timer()
self.__setup_handlers()
class Wall(object):
MIN_RED = MIN_GREEN = MIN_BLUE = 0x0
MAX_RED = MAX_GREEN = MAX_BLUE = 0xFF
PIXEL_WIDTH = 96
def __init__(self, width, height):
self.width = width
self.height = height
self._tk_init()
self.pixels = [(0, 0, 0) for i in range(self.width * self.height)]
def _tk_init(self):
self.root = Tk()
self.root.title("ColorWall %d x %d" % (self.width, self.height))
self.root.resizable(0, 0)
self.frame = Frame(self.root, bd=5, relief=SUNKEN)
self.frame.pack()
self.canvas = Canvas(self.frame,
width=self.PIXEL_WIDTH * self.width,
height=self.PIXEL_WIDTH * self.height,
bd=0, highlightthickness=0)
self.canvas.pack()
self.root.update()
def set_pixel(self, x, y, hsv):
self.pixels[self.width * y + x] = hsv
def get_pixel(self, x, y):
return self.pixels[self.width * y + x]
def draw(self):
self.canvas.delete(ALL)
for x in range(len(self.pixels)):
x_0 = (x % self.width) * self.PIXEL_WIDTH
y_0 = (x / self.width) * self.PIXEL_WIDTH
x_1 = x_0 + self.PIXEL_WIDTH
y_1 = y_0 + self.PIXEL_WIDTH
hue = "#%02x%02x%02x" % self._get_rgb(self.pixels[x])
self.canvas.create_rectangle(x_0, y_0, x_1, y_1, fill=hue)
self.canvas.update()
def clear(self):
for i in range(self.width * self.height):
self.pixels[i] = (0, 0, 0)
def _hsv_to_rgb(self, hsv):
rgb = colorsys.hsv_to_rgb(*hsv)
red = self.MAX_RED * rgb[0]
green = self.MAX_GREEN * rgb[1]
blue = self.MAX_BLUE * rgb[2]
return (red, green, blue)
def _get_rgb(self, hsv):
red, green, blue = self._hsv_to_rgb(hsv)
red = int(float(red) / (self.MAX_RED - self.MIN_RED) * 0xFF)
green = int(float(green) / (self.MAX_GREEN - self.MIN_GREEN) * 0xFF)
blue = int(float(blue) / (self.MAX_BLUE - self.MIN_BLUE) * 0xFF)
return (red, green, blue)
class CoordsCanvas(object):
def __init__(self, parent, **kwargs):
self._canvas = Canvas(parent, **kwargs)
self._canvas.pack(fill=BOTH, expand=YES)
self._canvas.bind("<Double-Button-1>", self.on_double_click)
self._canvas.bind("<Shift-Button-1>", self.on_shift_button_click)
self._canvas.bind("<Control-Button-1>", self.on_ctrl_button_click)
self._canvas.bind("<Alt-Button-1>", self.on_alt_button_click)
self._canvas.bind("<Option-Button-1>", self.on_alt_button_click)
self._canvas.bind("<Double-Button-1>", self.on_double_click)
self._canvas.bind("<ButtonPress-1>", self.on_button_press)
self._canvas.bind("<ButtonRelease-1>", self.on_button_release)
self._event_receiver = None
self._dragger = Dragger()
def on_double_click(self, _):
if hasattr(self._event_receiver, 'zoom_in'):
self._event_receiver.zoom_in()
def on_shift_button_click(self, _):
if hasattr(self._event_receiver, 'zoom_out'):
self._event_receiver.zoom_out()
def on_ctrl_button_click(self, event):
if hasattr(self._event_receiver, 'add'):
self._event_receiver.add(event.x, event.y)
def on_alt_button_click(self, event):
if hasattr(self._event_receiver, 'remove'):
self._event_receiver.remove(event.x, event.y)
def on_button_press(self, event):
self._dragger.start(event.x, event.y)
def on_button_release(self, event):
if hasattr(self._event_receiver, 'move'):
self._dragger.drag_to(event.x, event.y, self._event_receiver.move)
def create_circle(self, x, y, r, **kwargs):
return self._canvas.create_oval(x - r, y - r, x + r, y + r, **kwargs)
def create_text(self, x, y, **kwargs):
return self._canvas.create_text(x, y, **kwargs)
def get_width(self):
return self._canvas.winfo_reqwidth()
def get_height(self):
return self._canvas.winfo_reqheight()
def set_event_receiver(self, receiver):
self._event_receiver = receiver
def destroy(self, item):
self._canvas.delete(item)
def destroy_all(self):
self._canvas.delete("all")
class GUI(object):
def __init__(self, world):
self.ticks = 0
self.world = world
self.width = world.width
self.height = world.height
self.root = Tk()
self.root.title("Mars Explorer")
window_x, window_y = self._compute_window_coords()
self.root.geometry('%dx%d+%d+%d' %
(self.width, self.height, window_x, window_y))
self.canvas = Canvas(self.root, width=self.width, height=self.height)
self.canvas.pack()
self.canvas.after(1, self._tick)
def start(self):
self.root.mainloop()
def _tick(self):
# Stop if done.
if self.world.is_done():
return
self.world.tick()
self._draw()
self.ticks += 1
self.canvas.after(1, self._tick)
def _draw(self):
self.canvas.delete('all')
self.world.draw(self.canvas)
for entity in self.world.entities:
entity.draw(self.canvas)
self.canvas.create_text(self.width - 20, 10, text=str(self.ticks))
self.canvas.create_text(self.width - 70,
30,
text='Rocks in explorers: %d' %
self.world.rocks_in_explorers())
self.canvas.create_text(self.width - 70,
50,
text='Rocks delivered: %d' %
self.world.rocks_collected)
self.canvas.create_text(self.width - 55,
70,
text='Total rocks: %d' % self.world.num_rocks)
def _compute_window_coords(self):
# http://stackoverflow.com/a/14912644/742501
screen_width = self.root.winfo_screenwidth()
screen_height = self.root.winfo_screenheight()
window_x = screen_width / 2 - self.width / 2
window_y = screen_height / 2 - self.height / 2
return window_x, window_y
class Screen(Observer):
def __init__(self,parent,bg="white"):
self.canvas=Canvas(parent,bg=bg)
print("parent",parent.cget("width"),parent.cget("height"))
parent.bind("<Configure>", self.resize)
self.parent=parent
self.width=int(self.canvas.cget("width"))
self.height=int(self.canvas.cget("height"))
self.models=[]
def update(self,model):
if model not in self.models:
self.models.append(model)
print("View update")
signal=model.get_signal()
self.plot_signal(signal,model.get_color(),model.get_name())
def plot_signal(self,signal,color,name):
w,h=self.canvas.winfo_width(),self.canvas.winfo_height()
width,height=int(w),int(h)
print(self.canvas.find_withtag("signal"+name))
if self.canvas.find_withtag("signal"+name) :
self.canvas.delete("signal"+name)
if signal and len(signal) > 1:
if name=="X-Y" :
plot = [((x+2)*width/4, (2*y/self.m+1)*height/2) for (x, y) in signal]
else :
plot = [(x*width, y*height/self.m + height/2) for (x, y) in signal]
signal_id = self.canvas.create_line(plot, fill=color, smooth=1, width=3,tags="signal"+name)
return
def packing(self) :
self.canvas.pack(fill="both", expand=1)
def grid(self,n,m):
self.n=n
self.m=m
w,h=self.canvas.winfo_width(),self.canvas.winfo_height()
self.width,self.height=int(w),int(h)
self.canvas.create_line(0,self.height/2.0,self.width-4,self.height/2,arrow="last",tags="line",fill="blue")
self.canvas.create_line(self.width/2,self.height,self.width/2,5,arrow="last",tags="line",fill="blue")
step1=self.width/n
for t in range(1,n):
x =t*step1
self.canvas.create_line(x,0,x,self.height,tags="line")
step=self.height/m
for t in range(1,m):
y =t*step
self.canvas.create_line(0,y,self.width,y,tags="line")
def resize(self,event):
self.canvas.delete("line")
self.grid(self.n,self.m)
for model in self.models :
self.plot_signal(model.get_signal(),
model.get_color(),
model.get_name())
class View(Observer):
def __init__(self,parent,subject,bg="white"):
print("View : __init__")
Observer.__init__(self)
self.subject=subject
self.parent=parent
self.signal_id=None
self.canvas=Canvas(parent,bg=bg)
self.canvas.bind("<Configure>", self.resize)
self.width=int(self.canvas.cget("width"))
self.height=int(self.canvas.cget("height"))
def update(self,subject):
print("View : update")
signal=subject.get_signal()
self.signal_id=self.plot_signal(signal)
def plot_signal(self,signal,color="red"):
width,height=self.width,self.height
if self.signal_id!=None :
self.canvas.delete(self.signal_id)
if signal and len(signal)>1:
plot=[(x*width, height/2.0*(y+1)) for (x, y) in signal]
self.signal_id=self.canvas.create_line(plot,fill=color,smooth=1,width=3)
return self.signal_id
def resize(self, event):
"""
En cas de reconfiguration de fenetre
"""
if event:
self.width = event.width
self.height = event.height
## self.width = int(event.widget.cget("width"))
## self.height = int(event.widget.cget("height"))
## print("View : resize cget",event.widget.cget("width"),event.widget.cget("height"))
print("View : resize event",event.width,event.height)
self.canvas.delete("grid")
self.plot_signal(self.subject.get_signal())
self.grid()
def grid(self, steps=8):
width,height=self.width,self.height
# self.canvas.create_line(10,height/2,width,height/2,arrow="last",tags="grid")
# self.canvas.create_line(10,height-5,10,5,arrow="last",tags="grid")
step=width/steps*1.
for t in range(1,steps+2):
x =t*step
self.canvas.create_line(x,0,x,height,tags="grid")
self.canvas.create_line(0,x,width,x,tags="grid")
self.canvas.create_line(x,height/2-4,x,height/2+4,tags="grid")
def packing(self) :
self.canvas.pack(expand=1,fill="both",padx=6)
class GUI(object):
def __init__(self, world):
self.ticks = 0
self.world = world
self.width = world.width
self.height = world.height
self.root = Tk()
self.root.title("Mars Explorer")
window_x, window_y = self._compute_window_coords()
self.root.geometry('%dx%d+%d+%d' % (self.width, self.height,
window_x, window_y))
self.canvas = Canvas(self.root, width=self.width, height=self.height)
self.canvas.pack()
self.canvas.after(1, self._tick)
def start(self):
self.root.mainloop()
def _tick(self):
# Stop if done.
if self.world.is_done():
return
self.world.tick()
self._draw()
self.ticks += 1
self.canvas.after(1, self._tick)
def _draw(self):
self.canvas.delete('all')
self.world.draw(self.canvas)
for entity in self.world.entities:
entity.draw(self.canvas)
self.canvas.create_text(self.width - 20, 10, text=str(self.ticks))
self.canvas.create_text(self.width - 70, 30,
text='Rocks in carriers: %d' % self.world.rocks_in_carriers())
self.canvas.create_text(self.width - 70, 50, text='Rocks delivered: %d' % self.world.rocks_collected)
self.canvas.create_text(self.width - 55, 70, text='Total rocks: %d' % self.world.num_rocks)
def _compute_window_coords(self):
# http://stackoverflow.com/a/14912644/742501
screen_width = self.root.winfo_screenwidth()
screen_height = self.root.winfo_screenheight()
window_x = screen_width / 2 - self.width / 2
window_y = screen_height / 2 - self.height / 2
return window_x, window_y
class Display:
def __init__(self, fps=FPS, width=WIDTH, height=HEIGHT,
board_offset_bottom=BOARD_OFFSET_BOTTOM,
board_width=BOARD_WIDTH,
board_height=BOARD_HEIGHT):
self.root=Tk()
self.root.protocol("WM_DELETE_WINDOW", self.root.destroy)
self.width = width
self.height = height
self.canvas=Canvas(self.root, bg="black",width=width,height=height)
self.board_width = board_width
self.board_height = board_height
self.board_offset_bottom = board_offset_bottom
self.canvas.pack()
self.fps = fps
self.controllers = []
#For reset
self.root.bind("<space>", lambda e:self.reset_all())
self.root.bind("<Escape>", lambda e:self.root.destroy())
def run(self):
self.root.after(1000//self.fps, self.loop)
try:
self.root.mainloop()
except KeyboardInterrupt:
self.root.destroy()
def loop(self):
actions = [controller.get_action(self.model) for controller in self.controllers]
self.model.update(1./self.fps, actions)
self.draw()
self.root.after(1000//self.fps, self.loop)
def draw(self):
self.canvas.delete('all')
self.board = self.canvas.create_rectangle(
self.model.x()-self.board_width/2,
self.board_offset_bottom+self.height-self.board_height,
self.model.x()+self.board_width/2,
self.board_offset_bottom+self.height, fill="green")
self.pendulum = self.canvas.create_line(
self.model.x(),
self.board_offset_bottom+self.height-self.board_height,
self.model.x()+self.model.arm_length*math.sin(self.model.alpha()),
self.board_offset_bottom+self.height-self.board_height-self.model.arm_length*math.cos(self.model.alpha()),
fill="blue", width=20)
def attach_model(self, model):
self.model = model
self.draw()
def attach_controller(self, controller):
self.controllers.append(controller)
def reset_all(self):
self.model.randomize()
class Lissajou(Observer):
def __init__(self, parent,subjects,bg="black"):
self.subjects=subjects
self.canvas=Canvas(parent,bg=bg)
self.width = int(self.canvas.cget("width"))
self.height = int(self.canvas.cget("height"))
self.signalXY_id = None
self.canvas.bind("<Configure>", self.resize)
self.packing()
def update(self):
print("Lissajou update")
self.signalXY_id = self.plot_lissajou()
def resize(self, event):
if event:
self.width=event.width
self.height=event.height
self.grid()
self.update()
def grid(self, n=10, m=10,color="white"):
self.canvas.delete("all")
w,h=self.width,self.height
width,height=int(w),int(h)
self.canvas.create_line(n,(height/2.0),width,(height/2.0),arrow="last",fill=color)
self.canvas.create_line(width/2.0,height,width/2.0,5.0,arrow="last",fill=color)
stepX=(width)/m*1.0
stepY=(height)/n*1.0
for t in range(1,m+1):
x =t*stepX
self.canvas.create_line(x,height,x,20,fill=color)
for t in range(1,n+1):
y =t*stepY
self.canvas.create_line(10.0,y,width-10,y,fill=color)
def plot_lissajou(self,color='green'):
width,height=int(self.width-12),int(self.height)
signalXY = self.subjects.getSignalXY()
if signalXY!=None:
self.canvas.delete(self.signalXY_id)
if signalXY and len(signalXY)>1:
plot=[((x+1)*(width/2)+5, height/2.0*(y+1)) for (x, y) in signalXY]
signalValue = self.canvas.create_line(plot, fill=color, smooth=1, width=2)
return signalValue
def packing(self):
self.canvas.pack(expand=1, fill='both',side='top')
class Viewport(Frame):
def __init__(self, parent=None, canvassize=500):
Frame.__init__(self, parent)
# Incredibly, it's a pain to extract the canvas width,height directly
# from the canvas widget itself, so we store these here and push them
# down to the actual canvas widget whenever they change.
self.canvaswidth = canvassize
self.canvasheight = canvassize
# The flag for whether we display the camera or not is in menu.py
# as part the of menubar class.
self.readoutid = 0
self.framewidth = -1 # Will be set elsewhere
self.frameheight = -1
self.pack(side=BOTTOM, anchor=S, expand=YES, fill=BOTH)
self.canvas = Canvas(self, width=canvassize, \
height=canvassize, bg='white')
self.canvas.pack()
###########################
# DRAW_READOUT class function:
# - Build the text strings for the camera readout display
# - If a readout is already on the screen, remove it
# - Draw the new readout
# This routine does NOT check the menu.py variable that determines
# whether or not we should actually draw the readout. It's the
# caller's responsibility to do that.
#
def draw_readout(self, camera):
text1 = 'Camera:'
text2 = "x=%d y=%d z=%d" % (round(camera.t[0]), \
round(camera.t[1]), round(camera.t[2]))
text3 = "Rotation = %d" % (round(degrees(camera.yrot)))
text4 = "%s\n%s\n%s" % (text1, text2, text3)
if self.readoutid:
self.canvas.delete(self.readoutid)
self.readoutid = self.canvas.create_text(5,5, text=text4, \
anchor=NW)
def undraw_readout(self):
if self.readoutid:
self.canvas.delete(self.readoutid)
self.readoutid = 0
class Viewport(Frame):
def __init__(self, parent=None, canvassize=500):
Frame.__init__(self, parent)
# Incredibly, it's a pain to extract the canvas width,height directly
# from the canvas widget itself, so we store these here and push them
# down to the actual canvas widget whenever they change.
self.canvaswidth = canvassize
self.canvasheight = canvassize
# The flag for whether we display the camera or not is in menu.py
# as part the of menubar class.
self.readoutid = 0
self.framewidth = -1 # Will be set elsewhere
self.frameheight = -1
self.pack(side=BOTTOM, anchor=S, expand=YES, fill=BOTH)
self.canvas = Canvas(self, width=canvassize, \
height=canvassize, bg='white')
self.canvas.pack()
###########################
# DRAW_READOUT class function:
# - Build the text strings for the camera readout display
# - If a readout is already on the screen, remove it
# - Draw the new readout
# This routine does NOT check the menu.py variable that determines
# whether or not we should actually draw the readout. It's the
# caller's responsibility to do that.
#
def draw_readout(self, camera):
text1 = 'Camera:'
text2 = "x=%d y=%d z=%d" % (round(camera.t[0]), \
round(camera.t[1]), round(camera.t[2]))
text3 = "Rotation = %d" % (round(degrees(camera.yrot)))
text4 = "%s\n%s\n%s" % (text1, text2, text3)
if self.readoutid:
self.canvas.delete(self.readoutid)
self.readoutid = self.canvas.create_text(5,5, text=text4, \
anchor=NW)
def undraw_readout(self):
if self.readoutid:
self.canvas.delete(self.readoutid)
self.readoutid = 0
class Clock(Frame): def __init__(self, parent): Frame.__init__(self, parent) self.parent = parent self.canvas = Canvas(self, width=WIDTH, height=HEIGHT) self.initTime() self.draw() self.onTimer() def initTime(self): self.hourHand = time.localtime().tm_hour % 12 * 5 self.minuteHand = time.localtime().tm_min self.secondHand = time.localtime().tm_sec def draw(self): self.pack(fill=BOTH, expand=1) radius = 300 x, y = 50, 50 centerX, centerY = 180, 180 hourX = centerX + 0.3 * radius/2.0 * math.cos(self.toRadian(self.hourHand)) hourY = centerY + 0.3 * radius/2.0 * math.sin(self.toRadian(self.hourHand)) minuteX = centerX + 0.6 * radius/2.0 * math.cos(self.toRadian(self.minuteHand)) minuteY = centerY + 0.6 * radius/2.0 * math.sin(self.toRadian(self.minuteHand)) secondX = centerX + 0.75 * radius/2.0 * math.cos(self.toRadian(self.secondHand)) secondY = centerY + 0.75 * radius/2.0 * math.sin(self.toRadian(self.secondHand)) self.canvas.create_oval(x, y, radius, radius, outline="black", fill="black") self.canvas.create_line(centerX, centerY, hourX, hourY, width=3, fill="green") self.canvas.create_line(centerX, centerY, minuteX, minuteY, width=3, fill="green") self.canvas.create_line(centerX, centerY, secondX, secondY, fill="red") self.canvas.pack(fill=BOTH, expand=1) def toRadian(self, x): return (x * math.pi/30.0) - (math.pi/2.0) def onTimer(self): self.tick() self.canvas.delete(ALL) self.draw() self.after(DELAY, self.onTimer) def tick(self): self.secondHand = (self.secondHand + 1) % 60 if self.secondHand == 0: self.minuteHand = (self.minuteHand + 1) % 60 if self.minuteHand == 0: self.hourHand = (self.hourHand + 5) % 60
class ResultsTable(Frame):
"""A custom table widget which displays words alongside the users guesses"""
def __init__(self, parent, width=400, height=200):
Frame.__init__(self, parent)
self.canvas = Canvas(self, width=width, height=height, bg="#FFFFFF")
self.canvas.configure(bd=2, relief=SUNKEN)
self.canvas.pack(side=LEFT)
self.centre_line = self.canvas.create_line(0, 0, 0, 0)
scrollbar = Scrollbar(self)
scrollbar.pack(side=RIGHT, fill=Y)
scrollbar.configure(command=self.canvas.yview)
self.canvas.configure(yscrollcommand=scrollbar.set, scrollregion=(0, 0, width, height))
self.width=width
self.height_in_lines = height/18
self.item_count = 0
self.font = ("Helvetica", 12)
def add_word(self, word):
"""Add a word to the table"""
top = 20*self.item_count
if top > 200:
#If necessary extend scroll region downwards
self.canvas.configure(scrollregion=(0, 0, self.width, top+20))
colour = "#139E1C" if word.isCorrect else "#F30000"
#Draw the word in the left column
self.canvas.create_text(2, top, anchor=NW, text=word, font=self.font)
#Draw the guess in the right column
self.canvas.create_text(self.width/2+2, top, anchor=NW, text=word.answer, font=self.font, fill=colour)
#Draw a line to separate this row from those below
self.canvas.create_line(0, top+19, self.width, top+19)
#Extend centre line of tablr
self.canvas.coords(self.centre_line, self.width/2, 0, self.width/2,
top+19)
self.item_count += 1
def add_list(self, word_list):
"""Add a list to the table"""
for word in word_list:
self.add_word(word)
def clear(self):
"""Clear the table of all words"""
self.item_count = 0
self.canvas.delete(ALL)
class PRMViewer(object):
def __init__(self, width=500, height=500, title='PRM', background='tan'):
tk = Tk()
tk.withdraw()
top = Toplevel(tk)
top.wm_title(title)
top.protocol('WM_DELETE_WINDOW', top.destroy)
self.width = width
self.height = height
self.canvas = Canvas(top, width=self.width, height=self.height, background=background)
self.canvas.pack()
def pixel_from_point(self, point):
(x, y) = point
# return (int(x*self.width), int(self.height - y*self.height))
return (x * self.width, self.height - y * self.height)
def draw_point(self, point, radius=5):
(x, y) = self.pixel_from_point(point)
self.canvas.create_oval(x - radius, y - radius, x + radius, y + radius, fill='black')
def draw_line(self, segment):
(point1, point2) = segment
(x1, y1) = self.pixel_from_point(point1)
(x2, y2) = self.pixel_from_point(point2)
self.canvas.create_line(x1, y1, x2, y2, fill='black', width=2)
def draw_arrow(self, point1, point2):
(x1, y1) = self.pixel_from_point(point1)
(x2, y2) = self.pixel_from_point(point2)
self.canvas.create_line(x1, y1, x2, y2, fill='black', width=2, arrow=LAST)
def draw_rectangle(self, box, width=2, color='brown'):
(point1, point2) = box
(x1, y1) = self.pixel_from_point(point1)
(x2, y2) = self.pixel_from_point(point2)
self.canvas.create_rectangle(x1, y1, x2, y2, fill=color, width=width)
def draw_circle(self, center, radius, width=2, color='black'):
(x1, y1) = self.pixel_from_point(np.array(center) - radius * np.ones(2))
(x2, y2) = self.pixel_from_point(np.array(center) + radius * np.ones(2))
self.canvas.create_oval(x1, y1, x2, y2, outline='black', fill=color, width=width)
def clear(self):
self.canvas.delete('all')
class Application(Frame):
def __init__(self, parent, game):
Frame.__init__(self, parent, background="green")
self.parent = parent
self.game = game
self.initUI()
self.canvas = Canvas(self)
self.draw()
def initUI(self):
self.parent.title("Football")
self.pack(fill=BOTH, expand=1)
def draw(self):
self.game.next_round()
LAYOUT = self.game.get_layout()
self.canvas.delete("all")
self.canvas.create_text(300, 20, anchor=W, font="Purisa", text="RESULT " + str(LAYOUT[7][0]) + ":" + str(LAYOUT[7][1]))
self.canvas.create_text(50, 20, anchor=W, font="Purisa", text="Control WSAD" )
self.canvas.create_text(650, 20, anchor=W, font="Purisa", text="Control ARROWS" )
x0 = 10
y0 = 40
# WHOLE FIELD
self.canvas.create_rectangle(x0, y0, x0 + LAYOUT[0], y0 + LAYOUT[1], outline="white", fill="green", width=2)
self.canvas.create_rectangle(x0, y0, x0 + LAYOUT[0]/2, y0 + LAYOUT[1], outline="white", fill="green", width=1)
self.canvas.create_oval(x0 + LAYOUT[0]/2 -1 , y0 + LAYOUT[1]/2 - 1, x0 + LAYOUT[0]/2, y0 + LAYOUT[1]/2, outline="white",
fill="white", width=4)
# GOALKEEPER FIELDS
self.canvas.create_rectangle(x0, y0 + LAYOUT[1]/2 - LAYOUT[3][1]/2, x0 + LAYOUT[3][0], y0 + LAYOUT[1]/2 + LAYOUT[3][1]/2, outline="white", fill="green", width=2)
self.canvas.create_rectangle(x0 + LAYOUT[0] - LAYOUT[3][0], y0 + LAYOUT[1]/2 - LAYOUT[3][1]/2, x0 + LAYOUT[0], y0 + LAYOUT[1]/2 + LAYOUT[3][1]/2, outline="white", fill="green", width=2)
# GOALPOSTS
self.canvas.create_rectangle(x0 - 5, y0 + LAYOUT[1]/2 - LAYOUT[2]/2, x0, y0 + LAYOUT[1]/2 + LAYOUT[2]/2, fill="black")
self.canvas.create_rectangle(x0 + LAYOUT[0]-1, y0 + LAYOUT[1]/2 - LAYOUT[2]/2, x0 + LAYOUT[0] + 5, y0 + LAYOUT[1]/2 + LAYOUT[2]/2, fill="black")
# PLAYERS
self.canvas.create_oval(x0 + LAYOUT[4][0]-LAYOUT[8][0][0], y0 + LAYOUT[4][1]-LAYOUT[8][0][0], x0 + LAYOUT[4][0] + LAYOUT[8][0][0], y0 + LAYOUT[4][1] + LAYOUT[8][0][0], fill="blue")
self.canvas.create_oval(x0 + LAYOUT[5][0]-LAYOUT[8][1][0], y0 + LAYOUT[5][1]-LAYOUT[8][1][0], x0 + LAYOUT[5][0] + LAYOUT[8][1][0], y0 + LAYOUT[5][1] + LAYOUT[8][1][0], fill="gray")
# BALL
self.canvas.create_oval(x0 + LAYOUT[6][0]-LAYOUT[8][2][0], y0 + LAYOUT[6][1]-LAYOUT[8][2][0], x0 + LAYOUT[6][0] + LAYOUT[8][2][0], y0 + LAYOUT[6][1] + LAYOUT[8][2][0], fill="white")
self.canvas.pack(fill=BOTH, expand=1)
self.after(1, self.draw)
class Screen(Observer):
def __init__(self,parent,bg="white"):
self.canvas=Canvas(parent,bg=bg)
print("parent",parent.cget("width"),parent.cget("height"))
self.magnitude=Scale(parent,length=250,orient="horizontal",
label="Magnitude", sliderlength=20,
showvalue=0,from_=0,to=5,
tickinterval=25)
def update(self,model):
print("View update")
signal=model.get_signal()
self.plot_signal(signal)
def get_magnitude(self):
return self.magnitude
def plot_signal(self,signal,color="red"):
w,h=self.canvas.cget("width"),self.canvas.cget("height")
width,height=int(w),int(h)
# print(self.canvas.find_withtag("signal"))
if self.canvas.find_withtag("signal") :
self.canvas.delete("signal")
if signal and len(signal) > 1:
plot = [(x*width, height/2.0*(y+1)) for (x, y) in signal]
signal_id = self.canvas.create_line(plot, fill=color, smooth=1, width=3,tags="signal")
return
def grid(self, steps):
w,h=self.canvas.cget("width"),self.canvas.cget("height")
width,height=int(w),int(h)
self.canvas.create_line(10,height/2,width,height/2,arrow="last")
self.canvas.create_line(10,height-5,10,5,arrow="last")
step=(width-10)/steps*1.
for t in range(1,steps+2):
x =t*step
self.canvas.create_line(x,height/2-4,x,height/2+4)
def packing(self) :
self.canvas.pack()
self.magnitude.pack()
class SimWin(Tk,object):
WIN_HEIGHT = 600
WIN_WIDTH = 600
WIN_BG = '#fff'
def __init__(self, parent=None):
super(SimWin, self).__init__(parent)
self.canvas = Canvas(master=self,
height=SimWin.WIN_HEIGHT,
width=SimWin.WIN_WIDTH,
background=SimWin.WIN_BG)
self.canvas.pack()
def changeProps(self, height, width, bg):
SimWin.WIN_HEIGHT = height
SimWin.WIN_WIDTH = width
SimWin.WIN_BG = bg
def envDraw(self, redius, C):
# C is a 2D numpy array
if(not (type(C)==type(np.array([1])))):
print 'Input a valid NUMPY array'
else:
n = 0
for (i,j) in C:
self.canvas.create_oval(i-redius[n],j-redius[n],i+redius[n],j+redius[n],
fill='#f00',
outline='#f00')
n = n + 1
def cleanCanvas(self):
self.canvas.delete('delete')
class Plotter:
def __init__(self):
self.colors = ["red", "green"]
self.window = Tk()
self.window.title("R-L Reinfolge")
self.c = Canvas(master=self.window, width = 300, height= 250, bg="white")
self.c.create_text(20, 20, text="rechts")
self.c.create_text(20, 220, text="links")
self.c.pack()
t = right - left
self.pens = []
for i in range(len,(t)):
self.pens.append(Pen (self.c, t[i], self.colors[i%4]))
thread.start_new_thread(self.update, ())
self.window.mainloop()
def update(self):
while True:
for i in range(60):
for pen in self.pens:
pen.draw(i*5)
time.sleep(1)
self.c.delete("point")
class ResultsTable(Frame):
def __init__(self, parent, width=400, height=200):
Frame.__init__(self, parent)
self.canvas = Canvas(self, width=width, height=height, bg="#FFFFFF")
self.canvas.configure(bd=2, relief=SUNKEN)
self.canvas.pack(side=LEFT)
self.centre_line = self.canvas.create_line(0, 0, 0, 0)
scrollbar = Scrollbar(self)
scrollbar.pack(side=RIGHT, fill=Y)
scrollbar.configure(command=self.canvas.yview)
self.canvas.configure(yscrollcommand=scrollbar.set, scrollregion=(0, 0, width, height))
self.width=width
self.height_in_lines = height/18
self.item_count = 0
self.font = ("Helvetica", 12)
def add_word(self, word):
top = 20*self.item_count
if top > 200:
self.canvas.configure(scrollregion=(0, 0, self.width, top+20))
colour = "#139E1C" if word.isCorrect else "#F30000"
self.canvas.create_text(2, top, anchor=NW, text=word, font=self.font)
self.canvas.create_text(self.width/2+2, top, anchor=NW, text=word.answer, font=self.font, fill=colour)
self.canvas.create_line(0, top+19, self.width, top+19)
self.canvas.coords(self.centre_line, self.width/2, 0, self.width/2,
top+19)
self.item_count += 1
def add_list(self, word_list):
for word in word_list:
self.add_word(word)
def clear(self):
self.item_count = 0
self.canvas.delete(ALL)
canv.delete(rects[i][j])
rects[i][j]=canv.create_rectangle(w*i/n, h*j/n, w*(i+1)/n, h*(j+1)/n, fill="lightblue", outline="lightblue")
else: new_grid[i][j]=grid[i][j]
for i in range(len(new_grid)):
for j in range(len(new_grid[i])):
grid[i][j]=new_grid[i][j]
canv.after(20, tick, grid, rects)
w, h = 600, 600
n, m = 20, 20
paused = True
grid=[]; new_grid=[]; rects=[]
root = Tk()
canv = Canvas(root, width=w, height=h, bg="white")
##for i in range(n+1):canv.create_line(w*i/n,0,w*i/n,h, fill = "lightblue")
##for i in range(m+1):canv.create_line(0,h*i/m,w,h*i/m, fill = "lightblue")
for i in range(n):
grid.append([])
rects.append([])
for j in range(m):
grid[i].append(0)
rects[i].append(canv.create_rectangle(w*i/n, h*j/n, w*(i+1)/n, h*(j+1)/n, fill="white", outline="lightblue"))
for (i, j) in [(0, 1), (0, 2), (1, 0), (1, 1), (2, 1)]:
grid[i][j]=1
canv.delete(rects[i][j])
rects[i][j]=canv.create_rectangle(w*i/n, h*j/n, w*(i+1)/n, h*(j+1)/n, fill="lightblue", outline="lightblue")
canv.pack()
root.bind('<1>', lambda e: left(e, grid, rects))
root.bind('<space>', begin)
root.mainloop()
class MainWindow(Tk):
def __init__(self):
Tk.__init__(self)
self.title(mainWindowTitle)
self.resizable(width=0, height=0)
self.__setStyles()
self.__initializeComponents()
self.__dataController = DataController();
self.mainloop()
def __initializeComponents(self):
self.imageCanvas = Canvas(master=self, width=imageCanvasWidth,
height=windowElementsHeight, bg="white")
self.imageCanvas.pack(side=LEFT, padx=(windowPadding, 0),
pady=windowPadding, fill=BOTH)
self.buttonsFrame = Frame(master=self, width=buttonsFrameWidth,
height=windowElementsHeight)
self.buttonsFrame.propagate(0)
self.loadFileButton = Button(master=self.buttonsFrame,
text=loadFileButtonText, command=self.loadFileButtonClick)
self.loadFileButton.pack(fill=X, pady=buttonsPadding);
self.colorByLabel = Label(self.buttonsFrame, text=colorByLabelText)
self.colorByLabel.pack(fill=X)
self.colorByCombobox = Combobox(self.buttonsFrame, state=DISABLED,
values=colorByComboboxValues)
self.colorByCombobox.set(colorByComboboxValues[0])
self.colorByCombobox.bind("<<ComboboxSelected>>", self.__colorByComboboxChange)
self.colorByCombobox.pack(fill=X, pady=buttonsPadding)
self.rejectedValuesPercentLabel = Label(self.buttonsFrame, text=rejectedMarginLabelText)
self.rejectedValuesPercentLabel.pack(fill=X)
self.rejectedValuesPercentEntry = Entry(self.buttonsFrame)
self.rejectedValuesPercentEntry.insert(0, defaultRejectedValuesPercent)
self.rejectedValuesPercentEntry.config(state=DISABLED)
self.rejectedValuesPercentEntry.pack(fill=X, pady=buttonsPadding)
self.colorsSettingsPanel = Labelframe(self.buttonsFrame, text=visualisationSettingsPanelText)
self.colorsTableLengthLabel = Label(self.colorsSettingsPanel, text=colorsTableLengthLabelText)
self.colorsTableLengthLabel.pack(fill=X)
self.colorsTableLengthEntry = Entry(self.colorsSettingsPanel)
self.colorsTableLengthEntry.insert(0, defaultColorsTableLength)
self.colorsTableLengthEntry.config(state=DISABLED)
self.colorsTableLengthEntry.pack(fill=X)
self.scaleTypeLabel = Label(self.colorsSettingsPanel, text=scaleTypeLabelText)
self.scaleTypeLabel.pack(fill=X)
self.scaleTypeCombobox = Combobox(self.colorsSettingsPanel, state=DISABLED,
values=scaleTypesComboboxValues)
self.scaleTypeCombobox.set(scaleTypesComboboxValues[0])
self.scaleTypeCombobox.bind("<<ComboboxSelected>>", self.__scaleTypeComboboxChange)
self.scaleTypeCombobox.pack(fill=X)
self.colorsTableMinLabel = Label(self.colorsSettingsPanel, text=colorsTableMinLabelText)
self.colorsTableMinLabel.pack(fill=X)
self.colorsTableMinEntry = Entry(self.colorsSettingsPanel)
self.colorsTableMinEntry.insert(0, defaultColorsTableMin)
self.colorsTableMinEntry.config(state=DISABLED)
self.colorsTableMinEntry.pack(fill=X)
self.colorsTableMaxLabel = Label(self.colorsSettingsPanel, text=colorsTableMaxLabelText)
self.colorsTableMaxLabel.pack(fill=X)
self.colorsTableMaxEntry = Entry(self.colorsSettingsPanel)
self.colorsTableMaxEntry.insert(0, defaultColorsTableMax)
self.colorsTableMaxEntry.config(state=DISABLED)
self.colorsTableMaxEntry.pack(fill=X)
self.colorsSettingsPanel.pack(fill=X, pady=buttonsPadding)
self.redrawButton = Button(master=self.buttonsFrame, text=redrawButtonText,
state=DISABLED, command=self.__redrawButtonClick)
self.redrawButton.pack(fill=X, pady=buttonsPadding)
self.buttonsFrame.pack(side=RIGHT, padx=windowPadding, pady=windowPadding, fill=BOTH)
def __setStyles(self):
Style().configure("TButton", padding=buttonsTextPadding, font=buttonsFont)
def loadFileButtonClick(self):
fileName = tkFileDialog.askopenfilename(filetypes=[('Tablet files', '*.mtb'), ('Tablet files', '*.htd')])
if (fileName):
if (not self.__getInputParams()):
self.__showInvalidInputMessage()
return
self.lastFileName = fileName;
self.title(mainWindowTitle + " " + fileName)
self.__draw(fileName)
tkMessageBox.showinfo(measureDialogTitle,
measureDialogText + str(self.__dataController.getMeasure(fileName)))
self.redrawButton.config(state=NORMAL)
self.colorByCombobox.config(state="readonly")
self.colorsTableLengthEntry.config(state=NORMAL)
self.scaleTypeCombobox.config(state="readonly")
def __redrawButtonClick(self):
if (not self.__getInputParams()):
self.__showInvalidInputMessage()
return
self.__draw(self.lastFileName)
def __scaleTypeComboboxChange(self, event):
if (self.scaleTypeCombobox.get() == relativeScaleType):
self.colorsTableMinEntry.config(state=DISABLED)
self.colorsTableMaxEntry.config(state=DISABLED)
else:
self.colorsTableMinEntry.config(state=NORMAL)
self.colorsTableMaxEntry.config(state=NORMAL)
def __colorByComboboxChange(self, event):
if (self.colorByCombobox.get() == colorByNoneOption):
self.rejectedValuesPercentEntry.config(state=DISABLED)
else:
self.rejectedValuesPercentEntry.config(state=NORMAL)
def __draw(self, fileName):
self.imageCanvas.delete(ALL)
dataForDrawing = self.__dataController.getDataForDrawing(
fileName, self.colorByCombobox.get(), self.colorsTableLength,
self.scaleTypeCombobox.get(), self.colorsTableMinValue,
self.colorsTableMaxValue, self.rejectedValuesPercent)
for package in dataForDrawing:
x = package[0];
y = package[1];
color = package[2];
self.imageCanvas.create_line(x, y, x + 1, y + 1, fill=color)
def __drawColorBySpeed(self, dataPackages, minX, minY, ratio, hsv):
allSpeeds = self.__getAllSpeeds(dataPackages)
minSpeed = min(allSpeeds)
maxSpeed = max(allSpeeds)
if (self.scaleTypeCombobox.get() == relativeScaleType):
colorsTableMinValue = minSpeed
colorsTableMaxValue = maxSpeed
else:
colorsTableMinValue = self.colorsTableMinValue
colorsTableMaxValue = self.colorsTableMaxValue
i = 0
for package in dataPackages:
x = (package[dataXNumber] - minX) * ratio
y = (package[dataYNumber] - minY) * ratio
color = hsv.getColorByValue(colorsTableMinValue,
colorsTableMaxValue,
allSpeeds[i])
tk_rgb = "#%02x%02x%02x" % color
self.imageCanvas.create_line(x, y, x + 1, y + 1, fill=tk_rgb)
i += 1
def __showInvalidInputMessage(self):
tkMessageBox.showinfo(invalidInputMessageTitle, invalidInputMessageText)
def __getInputParams(self):
try:
self.colorsTableLength = int(self.colorsTableLengthEntry.get())
self.colorsTableMinValue = float(self.colorsTableMinEntry.get())
self.colorsTableMaxValue = float(self.colorsTableMaxEntry.get())
self.rejectedValuesPercent = float(self.rejectedValuesPercentEntry.get())
if (self.colorsTableLength < 1 or
self.colorsTableMinValue >= self.colorsTableMaxValue or
self.rejectedValuesPercent < 0 or self.rejectedValuesPercent >= 100):
raise
return True
except:
return False
while True:
#maps arm coordinates to servo values, and periodically move the rover's head there
coords = x.coords
servos = phantom_to_servos(coords)
if time() - t > 0.5 and not locked:
r.pan_servo(-servos[0])
r.tilt_servo(servos[1])
t = time()
#display arm's coordinates in tkinter window
x_label["text"] = "X: {}".format(coords[0])
y_label["text"] = "Y: {}".format(coords[1])
z_label["text"] = "Z: {}".format(coords[2])
#visual representation of where the arm's pen point is
c.delete(pointer)
pointer = c.create_circle(coords[0]+300, 600-coords[1]-300, (coords[2]+120)/15, fill="black")
#locks the head if button two is pressed
if coords[4]:
print("Toggled camera lock!")
locked = not locked
sleep(1)
#saves an image from the rover if button one is pressed
if coords[3]:
capture_image()
root.update_idletasks()
root.update()
class main:
def __init__ (self):
self.app = Tk()
self.app.title('Tic Tac Toe')
#self.app.resizable(width=False, height=False)
#width and hight of window
w = 900
h = 1100
#width and hight of screen
ws = self.app.winfo_screenwidth()
hs = self.app.winfo_screenheight()
#calculate position
x = ws/2 - w/2
y = hs/2 - h/2
#place window -> pramaters(visina, dolzina, pozicija x, pozicija y)
self.app.geometry("%dx%d+%d+%d" % (w,h, x, y))
#======================================
self.frame = Frame() #main frame
self.frame.pack(fill = 'both', expand = True)
self.label = Label(self.frame, text = 'Tic Tac Toe', height = 4, bg = 'white', fg = 'blue')
self.label.pack(fill='both', expand = True)
#self.label2 = Label(self.frame, text = 'here', height = 2, bg = 'white', fg = 'blue') odkomentiri samo za develop-------------
#self.label2.pack(fill='both', expand = True)
self.canvas = Canvas(self.frame, width = 900, height = 900)
self.canvas.pack(fill = 'both', expand = True)
self.framepod = Frame(self.frame)#sub frame
self.framepod.pack(fill = 'both', expand = True)
self.Single = Button(self.framepod, text = 'Start single player', height = 4, command = self.startsingle, bg = 'white', fg = 'blue')
self.Single.pack(fill='both', expand = True, side=RIGHT)
self.Multi = Button(self.framepod, text = 'Start double player', height = 4, command = self.double, bg = 'white', fg = 'blue')
self.Multi.pack(fill='both', expand = True, side=RIGHT)
self.board = AI()
self.draw()
def double(self):
#cleans the all simbols from canvas
self.canvas.delete(ALL)
self.label['text'] = ('Tic Tac Toe Game')
self.canvas.bind("<ButtonPress-1>", self.place)
self.draw() #---------------------------------------
self.table=[[-1,-1,-1],[-1,-1,-1],[-1,-1,-1]]
self.c=0 #counter
self.e=False #flag for end game
def draw(self): #draws the outline lines
self.canvas.create_rectangle(0,0,900,900, outline='black')
self.canvas.create_rectangle(300,900,600,0, outline='black')
self.canvas.create_rectangle(0,300,900,600, outline='black')
def place(self, event):
for i in range(0,900,300):
for j in range(0,900,300):
if event.x in range(i,i+300) and event.y in range(j, j+300):
if self.canvas.find_enclosed(i,j,i+300, j+300) == ():
if self.c % 2 == 0:
#calculate points to draw circle
x=(2*i+300)/2
y=(2*j+300)/2
x2=int(i/300)
y2=int(j/300)
self.canvas.create_oval(x+75,y+75,x-75,y-75, width = 4, outline="blue")
self.table[y2][x2] = 4
self.c+=1
else:
#calculate points to draw cross
x=(2*i+300)/2
y=(2*j+300)/2
x2=int(i/300)
y2=int(j/300)
self.canvas.create_line(x+60,y+60,x-60,y-60, width = 4, fill="red")
self.canvas.create_line(x-60,y+60,x+60,y-60, width = 4, fill="red")
self.table[y2][x2] = 1
self.c+=1
self.check()
def startsingle(self):
self.canvas.delete(ALL)
self.label['text'] = ('Tic Tac Toe Game')
self.canvas.bind("<ButtonPress-1>", self.placeone)
self.draw()
self.board = AI()
def placeone(self, event):
player = 'X'
for i in range(0,900,300):
for j in range(0,900,300):
if event.x in range(i,i+300) and event.y in range(j, j+300):
if self.canvas.find_enclosed(i,j,i+300, j+300) == ():
x=(2*i+300)/2
y=(2*j+300)/2
x2=int(i/300)
y2=int(j/300)
self.canvas.create_line(x+60,y+60,x-60,y-60, width = 4, fill="red")
self.canvas.create_line(x-60,y+60,x+60,y-60, width = 4, fill="red")
player_move = x2 + 3*y2 #spremeni
self.board.make_move(player_move, player)
if self.board.complete():
self.label['text'] = (self.board.winner())
self.canvas.unbind("ButtonPress-1")
self.board = AI()
elif self.board.winner() != None:
self.label['text'] = (self.board.winner())
self.canvas.unbind("ButtonPress-1")
self.board = AI()
else:
player = self.board.get_enemy(player)
computer_move = self.board.determine(self.board, player)
self.board.make_move(computer_move, player)
ti = computer_move % 3
tj = computer_move / 3
x=(600*ti+300)/2
y=(600*tj+300)/2
#self.label2['text'] = str(computer_move) + ' ti ' + str(ti) + ' tj ' + str(tj) + ' y ' + str(y) + ' x ' +str(x)
self.canvas.create_oval(x+75,y+75,x-75,y-75, width = 4, outline="blue")
if self.board.winner() != None:
self.label['text'] = (self.board.winner())
self.canvas.unbind("ButtonPress-1")
self.board = AI()
def check(self):
#checks for win
#horitontal
for i in range(3):
if sum(self.table[i])==3:
self.label['text'] = ('X wins')
self.end()
if sum(self.table[i])==12:
self.label['text'] = ('O wins')
self.end()
#vertical
self.vs=[[row[i] for row in self.table] for i in range(3)]
for i in range(3):
if sum(self.vs[i])==3:
self.label['text'] = ('X wins')
self.end()
if sum(self.vs[i])==12:
self.label['text'] = ('O wins')
self.end()
#diagonals
self.dig1=0
self.dig2=0
for i in range(3):
self.dig1+=self.table[i][i]
for i in range(3):
self.dig2+=self.table[2-i][i]
if self.dig1==3:
self.label['text'] = ('X wins')
self.end()
if self.dig1==12:
self.label['text'] = ('O wins')
self.end()
if self.dig2==3:
self.label['text'] = ('X wins')
self.end()
if self.dig2==12:
self.label['text'] = ('O wins')
self.end()
#draw
if self.e==False:
a=0
for i in range(3):
a+=sum(self.table[i])
if a == 24: #5 *4 + 4 * 1 --> 5 circles and 4 crosses
self.label['text'] = ('Draw')
self.end()
def end(self):
self.canvas.unbind("<ButtonPress-1>")
self.e=True
def mainloop(self):
self.app.mainloop()
class PinceauCanvas:
def __init__(self, master, width, height):
self.__master = master
self.__width = width
self.__height = height
self.__tmp = {}
self.__tmp_rendered = None
self.__shapes = []
# Default constants
self.__draw_mode = 'add'
self.__shape_mode = 'normal'
self.__shape_type = 'rectangle'
self.__tmp_color = '#E57373'
self.__final_color = '#F44336'
# Main canvas
self.__canvas = Canvas(self.__master,
width=self.__width,
height=self.__height)
self.bind_events()
def set_send(self, send_func):
# Method sending the drawn shape to the server.
self.__send = send_func
def switch_shape_mode(self):
# Method enabling to switch from a straight shape to a nomrmal shape
# and vice-versa.
self.__shape_mode = ('straight'
if self.__shape_mode == 'normal' else 'normal')
def switch_draw_mode(self):
# Method enabling to switch from the drawing mode to the erasing mode
# and vice-versa.
self.__draw_mode = ('erase' if self.__draw_mode == 'add' else 'add')
def change_color(self, tmp_color, color):
# Method enabling to switch from one color to another.
self.__tmp_color = tmp_color
self.__final_color = color
def change_shape(self, shape_type):
# Method enabling to switch from one shape to another.
self.__shape_type = shape_type
def pack(self):
self.__canvas.pack()
def bind_events(self):
self.__canvas.bind('<KeyPress>', self.key_press)
self.__canvas.bind('<KeyRelease>', self.key_press)
self.__canvas.bind('<Button-1>', self.mouse_click)
self.__canvas.bind('<B1-Motion>', self.mouse_drag)
self.__canvas.bind('<ButtonRelease-1>', self.mouse_release)
def key_press(self, event):
# Method to detect if the 'CTRL' key or 'MAJ' key is pressed using the
# keycodes from iOS and Windows.
# Indeed, if 'CTRL' is pressed, we turn to erasing mode.
# And if 'MAJ" is pressed, we turn to straight shapes mode.
keycode = event.keycode
if keycode == 262145 or keycode == 262401 or keycode == 17: # Ctrl key is pressed
self.switch_draw_mode()
if keycode == 131330 or keycode == 131074 or keycode == 131076 or keycode == 16: # Maj key is pressed
self.switch_shape_mode()
def mouse_click(self, event):
self.__canvas.focus_set()
x, y = event.x, event.y
if self.__draw_mode == 'erase':
action = {'action': 'erase', 'x': x, 'y': y}
self.erase(action)
self.__send(action)
elif self.__draw_mode == 'add':
self.__tmp = {
'action': 'add',
'x1': x,
'y1': y,
'x2': x,
'y2': y,
'mode': self.__shape_mode,
'type': self.__shape_type,
'fill': self.__tmp_color
}
def erase(self, action):
# Method erasing a shape on the canvas.
x, y = action['x'], action['y']
shape = self.__canvas.find_closest(x, y)
if shape:
self.__canvas.delete(shape)
def mouse_drag(self, event):
if self.__draw_mode == 'add':
self.__canvas.focus_set()
self.__tmp['x2'] = event.x
self.__tmp['y2'] = event.y
self.__tmp['mode'] = self.__shape_mode
self.__tmp_rendered = self.draw(self.__tmp)
def mouse_release(self, event):
if self.__draw_mode == 'add':
self.__tmp['fill'] = self.__final_color
if self.__tmp['type'] is not None:
final_shape = self.draw(self.__tmp)
self.__shapes.append(final_shape)
self.__send(self.__tmp)
# Reset temp shape
self.__tmp = {}
self.__tmp_rendered = None
def draw(self, shape):
# Method drawing a shape on the canvas.
self.__canvas.delete(self.__tmp_rendered)
rendered_shape = None
if shape['type'] == 'rectangle' and shape['mode'] == 'normal':
rendered_shape = Rectangle(shape)
elif shape['type'] == 'rectangle' and shape['mode'] == 'straight':
rendered_shape = Square(shape)
elif shape['type'] == 'oval' and shape['mode'] == 'normal':
rendered_shape = Oval(shape)
elif shape['type'] == 'oval' and shape['mode'] == 'straight':
rendered_shape = Circle(shape)
elif shape['type'] == 'line' and shape['mode'] == 'normal':
rendered_shape = Line(shape)
elif shape['type'] == 'line' and shape['mode'] == 'straight':
rendered_shape = Diagonal(shape)
shape_id = rendered_shape.draw_on(self.__canvas)
return shape_id
class MapUI:
def __init__(self, master):
def center(win):
win.update_idletasks()
width = win.winfo_width()
height = win.winfo_height()
x = (win.winfo_screenwidth() // 4) - (width // 2) + 40
y = (win.winfo_screenheight() // 4) - (height // 2) + 40
win.geometry('{}x{}+{}+{}'.format(width, height, x, y))
def callback(event):
event.widget.focus_set()
print "clicked at", event.x, event.y
if self.add_tasks_flg.get() == 1:
# Select number of robots
# Define elements of pop up window
self.top = Toplevel()
self.num_robots = StringVar(self.top)
self.num_robots.set("1") # default value
w = OptionMenu(self.top, self.num_robots, '1', '2', '3',
'4').grid(row=0, column=1)
text1 = Message(self.top, text="Number of robots:",
width=150).grid(row=0, column=0)
self.e = Entry(self.top, width=10)
self.e.grid(row=1, column=1)
text2 = Message(self.top, text="Task duration:",
width=150).grid(row=1, column=0)
text3 = Message(self.top, text="(s)", width=60).grid(row=1,
column=2)
newline = Message(self.top, text=" ").grid(row=2)
button = Button(self.top,
text='Enter',
command=lambda: self.enter_task(event)).grid(
row=3, column=1)
button_cancel = Button(self.top,
text='Cancel',
command=self.cancel_task).grid(row=3,
column=2)
center(self.top)
master.title("Map Interface")
master.minsize(width=1000, height=750)
master.maxsize(width=1000, height=750)
master.config(bg=BKG_COLOUR)
self.master = master
# Canvas for overlaying map
self.map_canvas = Canvas(master,
width=CANVAS_W,
height=CANVAS_H,
bg='gray85',
highlightthickness=0)
self.map_canvas.pack(side='right', padx=50)
self.map_canvas.bind("<Button-1>", callback)
global CANVAS_PTR
CANVAS_PTR = self.map_canvas
self.master.update()
w = self.map_canvas.winfo_width()
h = self.map_canvas.winfo_height()
# Overlay a grid
for i in range(0, w, SQ_SIZE):
if i != 0:
self.map_canvas.create_line(i, 0, i, h, dash=1)
for i in range(0, h, SQ_SIZE):
if i != 0:
self.map_canvas.create_line(0, i, w, i, dash=1)
# Load in flame icon from flame.gif
self.flame_icon = PhotoImage(file="flame.gif")
# Load in the drone icon from drone.gif
global DRONE_ICON
DRONE_ICON = PhotoImage(file="drone.gif")
buttons_frame = Canvas(master,
width=163,
height=230,
bg=BUTTONS_BKG_COLOUR,
highlightthickness=1,
highlightbackground='dim grey')
buttons_frame.place(x=40, y=200)
# Define UI buttons
self.add_tasks_flg = IntVar()
self.add_tasks_b = Checkbutton(master,
text="Add Tasks",
variable=self.add_tasks_flg,
highlightbackground=BUTTONS_BKG_COLOUR,
background=BUTTONS_BKG_COLOUR)
self.add_tasks_b.place(x=77, y=240)
self.clear_wp_b = Button(master,
text='Clear Tasks',
command=self.clear_wp,
highlightbackground=BUTTONS_BKG_COLOUR)
self.clear_wp_b.config(width=10)
self.clear_wp_b.place(x=65, y=270)
'''
self.gen_wp_file_b = Button(master, text='Generate Waypoints File', command=self.gen_wp_file, highlightbackground=BKG_COLOUR)
self.gen_wp_file_b.config(width=20)
self.gen_wp_file_b.place(x=20, y=250)
'''
self.land_b = Button(master,
text='Land',
command=self.land,
highlightbackground=BUTTONS_BKG_COLOUR)
self.land_b.config(width=10)
self.land_b.place(x=65, y=350)
# Set up coordinate system conversion and display corners of room:
file_obj = open('antenna_locations.txt', 'r')
anchors = []
for line in file_obj:
cur_anchors = map(float, line.split())
anchors.append(cur_anchors)
file_obj.close()
anchors = (np.array(anchors)).T
# Find largest (abs) x and y values to use a reference for conversion ratio
x_vals = anchors[0]
largest_x_val = x_vals[np.argmax(abs(x_vals))]
y_vals = anchors[1]
largest_y_val = y_vals[np.argmax(abs(y_vals))]
if largest_x_val > largest_y_val:
largest_y_val = largest_x_val
else:
largest_x_val = largest_y_val
global m_per_pixel_x
m_per_pixel_x = float(largest_x_val / (CANVAS_W / 2))
global m_per_pixel_y
m_per_pixel_y = float(largest_y_val / (CANVAS_H / 2))
# Place antenna (anchors) on UI
anchors = anchors.T
for cur_anchor in anchors:
x_pixel_loc = cur_anchor[0] / m_per_pixel_x + CANVAS_W / 2
y_pixel_loc = -1 * (cur_anchor[1] / m_per_pixel_y) + CANVAS_H / 2
# Draw antenna @ location
global ANTENNA_LIST
antenna_id = self.map_canvas.create_oval(x_pixel_loc - 15,
y_pixel_loc - 15,
x_pixel_loc + 15,
y_pixel_loc + 15,
fill='red')
self.master.update()
global SQ_SIZE
SQ_SIZE = 20
global BKG_COLOUR
BKG_COLOUR = 'gray95'
global BUTTONS_BKG_COLOUR
BUTTONS_BKG_COLOUR = 'grey66'
global CANVAS_W
CANVAS_W = 700
global CANVAS_H
CANVAS_H = 700
global TASK_LIST
TASK_LIST = None
global m_per_pixel_x
m_per_pixel_x = None
global m_per_pixel_y
m_per_pixel_y = None
global NEW_TASK_FLAG
NEW_TASK_FLAG = False
global ANTENNA_LIST
ANTENNA_LIST = None
global DRONE_ICON
DRONE_ICON = None
flame_icon = None
ui_wp_list = None
#task_list = None
add_wp_flag = False
task_id = 0
add_tasks_flg = None
def add_tasks(self):
print "adding tasks"
# function imp here
self.add_wp_flag = True
self.map_canvas.config(cursor='pencil')
def clear_wp(self):
print "clear tasks"
global TASK_LIST
TASK_LIST = None
for element_id in self.ui_wp_list:
self.map_canvas.delete(element_id[0])
self.ui_wp_list = None
'''
def gen_wp_file(self):
print "generate wp file"
# function imp here
'''
def land(self):
# Send a new task with position (0,0,0) z=0 tells drone to land
print("land")
def enter_task(self, event):
# Determine square (top left corner coords):
w_start = event.x - event.x % SQ_SIZE
h_start = event.y - event.y % SQ_SIZE
#Translate pixel location to physical location
x_pixel = event.x
y_pixel = event.y
# Find out how many pixels from center:
x_pixel = x_pixel - CANVAS_W / 2
x_physical = x_pixel * m_per_pixel_x
#vertical case, note this is flipped
y_pixel = y_pixel - CANVAS_W / 2
y_pixel = -1 * y_pixel
y_physical = y_pixel * m_per_pixel_y
try:
# Add to task list
global TASK_LIST
if TASK_LIST == None:
TASK_LIST = [[
self.task_id,
int(self.num_robots.get()),
float(self.e.get()), x_physical, y_physical
]]
global NEW_TASK_FLAG
NEW_TASK_FLAG = True
else:
TASK_LIST.append([
self.task_id,
int(self.num_robots.get()),
float(self.e.get()), x_physical, y_physical
])
global NEW_TASK_FLAG
NEW_TASK_FLAG = True
# Indicate task in UI
element_id = self.map_canvas.create_image(event.x,
event.y,
image=self.flame_icon)
if self.ui_wp_list == None:
self.ui_wp_list = [[element_id]]
else:
self.ui_wp_list.append([element_id])
except:
print("Invalid Task Entry")
self.map_canvas.config(cursor='arrow')
self.add_wp_flag = False
print(TASK_LIST)
self.task_id = self.task_id + 1
self.top.destroy()
def cancel_task(self):
self.top.destroy()
class Screen(Observer):
def __init__(self, parent, model_x, model_y, bg="white"):
self.canvas = Canvas(parent, bg=bg)
self.model_x = model_x
self.model_y = model_y
print("parent", parent.cget("width"), parent.cget("height"))
self.showX = True
self.showY = True
self.frame = Frame(parent)
# Signal X
self.magnitude_x = Scale(self.frame,
length=250,
orient="horizontal",
name="m_x",
label="Magnitude X",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
self.frequency_x = Scale(self.frame,
length=250,
orient="horizontal",
name="f_x",
label="Frequency X",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
self.phase_x = Scale(self.frame,
length=250,
orient="horizontal",
name="p_x",
label="Phase X",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
# Signal Y
self.magnitude_y = Scale(self.frame,
length=250,
orient="horizontal",
name="m_y",
label="Magnitude Y",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
self.frequency_y = Scale(self.frame,
length=250,
orient="horizontal",
name="f_y",
label="Frequency Y",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
self.phase_y = Scale(self.frame,
length=250,
orient="horizontal",
name="p_y",
label="Phase Y",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=25)
self.frame2 = Frame(parent, bg="black")
self.varX = IntVar()
self.varY = IntVar()
self.varXY = IntVar()
self.lbl = Label(self.frame2, text="Courbes", fg="black")
# Boutons de sélection (X, Y ou X-Y)
self.caseX = Checkbutton(self.frame2,
text="X",
variable=self.varX,
command=self.getX)
self.caseY = Checkbutton(self.frame2,
text="Y",
variable=self.varY,
command=self.getY)
self.caseXY = Checkbutton(self.frame2,
text="XY",
variable=self.varXY,
command=self.getXY)
self.caseXY.select()
self.wi = self.canvas.cget("width")
self.hi = self.canvas.cget("height")
self.stepx = 0
self.stepy = 0
# Step x
self.step_x = Entry(parent, name="x")
# Step y
self.step_y = Entry(parent, name="y")
def update(self, model):
print("View update")
if model.getId() == 0:
signal = model.get_signal()
self.plot_signal(signal)
elif model.getId() == 1:
signal = model.get_signal()
self.plot_signal(signal, "blue")
else:
raise ("Error")
# Signal X
def get_magnitude(self, whichOne):
if whichOne == 0:
return self.magnitude_x
elif whichOne == 1:
return self.magnitude_y
else:
raise ("Error")
def get_frequency(self, whichOne):
if whichOne == 0:
return self.frequency_x
elif whichOne == 1:
return self.frequency_y
else:
raise ("Error")
def get_phase(self, whichOne):
if whichOne == 0:
return self.phase_x
elif whichOne == 1:
return self.phase_y
else:
raise ("Error")
def get_step_x(self):
return self.step_x
def get_step_y(self):
return self.step_y
def getX(self):
print("update_X(self,event)")
self.caseY.deselect()
self.caseXY.deselect()
self.showX = True
self.showY = False
self.update(self.model_x)
if self.canvas.find_withtag("signal_y"):
self.canvas.delete("signal_y")
def getY(self):
print("update_Y(self,event)")
self.caseX.deselect()
self.caseXY.deselect()
self.showX = False
self.showY = True
self.update(self.model_y)
if self.canvas.find_withtag("signal_x"):
self.canvas.delete("signal_x")
def getXY(self):
print("update_XY(self,event)")
self.caseX.deselect()
self.caseY.deselect()
self.showX = True
self.showY = True
self.update(self.model_x)
self.update(self.model_y)
def plot_signal(self, signal, color="red"):
w, h = self.wi, self.hi
width, height = int(w), int(h)
if color == "red" and self.showX == True:
if self.canvas.find_withtag("signal_x"):
self.canvas.delete("signal_x")
if signal and len(signal) > 1:
plot = [(x * width, height / 2.0 * (y + 1))
for (x, y) in signal]
signal_id = self.canvas.create_line(plot,
fill=color,
smooth=1,
width=3,
tags="signal_x")
elif color == "blue" and self.showY == True:
if self.canvas.find_withtag("signal_y"):
self.canvas.delete("signal_y")
if signal and len(signal) > 1:
plot = [(x * width, height / 2.0 * (y + 1))
for (x, y) in signal]
signal_id = self.canvas.create_line(plot,
fill=color,
smooth=1,
width=3,
tags="signal_y")
def grid(self, step_x, step_y):
w, h = self.wi, self.hi
width, height = int(w), int(h)
self.stepx = (width - 10) / step_x * 1.
self.stepy = (height - 10) / step_y * 1.
for t in range(1, step_x + 2):
x = t * self.stepx
self.canvas.create_line(x, 0, x, height, tags="grid")
#self.canvas.create_line(x,height/2-4,x,height/2+4)
for t in range(1, step_y + 2):
y = t * self.stepy
self.canvas.create_line(0, y, width, y, tags="grid")
#self.canvas.create_line(width/2-4,y,width/2+4,y)
def resize(self, event):
if event:
self.wi = event.width
self.hi = event.height
self.canvas.delete("grid")
self.plot_signal(self.model_x.get_signal())
self.plot_signal(self.model_y.get_signal(), "blue")
self.grid(25, 25)
def packing(self):
self.canvas.pack(fill="both", expand=1)
self.step_x.pack(expand=1, fill="both")
self.step_y.pack(expand=1, fill="both")
self.frame.pack(expand=1, fill="both")
self.magnitude_x.grid(row=0, column=0)
self.magnitude_y.grid(row=0, column=1)
self.frequency_x.grid(row=1, column=0)
self.frequency_y.grid(row=1, column=1)
self.phase_x.grid(row=2, column=0)
self.phase_y.grid(row=2, column=1)
self.frame2.pack(side="bottom", expand=1)
self.lbl.grid(row=0, column=0)
self.caseX.grid(row=0, column=1)
self.caseY.grid(row=0, column=2)
self.caseXY.grid(row=0, column=3)
class FullScreenWindow:
def __init__(self, label_timeout, max_elements):
self.count = 0
self.colors_count = 0
self.tk = Tk()
self.max_elements = max_elements
self.frame = Frame(self.tk)
self.frame.bind("<Key>", self.key_press)
self.frame.focus_set()
self.state = False
self.tk.attributes("-fullscreen", True)
self.label_timeout = label_timeout
self.screen_width = self.tk.winfo_screenwidth()
self.screen_height = self.tk.winfo_screenheight()
screen_resolution = str(self.screen_width) + 'x' + str(self.screen_height)
self.tk.geometry(screen_resolution)
self.canvas = Canvas(self.frame, height=self.screen_height, width=self.screen_width)
self.canvas.pack(fill=BOTH)
self.frame.pack()
self.objects = deque()
def key_press(self, key):
self.draw_triangle()
def draw_triangle(self):
x1 = random.uniform(0, 1) * self.screen_width
y1 = random.uniform(0, 1) * self.screen_height
x2 = random.uniform(0, 1) * self.screen_width
y2 = random.uniform(0, 1) * self.screen_height
x3 = random.uniform(0, 1) * self.screen_width
y3 = random.uniform(0, 1) * self.screen_height
x4 = random.uniform(0, 1) * self.screen_width
y4 = random.uniform(0, 1) * self.screen_height
x5 = random.uniform(0, 1) * self.screen_width
y5 = random.uniform(0, 1) * self.screen_height
colors = ['black', 'red', 'green', 'blue', 'cyan', 'yellow', 'magenta']
if self.colors_count % 7 == 0:
self.colors_count = 0
if self.count == 0:
o = self.canvas.create_line(x1, y1, x2, y2, x3, y3, x1, y1)
self.count = 1
elif self.count == 1:
o = self.canvas.create_rectangle(x1, y1, x2, y2, fill=colors[self.colors_count])
self.colors_count += 1
self.count = 2
elif self.count == 2:
o = self.canvas.create_oval(x1, y1, x2, y2, fill=colors[self.colors_count])
self.colors_count += 1
self.count = 3
elif self.count == 3:
o = self.canvas.create_polygon(x1, y1, x2, y2, x3, y3, x4, y4, x5, y5, fill=colors[self.colors_count])
self.colors_count += 1
self.count = 0
if len(self.objects) >= self.max_elements:
obj_to_remove = self.objects.pop()
self.canvas.delete(obj_to_remove)
self.objects.appendleft(o)
self.canvas.after(self.label_timeout,self.canvas.delete, o)
self.frame.pack(fill=BOTH, expand=1)
class DiscreteTAMPViewer(object):
def __init__(self,
rows,
cols,
width=500,
height=250,
side=25,
block_buffer=10,
title='Grid',
background='tan',
draw_fingers=False):
assert (rows <= MAX_ROWS)
assert (cols <= MAX_COLS)
tk = Tk()
tk.withdraw()
top = Toplevel(tk)
top.wm_title(title)
top.protocol('WM_DELETE_WINDOW', top.destroy)
self.width = width
self.height = height
self.rows = rows
self.cols = cols
self.canvas = Canvas(top,
width=self.width,
height=self.height,
background=background)
self.canvas.pack()
self.side = side
self.block_buffer = block_buffer
self.draw_fingers = draw_fingers
self.cells = {}
self.robot = []
self.draw_environment()
def transform_r(self, r):
return self.table_y1 + r * (self.side + 2 * self.block_buffer
) + 2 * self.block_buffer + self.side / 2
def transform_c(self, c):
# assert r >= 0 and r < self.width
return self.table_x1 + c * (self.side + 2 * self.block_buffer
) + 2 * self.block_buffer + self.side / 2
def draw_environment(self, table_color='lightgrey', bin_color='grey'):
table_width = self.cols * (
self.side + 2 * self.block_buffer) + 2 * self.block_buffer
table_height = self.rows * (
self.side + 2 * self.block_buffer) + 2 * self.block_buffer
border_buffer = 50
#self.table_x1 = border_buffer
self.table_y1 = self.height - table_height - border_buffer
self.table_x1 = self.width / 2 - table_width / 2
#self.table_y1 = self.height/2-table_height/2
bin_width = 20
self.environment = [
self.canvas.create_rectangle(self.table_x1,
self.table_y1,
self.table_x1 + table_width,
self.table_y1 + table_height,
fill=table_color,
outline='black',
width=2),
self.canvas.create_rectangle(self.table_x1 - bin_width,
self.table_y1,
self.table_x1,
self.table_y1 + table_height,
fill=bin_color,
outline='black',
width=2),
self.canvas.create_rectangle(self.table_x1 + table_width,
self.table_y1,
self.table_x1 + table_width +
bin_width,
self.table_y1 + table_height,
fill=bin_color,
outline='black',
width=2),
self.canvas.create_rectangle(self.table_x1,
self.table_y1 + table_height,
self.table_x1 + table_width,
self.table_y1 + table_height +
bin_width,
fill=bin_color,
outline='black',
width=2),
self.canvas.create_rectangle(
self.table_x1 - bin_width,
self.table_y1 + table_height,
self.table_x1 + table_width + bin_width,
self.table_y1 + table_height + bin_width,
fill=bin_color,
outline='black',
width=2),
]
pose_radius = 2
for r in range(self.rows):
for c in range(self.cols):
x = self.transform_c(c)
y = self.transform_r(r)
self.environment.append(
self.canvas.create_oval(x - pose_radius,
y - pose_radius,
x + pose_radius,
y + pose_radius,
fill='black'))
def draw_robot(self, r, c, color='yellow'):
# TODO - could also visualize as top grasps instead of side grasps
grasp_buffer = 3 # 0 | 3 | 5
finger_length = self.side + grasp_buffer # + self.block_buffer
finger_width = 10
gripper_length = 20
if self.draw_fingers:
gripper_width = self.side + 2 * self.block_buffer + finger_width
else:
gripper_width = self.side
stem_length = 50
stem_width = 20
x = self.transform_c(c)
y = self.transform_r(
r) - self.side / 2 - gripper_length / 2 - grasp_buffer
finger_x = gripper_width / 2 - finger_width / 2
self.robot = [
self.canvas.create_rectangle(x - stem_width / 2.,
y - stem_length,
x + stem_width / 2.,
y,
fill=color,
outline='black',
width=2),
self.canvas.create_rectangle(x - gripper_width / 2.,
y - gripper_length / 2.,
x + gripper_width / 2.,
y + gripper_length / 2.,
fill=color,
outline='black',
width=2),
]
if self.draw_fingers:
self.robot += [
self.canvas.create_rectangle(x + finger_x - finger_width / 2.,
y,
x + finger_x + finger_width / 2.,
y + finger_length,
fill=color,
outline='black',
width=2),
self.canvas.create_rectangle(x - finger_x - finger_width / 2.,
y,
x - finger_x + finger_width / 2.,
y + finger_length,
fill=color,
outline='black',
width=2),
]
self.canvas.update()
def draw_block(self, r, c, name='', color='red'):
x = self.transform_c(c)
y = self.transform_r(r)
self.cells[(x, y)] = [
self.canvas.create_rectangle(x - self.side / 2.,
y - self.side / 2.,
x + self.side / 2.,
y + self.side / 2.,
fill=color,
outline='black',
width=2),
self.canvas.create_text(x, y, text=name),
]
# def delete(self, (x, y)):
# if (x, y) in self.cells:
# self.canvas.delete(self.cells[(x, y)])
def clear(self):
self.canvas.delete('all')
def save(self, filename):
self.canvas.postscript(file='%s.ps' % filename, colormode='color')
from PIL import ImageGrab
ImageGrab.grab((0, 0, self.width, self.height)).save(filename + '.jpg')
class SurfaceManipulator(Frame):
r"""
A translation surface editor in tk.
"""
# STATIC METHODS AND OBJECTS
current = None
# boolean variable to remember if the hook was run!
_clear_hook_was_run = 0
@staticmethod
def launch(geometry="800x700+10+10"):
r"""Prefered way to gain access to a SurfaceManipulator window."""
if SurfaceManipulator.current is None:
SurfaceManipulator._clear_hook()
root = Tk()
root.geometry(geometry)
SurfaceManipulator.current = SurfaceManipulator(root)
return SurfaceManipulator.current
@staticmethod
def _window_destroyed(surface_manipulator):
if SurfaceManipulator.current is surface_manipulator:
SurfaceManipulator.current = None
@staticmethod
def _clear_hook():
if not SurfaceManipulator._clear_hook_was_run:
# Hack due to Nathan Dunfield (http://trac.sagemath.org/ticket/15152)
import IPython.lib.inputhook as ih
ih.clear_inputhook()
SurfaceManipulator._clear_hook_was_run = 1
# NORMAL METHODS
def __init__(self, parent, surface=None, surfaces=[]):
r"""
INPUT:
- ``surfaces`` -- a list of surfaces that the editor may modify
- ``surface`` -- surface selected by default
- ``parent`` -- parent Tk window
"""
Frame.__init__(self, parent)
self._parent = parent
self.pack(fill="both", expand=1)
# Run something when closing
self._parent.wm_protocol("WM_DELETE_WINDOW", self.exit)
# Surface currently being manipulated
self._surface = None
# List of surfaces in editor
self._surfaces = []
# More variables to initialize
self._currentActor = None
# Initialization of GUI
self._init_menu()
self._init_gui()
# Setup surface list
for s in surfaces:
self.add_surface(s)
# Setup initial surface
if surface is not None:
self.add_surface(surface)
self.set_surface(surface)
def __repr__(self):
return "Surface manipulator"
def add_mega_wollmilchsau(self):
from geometry.mega_wollmilchsau import MegaWollmilchsau
s = MegaWollmilchsau()
sm, sb = s.get_bundle()
self.set_surface(sb)
def add_octagon(self):
from geometry.similarity_surface_generators import TranslationSurfaceGenerators
ss = TranslationSurfaceGenerators.regular_octagon()
ss.edit()
def _init_menu(self):
self._menubar = Menu(self._parent)
menubar = self._menubar
self._parent.config(menu=menubar)
#new_menu = Menu(menubar, tearoff=0)
#new_menu.add_command(label="Billiard Table", command=self.on_new_similarity_surface)
file_menu = Menu(menubar, tearoff=0)
#file_menu.add_cascade(label="New", menu=new_menu)
file_menu.add_command(label="Octagon", command=self.add_octagon)
file_menu.add_command(label="MegaWollmilchsau",
command=self.add_mega_wollmilchsau)
file_menu.add_separator()
file_menu.add_command(label="About", command=self.on_about)
file_menu.add_command(label="Export PostScript",
command=self.on_export)
file_menu.add_command(label="Exit",
command=self.exit,
accelerator="Alt+F4")
menubar.add_cascade(label="File", underline=0, menu=file_menu)
self._surface_menu = Menu(menubar, tearoff=0)
self._selected_surface = IntVar()
self._selected_surface.set(-1)
menubar.add_cascade(label="Surface",
underline=0,
menu=self._surface_menu)
self._surface_menu.add_radiobutton(label="None",
command=self.menu_select_surface,
variable=self._selected_surface,
value=-1)
def _init_gui(self):
self._parent.title("FlatSurf Editor")
self._canvas = Canvas(self, bg="#444", width=300, height=200)
self._canvas.pack(fill="both", expand=1)
self.bottom_text = Label(self, text="Welcome to FlatSurf.", anchor="w")
self.bottom_text.pack(fill="x", expand=0)
self.set_actor(None)
def add_surface(self, newsurface):
r"""
Add a surface to the display list for the window.
Returns the index of the new surface in the surface list.
"""
if (newsurface == None):
return -1
i = 0
for s in self._surfaces:
if (s == newsurface):
return i
i = i + 1
self._surfaces.append(newsurface)
newsurface.zoom_fit_nice_boundary()
self._reset_surface_menu()
return len(self._surfaces) - 1
def exit(self):
SurfaceManipulator._window_destroyed(self)
self._parent.destroy()
def find_bundle(self, surface):
for surface_bundle in self._surfaces:
if surface is surface_bundle.get_surface():
return surface_bundle
return None
def get_bundle(self):
return self._surface
def get_bundles(self):
return self._surfaces
def get_canvas(self):
return self._canvas
def get_center(self):
r"""
Return the center of the canvas as a pair of integers.
"""
return (self.get_width() / 2, self.get_height() / 2)
def get_height(self):
r"""
Return the height of the canvas (an integer).
"""
return self.get_canvas().winfo_height()
def get_parent(self):
return self._parent
def get_surface_bundle(self):
r"""
Get the current surface bundle, or None if there is none.
"""
return self._surface
def get_width(self):
r"""
Return the width of the canvas (an integer).
"""
return self.get_canvas().winfo_width()
def menu_select_surface(self):
r"""
Called when a surface is selected from a menu.
"""
i = self._selected_surface.get()
if i == -1:
self.set_surface(None)
else:
self.set_surface(self._surfaces[i])
def on_about(self):
self.set_text("Written by Vincent Delecroix and Pat Hooper.")
def on_delete_junk(self):
self._canvas.delete("junk")
def on_export(self):
r"""
Export image as postscript file.
"""
myFormats = [('PostScript', '*.ps')]
fileName = tkFileDialog.asksaveasfilename(parent=self,
filetypes=myFormats,
title="Save image as...")
if len(fileName) > 0:
self._canvas.update()
self._canvas.postscript(file=fileName)
self.set_text("Wrote image to " + fileName)
# def on_new_similarity_surface(self):
# s = CreateSimilaritySurfaceBundle(len(self._surfaces),self)
# if s is not None:
# i = self.set_surface(s)
# self.set_text("Created new surface `"+self._surfaces[i].get_name()+"'.")
def _on_no_surface(self):
self._canvas.delete("all")
def _on_zoom(self):
self.set_actor(ZoomActor(self))
def _on_zoom_box(self):
self.set_actor(ZoomBoxActor(self))
def _on_redraw_all(self):
if self._surface is not None:
self._surface.redraw_all()
def _on_recenter(self):
self.set_actor(RecenterActor(self))
def _reset_menus(self):
r"""
Reset all menus except the file and surface menu
"""
# The following loop removes all but the first two menus (File and Surface).
num = len(self._menubar.children)
for i in range(num, 2, -1):
self._menubar.delete(i)
if self._surface != None:
self._surface.make_menus(self._menubar)
def _reset_surface_menu(self):
r"""
Reset the surface menu.
"""
### This is a hack to get the number of items in the menu:
num = self._surface_menu.index(100) + 1
# First we remove everything but the first entry ("None")
for i in range(num - 1, 0, -1):
#print("removing a child2: "+str(i)+" of "+str(num))
self._surface_menu.delete(i)
# Add an entry for every surface in the list.
for i in range(len(self._surfaces)):
surface = self._surfaces[i]
self._surface_menu.add_radiobutton(
label=surface.get_name(),
command=self.menu_select_surface,
variable=self._selected_surface,
value=i)
def set_text(self, text):
self.bottom_text["text"] = text
def set_actor(self, actor):
r"""
Set the current mode of user interaction.
"""
if (actor != self._currentActor):
if self._currentActor != None:
self._currentActor.on_deactivate()
if (actor == None):
self.set_text("Nothing going on.")
# Event bindings
self._canvas.unbind('<Button-1>')
self._canvas.unbind('<Button-2>')
self._canvas.unbind('<Button-3>')
self._canvas.unbind('<Double-Button-1>')
self._canvas.unbind('<Shift-Button-1>')
self._canvas.unbind('<Motion>')
self.unbind('<FocusIn>')
self.unbind('<FocusOut>')
#self._canvas.unbind('<ButtonPress-1>')
self._canvas.unbind('<ButtonRelease-1>')
self._canvas.unbind('<B1-Motion>')
self._parent.unbind('<Key>')
self._parent.unbind('<KeyRelease>')
else:
# Event bindings
self._canvas.bind('<Button-1>', actor.single_left_click)
self._canvas.bind('<Double-Button-1>', actor.double_left_click)
self._canvas.bind('<Triple-Button-1>', actor.double_left_click)
self._canvas.bind('<Button-2>', actor.single_middle_click)
self._canvas.bind('<Double-Button-2>',
actor.double_middle_click)
self._canvas.bind('<Triple-Button-2>',
actor.double_middle_click)
self._canvas.bind('<Button-3>', actor.single_right_click)
self._canvas.bind('<Double-Button-3>',
actor.double_right_click)
self._canvas.bind('<Triple-Button-3>',
actor.double_right_click)
self._canvas.bind('<Shift-Button-1>', actor.shift_click)
self._canvas.bind('<Motion>', actor.mouse_moved)
#self._canvas.bind('<ButtonPress-1>', actor.left_mouse_pressed)
self._canvas.bind('<ButtonRelease-1>',
actor.left_mouse_released)
self._canvas.bind('<B1-Motion>', actor.left_dragged)
self.bind('<FocusIn>', actor.focus_in)
self.bind('<FocusOut>', actor.focus_out)
self._parent.bind('<Key>', actor.key_press)
self._parent.bind('<KeyRelease>', actor.key_release)
self._currentActor = actor
self._currentActor.on_activate()
def set_surface(self, surface_bundle):
r"""
Set the current surface to the one given by surface_bundle
"""
i = self.add_surface(surface_bundle)
if surface_bundle != self._surface:
self._canvas.delete("all")
self._surface = surface_bundle
self._surface_menu.invoke(i + 1)
if i >= 0:
self.set_text("Switched to `" + self._surface.get_name() +
"'.")
self._parent.title(self._surface.get_name())
self._reset_menus()
# stop the actor (was a bug).
self.set_actor(None)
if isinstance(self._surface, EditorRenderer):
self._surface.initial_render()
else:
self.set_text("No surface selected.")
self._parent.title("FlatSurf Editor")
self._reset_menus()
self.set_actor(None)
return i
def surface_renamed(self):
if self._surface is not None:
self._parent.title(self._surface.get_name())
self._reset_surface_menu()
class TutorWindow( Toplevel ):
"""
Window for displaying a basic help
"""
labels = {} # Dictionary for keeping clickable labels
size_x = 600 # horizontal size of canvas
size_y = 800 # vertical size of canvas
last_images = [] # handle on images currently on the canvas
images = [] # new images to go on the canvas
curr_key = None # Current key that is looked at
# Names of label links and list of pictures to load. These pictures are generated from a pdf by save as, type .png
help_dict = { "Get Pictures" : [ "Get_Pictures_Page_1.png" , "Get_Pictures_Page_2.png" , "Get_Pictures_Page_3.png" ],
"Save Pictures" : [ "Save_Pictures_Page_1.png", "Save_Pictures_Page_2.png", "Save_Pictures_Page_3.png" ],
"Pictures Effects": [ "Pic_Effects_Page_1.png" , "Pic_Effects_Page_2.png" ],
"Options" : [ "Options.png" ],
}
def __init__( self ):
"""
Initialize window settings
"""
Toplevel.__init__( self )
self.title( "Tutorial" )
self.iconbitmap( ICON_FILENAME )
self.geometry( "+100+50" )
# init frames for window. This window contains complicated frames. i.e. frames with frames inside them.
fr11 = Frame( self )
fr1 = Frame( fr11 )
fr2 = Frame( fr11 )
fr3 = Frame( self )
# create labels links for displaying different help information
for name in self.help_dict:
self.labels[ name ] = Label( fr1, text=name, fg="blue" )
self.labels[ name ].bind( "<ButtonPress-1>", lambda e, arg=name: self.HandleLB( e, arg ) )
self.labels[ name ].pack( fill=X )
fr1.pack( side=LEFT )
# create/configure canvas and scrollbar for displaying help pictures
self.canv = Canvas( fr2, width=self.size_x, height=self.size_y, scrollregion=( 0, 0, 300, 0 ) )
self.sbar = Scrollbar( fr2 )
self.sbar.config( command=self.canv.yview )
self.canv.config( yscrollcommand=self.sbar.set )
self.canv.focus_set()
self.sbar.pack( side=RIGHT, fill=Y )
self.canv.pack( side=LEFT, fill=Y )
fr2.pack( side=LEFT )
fr11.pack()
# create ok button for closing the window
btn = Button( fr3, text="Ok", width=10, command=self.quit )
btn.pack( side=LEFT )
fr3.pack()
self.mainloop()
self.destroy()
def HandleLB( self, event, key ):
"""
handle clicking a label link
"""
if( key != self.curr_key ):
# reset the position of the scrollbar to the top
self.canv.yview_moveto( 0.0 )
# load new images
print "Key: ", key
self.LoadImages( key )
# change formatting on labels, color red for current one clicked
self.FormatLabels( key )
# remove old pictures from the canvas before adding new ones
if( len( self.last_images ) != 0 ):
for image in self.last_images:
self.canv.delete( image )
self.last_images = []
# There's an offset required in order to show everything correctly, don't know why...
image_y = 390
# change scrollable area for the canvas to be exact size of all pictures
self.canv.config( scrollregion=( 0, 0, 300, 776*len( self.images ) ) )
# add new pictures to canvas stacking them on top of each other and making them seamless
for i in range( len( self.images ) ):
self.last_images.append( self.canv.create_image( ( self.size_x/2, image_y ), image=self.images[ i ] ) )
image_y += self.images[ i ].height()
self.curr_key = key
def LoadImages( self, key ):
"""
load new inmages into class storage
"""
self.images = []
print "help_dict: ", self.help_dict
# get images from hardcoded array
for image in self.help_dict[ key ]:
# open PIL image
print "image: ", path.join( HELP_DIR, image )
image1 = PILopen( path.join( HELP_DIR, image ) )
# resize to fit canvas area
image1 = image1.resize( ( self.size_x , self.size_y ), ANTIALIAS )
# make into a tkimage
im = PhotoImage( image1 )
# add to list of images to display
self.images.append( im )
def FormatLabels( self, key ):
for name in self.labels:
self.labels[ name ].config( fg="blue" )
self.labels[ key ].config( fg="red" )
class liuyao:
def __init__(self,root,gua64):
self.cntoint={u'少阳-----':'1',u'少阴-- --':'2',u'老阳--O--':'3',u'老阴--X--':'4'}
self.tfont=tkFont.Font(family='Fixdsys',size=25,weight=tkFont.BOLD)
self.gfont=tkFont.Font(family='Fixdsys',size=13,weight=tkFont.BOLD)
self.dgua=[] #动爻
self.ygua=[] #原始卦
self.bbgua=[] #变卦
self.yguastr=[] #原始卦
self.gua=[] #只有12的卦
self.pabout=True #右键显示消失淮南标题
self.guax=200
self.guay=100
self.liushen={'甲':0,'乙':0,'丙':1,'丁':1,'戊':2,'己':3,'庚':4,'辛':4,'壬':5,'癸':5}
self.liushencn=['青龙','朱雀','勾陈','腾蛇','白虎','玄武']
self.tiangan={'甲':1,'乙':2,'丙':3,'丁':4,'戊':5,'己':6,'庚':7,'辛':8,'壬':9,'癸':10}
self.dizhi={'子':1,'丑':2,'寅':3,'卯':4,'辰':5,'巳':6,'午':7,'未':8,'申':9,'酉':10,'戌':11,'亥':12}
self.kongwangzu=['子','丑','寅','卯','辰','巳','午','未','申','酉','戌','亥']
self.root=root
self.root.title(u'===六爻排盘===[淮南内部专用]')
self.root.minsize(550,380)
self.root.maxsize(550,380)
self.canvas=Canvas(root,width=460,height=380,bg='gray')
# self.picyang=PhotoImage(file='tk\\yang.gif')
# self.picyin=PhotoImage(file='tk\\yin.gif')
self.canvas.place(relx=0,rely=0)
self.com={}
for i in xrange(6):
self.com[i]=Combobox(root,state='readonly')
self.com[i]['values']=(u'少阳-----',u'少阴-- --',u'老阳--O--',u'老阴--X--')
self.com[i].current(0)
self.com[i].place(relx=0.85,rely=0.36-0.07*i,width=80)
bt1=Button(self.root,text=u'排盘',command=self.paipan)
bt2=Button(self.root,text=u'清除',command=self.cls)
l1=Label(self.root,text=u'右键水印')
l1.place(x=480,y=327)
# bt1.place(relx=0.85,rely=0.35+0.7)
# bt1.pack(side='right')
bt1.place(x=467,y=170,width=78)
bt2.place(x=467,y=350,width=78)
self.date() #干支
#===========================
self.root.bind('<Button-3>',self.about)
def cls(self):
self.canvas.delete('pic') #删除所有上次产生的ITEMS
self.canvas.delete('liushen')
def liushenf(self): #配六神
xu=self.liushen[self.ritian.encode('utf-8')]
for i in xrange(6):
self.canvas.create_text(self.guax-170,100+150-30*i,font=self.gfont,text=self.liushencn[xu],tag='liushen')
xu+=1
if xu>5:
xu-=6
def date(self):
turl=urllib2.urlopen('http://www.nongli.com/item4/index.asp',timeout=10).read()
soup=BeautifulSoup(turl)
zu=soup.findAll('td',{'width':'74%','bgcolor':'#FFFFFF'})[1].text
# print zu
wanzu=[] #wanzu里面是完成的年月日干支
wanzu.append(zu.split(' ')[0])
wanzu.append(zu.split(' ')[2])
wanzu.append(zu.split(' ')[3])
for i in xrange(3):
# print u'干支',wanzu[i]
self.canvas.create_text(self.guax-90+60*i,30,text=wanzu[i],font=self.gfont,tag='riqi')
ri=wanzu[2]
self.ritian=list(ri)[0]
self.ridi=list(ri)[1]
self.kongwang()
def kongwang(self):
# print u'日干支：',self.ridi,self.ritian
cha=self.dizhi[self.ridi.encode('utf-8')]-self.tiangan[self.ritian.encode('utf-8')]
if cha<0:
cha+=+10
self.canvas.create_text(self.guax-90+120+30,30,font=self.gfont,text='(',tag='riqi')
self.canvas.create_text(self.guax-90+120+30+15,30,font=self.gfont,text=self.kongwangzu[cha-2],tag='riqi')
self.canvas.create_text(self.guax-90+120+30+30,30,font=self.gfont,text=self.kongwangzu[cha-1],tag='riqi')
self.canvas.create_text(self.guax-90+120+30+45,30,font=self.gfont,text=')',tag='riqi')
def about(self,event):
if self.pabout:
self.canvas.create_text(self.guax,100+250,text='淮南法教专用水印',fill='tan',font=self.tfont,tag='about')
self.canvas.create_text(self.guax+140,370,text='--无名',fill='tan',tag='about')
self.pabout=False
else:
self.canvas.delete('about')
self.pabout=True
def paipan(self):
for i in xrange(6):
self.ygua.append(self.cntoint[self.com[i].get()]) #得到原始爻名，转换为1234，添加入gua
self.gua=self.ygua
bbgua=self.gua
print '======================='
print 'sel.gua',self.gua
for i in xrange(6):
if self.ygua[i]=='3':
self.gua[i]='1'
self.dgua.append(str(i))
self.dgua.append('1')
elif self.ygua[i]=='4':
self.gua[i]='2'
self.dgua.append(str(i))
self.dgua.append('2')
self.guastr=''.join(self.gua)
# print u'变卦',bbgua
# print u'字符串卦数',self.guastr
# print u'数列卦',self.gua
# print u'动卦',self.dgua
# print gua64[guastr]
self.draw()
self.liushenf()#六神
def draw(self):
self.canvas.delete('pic') #删除所有上次产生的ITEMS
self.canvas.delete('liushen')
# print u'当前itme数',self.canvas.find_all()
#本卦
for i in xrange(6):
if self.gua[i]=='1':
# self.canvas.create_image(self.guax,100+150-30*i,image=self.picyang,tag='pic')
self.canvas.create_text(self.guax,95+150-30*i,text='▅▅▅',font=('Fixdsys',17,tkFont.BOLD),tag='pic')
else:
# self.canvas.create_image(self.guax,100+150-30*i,image=self.picyin,tag='pic')
self.canvas.create_text(self.guax,95+150-30*i,text='▅ ▅',font=('Fixdsys',17,tkFont.BOLD),tag='pic')
#下面是六亲
for i in xrange(6):
self.canvas.create_text(self.guax-70,100+30*i,font=self.gfont,text=gua64[self.guastr][i],tag='pic')
#动爻标记
for i in xrange(0,len(self.dgua),2):
if self.dgua[i+1]=='1':
self.canvas.create_text(self.guax+70,247-30*int(self.dgua[i]),font=self.gfont,text='O',tag='pic',fill='red')
else:
self.canvas.create_text(self.guax+70,247-30*int(self.dgua[i]),font=self.gfont,text='X',tag='pic',fill='red')
#世
syw=gua64[self.guastr][6]
self.canvas.create_text(self.guax+55,280-30*syw,font=self.gfont,text='世',tag='pic')
#应
yyw=gua64[self.guastr][7]
self.canvas.create_text(self.guax+55,280-30*yyw,font=self.gfont,text='应',tag='pic')
#六合、冲
hc=gua64[self.guastr][8]
self.canvas.create_text(self.guax-70,100-30,font=self.gfont,text=hc,tag='pic')
#游魂、归魂
zg=gua64[self.guastr][9]
self.canvas.create_text(self.guax-70,100-30,font=self.gfont,text=zg,tag='pic')
#卦宫
gg=gua64[self.guastr][10]
self.canvas.create_text(self.guax,100-30,font=self.gfont,text=gg,tag='pic')
#变卦
self.biangua()
self.guastr=''
self.dgua=[] #动爻
self.ygua=[] #原始卦
self.bbgua=[] #变卦
self.yguastr=[] #原始卦
self.gua=[] #只有12的卦
def biangua(self):
self.bbgua=self.gua
# print 'biangua',self.bbgua
'''
sel.gua ['4', '4', '3', '3', '4', '3']
字符串卦数 221121
数列卦 ['2', '2', '1', '1', '2', '1']
动卦 ['0', '2', '1', '2', '2', '1', '3', '1', '4', '2', '5', '1']
当前itme数 (1, 2, 3, 4, 5, 6, 7)
biangua ['1', '1', '2', '2', '1', '2']
bguastr 112212
'''
for i in xrange(0,len(self.dgua),2):
if self.dgua[i+1]=='1':
self.bbgua[int(self.dgua[i])]='2'
else:
self.bbgua[int(self.dgua[i])]='1'
print 'biangua',self.bbgua
self.bguastr=''.join(self.bbgua)
print 'bguastr',self.bguastr
for i in xrange(6):
if self.bbgua[i]=='1':
# self.canvas.create_image(self.guax+130,100+150-30*i,image=self.picyang,tag='pic')
self.canvas.create_text(self.guax+130,95+150-30*i,text=u'▅▅▅',font=('Fixdsys',17,tkFont.BOLD),tag='pic')
else:
# self.canvas.create_image(self.guax+130,100+150-30*i,image=self.picyin,tag='pic')
self.canvas.create_text(self.guax+130,95+150-30*i,text=u'▅ ▅',font=('Fixdsys',17,tkFont.BOLD),tag='pic')
#下面是六亲
for i in xrange(6):
self.canvas.create_text(self.guax+200,100+30*i,font=self.gfont,text=gua64[self.bguastr][i],tag='pic')
class App(object):
def __init__(self, tk_root, monsters_initdata, board_dim, board_signs):
self.board = [[None for i in range(board_dim[0])]
for j in range(board_dim[0])]
self.jump_counter = 0
self.meet_counter = 0
self.data = monsters_initdata
self.signs = board_signs
self.collect = {
'red': [],
'blue': [],
'green': [],
'yellow': [],
'pink': [],
'brown': []
}
self.init_gui(tk_root)
self.monsters = self.init_monsters()
self.draw_board()
def init_gui(self, tk_root):
# GUI
frame = Frame(tk_root)
canvas_width = 600
canvas_height = 600
self.canvas = Canvas(frame, width=canvas_width, height=canvas_height)
self.canvas.pack()
frame.pack()
self.quit_button = Button(frame,
text="QUIT",
fg="red",
command=frame.quit)
self.quit_button.pack(side=LEFT)
self.jump_button = Button(frame, text="JUMP", command=self.jump)
self.jump_button.pack(side=LEFT)
self.text_counter = StringVar()
self.text_counter.set('Round: {}'.format(self.jump_counter))
self.label_counter = Label(frame,
textvariable=self.text_counter,
justify=LEFT)
self.label_counter.pack()
self.text_meet_counter = StringVar(self.meet_counter)
self.label_meet_counter = Label(frame,
textvariable=self.text_meet_counter,
justify=LEFT)
self.label_meet_counter.pack()
def init_monsters(self):
monsters = []
for color, values in self.data.iteritems():
for start_position in values['start']:
monsters.append(
Monster(self.board, color, start_position,
values['pattern']))
return monsters
def draw_board(self):
self.canvas.delete('all')
canvas_width = 600
canvas_height = 600
self.board
space = canvas_width / (len(self.board) + 2)
font = tkFont.Font(family='Helvetica', size=12, weight='bold')
for i in range(1, len(self.board) + 2):
self.canvas.create_line(space,
space * i,
canvas_width - space,
space * i,
fill='#476042')
self.canvas.create_line(space * i,
space,
space * i,
canvas_width - space,
fill='#476042')
for i in range(len(self.board)):
self.canvas.create_text(space * (i + 1) + 12,
18,
text=i,
font=font)
self.canvas.create_text(18,
space * (i + 1) + 12,
text=i,
font=font)
font = tkFont.Font(family='Helvetica', size=20, weight='bold')
for x, y, sign in self.signs:
self.canvas.create_text(space * x + 39,
space * y + 39,
text=sign,
font=font,
fill='lightgrey')
color_r = {
'red': (1, 1),
'green': (1, 2),
'blue': (1, 3),
'yellow': (2, 1),
'pink': (2, 2),
'brown': (2, 3)
}
for monster in self.monsters:
x1, y1 = monster.position
# r = color_r.get(monster.color) * 2
r = 2
shift_x, shift_y = color_r.get(monster.color)
# self.canvas.create_oval((1.5 + x1) * space - r, (1.5 + y1) * space - r,
# (1.5 + x1) * space + r, (1.5 + y1) * space + r,
# outline=monster.color, width=2)
self.canvas.create_oval((1.5 + x1) * space - 14 - r + shift_y * 7,
(1.5 + y1) * space - 14 - r + shift_x * 10,
(1.5 + x1) * space - 14 + r + shift_y * 7,
(1.5 + y1) * space - 14 + r + shift_x * 10,
outline=monster.color,
width=2)
def jump(self):
print
print('ROUND {0}'.format(self.jump_counter + 1))
print
track_positions = {}
for m in self.monsters:
if m.rest:
x, y = m.stay()
else:
x, y = m.jump()
# check for signs on the board
item = self.check_fields(m, self.signs)
if item:
self.collect[m.color].append(item)
# track position of all monsters in this round
if (x, y) in track_positions:
# already one monster on this location
track_positions[(x, y)].append(m)
else:
track_positions[(x, y)] = [m]
self.meet(track_positions)
print(self.collect)
print
self.draw_board()
self.jump_counter += 1
print('Meet counter: {}'.format(self.meet_counter))
self.text_counter.set(str(self.jump_counter))
def check_fields(self, monster, fields):
x, y = monster.position
for x_f, y_f, value in fields:
if x == x_f and y == y_f:
monster.collection += value
print '{} > {} -- {}'.format(monster.color, monster.collection,
monster.positions)
return value
return ''
def meet(self, track_positions):
pass
class GridUI(Frame):
def __init__(self, parent, height, width, cellSize, grid, robots,
frontier):
Frame.__init__(self, parent)
self.parent = parent
self.initialize(height, width, cellSize, grid, robots, frontier)
# Method to draw a grid of specified height and width
def initialize(self, height, width, cellSize, grid, robots, frontier):
self.parent.title('Grid')
self.pack(fill=BOTH, expand=1)
self.canvas = Canvas(self)
startX = cellSize
startY = cellSize
endX = startX + (cellSize * width)
endY = startY + (cellSize * height)
curX = startX
curY = startY
rectIdx = 0
xIdx = 0
yIdx = 0
while curX != endX and curY != endY:
# print 'x, y:', xIdx, yIdx
# First, check if the current location corresponds to that of any robot
robotFlag = False
for robot in robots:
if robot.curX == xIdx and robot.curY == yIdx:
robotFlag = True
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='#00FF00',
width=2)
# Then check if it corresponds to an obstacle
if grid.cells[xIdx][yIdx].obstacle == True:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='#000000',
width=2)
elif robotFlag == False:
# Then check if it corresponds to a frontier cell
frontierFlag = False
for pt in frontier:
if pt[0] == xIdx and pt[1] == yIdx:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='#00FFFF',
width=2)
frontierFlag = True
if frontierFlag == False:
if grid.cells[xIdx][yIdx].visited == True:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='#FFFFFF',
width=2)
else:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='#777777',
width=2)
curX = curX + cellSize
if curX == endX and curY != endY:
curX = startX
xIdx += 1
curY = curY + cellSize
yIdx = 0
# Move to the next iteration of the loop
continue
elif curX == endX and curY == endY:
break
rectIdx += 1
yIdx += 1
self.canvas.pack(fill=BOTH, expand=1)
# Method to redraw the positions of the robots and the frontier
def redraw(self, height, width, cellSize, grid, robots, frontier):
self.parent.title('Grid2')
self.pack(fill=BOTH, expand=1)
# canvas = Canvas(self.parent)
self.canvas.delete('all')
startX = cellSize
startY = cellSize
endX = startX + (cellSize * width)
endY = startY + (cellSize * height)
curX = startX
curY = startY
rectIdx = 0
xIdx = 0
yIdx = 0
while curX != endX and curY != endY:
# print 'x, y:', xIdx, yIdx
# First, check if the current location corresponds to that of any robot
robotFlag = False
if grid.cells[xIdx][yIdx].centroid == True:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='indian red',
width=2)
else:
for robot in robots:
if robot.curX == xIdx and robot.curY == yIdx:
robotFlag = True
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='#00FF00',
width=2)
# Then check if it corresponds to an obstacle
if grid.cells[xIdx][yIdx].obstacle == True:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='#000000',
width=2)
elif robotFlag == False:
# Then check if it corresponds to a frontier cell
frontierFlag = False
for pt in frontier:
if pt[0] == xIdx and pt[1] == yIdx:
if grid.cells[xIdx][yIdx].cluster == -1:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='#00FFFF',
width=2)
if grid.cells[xIdx][yIdx].cluster == 0:
self.canvas.create_rectangle(
curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='midnight blue',
width=2)
if grid.cells[xIdx][yIdx].cluster == 1:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='peach puff',
width=2)
if grid.cells[xIdx][yIdx].cluster == 2:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='gold',
width=2)
if grid.cells[xIdx][yIdx].cluster == 3:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='slate blue',
width=2)
if grid.cells[xIdx][yIdx].cluster == 4:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='royal blue',
width=2)
if grid.cells[xIdx][yIdx].cluster == 5:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='red',
width=2)
if grid.cells[xIdx][yIdx].cluster == 6:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='dark green',
width=2)
if grid.cells[xIdx][yIdx].cluster == 7:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='dim gray',
width=2)
if grid.cells[xIdx][yIdx].cluster == 8:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='orange',
width=2)
if grid.cells[xIdx][yIdx].cluster == 9:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='hot pink',
width=2)
frontierFlag = True
if frontierFlag == False:
if grid.cells[xIdx][yIdx].visited == True:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='#FFFFFF',
width=2)
#else:
#if grid.cells[xIdx][yIdx].cluster != -1:
# if grid.cells[xIdx][yIdx].cluster == 0:
# self.canvas.create_rectangle(curX, curY, curX + cellSize, curY + cellSize, outline = '#0000FF', fill = 'midnight blue', width = 2)
# if grid.cells[xIdx][yIdx].cluster == 1:
# self.canvas.create_rectangle(curX, curY, curX + cellSize, curY + cellSize, outline = '#0000FF', fill = 'peach puff', width = 2)
# if grid.cells[xIdx][yIdx].cluster == 2:
# self.canvas.create_rectangle(curX, curY, curX + cellSize, curY + cellSize, outline = '#0000FF', fill = 'dim gray', width = 2)
# if grid.cells[xIdx][yIdx].cluster == 3:
# self.canvas.create_rectangle(curX, curY, curX + cellSize, curY + cellSize, outline = '#0000FF', fill = 'slate blue', width = 2)
# if grid.cells[xIdx][yIdx].cluster == 4:
# self.canvas.create_rectangle(curX, curY, curX + cellSize, curY + cellSize, outline = '#0000FF', fill = 'royal blue', width = 2)
# if grid.cells[xIdx][yIdx].cluster == 5:
# self.canvas.create_rectangle(curX, curY, curX + cellSize, curY + cellSize, outline = '#0000FF', fill = 'red', width = 2)
# if grid.cells[xIdx][yIdx].cluster == 6:
# self.canvas.create_rectangle(curX, curY, curX + cellSize, curY + cellSize, outline = '#0000FF', fill = 'dark green', width = 2)
# if grid.cells[xIdx][yIdx].cluster == 7:
# self.canvas.create_rectangle(curX, curY, curX + cellSize, curY + cellSize, outline = '#0000FF', fill = 'gold', width = 2)
# if grid.cells[xIdx][yIdx].cluster == 8:
# self.canvas.create_rectangle(curX, curY, curX + cellSize, curY + cellSize, outline = '#0000FF', fill = 'orange', width = 2)
# if grid.cells[xIdx][yIdx].cluster == 9:
# self.canvas.create_rectangle(curX, curY, curX + cellSize, curY + cellSize, outline = '#0000FF', fill = 'hot pink', width = 2)
else:
self.canvas.create_rectangle(curX,
curY,
curX + cellSize,
curY + cellSize,
outline='#0000FF',
fill='#777777',
width=2)
curX = curX + cellSize
if curX == endX and curY != endY:
curX = startX
xIdx += 1
curY = curY + cellSize
yIdx = 0
# Move to the next iteration of the loop
continue
elif curX == endX and curY == endY:
break
rectIdx += 1
yIdx += 1
self.canvas.pack(fill=BOTH, expand=1)
class PhraseEditor(HasTraits):
"""A graphical editor for musical phrases."""
phrase = Instance(Phrase)
"""The phrase which is edited."""
selected_point = Instance(Point)
"""The point that is currently moved around."""
use_grid = Bool
"""Whether added points shall be snapped to a grid."""
grid_resolution = Range(2,64, 16)
"""The resolution of the grid."""
point_handle_size = Int(4)
"""The size of the handles used to move points around."""
def __init__(self, toplevel, phrase, **kwargs):
"""
Initializes a PhraseEditor.
@param toplevel: the Tk Toplevel window
@param phrase: the phrase to be edited
"""
# The Tk Toplevel object to which the editor will be attached
self.toplevel = toplevel
control_frame = Frame(self.toplevel)
control_frame.pack(side=TOP)
title_frame = Frame(control_frame, padx=8)
title_frame.pack(side=LEFT)
Label(title_frame, text="Title").pack(side=LEFT)
self.title_entry_manager = EntryManager(
title_frame, self, 'phrase.name'
)
self.title_entry_manager.entry.pack(side=LEFT)
grid_frame = Frame(control_frame, padx=8)
grid_frame.pack(side=LEFT)
self.grid_checkbutton_manager = CheckbuttonManager(
grid_frame, self, 'use_grid', text="Grid"
)
self.grid_checkbutton_manager.checkbutton.pack(side=LEFT)
Label(grid_frame, text="Resolution").pack(side=LEFT)
self.grid_resolution_spinbox_manager = SpinboxManager(
grid_frame, self, 'grid_resolution',
)
self.grid_resolution_spinbox_manager.spinbox.pack(side=LEFT)
steps_frame = Frame(control_frame, padx=8)
steps_frame.pack(side=LEFT)
Label(steps_frame, text="Steps").pack(side=LEFT)
self.steps_spinbox_manager = SpinboxManager(
steps_frame, self, 'phrase.steps',
)
self.steps_spinbox_manager.spinbox.pack(side=LEFT)
transpose_frame = Frame(control_frame, padx=8)
transpose_frame.pack(side=LEFT)
Label(transpose_frame, text="Transpose").pack(side=LEFT)
self.transpose_spinbox_manager = SpinboxManager(
transpose_frame, self, 'phrase.transpose',
)
self.transpose_spinbox_manager.spinbox.pack(side=LEFT)
self.v_point_type = StringVar()
self.v_point_type.set('Note')
OptionMenu(
control_frame, self.v_point_type, 'Note', 'Rest',
).pack(side=LEFT)
self.canvas = Canvas(self.toplevel, width=600, height=400)
self.canvas.pack(side=BOTTOM)
# Maps a Point to the ID of its handle, which is a rectangle on the
# canvas.
self._point_handles = {}
# Maps a tuple of two Points to the ID of the line connecting them on
# the canvas.
self._point_lines = {}
# Maps a Point to the line to its next Point that is currently played.
self._playing_lines = {}
# A set of dotted lines marking the grid on the canvas.
self._grid_lines = set()
super(PhraseEditor, self).__init__(
phrase=phrase, use_grid=True, **kwargs
)
def find_point(x,y):
"""
@return: the point at the specified position on the canvas.
"""
s = self.point_handle_size
for point in self.phrase.points:
px,py = point.pos
if px-s <= x <= px+s and py-s <= y <= py+s:
return point
return None
def snap_to_grid(x,y):
"""
Rounds the given coordinates to the grid defined by
L{PhraseEditor.grid_resolution}.
"""
res = self.grid_resolution
return round(x/float(res))*res, round(y/float(res))*res
def button_pressed(event):
"""
When the left mouse button is pressed over a point, it becomes the
L{PhraseEditor.selected_point}, which can be moved around by
L{button_motion()}.
If there is no point under the mouse pointer, a new point is
appended to the L{Phrase}.
"""
x = self.canvas.canvasx(event.x)
y = self.canvas.canvasy(event.y)
point = find_point(x,y)
if point is None:
if self.use_grid:
x,y = snap_to_grid(x,y)
point = Point(
pos=(int(x),int(y)),
type=self.v_point_type.get(),
)
self.phrase.points.append(point)
self.selected_point = point
self.canvas.bind('<Button-1>', button_pressed)
def button_motion(event):
"""
If the mouse is moved while the left or miffle mouse button is held
down and a point is selected, this point is moved to the current
mouse pointer position.
"""
if self.selected_point is None:
return
x = self.canvas.canvasx(event.x)
y = self.canvas.canvasy(event.y)
if self.use_grid:
x,y = snap_to_grid(x,y)
canvas_config = self.canvas.config()
canvas_width = int(canvas_config['width'][-1])
canvas_height = int(canvas_config['height'][-1])
self.selected_point.pos = (
min(canvas_width, max(0, int(x))),
min(canvas_height, max(0, int(y)))
)
self.canvas.bind('<B1-Motion>', button_motion)
self.canvas.bind('<B2-Motion>', button_motion)
def button_released(event):
"""
When releasing the left or middle mouse button, the currently
selected point is deselected.
"""
self.selected_point = None
self.canvas.bind('<ButtonRelease-1>', button_released)
self.canvas.bind('<ButtonRelease-2>', button_released)
def right_button_pressed(event):
"""
Pressing the right mouse button over a point removes it from the
L{Phrase}.
"""
x = self.canvas.canvasx(event.x)
y = self.canvas.canvasy(event.y)
point = find_point(x,y)
if point is not None:
self.phrase.points.remove(point)
self.canvas.bind('<Button-3>', right_button_pressed)
def middle_button_pressed(event):
if self.selected_point is not None:
return
x = self.canvas.canvasx(event.x)
y = self.canvas.canvasy(event.y)
point = find_point(x,y)
if point is None:
return
new_point = Point(pos=point.pos, type=self.v_point_type.get())
self.phrase.points.insert(
self.phrase.points.index(point)+1,
new_point
)
self.selected_point = new_point
self.canvas.bind('<Button-2>', middle_button_pressed)
def close(self):
"""
Closes the editor, destroying its Toplevel window.
"""
#del self.phrase
#del self.selected_point
#del self._point_handles
#del self._point_lines
#del self._playing_lines
self.toplevel.destroy()
def _add_point_handle(self, point):
"""
Adds a point handle for the given point to the canvas.
"""
s = self.point_handle_size
px, py = point.pos
self._point_handles[point] = self.canvas.create_rectangle(
px-s,py-s, px+s,py+s,
)
def _remove_point_handle(self, point):
"""
Removes the point handle for the given point.
"""
self.canvas.delete(self._point_handles[point])
del self._point_handles[point]
def _add_point_line(self, point1, point2):
"""
Adds a line between two points on the canvas.
"""
px1, py1 = point1.pos
px2, py2 = point2.pos
self._point_lines[
(point1, point2)
] = self.canvas.create_line(
px1,py1, px2,py2,
dash=[2,2] if point2.type == 'Rest' else None
)
def _remove_point_line(self, point1, point2):
"""
Removes the line between two given points.
"""
px1, py1 = point1.pos
px2, py2 = point2.pos
self.canvas.delete(self._point_lines[(point1, point2)])
del self._point_lines[(point1, point2)]
def _remove_point_lines(self):
for points, line in self._point_lines.iteritems():
self.canvas.delete(line)
self._point_lines = {}
def _remove_point_handles(self):
for point, handle in self._point_handles.iteritems():
self.canvas.delete(handle)
self._point_handles = {}
@on_trait_change('phrase, phrase:points')
def _points_changed(self, obj, name, old, new):
if self.phrase is None:
return
self._remove_point_handles()
self._remove_point_lines()
points = self.phrase.points
for i, point in enumerate(points):
self._add_point_handle(point)
if i > 0:
self._add_point_line(points[i-1], point)
@on_trait_change('phrase:points:pos')
def _point_pos_changed(self, point, name, old, new):
"""
When a point's position changes, its handle and lines to its
surrounding points are redefined.
"""
self._remove_point_handle(point)
self._add_point_handle(point)
points = self.phrase.points
assert point in points
i = points.index(point)
if i > 0:
source_point = points[i-1]
self._remove_point_line(source_point, point)
self._add_point_line(source_point, point)
if i < len(points)-1:
target_point = points[i+1]
self._remove_point_line(point, target_point)
self._add_point_line(point, target_point)
@on_trait_change('phrase.name')
def _phrase_name_changed(self):
"""
When the name of the phrase changes, the window title is update.
"""
if self.phrase is None:
return
self.toplevel.title("Phrase: %s" % self.phrase.name)
def add_playing_point(self, point, color):
if point in self._playing_lines:
self.remove_playing_point(point, color)
if point not in self.phrase.points:
return
px,py, px2,py2 = self.phrase.get_line(point)
self._playing_lines[point] = self.canvas.create_line(
px,py, px2,py2, fill=color, width=2.0,
dash=[2,2] if point.type == 'Rest' else None
)
def remove_playing_point(self, point, color):
if point not in self._playing_lines:
return
self.canvas.delete(self._playing_lines[point])
del self._playing_lines[point]
@on_trait_change('use_grid, grid_resolution')
def _grid_changed(self):
"""
Draws a grid if L{PhraseEditor.use_grid} is True, otherwise removes it.
"""
for rect in self._grid_lines:
self.canvas.delete(rect)
self._grid_lines.clear()
if self.use_grid:
config = self.canvas.config()
w = int(config['width'][-1])
h = int(config['height'][-1])
res = self.grid_resolution
for y in range(0, h, res):
self._grid_lines.add(self.canvas.create_line(
0,y, w,y, dash=[1,res-1], fill="#666666"
))
class Palette(Frame):
"""
Tkinter Frame that displays all items that can be added to the board.
"""
def __init__(self,
parent,
board,
width=PALETTE_WIDTH,
height=PALETTE_HEIGHT):
"""
|board|: the board on to which items will be added from this palette.
|width|: the width of this palette.
|height|: the height of this palette.
"""
assert isinstance(board, Board), 'board must be a Board'
Frame.__init__(self, parent, background=PALETTE_BACKGROUND_COLOR)
self.board = board
# canvas on which items are displayed
self.canvas = Canvas(self,
width=width,
height=height,
highlightthickness=0,
background=PALETTE_BACKGROUND_COLOR)
self.width = width
self.height = height
# x-position of last item added on the LEFT side of this palette
self.current_left_x = PALETTE_PADDING
# x-position of last item added on the RIGHT side of this palette
self.current_right_x = self.width
# line to separate left and right sides of palette
self.left_right_separation_line_id = None
# setup ui
self.canvas.pack()
self.pack()
def _add_item_callback(self, drawable_type, desired_offset_x, **kwargs):
"""
Returns a callback method that, when called, adds an item of the given
|drawable_type| to the board, at the given |desired_offset_x|.
"""
assert issubclass(drawable_type,
Drawable), ('drawable must be a Drawable '
'subclass')
def callback(event):
# clear current message on the board, if any
self.board.remove_message()
# create new drawable
new_drawable = drawable_type(**kwargs)
desired_offset_y = (self.board.height - new_drawable.height -
PALETTE_PADDING)
desired_offset = (desired_offset_x, desired_offset_y)
self.board.add_drawable(new_drawable, desired_offset)
return new_drawable
return callback
def _spawn_types_callback(self, types_to_add, desired_offset_x):
"""
Returns a callback method that, when called, adds the items given in
|types_to_add| to the board, starting at the given |desired_offset_x|.
"""
assert isinstance(types_to_add, list), 'types_to_add must be a list'
def callback(event):
dx = 0
# assign the same color and group_id to the types being spawned
color = '#%02X%02X%02X' % (randint(0, 200), randint(
0, 200), randint(0, 200))
group_id = int(round(time() * 1000))
num_drawables_added = 0
for add_type, add_kwargs in types_to_add:
add_kwargs['color'] = color
add_kwargs['group_id'] = group_id
new_drawable = self._add_item_callback(add_type,
desired_offset_x + dx,
**add_kwargs)(event)
if new_drawable:
num_drawables_added += 1
dx += new_drawable.width + BOARD_GRID_SEPARATION
if num_drawables_added > 1:
self.board._action_history.combine_last_n(num_drawables_added)
return callback
def add_drawable_type(self,
drawable_type,
side,
callback,
types_to_add=None,
**kwargs):
"""
Adds a drawable type for display on this palette.
|drawable_type|: a subclass of Drawable to display.
|side|: the side of this palette on which to put the display (LEFT or
RIGHT).
|callback|: method to call when display item is clicked. If None, the
default callback adds an item of the display type to the board.
|types_to_add|: a list of Drawables to add to the board when this item is
clicked on the palette, or None if such a callback is not desired.
|**kwargs|: extra arguments needed to initialize the drawable type.
"""
assert issubclass(drawable_type,
Drawable), ('drawable must be a Drawable '
'subclass')
# create a sample (display) drawable
display = drawable_type(**kwargs)
# draw the display on the appropriate side of the palette
if side == RIGHT:
offset_x = self.current_right_x - PALETTE_PADDING - display.width
self.current_right_x -= display.width + PALETTE_PADDING
# update left-right separation line
if self.left_right_separation_line_id:
self.canvas.delete(self.left_right_separation_line_id)
separation_x = self.current_right_x - PALETTE_PADDING
self.left_right_separation_line_id = self.canvas.create_line(
separation_x,
0,
separation_x,
self.height,
fill=PALETTE_SEPARATION_LINE_COLOR)
else:
# if given |side| is illegal, assume LEFT
offset_x = self.current_left_x + PALETTE_PADDING
self.current_left_x += PALETTE_PADDING + display.width + PALETTE_PADDING
offset_y = (self.height - display.height) / 2
if offset_y % BOARD_GRID_SEPARATION:
offset_y = (offset_y /
BOARD_GRID_SEPARATION) * BOARD_GRID_SEPARATION
offset = (offset_x, offset_y)
display.draw_on(self.canvas, offset)
display.draw_connectors(self.canvas, offset)
# attach callback to drawn parts
# default callback adds items of this drawable type to the board
if callback is None:
callback = self._add_item_callback(
drawable_type, offset_x, **kwargs) if (
types_to_add is None) else self._spawn_types_callback(
types_to_add, offset_x)
else:
assert types_to_add is None, (
'if callback is provided, types_to_add '
'will not be used')
# bind callback
for part in display.parts:
self.canvas.tag_bind(part, '<Button-1>', callback)
self.canvas.tag_bind(part, '<Double-Button-1>', callback)
for connector in display.connectors:
self.canvas.tag_bind(connector.canvas_id, '<Button-1>', callback)
self.canvas.tag_bind(connector.canvas_id, '<Double-Button-1>',
callback)
return display
def draw_separator(self):
"""
Draws a separation line at the current left position.
"""
self.canvas.create_line(self.current_left_x,
0,
self.current_left_x,
self.height,
fill=PALETTE_SEPARATION_LINE_COLOR)
self.current_left_x += PALETTE_PADDING
class Visualization(Tk):
"""
Window displaying a pretty version of the given simulation, with the state
shown around a circle of the given diameter. Pressing enter steps through
the simulation and refreshes the visualization.
"""
def __init__(self, simulator, diameter = 300, margin = 50, parent = None):
Tk.__init__(self, parent)
self.simulator = simulator
self.diameter = diameter
self.margin = margin
self.parent = parent
self.text_labels = []
self.initialize()
def initialize(self):
"""
Setup work for UI.
"""
self.title('Number Squares')
# Set window size. Don't allow resizing.
self.minsize(width = self.diameter + 2 * self.margin,
height = self.diameter + 2 * self.margin)
self.resizable(width = False, height = False)
# Draw circle.
self.canvas = Canvas(self)
self.canvas.create_oval(self.margin, self.margin,
self.diameter + self.margin, self.diameter + self.margin,
outline = 'black', fill = 'white', width = 2)
self.canvas.pack(fill = BOTH, expand = 1)
# Bind arrow keys to step through simulation.
self.bind('<Left>', lambda event: self.step_backward())
self.bind('<Right>', lambda event: self.step_forward())
# Draw initial state.
self.draw_state()
def draw_state(self):
"""
Writes the numbers in the state of the simulation to the visualization.
Does not update the simulator.
"""
# Delete all of the old text labels.
for text_label in self.text_labels:
self.canvas.delete(text_label)
self.text_labels = []
# Make new text labels, adding them to the list.
state = self.simulator.state
num_points = len(state)
for idx in range(num_points):
text_loc = self._get_text_loc(num_points, idx)
number = state[idx]
text_label = self.canvas.create_text(text_loc[0], text_loc[1],
text = str(number), font = ('Helvetica', '24'),
fill = 'red' if number == 0 else 'blue')
self.text_labels.append(text_label)
def step_backward(self):
"""
Steps the simulation backward and refreshes the UI.
"""
self.simulator.step_backward()
self.draw_state()
def step_forward(self):
"""
Steps the simulation forward and refreshes the UI.
"""
self.simulator.step_forward()
self.draw_state()
def _get_text_loc(self, num_points, idx):
"""
Returns the coordinates of point <idx> when <num_points> points are spaced
evenly on the circumference of the circle. The first (0th) point will be
placed north.
"""
text_radius = (self.diameter + self.margin) * 0.5
center = (self.margin + self.diameter / 2, self.margin + self.diameter / 2)
angle = (2 * math.pi * idx) / num_points - (math.pi / 2)
displacement = (text_radius * math.cos(angle),
text_radius * math.sin(angle))
return [int(center[i] + displacement[i]) for i in range(2)]
class Clock(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.canvas = Canvas(self, width=WIDTH, height=HEIGHT)
self.initTime()
self.draw()
self.onTimer()
def initTime(self):
self.hourHand = time.localtime().tm_hour % 12 * 5
self.minuteHand = time.localtime().tm_min
self.secondHand = time.localtime().tm_sec
def draw(self):
self.pack(fill=BOTH, expand=1)
radius = 300
x, y = 50, 50
centerX, centerY = 180, 180
hourX = centerX + 0.3 * radius / 2.0 * math.cos(
self.toRadian(self.hourHand))
hourY = centerY + 0.3 * radius / 2.0 * math.sin(
self.toRadian(self.hourHand))
minuteX = centerX + 0.6 * radius / 2.0 * math.cos(
self.toRadian(self.minuteHand))
minuteY = centerY + 0.6 * radius / 2.0 * math.sin(
self.toRadian(self.minuteHand))
secondX = centerX + 0.75 * radius / 2.0 * math.cos(
self.toRadian(self.secondHand))
secondY = centerY + 0.75 * radius / 2.0 * math.sin(
self.toRadian(self.secondHand))
self.canvas.create_oval(x,
y,
radius,
radius,
outline="black",
fill="black")
self.canvas.create_line(centerX,
centerY,
hourX,
hourY,
width=3,
fill="green")
self.canvas.create_line(centerX,
centerY,
minuteX,
minuteY,
width=3,
fill="green")
self.canvas.create_line(centerX, centerY, secondX, secondY, fill="red")
self.canvas.pack(fill=BOTH, expand=1)
def toRadian(self, x):
return (x * math.pi / 30.0) - (math.pi / 2.0)
def onTimer(self):
self.tick()
self.canvas.delete(ALL)
self.draw()
self.after(DELAY, self.onTimer)
def tick(self):
self.secondHand = (self.secondHand + 1) % 60
if self.secondHand == 0:
self.minuteHand = (self.minuteHand + 1) % 60
if self.minuteHand == 0:
self.hourHand = (self.hourHand + 5) % 60
class at_graph(Frame):
def __init__(self, parent):
Frame.__init__(self, parent)
self.parent = parent
self.u = utils('atoutput.pkl')
self.km = dict()
self.price = dict()
self.km[0] = (min(self.u.all_km), max(self.u.all_km))
self.price[0] = (min(self.u.all_price), max(self.u.all_price))
self.zoom_level = 0
try:
self.parent.title("Auto trader results")
self.is_standalone = True
except:
self.is_standalone = False
self.style = Style()
self.style.theme_use("classic")
# Assume the parent is the root widget; make the frame take up the
# entire widget size.
print self.is_standalone
if self.is_standalone:
self.w, self.h = map(int,
self.parent.geometry().split('+')[0].split('x'))
self.w, self.h = 800, 800
else:
self.w, self.h = 600, 600
self.c = None
# Are they hovering over a data point?
self.is_hovering = False
# Filter the description strings: lower and whiten any non-matching
# data point.
self.filter = ''
self.re = list()
self.replot()
def replot(self, zlfrac=None):
"""Replot the graph. If zlfrac is not None, then it should be a
fractional value between 0 and 1; this is used to do smooth zooming,
which doesn't plot the axes (it only redraws the car points)."""
if self.c is not None:
self.c.destroy()
self.c = Canvas(self, height=self.h, width=self.w, bd=1, bg='#f3f5f9')
self.c.grid(sticky=S, pady=1, padx=1)
zl = self.zoom_level
if zlfrac is not None:
z1l, z1h = self.zoom_price_start
z2l, z2h = self.zoom_price_end
price_low = z1l + (z2l - z1l) * zlfrac
price_high = z1h + (z2h - z1h) * zlfrac
z1l, z1h = self.zoom_km_start
z2l, z2h = self.zoom_km_end
km_low = z1l + (z2l - z1l) * zlfrac
km_high = z1h + (z2h - z1h) * zlfrac
self.axis((price_low, price_high), 'y', draw=False)
self.axis((km_low, km_high), 'x', draw=False)
self.car_points(draw=False)
else:
self.axis(self.price[zl], 'y')
self.axis(self.km[zl], 'x')
self.car_points()
self.pack(fill=BOTH, expand=1)
def xyp(self, x, y):
"Given x in km and y in $, return canvas position (xp, yp)."
xp = int(math.floor((1.0 * x - self.x1) / (self.x2 - self.x1) \
* (self.xp2 - self.xp1) + self.xp1 + 0.5))
yp = int(math.floor((1.0 * y - self.y1) / (self.y2 - self.y1) \
* (self.yp2 - self.yp1) + self.yp1 + 0.5))
return (xp, yp)
def axis(self, arange, ax, draw=True):
"Add an axis ax='x' or 'y', with arange=(min, max) values."
if draw:
a1, a2, ast = self.u.axis(*arange)
else:
a1, a2 = arange
ast = (a2 - a1) * 0.2
nt = int(math.floor((a2 - a1) / ast + 0.5)) + 1
st_offset = 50
# Remember the min and max axis values, along with the canvas points
# that correspond to each location (xp1 and xp2). This allows us to
# calculate where on the canvas a particular (x, y) value falls.
if ax == 'x':
self.x1, self.x2 = a1, a2
self.xp1, self.xp2 = st_offset, self.w - st_offset
self.xtick = [a1 + i * ast for i in range(nt)]
# Remember where the midpoint of the axis is, relative to canvas.
self.xmid = (self.xp1 + self.xp2) / 2
else:
self.y1, self.y2 = a1, a2
self.yp1, self.yp2 = self.h - st_offset, st_offset
self.ytick = [a1 + i * ast for i in range(nt)]
# Remember where the midpoint of the axis is, relative to canvas.
self.ymid = (self.yp1 + self.yp2) / 2
# Figure out tick labels.
atick = ['%g' % ((a1 + i * ast) / 1000) for i in range(nt)]
# Figure out maximum decimal places on all tick labels, and ensure
# they all have that many decimal places.
max_dec = max(map(lambda x: 0 if '.' not in x
else len(x.split('.')[1]), atick))
if max_dec > 0:
atick = map(lambda x: x + '.' + '0'*max_dec if '.' not in x
else x + '0'*(max_dec - len(x.split('.')[1])), atick)
yst, xst = self.h - st_offset, st_offset
# Draw axis line proper, and axis label.
if draw:
if ax == 'x':
self.c.create_line(xst, yst, self.w - st_offset, yst)
xp = (xst + self.w - st_offset) / 2
self.c.create_text(xp, yst + 30, text='Mileage (km x 1000)')
else:
self.c.create_line(xst, yst, xst, st_offset)
self.c.create_text(xst, st_offset - 30, text='Price')
self.c.create_text(xst, st_offset - 15, text='($000)')
tick_anchor = [N, E][ax == 'y']
tick_x, tick_y = xst, yst
tick_step = ([self.w, self.h][ax == 'y'] - st_offset * 2 * 1.0) / \
(nt - 1)
label_offset = 3
for i1, tick in enumerate(atick):
x_of, y_of = -label_offset, label_offset
if ax == 'y':
y_of = int(-i1 * tick_step)
else:
x_of = int(i1 * tick_step)
if draw:
self.c.create_text(tick_x + x_of, tick_y + y_of,
text=tick, anchor=tick_anchor)
x_mini, y_mini = 0, 0
x_maxi, y_maxi = 0, 0
if ax == 'y':
x_of += label_offset
x_mini, x_maxi = 8, self.w - st_offset * 2
# Remember what y coord this grid line is at.
if i1 == 0:
self.y_grid = []
self.y_grid.append(tick_y + y_of)
else:
y_of -= label_offset
y_mini, y_maxi = -8, st_offset * 2 - self.h
# Remember what x coord this grid line is at.
if i1 == 0:
self.x_grid = []
self.x_grid.append(tick_x + x_of)
if draw:
# Draw the little solid tick, next to the axis.
self.c.create_line(tick_x + x_of, tick_y + y_of,
tick_x + x_of + x_mini, tick_y + y_of + y_mini)
# Draw a dashed grid line, across the entire graph.
self.c.create_line(tick_x + x_of, tick_y + y_of,
tick_x + x_of + x_maxi, tick_y + y_of + y_maxi,
dash=(1, 3))
def car_points(self, draw=True):
"Plot the cars themselves."
# 199 215 151 151 199 224 230 162 157 250 224 167 178 165 192 249 200 216 204 204 204 191 173 158
color_order = ['#c7d797', '#97c7e0', '#e6a29d', '#fae0a7', '#b2a5c0',
'#f9c8d8', '#bfad9e', '#cccccc']
#color_order = ['#98df8a', '#dbdb8d', '#aec7e8', '#c9acd4', '#f7b6d2',
# '#ffbb80', '#dc9b8d', '#e9ab17', '#dddddd']
# Those colors above aren't saturated enough. Saturate them more.
color_order = map(lambda x: resaturate(x, -80), color_order)
# Change color depending on year.
cy = dict()
for i1, year in enumerate(reversed(sorted(set(self.u.all_year)))):
cy[year] = color_order[-1]
if i1 < len(color_order):
cy[year] = color_order[i1]
i1 = -1
# Tuples of (index into self.u.all_* arrays, x position, y position).
self.ov_dict = dict()
if draw:
self.c.focus_set()
self.c.bind('<Button-1>', func=self.zoom)
self.c.bind('<Button-2>', func=self.unzoom)
self.c.bind('<Left>', func=self.left_key)
self.c.bind('<Right>', func=self.right_key)
self.c.bind('<Up>', func=self.up_key)
self.c.bind('<Down>', func=self.down_key)
legend = set()
osz = 3 + self.zoom_level * 1
# Total vehicle count, and vehicles which pass the filter count.
self.vcount = self.fcount = 0
for year, km, price in zip(self.u.all_year, self.u.all_km,
self.u.all_price):
x, y = self.xyp(km, price)
i1 += 1
if x < self.x_grid[0] or x > self.x_grid[-1] or \
y > self.y_grid[0] or y < self.y_grid[-1]:
continue
self.vcount += 1
legend.add((year, cy[year]))
filtered = False
if not re.search(self.filter, self.u.all_descr[i1], re.I):
filtered = True
# If a data point is filtered out, make its outline reflect its
# model year, and fill it with white.
#
# Else, make its outline and fill color reflect the model year, and
# upon mouseover, make it entirely red.
ov = self.c.create_oval(x-osz, y-osz, x+osz, y+osz,
outline=cy[year],
activeoutline=['red', cy[year]][filtered],
fill=[cy[year], 'white'][filtered],
activefill=['red', 'white'][filtered],
)
self.ov_dict[ov] = (i1, x, y, cy[year], filtered)
# If a data point is filtered out, mousing over it does nothing,
# and also, lower it behind everything else.
if filtered:
self.c.lower(ov)
else:
self.fcount += 1
if draw:
use_tag = 'Tag %d' % i1
self.c.addtag_withtag(use_tag, ov)
self.c.tag_bind(use_tag, sequence='<Enter>',
func=self.mouseover)
self.c.tag_bind(use_tag, sequence='<Leave>',
func=self.mouseoff)
self.c.tag_bind(use_tag, sequence='<Button-1>',
func=self.select)
if draw:
# OK, add a legend for every year that's displayed.
i1 = 0
for yr, color in reversed(sorted(legend)):
xp, yp = self.x_grid[-1] + 10, self.y_grid[-1] + 15 * i1
self.c.create_oval(xp-osz, yp-osz, xp+osz, yp+osz,
outline=color, fill=color)
self.c.create_text(xp + 8, yp, text=str(yr), anchor=W)
i1 += 1
# And, add a title.
tistr = 'Vehicle count: %d' % self.vcount
if self.fcount != self.vcount:
tistr = 'Filtered vehicle count: %d' % self.fcount
xp = (self.x_grid[0] + self.x_grid[-1]) / 2
yp = self.y_grid[-1] - 30
self.c.create_text(xp, yp, text=tistr, font=('Helvetica', '16'))
zstr1 = 'Click on a blank graph location to zoom in'
zstr2 = 'Right click to zoom out'
if self.zoom_level == 0:
zstr = zstr1
elif self.zoom_level == 2:
zstr = zstr2
else:
zstr = zstr1 + ', or r' + zstr2[1:]
self.c.create_text(xp, yp + 16, text=zstr, font=('Helvetica', '14'))
def mouseover(self, event):
oval = event.widget.find_closest(event.x, event.y)[0]
# XXX Sometimes, the closest widget is an axis grid line, not an oval.
# Need to handle this correctly eventually.
if oval not in self.ov_dict:
return
self.is_hovering = True
ind, x, y, color, filtered = self.ov_dict[oval]
# Figure out how high the box needs to be by creating the text off-
# graph, then getting its bbox and deleting it.
w = 200
de_text = self.u.all_descr[ind]
deobj = self.c.create_text(self.w + 3, self.h + 3, text=de_text,
anchor=N+W, width=w-6, font=('Helvetica', '14'))
bbox = self.c.bbox(deobj)
self.c.delete(deobj)
h = 18 + bbox[3] - bbox[1]
border = 5
if x > self.xmid:
x -= (w + border)
else:
x += border
if y > self.ymid:
y -= (h + border)
else:
y += border
self.re = list()
self.re.append(self.c.create_rectangle(x, y, x + w, y + h,
fill=resaturate(color, 50)))
pr_text = '$%s' % self.u.commafy(self.u.all_price[ind])
self.re.append(self.c.create_text(x + 3, y + 3, text=pr_text,
anchor=N+W, font=('Helvetica', '10')))
km_text = '%skm' % self.u.commafy(self.u.all_km[ind])
self.re.append(self.c.create_text(x + w - 3, y + 3, text=km_text,
anchor=N+E, font=('Helvetica', '10')))
wh_text = self.u.all_wherestr[ind]
if wh_text[0].isdigit():
wh_text += ' away'
self.re.append(self.c.create_text(x + w/2, y + 3, text=wh_text,
anchor=N, font=('Helvetica', '10')))
self.re.append(self.c.create_text(x + 3, y + 16, text=de_text,
anchor=N+W, width=w-6, font=('Helvetica', '14')))
def set_filter(self, st):
"Given a string 'st', filter ovals whose description doesn't match."
self.filter = st
self.replot()
def mouseoff(self, event):
"Code for mousing off a data point."
# The tooptip rectangle and all its sub-objects need to be destroyed.
map(self.c.delete, self.re)
# Also, need to note that we're no longer over an oval -- that way,
# Button-1 events will cause a zoom, rather than launching a web page.
self.is_hovering = False
def _zoom_animation(self):
import time
from math import tanh
scale = 5
for i1 in range(-scale, scale+1):
self.replot(zlfrac=0.5 + 0.5*tanh(i1*2.0/scale)/tanh(2.0))
self.c.update()
def zoom(self, event):
# Only zoom in if we're actually within the graph boundaries.
if event.x <= self.x_grid[0] or event.x > self.x_grid[-1]:
return
if event.y >= self.y_grid[0] or event.y < self.y_grid[-1]:
return
# Don't zoom if we're hovering over a data point: let the web browser
# event handler operate.
if self.is_hovering:
return
# Don't zoom in more than twice.
if self.zoom_level >= 2:
return
# Find the grid square which we're inside.
for i1 in range(len(self.x_grid) - 1):
if event.x <= self.x_grid[i1 + 1]:
xgrid = i1 + 1
break
for i1 in range(len(self.y_grid) - 1):
if event.y >= self.y_grid[i1 + 1]:
ygrid = i1 + 1
break
self.zoom_level += 1
zl = self.zoom_level
# Make the limits of the new graph be those of the grid square which
# was clicked inside.
self.km[zl] = (self.xtick[xgrid-1], self.xtick[xgrid])
self.price[zl] = (self.ytick[ygrid-1], self.ytick[ygrid])
if zl == 1:
self.zoom_price_start = self.u.axis(*self.price[0])[:2]
self.zoom_km_start = self.u.axis(*self.km[0])[:2]
else:
self.zoom_price_start = self.price[zl - 1]
self.zoom_km_start = self.km[zl - 1]
self.zoom_price_end = self.price[zl]
self.zoom_km_end = self.km[zl]
self._zoom_animation()
self.replot()
def unzoom(self, event):
# If already at maximum zoom, nothing to be done.
if self.zoom_level == 0:
return
# If not clicking inside graph boundaries, don't unzoom.
if event.x <= self.x_grid[0] or event.x > self.x_grid[-1]:
return
if event.y >= self.y_grid[0] or event.y < self.y_grid[-1]:
return
self.zoom_level -= 1
zl = self.zoom_level
self.zoom_price_start = self.price[zl + 1]
self.zoom_km_start = self.km[zl + 1]
if zl == 0:
self.zoom_price_end = self.u.axis(*self.price[0])[:2]
self.zoom_km_end = self.u.axis(*self.km[0])[:2]
else:
self.zoom_price_end = self.price[zl]
self.zoom_km_end = self.km[zl]
self._zoom_animation()
self.replot()
def left_key(self, event):
zl = self.zoom_level
if zl == 0:
return
# If at left edge already, don't scroll.
kz = self.km[zl]
if self.km[0][0] > kz[0]:
return
self.zoom_price_start = self.zoom_price_end = self.price[zl]
self.zoom_km_start = kz
self.km[zl] = (kz[0] - (kz[1] - kz[0]), kz[0])
self.zoom_km_end = self.km[zl]
self._zoom_animation()
self.replot()
def right_key(self, event):
zl = self.zoom_level
if zl == 0:
return
# If at right edge already, don't scroll.
kz = self.km[zl]
if self.km[0][1] < kz[1]:
return
self.zoom_price_start = self.zoom_price_end = self.price[zl]
self.zoom_km_start = kz
self.km[zl] = (kz[1], kz[1] + (kz[1] - kz[0]))
self.zoom_km_end = self.km[zl]
self._zoom_animation()
self.replot()
def down_key(self, event):
zl = self.zoom_level
if zl == 0:
return
# If at bottom edge already, don't scroll.
pz = self.price[zl]
if self.price[0][0] > pz[0]:
return
self.zoom_km_start = self.zoom_km_end = self.km[zl]
self.zoom_price_start = pz
self.price[zl] = (pz[0] - (pz[1] - pz[0]), pz[0])
self.zoom_price_end = self.price[zl]
self._zoom_animation()
self.replot()
def up_key(self, event):
zl = self.zoom_level
if zl == 0:
return
# If at top edge already, don't scroll.
pz = self.price[zl]
if self.price[0][1] < pz[1]:
return
self.zoom_km_start = self.zoom_km_end = self.km[zl]
self.zoom_price_start = pz
self.price[zl] = (pz[1], pz[1] + (pz[1] - pz[0]))
self.zoom_price_end = self.price[zl]
self._zoom_animation()
self.replot()
def select(self, event):
"Open a web page, when a data point has been clicked on."
oval = event.widget.find_closest(event.x, event.y)[0]
# XXX As above, sometimes the closest widget is a grid line, not an
# oval. Need to handle this correctly, eventually.
if oval not in self.ov_dict:
return
ind, xp, yp, color, filtered = self.ov_dict[oval]
webbrowser.open(self.u.all_alink[ind])
class SudokuUI(Frame):
def __init__(self, parent, game):
self.game = game
self.parent = parent
Frame.__init__(self, parent)
self.row, self.col = 0, 0
self.__initUI()
def __initUI(self):
self.parent.title("Sudoku")
self.pack(fill=BOTH, expand=1)
self.canvas = Canvas(self, width=WIDTH, height=HEIGHT)
self.canvas.pack(fill=BOTH, side=TOP)
clear_button = Button(self,
text="Clear answers",
command=self.__clear_answers)
clear_button.pack(fill=BOTH, side=BOTTOM)
self.__draw_grid()
self.__draw_puzzle()
self.canvas.bind("<Button-1>", self.__cell_clicked)
self.canvas.bind("<Key>", self.__key_pressed)
def __draw_grid(self):
for i in xrange(10):
color = "blue" if i % 3 == 0 else "gray"
x0 = MARGIN + i * SIDE
y0 = MARGIN
x1 = MARGIN + i * SIDE
y1 = HEIGHT - MARGIN
self.canvas.create_line(x0, y0, x1, y1, fill=color)
x0 = MARGIN
y0 = MARGIN + i * SIDE
x1 = WIDTH - MARGIN
y1 = MARGIN + i * SIDE
self.canvas.create_line(x0, y0, x1, y1, fill=color)
def __draw_puzzle(self):
self.canvas.delete("numbers")
for i in xrange(9):
for j in xrange(9):
answer = self.game.puzzle[i][j]
if answer != 0:
x = MARGIN + j * SIDE + SIDE / 2
y = MARGIN + i * SIDE + SIDE / 2
original = self.game.start_puzzle[i][j]
color = "black" if answer == original else "sea green"
self.canvas.create_text(x,
y,
text=answer,
tags="numbers",
fill=color)
def __clear_answers(self):
self.game.start()
self.canvas.delete("victory")
self.__draw_puzzle()
def __cell_clicked(self, event):
if self.game.game_over:
return
x, y = event.x, event.y
if (MARGIN < x < WIDTH - MARGIN and MARGIN < y < HEIGHT - MARGIN):
self.canvas.focus_set()
row, col = (y - MARGIN) / SIDE, (x - MARGIN) / SIDE
if (row, col) == (self.row, self.col):
self.row, self.col = -1, -1
elif self.game.puzzle[row][col] == 0 or self.game.puzzle[row][
col] != self.game.start_puzzle[row][col]:
self.row, self.col = row, col
else:
self.row, self.col = -1, -1
self.__draw_cursor()
def __draw_cursor(self):
self.canvas.delete("cursor")
if self.row >= 0 and self.col >= 0:
x0 = MARGIN + self.col * SIDE + 1
y0 = MARGIN + self.row * SIDE + 1
x1 = MARGIN + (self.col + 1) * SIDE - 1
y1 = MARGIN + (self.row + 1) * SIDE - 1
self.canvas.create_rectangle(x0,
y0,
x1,
y1,
outline="red",
tags="cursor")
def __key_pressed(self, event):
if self.game.game_over:
return
if self.row >= 0 and self.col >= 0 and event.char in "1234567890":
self.game.puzzle[self.row][self.col] = int(event.char)
self.col, self.row = -1, -1
self.__draw_puzzle()
self.__draw_cursor()
if self.game.check_win():
self.__draw_victory()
def __draw_victory(self):
x0 = y0 = MARGIN + SIDE * 2
x1 = y1 = MARGIN + SIDE * 7
self.canvas.create_oval(x0,
y0,
x1,
y1,
tags="victory",
fill="dark orange",
outline="orange")
x = y = MARGIN + 4 * SIDE + SIDE / 2
self.canvas.create_text(x,
y,
text="You win!",
tags="winner",
fill="white",
font=("Arial", 32))
class CraterViz(Tk):
"""
Visualization class using Tkinter to build objects
and track them on a canvas
"""
def __init__(self, surface):
Tk.__init__(self)
self.title("Crater Density Visualization")
self.surface = surface
self.craters = {}
fr = Frame(self)
fr.pack()
self.canvas = Canvas(fr, height = 580, width = 500)
self.canvas.pack()
self.init_ui()
self.counter = 0;
self.text_year = None
self.text_craters = None
#Builds canvas and adds the craters to it
def init_ui(self):
self._create_grid(self.canvas)
self.canvas.pack()
counter = 1
for crater in self.surface.get_all_craters():
self.after(counter * 100, self._add_crater, crater)
counter += 1
#Creates the grid on the canvas
def _create_grid(self, canvas):
""" Create 10km Grid """
for i in range(50):
canvas.create_line(10 * i, 0, 10 * i, 500, fill="#eee")
canvas.create_line(0, 10 * i, 500, 10 * i, fill="#eee")
#Adds a single crater to the map
def _add_crater(self, crater):
x, y = crater.get_location()
outer_left = x - (25 * 1.2)
outer_right = x + (25 * 1.2)
outer_top = y - (25 * 1.2)
outer_bottom = y + (25 * 1.2)
outer = self.canvas.create_oval(
outer_left, outer_top,
outer_right,
outer_bottom,
outline="#f11",
fill="#1f1",
width=2)
inner_left = x - 25
inner_right = x + 25
inner_top = y - 25
inner_bottom = y + 25
inner = self.canvas.create_oval(
inner_left,
inner_top,
inner_right,
inner_bottom,
outline="#ccc",
fill="green",
width=2)
craters_to_obliterate = self._find_obliterated_craters(crater)
for obliterated in craters_to_obliterate:
self._obliterate_crater(obliterated)
self.craters[crater] = (x, y, inner, outer)
self.counter += 1
self._update_hud(self.counter, len(self.craters))
#Removes crater from surface
def _obliterate_crater(self, crater):
x, y, inner, outer = self.craters[crater]
del self.craters[crater]
self.canvas.delete(inner)
self.canvas.delete(outer)
#Finds all Craters that need to be removed
def _find_obliterated_craters(self, new_crater):
obliterated_craters = []
#Check if other craters are within cover radius
cover_radius = new_crater.get_covering_radius()
for crater in self.craters:
if cover_radius > self._get_distance(crater, new_crater):
obliterated_craters.append(crater)
return obliterated_craters
#Gets the distance between crater centers
def _get_distance(self, crater1, crater2):
x1, y1 = crater1.get_location()
x2, y2 = crater2.get_location()
return math.sqrt((x1 - x2)**2 + (y1 - y2)**2)
#Updates the heads up display on the bottom of the canvas
def _update_hud(self, year, craters):
if self.text_year:
self.canvas.delete(self.text_year)
self.text_year = self.canvas.create_text(480, 560, anchor="e", text="Year: "+str(year)+"000")
if self.text_craters:
self.canvas.delete(self.text_craters)
self.text_craters = self.canvas.create_text(20, 560, anchor="w", text="Craters: "+str(craters))
class App:
grid_size = 15
num_pixels = 30
ser = None
t = None
pixel_dictionary = {}
def __init__(self, master):
# Set main window's title
master.title("ADNS3080ImageGrabber")
frame = Frame(master)
frame.grid(row=0, column=0)
self.comPortStr = StringVar()
ports = serial_ports()
if not ports:
ports = ['No serial ports found']
self.comPortStr.set(ports[0]) # Set first port as default
comports = apply(OptionMenu, (frame, self.comPortStr) + tuple(ports))
comports.grid(row=0, column=0)
self.baudrateStr = StringVar()
self.baudrateStr.set('115200')
baudrates = apply(OptionMenu, (frame, self.baudrateStr) + tuple(Serial.BAUDRATES))
baudrates.grid(row=0, column=1)
button = Button(frame, text="Open", command=self.open)
button.grid(row=0, column=2)
button = Button(frame, text="Close", command=self.close)
button.grid(row=0, column=3)
self.canvas = Canvas(master, width=self.grid_size*self.num_pixels, height=self.grid_size*self.num_pixels)
self.canvas.grid(row=1)
def __del__(self):
self.close()
def close(self):
self.stop_read_loop()
self.close_serial()
def open(self):
# Close the serial port
self.close_serial()
# Open the serial port
try:
self.ser = Serial(port=self.comPortStr.get(), baudrate=self.baudrateStr.get(), timeout=.1)
print("Serial port '" + self.comPortStr.get() + "' opened at " + self.baudrateStr.get())
self.read_loop() # Read from serial port
except SerialException:
print("Failed to open serial port '" + self.comPortStr.get() + "'")
def close_serial(self):
if self.ser and self.ser.isOpen():
try:
self.ser.close()
print("Closed serial port")
except SerialException:
pass # Do nothing
def read_loop(self):
if self.t:
self.stop_read_loop()
if self.ser.isOpen():
try:
self.read_from_serial()
except (IOError, TypeError):
pass
self.t = Timer(0.0, self.read_loop)
self.t.start()
def stop_read_loop(self):
try:
self.t.cancel()
except AttributeError:
print("Failed to cancel timer")
def read_from_serial(self):
while self.ser and self.ser.isOpen() and self.ser.inWaiting() > 0:
# Process the line read
line = self.ser.readline()
if line.find("start") == 0:
# print('Started reading image')
pixels = self.ser.read(self.num_pixels * self.num_pixels)
if len(pixels) == self.num_pixels * self.num_pixels:
for row in range(self.num_pixels):
# print(row)
col = 0
for p in pixels[row * self.num_pixels:(row + 1) * self.num_pixels]:
try:
colour = ord(p)
except TypeError:
colour = 0
# print('Colour', colour)
self.display_pixel(self.num_pixels - 1 - row, self.num_pixels - 1 - col, colour)
col += 1
# print('Done reading image')
else:
print(len(pixels))
# print("Bad line: " + pixels)
else:
# Display the line if we couldn't understand it
print('Error while processing string:', line)
self.ser.flushInput() # Flush the input, as this was likely caused by a timeout
def display_default_image(self):
# Display the grid
for x in range(self.num_pixels):
for y in range(self.num_pixels):
colour = x * y / 3.53
self.display_pixel(x, y, colour)
def display_pixel(self, x, y, colour):
if 0 <= x < self.num_pixels and 0 <= y < self.num_pixels:
# Find the old pixel if it exists and delete it
if x+y*self.num_pixels in self.pixel_dictionary:
old_pixel = self.pixel_dictionary[x+y*self.num_pixels]
self.canvas.delete(old_pixel)
del old_pixel
fill_colour = "#%02x%02x%02x" % (colour, colour, colour)
# Draw a new pixel and add to pixel_array
new_pixel = self.canvas.create_rectangle(x*self.grid_size, y*self.grid_size, (x+1)*self.grid_size,
(y+1)*self.grid_size, fill=fill_colour)
self.pixel_dictionary[x+y*self.num_pixels] = new_pixel
class SudokuUI(Frame): # Frame is a rectangular region on a screen
"""
The Tkinter UI, responsible for drawing the board and accepting user input
"""
def __init__(self, parent, game):
self.game = game
Frame.__init__(self, parent)
self.parent = parent # all widgets belong to a parent
self.row, self.col = -1, -1 # initialize row and col to use later
self.__initUI() # calls the initUI function
def __initUI(self):
self.parent.title("Sudoku") # our parent window will be called Sudoku
self.pack(
fill=BOTH, expand=1
) # Frame attribute, organizes geometry relative to parent, fill options: both, none, x, y
self.canvas = Canvas(self, width=WIDTH, height=HEIGHT)
self.canvas.pack(fill=BOTH, side=TOP) # canvas attribute, helps display our board
clear_button = Button(self, text="Clear answers", command=self.__clear_answers)
clear_button.pack(fill=BOTH, side=BOTTOM) # Clear button is at the bottom and fills the space
self.__draw_grid() # helper functions
self.__draw_puzzle()
self.canvas.bind(
"<Button-1>", self.__cell_clicked
) # binds Button-1 to a callback, another method: cell_clicked
# in Tkinter, Button-1 is a default left mouse click
self.canvas.bind("<Key>", self.__key_pressed) # binds the key (guesed number) to the key presseed method
def __draw_grid(
self
): # make the sudoku layout, do all private functions take self and then other potential arguments?
"""
Draws grid divided with blue lines into 3x3 squares
"""
for i in xrange(10):
color = "blue" if i % 3 == 0 else "gray" # blue lines if divisible by 3
# draw vertical lines
x0 = MARGIN + i * SIDE
y0 = MARGIN
x1 = MARGIN + i * SIDE
y1 = HEIGHT - MARGIN
self.canvas.create_line(
x0, y0, x1, y1, fill=color
) # draw the vertical lines coordinates are (x0, y0) (x1, y1)
# draw horizontal lines
x0 = MARGIN
y0 = MARGIN + i * SIDE
x1 = WIDTH - MARGIN
y1 = MARGIN + i * SIDE
self.canvas.create_line(x0, y0, x1, y1, fill=color)
def __draw_puzzle(self):
self.canvas.delete("numbers") # delete old numbers?
for i in xrange(9):
for j in xrange(9):
answer = self.game.puzzle[i][j]
if answer != 0:
x = MARGIN + j * SIDE + SIDE / 2 # in the middle of the applicable cell
y = MARGIN + i * SIDE + SIDE / 2
original = self.game.start_puzzle[i][j]
color = "black" if answer == original else "sea green"
self.canvas.create_text(x, y, text=answer, tags="numbers", fill=color)
def __draw_cursor(self):
self.canvas.delete("cursor")
if self.row >= 0 and self.col >= 0: # you set these variables as 0 first in init
x0 = MARGIN + self.col * SIDE + 1 # what does -1 do to these variables?
y0 = MARGIN + self.row * SIDE + 1
x1 = MARGIN + (self.col + 1) * SIDE - 1
y1 = MARGIN + (self.row + 1) * SIDE - 1
self.canvas.create_rectangle(x0, y0, x1, y1, outline="red", tags="cursor")
def __draw_victory(self):
# creates an oval/circle
x0 = y0 = MARGIN + SIDE * 2 # upper left box of circle starts margin + 2 rows in
x1 = y1 = MARGIN + SIDE * 7
self.canvas.create_oval(x0, y0, x1, y1, tags="victory", fill="dark orange", outline="orange")
# create text
x = y = MARGIN + 4 * SIDE + SIDE / 2 # middle of the circle
self.canvas.create_text(x, y, text="You win!", tags="victory", fill="white", font=("Arial", 32))
def __cell_clicked(self, event): # event parameter: gives us x&y coordinates of where user clicked
if self.game.game_over:
return # do nothing if game is over
x, y = event.x, event.y
if MARGIN < x < WIDTH - MARGIN and MARGIN < y < HEIGHT - MARGIN: # if our puzzle grid is clicked
self.canvas.focus_set() # focus_set: move focus to a widget
# get row and col numbers from x, y coordinates
row, col = (y - MARGIN) / SIDE, (x - MARGIN) / SIDE
# if cell was selected already, another click should de-select it
if (row, col) == (self.row, self.col):
self.row, self.col = -1, -1 # I assume -1 means de-selecting?
elif self.game.puzzle[row][col] == 0: # otherwise, grab corresponding cell
self.row, self.col = row, col
else:
self.row, self.col = -1, -1
self.__draw_cursor()
def __key_pressed(self, event):
if self.game.game_over:
return
if self.row >= 0 and self.col >= 0 and event.char in "1234567890": # where does event.char come from? tkinter?
self.game.puzzle[self.row][self.col] = int(event.char)
self.col, self.row = -1, -1
self.__draw_puzzle()
self.__draw_cursor()
if self.game.check_win(): # every time you enter in a number, the game checks to see if you have won
self.__draw_victory()
def __clear_answers(self):
self.game.start()
self.canvas.delete("victory") # remove the victory circle
self.__draw_puzzle()
class main:
def __init__(self,master):
self.frame = Frame(master)
self.frame.pack(fill="both", expand=True)
self.canvas = Canvas(self.frame, width=300, height=300)
self.canvas.pack(fill="both", expand=True)
self.label=Label(self.frame, text='Tic Tac Toe Game', height=6, bg='black', fg='blue')
self.label.pack(fill="both", expand=True)
self.frameb=Frame(self.frame)
self.frameb.pack(fill="both", expand=True)
self.Start1=Button(self.frameb, text='Click here to start\ndouble player', height=4, command=self.start1,bg='white', fg='purple')
self.Start1.pack(fill="both", expand=True, side=RIGHT)
self.Start2=Button(self.frameb, text='Click here to start\nsingle player', height=4, command=self.start2,bg='purple', fg='white')
self.Start2.pack(fill="both", expand=True, side=LEFT)
self._board()
def start1(self):
self.canvas.delete(ALL)
self.label['text']=('Tic Tac Toe Game')
self.canvas.bind("<ButtonPress-1>", self.sgplayer)
self._board()
self.TTT=[[0,0,0],[0,0,0],[0,0,0]]
self.i=0
self.j=False
def start2(self):
self.canvas.delete(ALL)
self.label['text']=('Tic Tac Toe Game')
self.canvas.bind("<ButtonPress-1>", self.dgplayer)
self._board()
self.TTT=[[0,0,0],[0,0,0],[0,0,0]]
self.i=0
self.j=False
self.trigger=False
def end(self):
self.canvas.unbind("<ButtonPress-1>")
self.j=True
def _board(self):
self.canvas.create_rectangle(0,0,300,300, outline="black")
self.canvas.create_rectangle(100,300,200,0, outline="black")
self.canvas.create_rectangle(0,100,300,200, outline="black")
def sgplayer(self,event):
for k in range(0,300,100):
for j in range(0,300,100):
if event.x in range(k,k+100) and event.y in range(j,j+100):
if self.canvas.find_enclosed(k,j,k+100,j+100)==():
if self.i%2==0:
X=(2*k+100)/2
Y=(2*j+100)/2
X1=int(k/100)
Y1=int(j/100)
self.canvas.create_oval( X+25, Y+25, X-25, Y-25, width=4, outline="black")
self.TTT[Y1][X1]+=1
self.i+=1
else:
X=(2*k+100)/2
Y=(2*j+100)/2
X1=int(k/100)
Y1=int(j/100)
self.canvas. create_line( X+20, Y+20, X-20, Y-20, width=4, fill="black")
self.canvas. create_line( X-20, Y+20, X+20, Y-20, width=4, fill="black")
self.TTT[Y1][X1]+=9
self.i+=1
self.check()
def dgplayer(self,event):
for k in range(0,300,100):
for j in range(0,300,100):
if self.i%2==0:
if event.x in range(k,k+100) and event.y in range(j,j+100):
if self.canvas.find_enclosed(k,j,k+100,j+100)==():
X=(2*k+100)/2
Y=(2*j+100)/2
X1=int(k/100)
Y1=int(j/100)
self.canvas.create_oval( X+25, Y+25, X-25, Y-25, width=4, outline="black")
self.TTT[Y1][X1]+=1
self.i+=1
self.check()
self.trigger=False
else:
print(self.i)
self.check()
print("checked")
self.AIcheck()
print("AIchecked")
self.trigger=False
def check(self):
#horizontal check
for i in range(0,3):
if sum(self.TTT[i])==27:
self.label['text']=('2nd player wins!')
self.end()
if sum(self.TTT[i])==3:
self.label['text']=('1st player wins!')
self.end()
#vertical check
#the matrix below transposes self.TTT so that it could use the sum fucntion again
self.ttt=[[row[i] for row in self.TTT] for i in range(3)]
for i in range(0,3):
if sum(self.ttt[i])==27:
self.label['text']=('2nd player wins!')
self.end()
if sum(self.ttt[i])==3:
self.label['text']=('1st player wins!')
self.end()
#check for diagonal wins
if self.TTT[1][1]==9:
if self.TTT[0][0]==self.TTT[1][1] and self.TTT[2][2]==self.TTT[1][1] :
self.label['text']=('2nd player wins!')
self.end()
if self.TTT[0][2]==self.TTT[1][1] and self.TTT[2][0]==self.TTT[1][1] :
self.label['text']=('2nd player wins!')
self.end()
if self.TTT[1][1]==1:
if self.TTT[0][0]==self.TTT[1][1] and self.TTT[2][2]==self.TTT[1][1] :
self.label['text']=('1st player wins!')
self.end()
if self.TTT[0][2]==self.TTT[1][1] and self.TTT[2][0]==self.TTT[1][1] :
self.label['text']=('1st player wins!')
self.end()
#check for draws
if self.j==False:
a=0
for i in range(0,3):
a+= sum(self.TTT[i])
if a==41:
self.label['text']=("It's a pass!")
self.end()
def AIcheck(self):
#This is built on the self.check function
self.ttt=[[row[i] for row in self.TTT] for i in range(3)]
#DEFENSE
#this is the horizontal checklist
for h in range(0,3):
k=0
j=0
if sum(self.TTT[h])==2:
while k <3:
if k==h:
while j <3:
if self.trigger==False:
if self.TTT[k][j]==0:
self.cross(j,k)
break
j+=1
k+=1
#this is the vertical checklist
for h in range(0,3):
k=0
j=0
if sum(self.ttt[h])==2:
while k <3:
if k==h:
while j <3:
if self.trigger==False:
if self.ttt[k][j]==0:
self.cross(k,j)
break
j+=1
k+=1
#this is the diagonal checklist
if self.TTT[1][1]==1:
if self.TTT[0][0]==1:
if self.trigger==False:
if self.TTT[2][2]==0:
self.cross(2,2)
if self.TTT[0][2]==1:
if self.trigger==False:
if self.TTT[2][0]==0:
self.cross(0,2)
if self.TTT[2][0]==1:
if self.trigger==False:
if self.TTT[0][2]==0:
self.cross(2,0)
if self.TTT[2][2]==1:
if self.trigger==False:
if self.TTT[0][0]==0:
self.cross(0,0)
if self.TTT[1][1]==0:
if self.trigger==False:
self.cross(1,1)
self.trigger=True
else:
if self.trigger==False:
self.randmove()
def cross(self, k, j):
# k is the x coords
# j is the y coords
X=(200*k+100)/2
Y=(200*j+100)/2
X1=int(k)
Y1=int(j)
self.canvas. create_line( X+20, Y+20, X-20, Y-20, width=4, fill="black")
self.canvas. create_line( X-20, Y+20, X+20, Y-20, width=4, fill="black")
self.TTT[Y1][X1]+=9
self.check()
self.i+=1
self.trigger=True
def randmove(self):
while True:
k=(randint(0,2))
j=(randint(0,2))
if self.TTT[j][k]==0:
X=(200*k+100)/2
Y=(200*j+100)/2
self.canvas. create_line( X+20, Y+20, X-20, Y-20, width=4, fill="black")
self.canvas. create_line( X-20, Y+20, X+20, Y-20, width=4, fill="black")
self.TTT[j][k]+=9
self.check()
self.i+=1
self.trigger=True
break
else:
k=(randint(0,2))*100
j=(randint(0,2))*100
class World(Tk):
# def __init__(self,filename=None,block=50,debug=True,delay=0.25,image=False,width=10,height=10):
def __init__(self,
filename=None,
block=50,
debug=True,
delay=0.25,
image=True,
width=10,
height=10):
Tk.__init__(self)
self.title("")
arg, self.width, self.height = block, width, height
self.photos = [
PhotoImage(file=(k + ".gif"))
for k in ["east", "north", "west", "south"]
]
self.beepers, self.ovals, self.numbers, self.robots, self.walls = {},{},{},{},{}
self.m, self.n, self.t, self.delay = arg * (width + 3), arg * (
height + 3), arg, delay
self.debug, self.useImage = debug, image
a, b, c = self.t + self.t / 2, self.m - self.t - self.t / 2, self.n - self.t - self.t / 2
self.canvas = Canvas(self, bg="white", width=self.m, height=self.n)
self.canvas.pack()
count = 1
for k in range(2 * self.t, max(self.m, self.n) - self.t, self.t):
if k < b:
self.canvas.create_line(k, c, k, a, fill="red")
self.canvas.create_text(k,
c + self.t / 2,
text=str(count),
font=("Times",
max(-self.t * 2 / 3, -15), ""))
if k < c:
self.canvas.create_line(b, k, a, k, fill="red")
self.canvas.create_text(a - self.t / 2,
self.n - k,
text=str(count),
font=("Times",
max(-self.t * 2 / 3, -15), ""))
count += 1
self.canvas.create_line(a, c, b, c, fill="black", width=3)
self.canvas.create_line(a, a, a, c, fill="black", width=3)
if filename is not None:
self.readWorld(filename)
self.refresh()
def readWorld(self, filename):
try:
infile = open("worlds\\%s.wld" % filename, "r")
except IOError:
try:
infile = open("worlds/%s.wld" % filename, "r")
except IOError:
infile = open(filename, "r")
text = infile.read().split("\n")
infile.close()
for t in text:
if t.startswith("eastwestwalls"):
s = t.split(" ")
y, x = int(s[1]), int(s[2])
self.addWall(x, y, -1, y)
if t.startswith("northsouthwalls"):
s = t.split(" ")
x, y = int(s[1]), int(s[2])
self.addWall(x, y, x, -1)
if t.startswith("beepers"):
s = t.split(" ")
y, x, n = int(s[1]), int(s[2]), int(s[3])
if n is infinity:
self.addInfiniteBeepers(x, y)
else:
for k in range(n):
self.addBeeper(x, y)
def pause(self):
sleep(self.delay)
def isBeeper(self, x, y):
return (x, y) in self.beepers.keys() and not self.beepers[(x, y)] == 0
def countRobots(self, x, y):
if (x, y) not in self.robots.keys():
return 0
return len(self.robots[(x, y)])
def crash(self, x1, y1, x2, y2):
if 0 in (x1, y1, x2, y2):
return True
if (x2, y2) in self.walls.keys() and (x1, y1) in self.walls[(x2, y2)]:
return True
if (x1, y1) in self.walls.keys() and (x2, y2) in self.walls[(x1, y1)]:
return True
return False
def addInfiniteBeepers(self, x, y):
flag = (x, y) not in self.beepers.keys() or self.beepers[(x, y)] is 0
self.beepers[(x, y)] = infinity
text = "oo"
a, b = self.t + x * self.t, self.n - (self.t + y * self.t)
t = self.t / 3
if flag:
self.ovals[(x, y)] = self.canvas.create_oval(a - t,
b - t,
a + t,
b + t,
fill="black")
self.numbers[(x, y)] = self.canvas.create_text(
a,
b,
text=text,
fill="white",
font=("Times", max(-self.t / 2, -20), ""))
else:
self.canvas.itemconfig(self.numbers[(x, y)], text=text)
if (x, y) in self.robots.keys():
for robot in self.robots[(x, y)]:
robot.lift()
def addBeeper(self, x, y):
if (x, y) in self.beepers.keys() and self.beepers[(x, y)] is infinity:
return
flag = (x, y) not in self.beepers.keys() or self.beepers[(x, y)] is 0
if flag:
self.beepers[(x, y)] = 1
else:
self.beepers[(x, y)] += 1
text = str(self.beepers[(x, y)])
a, b = self.t + x * self.t, self.n - (self.t + y * self.t)
t = self.t / 3
if flag:
self.ovals[(x, y)] = self.canvas.create_oval(a - t,
b - t,
a + t,
b + t,
fill="black")
self.numbers[(x, y)] = self.canvas.create_text(
a,
b,
text=text,
fill="white",
font=("Times", max(-self.t / 2, -20), ""))
else:
self.canvas.itemconfig(self.numbers[(x, y)], text=text)
if (x, y) in self.robots.keys():
for robot in self.robots[(x, y)]:
robot.lift()
def removeBeeper(self, x, y):
if self.beepers[(x, y)] is infinity:
return
self.beepers[(x, y)] -= 1
flag = self.beepers[(x, y)] is 0
text = str(self.beepers[(x, y)])
if flag:
self.canvas.delete(self.ovals[(x, y)])
self.canvas.delete(self.numbers[(x, y)])
else:
self.canvas.itemconfig(self.numbers[(x, y)], text=text)
if (x, y) in self.robots.keys():
for robot in self.robots[(x, y)]:
robot.lift()
def addWall(self, x1, y1, x2, y2):
if not x1 == x2 and not y1 == y2:
return
if x1 == x2:
y1, y2 = min(y1, y2), max(y1, y2)
if y1 == -1:
y1 = y2
for k in range(y1, y2 + 1):
self.walls.setdefault((x1, k), []).append((x1 + 1, k))
a, b = self.t + x1 * self.t + self.t / 2, self.n - (
self.t + k * self.t) + self.t / 2
c, d = self.t + x1 * self.t + self.t / 2, self.n - (
self.t + k * self.t) - self.t / 2
self.canvas.create_line(a,
b + 1,
c,
d - 1,
fill="black",
width=3)
else:
x1, x2 = min(x1, x2), max(x1, x2)
if x1 == -1:
x1 = x2
for k in range(x1, x2 + 1):
self.walls.setdefault((k, y1), []).append((k, y1 + 1))
a, b = self.t + k * self.t - self.t / 2, self.n - (
self.t + y1 * self.t) - self.t / 2
c, d = self.t + k * self.t + self.t / 2, self.n - (
self.t + y1 * self.t) - self.t / 2
self.canvas.create_line(a - 1,
b,
c + 1,
d,
fill="black",
width=3)
def draw(self, x, y, d, img):
if self.useImage:
if img is not None:
self.canvas.delete(img)
x, y = self.t + x * self.t, self.n - (self.t + y * self.t)
photo = self.photos[d / 90]
img = self.canvas.create_image(x, y, image=photo)
return img
else:
t, angle = self.t / 2, 120
x, y = self.t + x * self.t, self.n - (self.t + y * self.t)
x1, y1 = x + 3**0.5 * t / 2 * cos(
radians(d)), y - 3**0.5 * t / 2 * sin(radians(d))
x2, y2 = x + t * cos(radians(d + angle)), y - t * sin(
radians(d + angle))
x3, y3 = x + t / 4 * cos(radians(d + 180)), y - t / 4 * sin(
radians(d + 180))
x4, y4 = x + t * cos(radians(d - angle)), y - t * sin(
radians(d - angle))
if img is not None:
self.canvas.delete(img)
img = self.canvas.create_polygon(x1,
y1,
x2,
y2,
x3,
y3,
x4,
y4,
fill="blue")
return img
def erase(self, img):
self.canvas.delete(img)
def recordMove(self, count, x1, y1, x2, y2):
for robot in self.robots[(x1, y1)]:
if robot.count == count:
self.robots[(x1, y1)].remove(robot)
self.robots.setdefault((x2, y2), []).append(robot)
break
def lift(self, img):
self.canvas.lift(img)
def refresh(self):
self.canvas.update()
self.pause()
def register(self, x, y, robot):
self.robots.setdefault((x, y), []).append(robot)
def remove(self, x, y, robot):
self.robots[(x, y)].remove(robot)
class Container(Frame):
def __init__(self, parent, width, height):
Frame.__init__(self, parent, background="#22aaff")
self.parent = parent
self.initUI(width, height)
def initUI(self, width, height):
self.inMenu = True
self.width = width
self.height = height
self.parent.title("Stripes")
self.style = Style()
self.style.theme_use('default') #clam, default, alt, classic
self.pack(fill=BOTH, expand=1)
self.canvas = Canvas(self, width=width, height=height-30, background='#335533')
def resize(event):
self.width = event.width
self.height = event.height
if self.inMenu:
pass
else:
self.draw()
self.bind('<Configure>', resize)
self.canvas.bind('<B1-Motion>', lambda(e): motion(e, self, self.draw))
self.canvas.bind('<ButtonRelease-1>', lambda(e): release(e, self, self.draw))
self.canvas.bind('<MouseWheel>', lambda(e): zoom(e, self, self.draw))
def initializeLevel(levelNum):
self.currentLevel = levelNum
self.inMenu = False
self.canvas.delete('all')
self.camera = Camera(200, pi / 40)
self.cells = CellGroup('cube', '3', 4, self)
file = open('levels.txt', 'r')
colors = eval(file.readline())
file.close()
self.routes = RouteGroup('cube', '3', 4, levelNum, self.cells, self, colors)
self.activeIndex = 0
self.draw()
hideIdcs(self, self.draw)
numLevels = 10
def save(toMenu):
lines = []
file = open('levels.txt', 'r+')
for i in range(numLevels+2):
lines.append(file.readline())
levelInfo = eval(lines[self.currentLevel+1])
percent = self.cells.percent(self.routes.routes)
complete = self.routes.complete()
if percent < levelInfo[2]:
percent = levelInfo[2]
if levelInfo[1] == True:
complete = True
nodes = levelInfo[0]
lines[self.currentLevel+1] = '(' + str(nodes) + ',' + str(complete) + ',' + str(percent) + ')\n'
file.seek(0)
for line in lines:
file.write(line)
file.write('\n' + lines[len(lines)-1])
file.close()
if toMenu:
showLevelSelection(self, initializeLevel, numLevels)
frame = Frame(self, width=width, height=30,background='#999999')
menuButton = Button(self, text="Level Select", command=lambda: save(True))
menuButton.pack(in_=frame, side=LEFT, anchor=W, ipadx=6, padx=6)
closeButton = Button(self, text="Close", command=self.quit)
closeButton.pack(in_=frame, side=LEFT, anchor=E, padx=6)
showButton = Button(self, text='Show #s', command=lambda: showIdcs(self, self.draw))
showButton.pack(in_=frame, side=LEFT, anchor=E, padx=6)
hideButton = Button(self, text='Hide #s', command=lambda: hideIdcs(self, self.draw))
hideButton.pack(in_=frame, side=LEFT, anchor=E, padx=6)
frame.pack(anchor=W, fill=BOTH, expand=1)
self.canvas.pack(fill=BOTH, expand=1)
showLevelSelection(self, initializeLevel, numLevels)
def draw(self):
drawCells(self)
drawRoutes(self)
class ImageViewer(Frame, object):
class _Panner(object):
def __init__(self):
self.viewers = []
self._factor = 1
self._drags = []
self._cdrag = None
def add(self, val):
self.viewers.append(val)
for mark, end in self._drags:
val.canvas.scan_mark(*mark)
val.canvas.scan_dragto(*end, gain=1)
if self._cdrag:
val.canvas.scan_mark(*self._cdrag[0])
val.canvas.scan_dragto(*self._cdrag[1], gain=1)
def move_mark(self, x, y):
if self._cdrag:
self._drags.append(self._cdrag)
self._cdrag = [(x, y), (x, y)]
for viewer in self.viewers:
viewer.canvas.scan_mark(x, y)
def move_actual(self, x, y):
self._cdrag[1] = (x, y)
for viewer in self.viewers:
viewer.canvas.scan_dragto(x, y, gain=1)
def update(self):
for viewer in self.viewers:
viewer._update()
def __init__(self, master, panner=None):
super(ImageViewer, self).__init__(master)
self._image = None
self._view = None
self._view_id = None
self.canvas = Canvas(self, background="#000")
self.canvas.pack(fill='both', expand=1)
self.canvas.bind("<MouseWheel>", self.zoom)
self.canvas.bind("<ButtonPress-1>", self.scroll_start)
self.canvas.bind("<B1-Motion>", self.scroll_move)
# self.canvas.bind("<Enter>", self.focus_widget)
# self.canvas.bind("<Leave>", self.unfocus_widget)
self.popup_menu = PopupMenu(self.canvas)
for val in (10, 25, 50, 75, 100, 150, 200, 250, 300, 500):
self.popup_menu.add_command(label="%d%%"%val, command=(lambda v:(lambda :self.set_factor(v/100.)))(val))
self.popup_menu.attach()
self._panner = panner
if panner is None:
self._panner = ImageViewer._Panner()
self._panner.add(self)
self._focus_prev = None
def destroy(self):
self._panner.viewers.remove(self)
super(ImageViewer, self).destroy()
@property
def image(self):
return self._image
@image.setter
def image(self, value):
self._image = value
self.after(1, self.show)
@property
def factor(self):
return self._panner._factor
@factor.setter
def factor(self, value):
self._panner._factor = value
self.after(1, self.show)
def set_factor(self, value):
self.factor = value
def zoom(self, event):
if event.delta < 0:
if self.factor == .1:
return
self.factor -= .1
elif event.delta > 0:
if self.factor == 5:
return
self.factor += .1
self.show()
def scroll_start(self, event):
self._panner.move_mark(event.x, event.y)
def scroll_move(self, event):
self._panner.move_actual(event.x, event.y)
def focus_widget(self, event):
self._focus_prev = self.canvas.focus_get()
self.focus_set()
def unfocus_widget(self, event):
self._focus_prev.focus_set()
def show(self):
self._panner.update()
def _update(self):
if self._image is None:
return
if self._view_id is not None:
self.canvas.delete(self._view_id)
x, y = self.image.size
x, y = int(round(x*self.factor)), int(round(y*self.factor))
self._view = ImageTk.PhotoImage(self.image.resize((x, y)))
self._view_id = self.canvas.create_image(0, 0, image=self._view, anchor="nw")
self.canvas.configure(scrollregsion=self.canvas.bbox("ALL"))
class Palette(Frame):
"""
Tkinter Frame that displays all items that can be added to the board.
"""
def __init__(self, parent, board, width=PALETTE_WIDTH,
height=PALETTE_HEIGHT):
"""
|board|: the board on to which items will be added from this palette.
|width|: the width of this palette.
|height|: the height of this palette.
"""
assert isinstance(board, Board), 'board must be a Board'
Frame.__init__(self, parent, background=PALETTE_BACKGROUND_COLOR)
self.board = board
# canvas on which items are displayed
self.canvas = Canvas(self, width=width, height=height,
highlightthickness=0, background=PALETTE_BACKGROUND_COLOR)
self.width = width
self.height = height
# x-position of last item added on the LEFT side of this palette
self.current_left_x = PALETTE_PADDING
# x-position of last item added on the RIGHT side of this palette
self.current_right_x = self.width
# line to separate left and right sides of palette
self.left_right_separation_line_id = None
# setup ui
self.canvas.pack()
self.pack()
def _add_item_callback(self, drawable_type, desired_offset_x, **kwargs):
"""
Returns a callback method that, when called, adds an item of the given
|drawable_type| to the board, at the given |desired_offset_x|.
"""
assert issubclass(drawable_type, Drawable), ('drawable must be a Drawable '
'subclass')
def callback(event):
# clear current message on the board, if any
self.board.remove_message()
# create new drawable
new_drawable = drawable_type(**kwargs)
desired_offset_y = (self.board.height - new_drawable.height -
PALETTE_PADDING)
desired_offset = (desired_offset_x, desired_offset_y)
self.board.add_drawable(new_drawable, desired_offset)
return new_drawable
return callback
def _spawn_types_callback(self, types_to_add, desired_offset_x):
"""
Returns a callback method that, when called, adds the items given in
|types_to_add| to the board, starting at the given |desired_offset_x|.
"""
assert isinstance(types_to_add, list), 'types_to_add must be a list'
def callback(event):
dx = 0
# assign the same color and group_id to the types being spawned
color = '#%02X%02X%02X' % (randint(0, 200), randint(0, 200),
randint(0, 200))
group_id = int(round(time() * 1000))
num_drawables_added = 0
for add_type, add_kwargs in types_to_add:
add_kwargs['color'] = color
add_kwargs['group_id'] = group_id
new_drawable = self._add_item_callback(add_type, desired_offset_x + dx,
**add_kwargs)(event)
if new_drawable:
num_drawables_added += 1
dx += new_drawable.width + BOARD_GRID_SEPARATION
if num_drawables_added > 1:
self.board._action_history.combine_last_n(num_drawables_added)
return callback
def add_drawable_type(self, drawable_type, side, callback, types_to_add=None,
**kwargs):
"""
Adds a drawable type for display on this palette.
|drawable_type|: a subclass of Drawable to display.
|side|: the side of this palette on which to put the display (LEFT or
RIGHT).
|callback|: method to call when display item is clicked. If None, the
default callback adds an item of the display type to the board.
|types_to_add|: a list of Drawables to add to the board when this item is
clicked on the palette, or None if such a callback is not desired.
|**kwargs|: extra arguments needed to initialize the drawable type.
"""
assert issubclass(drawable_type, Drawable), ('drawable must be a Drawable '
'subclass')
# create a sample (display) drawable
display = drawable_type(**kwargs)
# draw the display on the appropriate side of the palette
if side == RIGHT:
offset_x = self.current_right_x - PALETTE_PADDING - display.width
self.current_right_x -= display.width + PALETTE_PADDING
# update left-right separation line
if self.left_right_separation_line_id:
self.canvas.delete(self.left_right_separation_line_id)
separation_x = self.current_right_x - PALETTE_PADDING
self.left_right_separation_line_id = self.canvas.create_line(
separation_x, 0, separation_x, self.height,
fill=PALETTE_SEPARATION_LINE_COLOR)
else:
# if given |side| is illegal, assume LEFT
offset_x = self.current_left_x + PALETTE_PADDING
self.current_left_x += PALETTE_PADDING + display.width + PALETTE_PADDING
offset_y = (self.height - display.height) / 2
if offset_y % BOARD_GRID_SEPARATION:
offset_y = (offset_y / BOARD_GRID_SEPARATION) * BOARD_GRID_SEPARATION
offset = (offset_x, offset_y)
display.draw_on(self.canvas, offset)
display.draw_connectors(self.canvas, offset)
# attach callback to drawn parts
# default callback adds items of this drawable type to the board
if callback is None:
callback = self._add_item_callback(drawable_type, offset_x, **kwargs) if (
types_to_add is None) else self._spawn_types_callback(types_to_add,
offset_x)
else:
assert types_to_add is None, ('if callback is provided, types_to_add '
'will not be used')
# bind callback
for part in display.parts:
self.canvas.tag_bind(part, '<Button-1>', callback)
self.canvas.tag_bind(part, '<Double-Button-1>', callback)
for connector in display.connectors:
self.canvas.tag_bind(connector.canvas_id, '<Button-1>', callback)
self.canvas.tag_bind(connector.canvas_id, '<Double-Button-1>', callback)
return display
def draw_separator(self):
"""
Draws a separation line at the current left position.
"""
self.canvas.create_line(self.current_left_x, 0, self.current_left_x,
self.height, fill=PALETTE_SEPARATION_LINE_COLOR)
self.current_left_x += PALETTE_PADDING
class main(Frame):
def __init__(self, master):
root_frame = Frame(master)
root_frame.pack()
menubar = Menu(master)
menufile = Menu(menubar, tearoff=0)
menufile.add_command(label="Open")
menufile.add_command(label="Save")
menubar.add_cascade(label="File", menu=menufile)
master.config(menu=menubar)
right_frame = Frame(root_frame, bg="white")
right_frame.pack(side=RIGHT)
self.button = Button(right_frame,
text="quit",
fg="red",
command=root_frame.quit)
self.button.pack(side=TOP)
MODES = [("3D", "rectangle"), ("2D", "line")]
self.mode = StringVar()
self.mode.set("line")
for text, mode in MODES:
b = Radiobutton(right_frame,
text=text,
variable=self.mode,
value=mode)
b.pack(anchor=W)
self.camera_canvas = Canvas(right_frame, bg="red")
self.camera_canvas.bind("<ButtonPress-1>", self.pressed)
self.camera_canvas.bind("<B1-Motion>", self.moved)
self.camera_canvas.bind("<ButtonRelease-1>", self.released)
self.camera_canvas.pack(side=BOTTOM)
self.plot_canvas = Canvas(root_frame, width=100, bg="blue")
self.plot_canvas.pack(side=LEFT)
self.tomogram_canvas = Canvas(root_frame, bg="black")
self.tomogram_canvas.pack(side=LEFT)
def pressed(self, event):
self.start_pos = (event.x, event.y)
def moved(self, event):
self.camera_canvas.delete(tk.ALL)
coordinates = self.start_pos + (event.x, event.y)
selector = {
"line": self.camera_canvas.create_line,
"rectangle": self.camera_canvas.create_rectangle
}[self.mode.get()]
selector(*coordinates)
def released(self, event):
pass
def plot(points):
ax = self.plot_canvas
p2 = points.roll(1)
a = zip(points, p2)
a.pop()
lines = [(p[0], y1, p[1], y1 + 1) for p in a]
create_line = lambda coordinate: ax.create_line(*coordinate)
map(create_line, lines)
class gui:
def __init__(self, sonar):
self.tk = Tk()
self.canvas = Canvas(self.tk, height=800, width=800)
self.canvas.pack()
self.next = Button(self.tk, text='next', command=self.step)
self.next.pack()
self.rb = Button(self.tk, text='run', command=self.run)
self.rb.pack()
self.sonar = sonar
self.draw_map()
self.draw_move_points()
self.delete_old = True
#self.tk.after(20,self.redraw)
self.tk.mainloop()
def run(self):
self.next.config(state='disabled')
self.rb.config(state='disabled')
self.manual = False
self.tk.after(50, self.redraw)
def step(self):
self.manual = True
self.redraw()
def redraw(self):
check = self.sonar.sim_step()
if self.delete_old:
self.canvas.delete('scan')
self.canvas.delete('intersect')
self.canvas.delete('particle')
self.canvas.delete('mvln')
self.draw_sonar_data()
self.draw_particle_data()
if check is not -1 and self.manual is False:
self.tk.after(50, self.redraw)
def draw_sonar_data(self):
#print 'data'
#for line in self.sonar.scan_lines:
#draw_line(self.canvas, line, tag='scan')
#for point in self.sonar.intersection_points:
#draw_point(self.canvas, point, tag='intersect')
draw_point(self.canvas, self.sonar.loc, tag='sonar', colour='red')
def draw_particle_data(self):
particles = self.sonar.particles.list()
for particle in particles:
draw_point(self.canvas, particle.loc, weight=particle.wt, tag='particle')
if particle.move_line:
draw_line(self.canvas, particle.move_line, tag='mvln')
#for line in particle.scan:
# draw_line(self.canvas, line, tag='scan')
#for intersect in particle.int:
#draw_point(self.canvas, intersect, tag='intersect')
def draw_map(self):
#print 'map'
for line in self.sonar.map.lines:
draw_line(self.canvas, line, tag='map')
def draw_move_points(self):
for point in self.sonar.get_move_list():
draw_point(self.canvas, point[0], tag='mvpt')
class Game:
def __init__(self):
self.root = Tk()
self.frame1 = None
self.frame2 = None
self.w = None
self.scoreC = None
self.score = 0
self.hor = True
self.upid = self.downid = self.rightid = self.leftid = 0
self.head = -1
self.time = 700
def home(self):
self.frame1 = Frame(self.root, width=750, height=350, padx=250, bg="black")
self.frame2 = Frame(self.root, height=250, width=750, bg="black", padx=25)
self.root.wm_minsize(width=750, height=666)
self.root.configure(bg="black")
self.frame1.pack_propagate(0)
self.frame1.update()
self.frame1.configure(pady=self.frame1.cget("height") / 2.5)
logo = PhotoImage(file="Game_Logo.gif")
starth = Button(self.frame1, text="Hard", bg="orange", padx=25, pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(40))
startm = Button(self.frame1, text="Medium", bg="teal", padx=25, pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(60))
starte = Button(self.frame1, text="Easy", bg="orange", padx=25, pady=5,
font=Font(family="comic sans MS", size=10),
command=lambda: self.callgame(75))
self.frame2.pack_propagate(0)
exp = """ This is a game in which
the arrow keys are used
to move the snake around
and to get points"""
exf = Font(family="comic sans MS", size=20)
Label(self.frame2, image=logo, bg="black", text=exp, padx=10).pack(side="right")
Label(self.frame2, fg="white", bg="black", text=exp, justify="left", font=exf).pack(side="left")
starte.grid(row=0, columnspan=2)
startm.grid(row=0, columnspan=2, column=4, padx=18)
starth.grid(row=0, columnspan=2, column=8)
head = Font(family="comic sans MS", size=30)
self.H=Label(self.root, text="SNAKES", font=head, fg="orange", bg="black", pady=10)
self.H.pack()
self.frame2.pack(expand=True)
self.frame1.pack(expand=True)
self.root.mainloop()
def callgame(self, time):
self.time = time
self.game()
def calldown(self, key):
if self.hor:
self.w.after_cancel(self.leftid)
self.w.after_cancel(self.rightid)
self.down(0)
def callup(self, key):
if self.hor:
self.w.after_cancel(self.leftid)
self.w.after_cancel(self.rightid)
self.up(0)
def callright(self, key):
if not self.hor:
self.w.after_cancel(self.upid)
self.w.after_cancel(self.downid)
self.right(0)
def callleft(self, key):
if not self.hor:
self.w.after_cancel(self.upid)
self.w.after_cancel(self.downid)
self.left(0)
def game(self):
self.score = 0
self.w = Canvas(self.root, width=750, height=500, relief="flat", highlightbackground="grey",
highlightthickness=10)
self.frame1.destroy()
self.frame2.destroy()
self.root.configure(width=1000, padx=10)
self.root.pack_propagate(0)
self.w.configure(background="black")
self.w.pack(side="left")
self.w.create_line(300, 250, 450, 250, width=10, fill="teal")
self.scoreC = Label(self.root, text="Score\n" + str(self.score), bg="black", fg="teal", padx=25, pady=35,
font=Font(family="comic sans MS", size=25))
self.head = self.w.create_line(450, 250, 455, 250, width=10, fill="white")
self.scoreC.pack(side="top")
self.root.bind("<Up>", self.callup)
self.root.bind("<Down>", self.calldown)
self.root.bind("<Right>", self.callright)
self.root.bind("<Left>", self.callleft)
self.createFood()
self.right(0)
def down(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-1] += 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-3] -= 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2], crd[-1] + 5, width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = False
if not end:
self.downid = self.w.after(self.time, self.down, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def up(self, i):
crd = self.w.coords(1)
if len(crd)>0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-1] -= 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-3] += 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2], crd[-1] - 5, width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = False
if not end:
self.upid = self.w.after(self.time, self.up, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def right(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-2] += 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-4] -= 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2] + 5, crd[-1], width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = True
if not end:
self.rightid = self.w.after(self.time, self.right, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def left(self, i):
crd = self.w.coords(1)
if len(crd) > 0:
if crd[0] == crd[2]:
if crd[1] > crd[3]:
# print("inside if1")
crd[1] -= 10
if crd[1] < crd[3]:
# print("inside if2")
crd[1] += 10
else:
if crd[0] > crd[2]:
crd[0] -= 10
if crd[0] < crd[2]:
crd[0] += 10
crd[-2] -= 10
if i == 0:
crd.append(crd[-2])
crd.append(crd[-2])
crd[-4] += 10
if crd[0] == crd[2] and crd[1] == crd[3]:
crd = crd[2:]
self.w.coords(1, *crd)
self.w.delete(self.head)
self.head = self.w.create_line(crd[-2], crd[-1], crd[-2] - 5, crd[-1], width=10, fill="orange")
end = self.end()
self.checkEaten()
i += 1
self.hor = True
if not end:
self.leftid = self.w.after(self.time, self.left, i)
else:
self.w.delete(1)
self.w.delete(self.head)
self.w.delete(self.food)
self.start = Button(self.root, text="Start", bg="orange", padx=25, pady=25,
font=Font(family="comic sans MS", size=15),
command=lambda: self.callhome())
self.start.pack(side="bottom")
def createFood(self):
# self.w.delete(self.food) #deleting old food.
crd = self.w.coords(1)
ext = []
for i in crd:
ext.append(i)
for j in range(-50, 50):
ext.append(i + j)
randx = random.randrange(20, 730)
randy = random.randrange(20, 480)
while randx not in ext and randy not in ext:
randx = random.randrange(20, 730)
randy = random.randrange(20, 480)
self.food = self.w.create_line(randx, randy, randx + 12, randy, width=10, fill="yellow")
def checkEaten(self):
headcoords = self.w.coords(self.head)
foodcoords = self.w.coords(self.food)
# self.w.delete(self.food)
flag = False
# print(headcoords[-4])
# print(foodcoords[-4])
# print(foodcoords[-2])
if int(headcoords[-4]) in range(int(foodcoords[-4]) - 7, int(foodcoords[-2]) + 7) and int(
headcoords[-3]) in range(int(foodcoords[-1]) - 10, int(foodcoords[-1] + 10)):
flag = True
if flag:
self.grow()
self.score += 10
self.scoreC.configure(text="Score\n" + str(self.score), bg="black", fg="teal", padx=25, pady=35,
font=Font(family="comic sans MS", size=25))
self.w.delete(self.food)
self.createFood()
def grow(self):
crd = self.w.coords(1)
if crd[0] != crd[2]: # horizontal condition
if crd[0] < crd[2]:
crd[0] -= 20
else:
crd[0] += 20
self.w.coords(1, *crd)
else:
if crd[3] < crd[1]:
crd[1] += 20
else:
crd[1] -= 20
self.w.coords(1, *crd)
def end(self):
crd = self.w.coords(1)
h = self.w.coords(self.head)
a = 0
while a < len(crd) - 2:
if crd[a] == crd[a + 2]:
if (h[0] == crd[a] and crd[a + 1] < h[1] < crd[a + 3]) or (
h[0] == crd[a] and crd[a + 1] > h[1] > crd[a + 3]):
return True
else:
if (h[1] == crd[a + 1] and crd[a] < h[0] < crd[a + 2]) or (h[1] == crd[a + 1] and crd[a] > h[0] > crd[a + 2]):
return True
a += 2
if (h[0] == 0 and 0 < h[1] < 500) or (h[1] == 0 and 0 < h[0] < 750) or (h[1] == 510 and 0 < h[0] < 750) or (h[0] == 760 and 0<h[1]<500):
return True
return False
def callhome(self):
self.w.destroy()
self.start.destroy()
self.H.destroy()
self.scoreC.destroy()
self.home()
class Screen(Observer):
def __init__(self, parent, bg="white"):
self.menu_bar = MenuBar(parent)
self.canvas = Canvas(parent, bg=bg, name="screen")
self.frameControl = Frame(parent)
self.frameLabelSignals = LabelFrame(self.frameControl,
text="Signaux",
padx=20,
pady=20)
self.frameLabelMode = LabelFrame(self.frameControl,
text="Mode",
padx=20,
pady=20)
self.panelControl = ttk.Notebook(self.frameLabelSignals)
self.checkbox_signalX = Checkbutton(self.frameLabelMode,
text="Signal X")
self.checkbox_signalY = Checkbutton(self.frameLabelMode,
text="Signal Y")
self.checkbox_XY = Checkbutton(self.frameLabelMode, text="XY")
self.panel_control_page = [] # contient les références de mes curseurs
for p in parent.get_models():
self.addPage(p.get_name())
def addPage(self, name):
page = ttk.Frame(self.panelControl)
self.panelControl.add(page, text='signal ' + name)
visible_checkbox = Checkbutton(page, text="Afficher")
magnitude = Scale(page,
length=250,
orient="horizontal",
label="Amplitude",
sliderlength=20,
showvalue=0,
from_=0,
to=5,
tickinterval=1,
name="magnitudeScale")
frequency = Scale(page,
length=250,
orient="horizontal",
label="Frequency",
sliderlength=20,
showvalue=0,
from_=0,
to=25,
tickinterval=5,
name="frequencyScale")
phase = Scale(page,
length=250,
orient="horizontal",
label="Phase",
sliderlength=20,
showvalue=0,
from_=0,
to=20,
tickinterval=5,
name="phaseScale")
visible_checkbox.pack(fill="x", pady=6)
magnitude.pack(expand=1, fill="both", pady=6)
frequency.pack(expand=1, fill="both", pady=6)
phase.pack(expand=1, fill="both", pady=6)
self.panel_control_page.append({
'visible': visible_checkbox,
'magnitude': magnitude,
'frequency': frequency,
'phase': phase
})
def update(self, model):
if type(model) == list:
for i, m in enumerate(model):
signal = m.get_signal()
#self.plot_signal(signal, m.get_color())
self.plot_signal(m)
else:
signal = model.get_signal()
self.plot_signal(model)
self.grid(6, 8)
def get_panel_control_index(self):
return self.panelControl.index('current')
def get_canvas(self):
return self.canvas
def get_panel_control_page(self):
return self.panel_control_page
def get_magnitude(self, index):
return self.panel_control_page[index]['magnitude']
def get_frequency(self, index):
return self.panel_control_page[index]['frequency']
def get_phase(self, index):
return self.panel_control_page[index]['phase']
def get_visible(self, index):
return self.panel_control_page[index]['visible']
def get_checkbox_signalX(self):
return self.checkbox_signalX
def get_checkbox_signalY(self):
return self.checkbox_signalY
def get_checkbox_XY(self):
return self.checkbox_XY
def plot_signal(self, model):
w, h = self.canvas.winfo_width(), self.canvas.winfo_height()
width, height = int(w), int(h)
signal = model.get_signal()
name = model.get_name()
color = model.get_color()
if self.canvas.find_withtag("signal" + name):
self.canvas.delete("signal" + name)
if signal and len(signal) > 1 and model.is_visible():
plot = [(x * width, height / 2.0 * (y + 1)) for (x, y) in signal]
self.canvas.create_line(plot,
fill=color,
smooth=1,
width=3,
tags="signal" + name)
self.canvas.scale("signal" + name, width / 2, height / 2, 1.0,
0.25)
def grid(self, row, col):
w, h = self.canvas.winfo_width(), self.canvas.winfo_height()
width, height = int(w), int(h)
if self.canvas.find_withtag("grid"):
self.canvas.delete("grid")
# dessin des axes X et Y
self.canvas.create_line(5,
height / 2,
width,
height / 2,
arrow="last",
tags=('grid', 'axe-x'))
self.canvas.create_line(width / 2,
height - 5,
width / 2,
5,
arrow="last",
tags=('grid', 'axe-y'))
# dessin des lignes verticales
for c in range(1, int(row / 2) + 1):
stepW = width / row
xd = width / 2 + c * stepW
xg = width / 2 - c * stepW
#Creation des lignes verticales
self.canvas.create_line(xd,
height - 5,
xd,
5,
dash=1,
tags=('grid', 'vertical-line'),
fill='grey') #cote droit
self.canvas.create_line(xg,
height - 5,
xg,
5,
dash=1,
tags=('grid', 'vertical-line'),
fill='grey') #cote gauche
#Creation des tirets sur x
self.canvas.create_line(xd,
height / 2 - 4,
xd,
height / 2 + 4,
tags=('grid', 'horizontal-line'),
fill='grey')
self.canvas.create_line(xg,
height / 2 - 4,
xg,
height / 2 + 4,
tags=('grid', 'horizontal-line'),
fill='grey')
# dessin des lignes horizontales
for r in range(1, int(col / 2) + 1):
stepH = height / col
yB = height / 2 + r * stepH
yH = height / 2 - r * stepH
#Creation des lignes horizontales
self.canvas.create_line(5,
yB,
width,
yB,
dash=1,
tags=('grid', 'horizontal-line'),
fill='grey')
self.canvas.create_line(5,
yH,
width,
yH,
dash=1,
tags=('grid', 'horizontal-line'),
fill='grey')
#Creation des tirets sur y
self.canvas.create_line(width / 2 - 4,
yB,
width / 2 + 4,
yB,
tags=('grid', 'vertical-line'),
fill='grey')
self.canvas.create_line(width / 2 - 4,
yH,
width / 2 + 4,
yH,
tags=('grid', 'vertical-line'),
fill='grey')
def packing(self):
self.menu_bar.pack(fill='x')
self.canvas.pack(side=LEFT, expand=1, fill="both", padx=6, pady=6)
self.panelControl.pack(side=RIGHT, expand=1, fill="both", pady=6)
self.frameLabelSignals.pack(expand=1, fill="both")
self.frameLabelMode.pack(expand=1, fill="both")
self.checkbox_signalX.pack(side=LEFT)
self.checkbox_signalY.pack(side=LEFT)
self.checkbox_XY.pack(side=RIGHT)
self.frameControl.pack(side=RIGHT, expand=1, fill="both", pady=6)
class SudokuUI(Frame):
"""
Sudoku grid UI class.
Adapted from: http://newcoder.io/gui/part-4/
"""
def __init__(self, parent, board):
self.game = board
Frame.__init__(self, parent)
self.parent = parent
self.row, self.col = -1, -1
self.new_entry = None
self.previous_guess = None
self.game_state = 0
self.scores = []
self.__initUI()
def __initUI(self):
"""
Initialize sudoku playing field grid and bind clicking and entry handlers."""
self.parent.title("Sudoku")
self.pack(fill=BOTH, expand=1)
self.canvas = Canvas(self, width=WIDTH, height=HEIGHT)
self.canvas.grid(row=1, column=0)
self.__draw_grid()
self.__draw_puzzle()
self.__draw_scores()
self.canvas.bind("<Button-1>", self.__cell_clicked)
self.canvas.bind("<Key>", self.__key_pressed)
def __draw_grid(self):
"""
Draw Sudoku 3x3 x 3x3 grid."""
for i in xrange(10):
color = "blue" if i % 3 == 0 else "gray"
x0 = MARGIN + i * SIDE
y0 = MARGIN
x1 = MARGIN + i * SIDE
y1 = HEIGHT - MARGIN
self.canvas.create_line(x0, y0, x1, y1, fill=color)
x0 = MARGIN
y0 = MARGIN + i * SIDE
x1 = WIDTH - MARGIN
y1 = MARGIN + i * SIDE
self.canvas.create_line(x0, y0, x1, y1, fill=color)
def __draw_puzzle(self):
"""
Draw Sudoku solution numbers."""
self.canvas.delete("numbers")
for i in xrange(9):
for j in xrange(9):
answer = self.game.board[i][j]
if answer != 0:
x = MARGIN + j * SIDE + SIDE / 2
y = MARGIN + i * SIDE + SIDE / 2
self.canvas.create_text(x, y, text=answer, tags="numbers")
def __cell_clicked(self, event):
"""
Handle a single cell click and highlight the clicked cell.
:param event:
"""
x, y = event.x, event.y
if MARGIN < x < WIDTH - MARGIN and MARGIN < y < HEIGHT - MARGIN:
self.canvas.focus_set()
# get row and col numbers from x,y coordinates
row, col = (y - MARGIN) / SIDE, (x - MARGIN) / SIDE
# if cell was selected already - deselect it
if (row, col) == (self.row, self.col):
self.row, self.col = -1, -1
elif self.game.board[row][col] == 0:
self.row, self.col = row, col
self.__draw_cursor()
def __draw_cursor(self):
"""
Draw the red outline for the selected square."""
self.canvas.delete("cursor")
if self.row >= 0 and self.col >= 0:
x0 = MARGIN + self.col * SIDE + 1
y0 = MARGIN + self.row * SIDE + 1
x1 = MARGIN + (self.col + 1) * SIDE - 1
y1 = MARGIN + (self.row + 1) * SIDE - 1
self.canvas.create_rectangle(x0,
y0,
x1,
y1,
outline="green",
tags="cursor")
def __key_pressed(self, event):
"""
Handle solution number entry."""
if self.row >= 0 and self.col >= 0 and event.char in "123456789" and self.game_state == 1:
self.new_entry = (self.row, self.col, int(event.char))
self.col, self.row = -1, -1
self.__draw_puzzle()
self.__draw_cursor()
def __draw_scores(self):
self.score_list = Treeview(self, columns=('name', 'score'))
self.score_list['show'] = 'headings'
self.score_list.heading('name', text='Name')
self.score_list.column('name', width=80, anchor=CENTER)
self.score_list.heading('score', text='Score')
self.score_list.column('score', width=80, anchor=CENTER)
self.score_list.grid(row=1, column=1, padx=(0, 20))
def __update_scores(self, scores):
self.score_list.delete(*self.score_list.get_children())
for entry in scores:
self.score_list.insert('', 'end', values=(entry[0], entry[1]))
def show_winner(self, score, user_id):
if score[2] == user_id:
winner_text = "YOU HAVE WON!"
else:
winner_text = "Player " + str(score[0]) + " has won!"
tkMessageBox.showwarning("A WINNER IS FOUND", winner_text)
def update_board(self, root, board, scores, new_game_state):
"""
Update board during the gameplay. If all players are not connected, solution entry is not permitted.
In case of a wrong answer the selected square is flashed red for a fraction of a second to notify
the player about his life decisions.
:param root:
:param board:
:param new_game_state:
:return entered value:
"""
return_val = None
self.__update_scores(scores)
# Check for game state, if it is "0", just return, else continue the game
if self.game_state == 0:
root.update()
if new_game_state != 0:
self.game_state = new_game_state
return return_val
# If previous guess was not correct flash it red
if self.previous_guess is not None and board[self.previous_guess[0]][self.previous_guess[1]] != \
self.previous_guess[2]:
row, col, _ = self.previous_guess
x0 = MARGIN + col * SIDE + 1
y0 = MARGIN + row * SIDE + 1
x1 = MARGIN + (col + 1) * SIDE - 1
y1 = MARGIN + (row + 1) * SIDE - 1
self.canvas.create_rectangle(x0,
y0,
x1,
y1,
fill="red",
tags="fail")
else:
self.canvas.delete("fail")
# Initiate return value to none, update the board and draw it
self.game.update_board(board)
self.__draw_puzzle()
root.update()
# If user has entered anything in between, write it into the return value and previous guess and return
if self.new_entry is not None:
return_val = self.new_entry
self.previous_guess = self.new_entry
self.new_entry = None
else:
self.previous_guess = None
return return_val
class ContinuousTMPViewer(object):
def __init__(self,
suction_height,
regions,
tl_x=0,
tl_y=0,
width=500,
height=150,
title='Grid',
background='tan'):
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.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.center()
self.move_frame(self.tl_x, self.tl_y)
max_width = max(
map(get_width,
regions.values())) # Really should take width of max minus min
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.robot = []
self.blocks = []
self.holding = None
self.environment = []
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.dist_to_pixel * (x + self.dist_width / 2.)
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.blocks.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='', color='red'):
x1, x2 = map(self.scale_x, region)
y1, y2 = self.ground_height, self.height
self.environment.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.environment = []
for name, region in sorted(self.regions.items(),
key=lambda pair: get_width(pair[1]),
reverse=True):
self.draw_region(region, name=name, color=name)
def draw_robot(
self,
x,
y,
color='yellow'
): # TODO - could also visualize as top grasps instead of side grasps
#y = self.robot_dist
self.robot = [
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_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 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):
# 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:
return None
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'
ImageGrab.grab((x, y, x + width, y + height)).save(path)
return path
class SudokuUI(Frame):
"""
The Tkinter UI, responsible for drawing the board and accepting user input.
"""
def __init__(self, parent, game):
self.game = game
Frame.__init__(self, parent)
self.parent = parent
self.row, self.col = -1, -1
self.__initUI()
def __initUI(self):
self.parent.title("Sudoku")
self.pack(fill=BOTH)
self.canvas = Canvas(self, width=WIDTH, height=HEIGHT)
self.canvas.pack(fill=BOTH, side=TOP)
clear_button = Button(self,
text="Clear answers",
command=self.__clear_answers)
clear_button.pack(fill=BOTH, side=BOTTOM)
self.__draw_grid()
self.__draw_puzzle()
self.canvas.bind("<Button-1>", self.__cell_clicked)
self.canvas.bind("<Key>", self.__key_pressed)
def __draw_grid(self):
"""
Draws grid divided with blue lines into 3x3 squares
"""
for i in range(10):
color = "blue" if i % 3 == 0 else "grey"
x0 = MARGIN + i * SIDE
y0 = MARGIN
x1 = MARGIN + i * SIDE
y1 = HEIGHT - MARGIN
self.canvas.create_line(x0, y0, x1, y1, fill=color)
x0 = MARGIN
y0 = MARGIN + i * SIDE
x1 = WIDTH - MARGIN
y1 = MARGIN + i * SIDE
self.canvas.create_line(x0, y0, x1, y1, fill=color)
def __draw_puzzle(self):
self.canvas.delete("numbers")
for i in range(9):
for j in range(9):
answer = self.game.puzzle[i][j]
if answer != 0:
x = MARGIN + j * SIDE + SIDE / 2
y = MARGIN + i * SIDE + SIDE / 2
original = self.game.start_puzzle[i][j]
color = "black" if answer == original else "sea green"
self.canvas.create_text(x,
y,
text=answer,
tags="numbers",
fill=color)
def __draw_cursor(self):
self.canvas.delete("cursor")
if self.row >= 0 and self.col >= 0:
x0 = MARGIN + self.col * SIDE + 1
y0 = MARGIN + self.row * SIDE + 1
x1 = MARGIN + (self.col + 1) * SIDE - 1
y1 = MARGIN + (self.row + 1) * SIDE - 1
self.canvas.create_rectangle(x0,
y0,
x1,
y1,
outline="red",
tags="cursor")
def __draw_victory(self):
# create a oval (which will be a circle)
x0 = y0 = MARGIN + SIDE * 2
x1 = y1 = MARGIN + SIDE * 7
self.canvas.create_oval(x0,
y0,
x1,
y1,
tags="victory",
fill="dark orange",
outline="orange")
# create text
x = y = MARGIN + 4 * SIDE + SIDE / 2
self.canvas.create_text(x,
y,
text="You win!",
tags="victory",
fill="white",
font=("Arial", 32))
def __draw_loose(self):
# create a oval (which will be a circle)
x0 = y0 = MARGIN + SIDE * 2
x1 = y1 = MARGIN + SIDE * 7
self.canvas.create_oval(x0,
y0,
x1,
y1,
tags="victory",
fill="yellow",
outline="yellow")
# create text
x = y = MARGIN + 4 * SIDE + SIDE / 2
self.canvas.create_text(x,
y,
text="You loose!",
tags="victory",
fill="white",
font=("Arial", 32))
def __cell_clicked(self, event):
if self.game.game_over:
return
x, y = event.x, event.y
if (MARGIN < x < WIDTH - MARGIN and MARGIN < y < HEIGHT - MARGIN):
self.canvas.focus_set()
# get row and col numbers from x,y coordinates
row, col = (y - MARGIN) // SIDE, (x - MARGIN) // SIDE
# if cell was selected already - deselect it
if (row, col) == (self.row, self.col):
self.row, self.col = -1, -1
elif self.game.check[row][col] == 0:
self.row, self.col = row, col
else:
self.row, self.col = -1, -1
self.__draw_cursor()
def __key_pressed(self, event):
if self.game.game_over:
return
if self.row >= 0 and self.col >= 0 and event.char in "1234567890":
self.game.puzzle[self.row][self.col] = int(event.char)
self.col, self.row = -1, -1
self.__draw_puzzle()
self.__draw_cursor()
a = self.game.check_win()
# print(a)
if a == 0:
self.__draw_loose()
return 0
elif a == 1:
self.__draw_victory()
def __clear_answers(self):
self.game.start()
self.canvas.delete("victory")
self.__draw_puzzle()
