class TkWindow(tkinter.Tk):
def __init__(self,parent):
tkinter.Tk.__init__(self,parent)
self.parent = parent
self.initialize()
def initialize(self):
self.grid()
buttonFile = tkinter.Button(self,text=u"Get file",command=self.getFile)
buttonFile.grid(column=0,row=1,sticky='EW',padx=10,pady=10)
buttonCrypto = tkinter.Button(self,text=u"Crypto",command=self.crypto)
buttonCrypto.grid(column=0,row=3,sticky='EW',padx=10,pady=10)
#labelHeader = Tkinter.Label(self,text=u"Database file:",anchor="w")
#labelHeader.grid(column=0,row=0,columnspan=3,padx=10,pady=10,sticky='EW')
self.labelVariable = tkinter.StringVar()
labelFileName = tkinter.Label(self,textvariable=self.labelVariable,anchor="w",fg="black",bg="white")
labelFileName.grid(column=1,row=1,columnspan=2,sticky='EW',padx=10,pady=10)
self.canvas = Canvas(self,width=400, height=400,bd=0,bg="blue")
self.canvas.grid(row = 2,column = 0,columnspan=2,sticky='EW',padx=10,pady=10)
#self.photo = ImageTk.PhotoImage(file = "/home/paulina/obrazki/obrazek.jpg")
#self.canvas.create_image(0,0, image = self.photo)
def getFile(self):
self.fileName = filedialog.askopenfilename(initialdir = "/home/paulina/obrazki",title = "choose your file",filetypes = (("jpeg files","*.jpg"),("all files","*.*")))
self.labelVariable.set(self.fileName)
self.photo = Image.open(self.fileName)
(imageSizeWidth, imageSizeHeight) = self.photo.size
print(imageSizeWidth, imageSizeHeight)
newImageSizeHeight = 400
n = imageSizeHeight/newImageSizeHeight
print(n)
newImageSizeWidth = int(imageSizeWidth/n)
print(newImageSizeWidth, newImageSizeHeight)
self.canvas.config(width=newImageSizeWidth,height=newImageSizeHeight)
self.photo = self.photo.resize((newImageSizeWidth, newImageSizeHeight), Image.ANTIALIAS)
self.photo = ImageTk.PhotoImage(self.photo)
self.canvas.create_image(int(newImageSizeWidth/2), int(newImageSizeHeight/2), image = self.photo)
def crypto(self):
obj = AES.new('This is a key123', AES.MODE_CBC, 'This is an IV456')
message = "The answer is no"
ciphertext = obj.encrypt(message)
print(ciphertext)
obj2 = AES.new('This is a key123', AES.MODE_CBC, 'This is an IV456')
messagedec = obj2.decrypt(ciphertext)
print(messagedec)
def loo_lumi(aken, lume_pilt, kingi_pilt):
"""Create new snow, gifts and make both move with another function."""
lumi = Canvas(aken, bg="Blue", highlightthickness=0, width=20, height=20)
pilt = [lume_pilt, kingi_pilt]
pilt = random.choice(pilt)
positsioon_x = random.randint(0, 780)
lumi.create_image(9, 9, image=pilt)
lumi.pack()
lumi.after(500, loo_lumi, aken, lume_pilt, kingi_pilt)
lumesadu(aken, lumi, positsioon_x, 120)
def demo1():
try:
if sys.version_info[0] == 3:
from tkinter import Tk, Canvas, PhotoImage, NW, SW
else:
from Tkinter import Tk, Canvas, PhotoImage, NW, SW
except ImportError:
Tk = Canvas = None
if Tk:
from pykbool import connect
contour = [(491.1025968497233, 19.886736214605065), (491.1025968497233, 5.524093392945851), (455.34269902086, 5.524093392945851), (455.34269902086, 19.886736214605065), (353.68241805023416, 17.677098857426728), (353.68241805023416, 8.838549428713364), (323.20136228182207, 8.838549428713364), (323.20136228182207, 17.677098857426728), (210.81311196253725, 14.362642821659207), (210.81311196253725, 3.3144560357675132), (175.05321413367392, 3.3144560357675132), (175.05321413367392, 14.362642821659207), (73.22264793529162, 14.362642821659207), (73.22264793529162, 10.0), (34.05704555129843, 10.0), (32.18390804597701, 110.48186785891704), (10.0, 110.48186785891704), (10.0, 162.40834575260803), (48.36100468284376, 156.88425235966218), (75.09578544061303, 156.88425235966218), (128.56534695615156, 162.40834575260803), (178.62920391656024, 176.77098857426725), (226.81992337164752, 196.65772478887232), (249.9787143465304, 211.02036761053148), (291.18773946360153, 246.374565325385), (328.65048957002983, 283.9384003974168), (337.5053214133674, 298.30104321907595), (337.5053214133674, 341.3889716840536), (448.1907194550873, 350.22752111276696), (448.1907194550873, 333.6552409339294), (685.7386121753938, 350.22752111276696), (683.8654746700724, 356.856433184302), (771.3920817369094, 364.5901639344262), (774.9680715197957, 318.18777943368104), (767.816091954023, 318.18777943368104), (789.272030651341, 60.765027322404364), (796.4240102171137, 60.765027322404364), (800.0, 8.838549428713364), (757.088122605364, 8.838549428713364), (757.088122605364, 23.20119225037257), (644.6998722860792, 19.886736214605065), (644.6998722860792, 8.838549428713364), (610.8131119625373, 5.524093392945851), (608.9399744572158, 19.886736214605065)]
holea = [(162.62239250744997, 127.0541480377546), (189.35717326521925, 135.89269746646795), (239.42103022562793, 159.09388971684052), (287.6117496807152, 187.81917536015894), (308.8974031502767, 205.49627421758566), (348.2332907620264, 246.374565325385), (366.1132396764581, 266.26130153999003), (389.272030651341, 301.6154992548435), (450.0638569604087, 307.13959264778936), (451.7667092379736, 57.45057128663686), (355.38527032779905, 55.24093392945852), (355.38527032779905, 66.28912071535022), (323.20136228182207, 66.28912071535022), (323.20136228182207, 55.24093392945852), (210.81311196253725, 55.24093392945852), (210.81311196253725, 60.765027322404364), (173.35036185610898, 60.765027322404364), (173.35036185610898, 55.24093392945852), (73.22264793529162, 51.926477893691), (71.51979565772669, 116.00596125186286), (107.27969348659005, 119.32041728763039)]
holeb = [(749.9361430395913, 60.765027322404364), (498.254576415496, 57.45057128663686), (494.67858663260967, 294.9865871833085), (566.0280970625798, 301.6154992548435), (566.0280970625798, 292.77694982613014), (591.0600255427842, 292.77694982613014), (589.3571732652192, 303.8251366120218), (730.3533418475947, 315.9781420765027)]
connected_polygon = connect([contour, holea, holeb])
root = Tk()
root.title(string='connect holes to contour / fill resulting polygon')
canvas1 = Canvas(root, width=900, height=415, background='white')
canvas1.pack()
canvas1.create_polygon(contour, outline='blue', fill='')
canvas1.create_text(contour[0], text='C(1)')
canvas1.create_text(contour[20], text='C(i)')
canvas1.create_text(contour[-1], text='C(n)')
canvas1.create_polygon(holea, outline='red', fill='')
canvas1.create_text(holea[0], text='H1(1)')
canvas1.create_text(holea[9], text='H1(i)')
canvas1.create_text(holea[-1], text='H1(n)')
canvas1.create_polygon(holeb, outline='green', fill='')
canvas1.create_text(holeb[0], text='H2(1)')
canvas1.create_text(holeb[2], text='H2(i)')
canvas1.create_text(holeb[-1], text='H2(n)')
canvas1.create_text((10, 350), text='# More info in setup.py\n'
'from pykbool import connect\n'
'contour=[(... , ...) ... ]; hole1=[(... , ...) ... ]; hole2=...\n'
'polygon=connect([contour, hole1, hole2, ...])', anchor=SW)
canvas2 = Canvas(root, width=900, height=415, background='white')
canvas2.pack()
image=PhotoImage(file=os.path.join('data','demo.gif'))
canvas2.create_image((0,0), image=image, anchor=NW)
canvas2.image=image
canvas2.create_polygon(connected_polygon, outline='black', fill='grey')
canvas2.create_text(connected_polygon[0], text='P1')
canvas2.create_text(connected_polygon[62], text='Pi')
canvas2.create_text(connected_polygon[-1], text='Pn')
root.mainloop()
def progress( self ):
o=os.popen("cd {0} && snakemake --dryrun --rerun-incomplete > {0}/Reports/checkpoint".format(self.workpath.get()))
o.close()
F=open("{0}/Reports/checkpoint".format(self.workpath.get()),"r").read()
rules2={}
rules=re.findall(r'rule .+:',F)
for i in rules:
i=re.sub("rule ","",i)
i=re.sub(":","",i)
rules2[i]=0
F=open("{0}/Reports/{1}.dot".format(self.workpath.get(), self.Pipeline.get() ),"r").read()
for i in rules2.keys():
F=re.sub(r'('+i+')(\".+?)\".+?\"',r'\1_pending\2"0.0 0.0 0.0"',F)
# F=re.sub(i,"",F)
G=open("{0}/Reports/{1}-{2}.dot".format(self.workpath.get(),self.Pipeline.get(),"progress"),"w")
G.write(F)
G.close()
o=os.popen("cd {0}/Reports && dot -Tpng -o {0}/Reports/{1}-progress.png {0}/Reports/{1}-progress.dot;convert {0}/Reports/{1}-progress.png {0}/Reports/{1}-progress.gif".format(self.workpath.get(),self.Pipeline.get()))
# tkinter.messagebox.showerror("o",o)
PL=self.Pipeline.get() #pipelineget()
gf=Toplevel()
gf.title("CCBR Pipeliner: {0} Progress Graph".format(PL))
cgf = Canvas(gf,bg="white")
# gff=Frame(cgf,width=300,height=300)
xscrollbar = Scrollbar(gf, orient=HORIZONTAL)
xscrollbar.pack(side = BOTTOM, fill=X )
xscrollbar.config(command=cgf.xview)
yscrollbar = Scrollbar(gf,orient=VERTICAL)
yscrollbar.pack(side = RIGHT, fill=Y )
yscrollbar.config(command=cgf.yview)
cgf.config(xscrollcommand=xscrollbar.set, yscrollcommand=yscrollbar.set)
cgf.config(width=600,height=600)
cgf.pack(expand=1,fill=BOTH,side=RIGHT)
cgf.config(scrollregion=(0,0,1000,5000))
try:
time.sleep(5)
img = PhotoImage(file="{0}/Reports/{1}-progress.gif".format(self.workpath.get(),PL))
except:
time.sleep(5)
img = PhotoImage(file="{0}/Reports/{1}-progress.gif".format(self.workpath.get(),PL))
cgf.create_image(0,0,image=img, anchor="nw")
cgf.image=img
def __init__(self, image, COLORFLAG = False):
self.img = PhotoImage(width = WIDTH, height = HEIGHT)
for row in range(HEIGHT):
for col in range(WIDTH):
num = image[row*WIDTH + col]
if COLORFLAG == True:
kolor = '#%02x%02x%02x' % (num[0], num[1], num[2])
else:
kolor = '#%02x%02x%02x' % (num, num, num)
self.img.put(kolor, (col, row))
c = Canvas(root, width = WIDTH, height = HEIGHT); c.pack()
c.create_image(0, 0, image = self.img, anchor = NW)
printElapsedTime('displayed image')
def loo_pilv(aken, pildi_list, mitu_pilve):
"""Create desired amount of clouds and call out a function to make them move."""
arv = 0
pilve_koht_x = 0
while mitu_pilve != arv:
kiirus = 30
pilt = random.choice(pildi_list)
pilv = Canvas(aken, width=100, height=55, bg="blue", highlightthickness=0)
pilv.create_image(50, 30, image=pilt)
pilv.place(x=pilve_koht_x, y=0)
pilv.pack()
pilve_koht_y = random.randint(0, 85)
liiguta_pilve(pilv, pilve_koht_x, pilve_koht_y, kiirus, aken, pildi_list)
pilve_koht_x += 100
arv += 1
def __init__(self, root, x1, y1, x2, y2):
t = time.time()
self.img = PhotoImage(width=wid, height=hei)
canv = Canvas(root, width = wid, height = hei)
canv.pack()
canv.create_image(0, 0, image = self.img, anchor=NW)
dx = abs(x2-x1)/wid
dy = abs(y2-y1)/hei
#c = complex(-0.8, 0.156)
#c = complex(-0.74543,+0.11301)
#c = complex(-0.1,0.651)
#c = complex(-0.70176,-0.3842)
c = complex(-0.835,-0.2321)
#c = complex(-0.74434, -0.10772)
#c = complex(-0.62772, 0.42193)
y = y1
for j in range(hei):
line = '{'
x = x1
for i in range(wid):
x = x + dx
a = complex(x, y)
for k in range(maxiter):
a = a*a + c
if(abs(a) > blowup):
break
if(k == maxiter-1):
#line += '#%02x%02x%02x ' % (255,255,255)
line += '#%02x%02x%02x ' % (0,0,0)
else:
line += '#%02x%02x%02x ' % color(k)
line += '}'
self.img.put(line, (0, j))
canv.update()
y = y - dy
print(time.time() - t)
def __init__(self, region_list=None, player_list=None, canvas:tk.Canvas=None):
if player_list is None:
# player_list 가 없는 경우에는 자동으로 constant.PLAYER_NO 에 해당하는 만큼 player 를 생성해서 넣는다.
self.__player_list = []
for i in range(constant.PLAYER_NO):
self.__player_list.append(player.Player())
else:
# player_list 가 있는 경우에는 이것을 사용하고 알맞은 플레이어 수로 업데이트한다.
self.__player_list = player_list
constant.PLAYER_NO = len(player_list)
self.__region_list = region_list # 맵에 있는 모든 땅의 정보를 의미한다.
assert len(region_list) == constant.TOTAL_REGIONS
self.__current_turn = 0 # 현재 턴 수
self.__canvas = canvas
self.__dices_list = [dice.Dice(), dice.Dice()]
canvas.create_image(275, 350, anchor=tk.NW, image=self.__dices_list[0])
canvas.create_image(375, 350, anchor=tk.NW, image=self.__dices_list[1])
def __init__(self, root, x1, y1, x2, y2):
t = time.time()
self.img = PhotoImage(width=wid, height=hei)
canv = Canvas(root, width = wid, height = hei)
canv.pack()
canv.create_image(0, 0, image = self.img, anchor=NW)
dx = abs(x2-x1)/wid
dy = abs(y2-y1)/hei
y = y1
for j in range(hei):
line = '{'
x = x1
for i in range(wid):
x = x + dx
c = complex(x, y)
a = 0
for k in range(maxiter):
a = a**2 + c
if(abs(a) > blowup):
break
if(k == maxiter-1):
line += '#%02x%02x%02x ' % (255,255,255)
else:
line += '#%02x%02x%02x ' % color(k)
line += '}'
self.img.put(line, (0, j))
canv.update()
y = y - dy
print(time.time() - t)
def workflow(self):
PL=self.Pipeline.get() #pipelineget()
gf=Toplevel()
#MkaS=os.popen("./makeasnake.py 2>&1 | tee -a "+workpath.get()+"/Reports/makeasnake.log").read()
gf.title("CCBR Pipeliner: "+ PL + " Workflow Graph")
cgf = Canvas(gf,bg="white")
#gff=Frame(cgf,width=300,height=300)
xscrollbar = Scrollbar(gf, orient=HORIZONTAL)
xscrollbar.pack(side = BOTTOM, fill=X )
xscrollbar.config(command=cgf.xview)
yscrollbar = Scrollbar(gf,orient=VERTICAL)
yscrollbar.pack(side = RIGHT, fill=Y )
yscrollbar.config(command=cgf.yview)
cgf.config(xscrollcommand=xscrollbar.set, yscrollcommand=yscrollbar.set)
cgf.config(width=600,height=600)
cgf.pack(expand=1,fill=BOTH,side=RIGHT)
cgf.config(scrollregion=(0,0,5000,20000))
img = PhotoImage(file=self.workpath.get()+"/Reports/"+PL+".gif")
cgf.create_image(0,0,image=img, anchor="nw")
cgf.image=img
def showWaitingTime():
try:
noOfPeople = VarPeople.get() #Get number of people entered in entry field
stallChosen = VarStall.get()
if stallChosen == '':
return messagebox.showerror('ERROR',"Stall not selected/no stall available. \nTry again.\n")
swt=0 #Create variable for stall's waiting time
for item in allStalls_dict:
if stallChosen == item['Name']:
swt = item['Waiting Time']
answer = int(noOfPeople) * int(swt)
#Creates the frame for showing waiting time
frame6 = Toplevel(frame2) #Pop up new frame
frame6.geometry("700x680")
screen6=Canvas(frame6)
screen6.create_image(0,0,image=wallpaper,anchor="nw")
screen6.pack(expand="true",fill="both")
waitingtimeLabel=Label(screen6,
text="Waiting Time for " + stallChosen + " will be: \n" + str(answer) + " minutes",
font=("Comic Sans MS", 15),
bg='gray22',
fg="white")
waitingtimeLabel.place(relx=.5, rely=.5, anchor="center")
destroyButton =Button(screen6,text='Back to Stall Info',
font=("Comic Sans MS", 15),
bg='gray22',
fg="white",
command=lambda:(frame6.destroy()))
screen6.create_window(260, 550, anchor="nw", window=destroyButton)
except:
messagebox.showerror('Invalid number of people',"Invalid number of people entered.\nTry again.\n")
def start_game(event):
btn_start.pack_forget()
empty_frame(frm_error_msg)
try:
dice_num = int(ent_dice_num.get())
except ValueError:
dice_num = 1
for _ in range(dice_num):
num = randrange(1, 7)
img = Image.open('img/' + str(num) + '.png').resize((200, 200))
filename = ImageTk.PhotoImage(img)
canvas = Canvas(master=frm_dice,
height=200,
width=200,
highlightthickness=0)
canvas.image = filename
canvas.configure(background='#212529')
canvas.create_image(0, 0, anchor='nw', image=filename)
canvas.pack(side='left')
btn_repeat.pack(side='left', expand=True)
def splash(self):
'''
'''
root = tk.Tk()
#root.title('Splash')
#root.wm_attributes('-fullscreen','true')
#eliminate the titlebar
root.overrideredirect(1)
image = Image.open("medmatix_tilt.png")
canvas=Canvas(root, height=500, width=500, background='SteelBlue3')
basewidth = 220
wpercent = (basewidth / float(image.size[0]))
hsize = int((float(image.size[1]) * float(wpercent)))
image = image.resize((basewidth, hsize), PIL.Image.ANTIALIAS)
photo = ImageTk.PhotoImage(image)
canvas.create_image(250,250, image=photo)
canvas.create_text(250,161, text='Welcome to', font=('Helvetica', '18', 'italic'))
canvas.create_text(250,200, text='Open Accounting', font=('Helvetica', '32', 'bold italic' ))
canvas.create_text(250,239, text='by Medmatix Analytics', font=('Helvetica', '18', 'italic'))
canvas.grid() #.pack(side = tk.TOP, expand=True, fill=tk.BOTH)
root.mainloop()
def display_mandelbrot():
width = 700
height = 700
window = Tk()
canvas = Canvas(window, width=width, height=height, bg="#ffffff")
canvas.pack()
img = PhotoImage(width=width, height=height)
canvas.create_image((width//2, height//2), image=img, state="normal")
real_range = (-2.25, .75)
imag_range = (-1.5, 1.5)
precision = 0.003
max_iterations = 20
real_to_x_mapper = make_linear_mapper(real_range, (0, width), int_out=True)
imag_to_y_mapper = make_linear_mapper(imag_range, (0, height), int_out=True)
color_mapper = make_color_mapper(max_iterations)
m_set = calc_mandelbrot_for_range(real_range[0], real_range[1], imag_range[0],
imag_range[1], precision, max_iterations)
for item in m_set:
point, result = item
(x, y) = point
x_pixel = real_to_x_mapper(x)
y_pixel = imag_to_y_mapper(y)
(in_mandelbrot_set, z_cur, steps_taken) = result
color = "#000000"
if not in_mandelbrot_set:
color = color_mapper(steps_taken)
print("plotting: {}, {} -> {}".format(x_pixel, y_pixel, color))
img.put(color, (x_pixel, y_pixel))
mainloop()
def fit_center(pil_image):
root = Tk()
w, h = root.winfo_screenwidth(), root.winfo_screenheight()
root.bind("<Escape>", lambda e: (e.widget.withdraw(), e.widget.quit()))
root.after(20000, root.destroy)
canvas = Canvas(root, width=w, height=h, highlightthickness=0)
canvas.pack()
canvas.configure(background='black')
img_width, img_height = pil_image.size
ratio = min(w / img_width, h / img_height)
img_width = int(img_width * ratio)
img_height = int(img_height * ratio)
image = ImageTk.PhotoImage(pil_image)
imagesprite = canvas.create_image(w / 2, h / 2, image=image)
root.mainloop()
def _draw_bounce_block(self, instance: BounceBlock, shape: pymunk.Shape,
view: tk.Canvas, offset: Tuple[int, int]) -> List[int] :
if instance.get_active() :
if time.time() %1<= 0.25:
image = self.load_image2("bounce_block3")
elif time.time() %1 <= 0.5:
image = self.load_image2("bounce_block2")
elif time.time() % 1 <= 0.75:
image = self.load_image2("bounce_block1")
else:
image = self.load_image2("bounce_block2")
else :
image = self.load_image2("bounce_block2")
return [view.create_image(shape.bb.center().x + offset[0], shape.bb.center().y,
image=image, tags="block")]
def __init__(self,
canvas: Canvas,
x,
y,
*,
image,
anchor="center",
tags=tuple()):
self._id = canvas.create_image(x,
y,
image=image,
anchor=anchor,
tags=tags) # , anchor=anchor)
self._canvas: Canvas = canvas
self._image: Union[ImageTk.PhotoImage, PhotoImage] = image
self._anchor = anchor
self._tags = tags
def show_score(self):
# make windows
window1 = Tk()
# create canvass
canvas_one = Canvas(window1, width=1200, height=800, bg='white')
canvas_one.pack()
# create image from PNG and put in position on canvas
score1 = PhotoImage(file=score_to_show)
# score1_large = score1.zoom(2, 2) # zoom 2x
mypart1 = canvas_one.create_image(
600, 400, image=score1) # put in middle of canvas
window1.update()
if not self.running:
window1.destroy()
def __init__(self, image):
super(Threshold, self).__init__()
root = Tk()
root.title("Threshold")
root.geometry("600x600")
root.resizable(0,0)
im = image.apply_threshold()
height, width = im.shape
frame= Frame(root, width = width, height = height, highlightthickness=1,highlightbackground="black")
canvas = Canvas(frame, width = width, height = height)
photo = PIL.ImageTk.PhotoImage(image = PIL.Image.fromarray(im))
image_on_canvas =canvas.create_image(0, 0, image=photo, anchor=NW)
canvas.pack()
frame.pack()
redbutton = Button(root, text = "Next",command=lambda:next(root,image))
redbutton.pack()
root.mainloop()
class Display(Frame):
def __init__(self, parent, width=200, height=100):
Frame.__init__(self, parent)
self.w = width
self.h = height
self.default_image = self.blanktkimage(self.w, self.h)
self.screen = Canvas(self, width=self.w, height=self.h)
self.screen.pack()
self.display = self.screen.create_image(0, 0,
image=self.default_image,
anchor='nw')
self.image = self.default_image
return
def update(self, img):
self.image = self.cv2tk(img, self.w, self.h)
self.screen.itemconfig(self.display,
image=self.image)
return
######################################################################
@staticmethod
def fl2tk(filename, w, h):
img = Image.open(filename)
im = img.resize((int(w), int(h)),
Image.ANTIALIAS)
return ImageTk.PhotoImage(im)
@staticmethod
def cv2tk(img, w, h):
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, (w, h), interpolation=cv2.INTER_AREA)
tk_img = ImageTk.PhotoImage(image=Image.fromarray(img))
return tk_img
@staticmethod
def blanktkimage(w, h):
img = Image.new('RGB', (w, h), color='blue')
return ImageTk.PhotoImage(img)
def __init__(self,
canvas: _tk.Canvas,
x,
y,
*,
image,
anchor="center",
tags=tuple()):
# noinspection PyProtectedMember
self.root = canvas._root()
self._id = canvas.create_image(x,
y,
image=image,
anchor=anchor,
tags=tags) # , anchor=anchor)
self._canvas: _tk.Canvas = canvas
self._image: _t.Union[_PIL.ImageTk.PhotoImage, _tk.PhotoImage] = image
self._anchor = anchor
self._tags = tags
def _draw_coin(self, instance: Player, shape: pymunk.Shape,
view: tk.Canvas, offset: Tuple[int, int]) -> List[int]:
if self._coin_count.get(shape, None) == None:
self._coin_count[shape] = 0
self._coin_speed[shape] = 5
if self._coin_count[shape] <= self._coin_speed[shape]:
image = self.load_image("spr_coin0")
self._coin_count[shape] += 1
elif self._coin_count[shape] <= self._coin_speed[shape] * 2:
image = self.load_image("spr_coin1")
self._coin_count[shape] += 1
else:
image = self.load_image("spr_coin0")
self._coin_count[shape] = 0
return [
view.create_image(shape.bb.center().x + offset[0],
shape.bb.center().y,
image=image,
tags="item")
]
class SpaceSim(object): #
def __init__(self):
self.win = Tk()
self.win.title('Space-Simulator - press q to exit')
self.canvas = Canvas(master=self.win, width='10c',
height='7c', bg='black')
self.canvas.pack()
m1 = PhotoImage(file='data/metgross.gif')
m2 = PhotoImage(file='data/metklein.gif')
o1 = PhotoImage(file='data/portal.gif')
obs = [m1, m2, o1]
self.spobjects = []
for a in range(15): #create 15 objects of random shape and add Threads to list
img=choice(obs)
#img=m1 if randint(1, 2)==1 else m2
id_nr = self.canvas.create_image(50, -50, image=img)
m=SpaceObject(canvas=self.canvas, id_nr=id_nr)
self.spobjects.append(m)
self.win.bind('<KeyPress-q>', self.close)
self.win.bind('<KeyPress-q>', self.close)
# for a in self.canvas.find_all(): #debug
# print(a)
self.win.protocol("WM_DELETE_WINDOW", self.on_closing)
self.win.mainloop()
def on_closing(self): #protocol handler
for m in self.spobjects:
m.stop()
sleep(0.05) #give threads time to close gracefully
self.win.destroy() #destroy GUI
def close(self, event):
for m in self.spobjects:
m.stop()
sleep(0.05) #give threads time to close gracefully
self.win.destroy() #destroy GUI
def rotateImage():
global imagePath
global image
global im
global im_width
global im_height
global im_size
global photo
global canvas
global xscrollbar
global yscrollbar
global t
canvas.destroy()
canvas = Canvas(root,
height=canvasHeight,
width=canvasWidth,
xscrollcommand=xscrollbar.set,
yscrollcommand=yscrollbar.set)
canvas.place(x=canvasxPosition, y=canvasyPosition)
im = Image.open(imagePath.get())
im_width, im_height = im.size
im = im.resize((int(im_width * imageMagnification.get()),
int(im_height * imageMagnification.get())),
Image.ANTIALIAS)
im = im.rotate(-theta.get() * 180 / pi)
photo = ImageTk.PhotoImage(im)
image = canvas.create_image(0, 0, anchor=NW, image=photo)
canvas.grid(row=0, column=0, sticky=N + S + E + W)
canvas.config(scrollregion=canvas.bbox(ALL))
xscrollbar.config(command=canvas.xview)
yscrollbar.config(command=canvas.yview)
print("openImage")
canvas.bind("<Motion>", crop)
canvas.bind("<ButtonPress-1>", printcoord)
canvas.bind('<B1-Motion>', onGrow)
t = 1
global dn
global times
global correct
global direcs
global totalresp
global top
global curd
correct = []
times = []
direcs = []
totalresp = 0
top = tkinter.Tk()
gameboard = Canvas(top, bg = "black", width = 1000, height = 750)
downI = PhotoImage(file = "Down.PNG")
upI = PhotoImage(file = "Up.PNG")
leftI = PhotoImage(file = "Left.PNG")
rightI = PhotoImage(file = "Right.PNG")
cur = 1
curd = 1
dn = 0
arrow = gameboard.create_image(650, 200, anchor= "ne", image = downI)
tdisp = gameboard.create_text(0, 0, anchor = "ne", text = '', fill = 'red')
gameboard.pack()
gameboard.bind_all('<KeyRelease>', kp)
start = time.time()
top.mainloop()
def take_screenshot_crop(path):
pimage = _r.take_screenshot()
_, _, width, height = pimage.getbbox()
displays = _r.get_display_monitors()
leftmost, topmost = 0, 0
for d in displays:
if d[0] < leftmost:
leftmost = d[0]
if d[1] < topmost:
topmost = d[1]
root = Tk() # Creates a Tkinter window
root.overrideredirect(True) # Makes the window borderless
root.geometry("{0}x{1}+{2}+{3}".format(width, height, leftmost, topmost)) # window size = screenshot size
root.config(cursor="crosshair") # Sets the cursor to a crosshair
pimage_tk = ImageTk.PhotoImage(pimage) # Converts the PIL.Image into a Tkinter compatible PhotoImage
can = Canvas(root, width=width, height=height) # Creates a canvas object on the window
can.pack()
can.create_image((0, 0), image=pimage_tk, anchor="nw") # Draws the screenshot onto the canvas
# This class holds some information about the drawn rectangle
class CanInfo:
rect = None
startx, starty = 0, 0
# Stores the starting position of the drawn rectangle in the CanInfo class
def xy(event):
CanInfo.startx, CanInfo.starty = event.x, event.y
# Redraws the rectangle when the cursor has been moved
def capture_motion(event):
can.delete(CanInfo.rect)
CanInfo.rect = can.create_rectangle(CanInfo.startx, CanInfo.starty, event.x, event.y)
# Cancels screen capture
def cancel(event):
if event.keycode == 27: # cancel when pressing ESC
root.destroy()
# Saves the image when the user releases the left mouse button
def save_img(event):
startx, starty = CanInfo.startx, CanInfo.starty
endx, endy = event.x, event.y
# Puts the starting point in the upper left and the ending point in the lower right corner of the rectangle
if startx > endx:
startx, endx = endx, startx
if starty > endy:
starty, endy = endy, starty
crop_image = pimage.crop((startx, starty, endx, endy))
crop_image.save(path, "PNG")
root.destroy() # Closes the Tkinter window
# Binds mouse actions to the functions defined above
can.bind("<KeyPress>", cancel)
can.bind("<Button-1>", xy)
can.bind("<B1-Motion>", capture_motion)
can.bind("<ButtonRelease-1>", save_img)
can.focus_force() # Force focus of capture screen
root.mainloop() # Shows the Tk window and loops until it is closed
##Select Operation Frame.....
opsFrame = LabelFrame(window,text="Select Operation")
opsFrame.grid(row=0,column=2,ipadx=10,ipady=10)
Radiobutton(opsFrame, text=" Backup using Snapshots ", variable=ops, value=1, command=operation).grid(row=0,sticky=W+E+N+S,ipadx=10,ipady=5)
Radiobutton(opsFrame, text=" Recover System ", variable=ops, value=2,command=operation).grid(row=1,sticky=W+E+N+S,ipadx=10,ipady=5)
Radiobutton(opsFrame, text=" System Copy using Snapshots ", variable=ops, value=3,command=operation).grid(row=2,sticky=W+E+N+S,ipadx=10,ipady=5)
print ( "Inside Operation New... ")
##Photo Image embed
canvas = Canvas(window)
canvas.grid(row = 0, column = 3)
photo = PhotoImage(file = 'ps_200.gif')
canvas.create_image(200,130,image=photo)
##Select SID Selection Frame.....
sidFrame = LabelFrame(window,text="Main")
sidFrame.grid(row=1,column=0)
##Label(sidFrame, text=" Select Source SID...").grid(row=0,column=0,columnspan=10)
vSourceSID = StringVar(sidFrame)
vSourceSID.set("Source SID")
sidMenuSource = OptionMenu(sidFrame, vSourceSID, "Source SID","PSD","QSD","DSD")
sidMenuSource.grid(row=0,column=0)
##Label(sidFrame, text=".............").grid(row=0, column=0,columnspan=20,sticky=W)
##Label(sidFrame, text=" Select Target SID...").grid(row=0,column=10)
vTargetSID = StringVar(sidFrame)
def main():
parser = ArgumentParser(prog="YandereLauncher")
parser.add_argument("-d", "--dryrun", help="Don't change anything on the filesystem, just print what's going on", action="store_true")
parser.add_argument("-s", "--cdn", help="Specify a different server URL, with trailing slash")
parser.add_argument("-e", "--skip-extract", help="Skip extraction of zip", action="store_false")
parser.add_argument("-v", "--verbose", help="Print full traceback for all exceptions", action="store_true")
parser.add_argument("--redownload", help="Redownload game files (DELETES ALL DIRECTORIES AND ZIPS MATCHING YandereSim* IN CURRENT DIR)", action="store_true")
parser.add_argument("--gui", help="Show GUI (defaults to true if frozen)", action="store_true")
args = parser.parse_args()
if args.cdn:
global CDN
CDN = args.cdn
if args.dryrun:
global DRYRUN
DRYRUN = True
if args.verbose:
global VERBOSE
VERBOSE = True
if args.redownload:
from glob import glob
for a in glob(os.path.join(ROOT, "YandereSim*")):
if os.path.isdir(a):
rmtree(a)
elif a[-4:] == ".zip":
unlink(a)
if getattr(sys, 'frozen', False) or args.gui:
# init tkinter
root = Tk()
root.title("YandereLauncher")
# background image
with open(path_to("YandereLauncher.gif"), "rb") as f:
photo = PhotoImage(data=base64.encodestring(f.read()))
cv = Canvas(width=635, height=355)
cv.pack(side='top', fill='both', expand='yes')
cv.create_image(0, 0, image=photo, anchor=NW)
def start_game(event):
try:
with open(getcfg()) as f:
Popen(["start", f.read()])
except:
print("You need to run an update")
play = cv.create_rectangle(88, 260, 244, 323, fill="", outline="")
cv.tag_bind(play, "<ButtonPress-1>", start_game)
update = cv.create_rectangle(400, 260, 555, 323, fill="", outline="")
cv.tag_bind(update, "<ButtonPress-1>", lambda event: Thread(target=get_latest_zip))
global GUI_LOGSTR
GUI_LOGSTR = (cv, cv.create_text(166, 199, text="Ready to update...", width=311, justify=CENTER, anchor=NW))
# close = cv.create_rectangle(622, 5, 640, 22, fill="", outline="")
# cv.tag_bind(close, "<ButtonPress-1>", lambda root=root:root.destroy())
root.mainloop()
else:
if get_latest_zip(extract=args.skip_extract):
print("Download was successful")
return 0
else:
print("Download was unsuccessful")
return 1
class Board:
__isWhitesTurn = True
__whiteKing = None
__blackKing = None
#this method initializes the pieces without the GUI components.
def __initPieces(self):
self.__tiles = [0] * 8
for i in range(0, len(self.__tiles)):
self.__tiles[i] = [0] * 8
for j in range(0, len(self.__tiles[i])):
self.__tiles[i][j] = Tile(tx=i, ty=j)
(self.__tiles[0][0]).setOwner(Rook(True))
(self.__tiles[1][0]).setOwner(Knight(True))
(self.__tiles[2][0]).setOwner(Bishop(True))
self.__whiteKing = King(True)
(self.__tiles[3][0]).setOwner(self.__whiteKing)
(self.__tiles[4][0]).setOwner(Queen(True))
(self.__tiles[5][0]).setOwner(Bishop(True))
(self.__tiles[6][0]).setOwner(Knight(True))
(self.__tiles[7][0]).setOwner(Rook(True))
for i in range(0, 8):
(self.__tiles[i][1]).setOwner(Pawn(True))
for i in range(0, 8):
(self.__tiles[i][6]).setOwner(Pawn(False))
(self.__tiles[0][7]).setOwner(Rook(False))
(self.__tiles[1][7]).setOwner(Knight(False))
(self.__tiles[2][7]).setOwner(Bishop(False))
self.__blackKing = King(False)
(self.__tiles[3][7]).setOwner(self.__blackKing)
(self.__tiles[4][7]).setOwner(Queen(False))
(self.__tiles[5][7]).setOwner(Bishop(False))
(self.__tiles[6][7]).setOwner(Knight(False))
(self.__tiles[7][7]).setOwner(Rook(False))
#this method adds the images of the pieces to the GUI board. Not to be used if the Board GUI is not initialized.
def __addPiecestoBoard(self):
self.__images = {}
for i in range(0, numOfRows):
for j in range(0, numOfColumns):
box = i, j
if (not (self.__tiles[i][j]).getOwner() == None):
image = ((self.__tiles[i][j]).getOwner()).getImage(
master=self.__canvas)
image = (image).subsample(self.__scale_h)
(self.__canvas).create_image(
(self.__height / numOfRows) * i + 40 + sideLength,
(self.__width / numOfColumns) * j + 35 + sideLength,
image=image,
tags=str(i) + str(j))
self.__images[(i, j)] = box, image
else:
self.__images[(i, j)] = box, None
self.__canvas.update
#this method initializes the Board GUI and calls the __addPiecestoBoard function.
def __initBoardView(self):
for i in range(0, numOfRows):
self.__canvas.create_rectangle(
0,
i * (self.__height / numOfRows) + sideLength,
sideLength, (i + 1) * (self.__height / numOfRows) + sideLength,
fill="lightgrey")
self.__canvas.create_text(sideLength / 2, (i + 0.5) *
(self.__height / numOfRows) + sideLength,
text=str(i + 1),
font=('Helvetica', 20, 'bold'),
justify='center',
fill='black',
tags="num" + str(i + 1))
for j in range(0, numOfRows):
self.__canvas.create_rectangle(
j * (self.__width / numOfColumns) + sideLength,
0, (j + 1) * (self.__width / numOfColumns) + sideLength,
sideLength,
fill="lightgrey")
self.__canvas.create_text(
(j + 0.5) * (self.__width / numOfColumns) + sideLength,
sideLength / 2,
text=str(chr((numOfRows - 1 - j) + 65)),
font=('Helvetica', 20, 'bold'),
justify='center',
fill='black',
tags="alph" + str(i + 1))
for i in range(0, numOfRows):
for j in range(0, numOfColumns):
if ((i + j) % 2 == 0):
self.__canvas.create_rectangle(
j * (self.__width / numOfColumns) + sideLength,
i * (self.__height / numOfRows) + sideLength,
(j + 1) * (self.__width / numOfColumns) + sideLength,
(i + 1) * (self.__height / numOfRows) + sideLength,
fill="whitesmoke")
else:
self.__canvas.create_rectangle(
j * (self.__width / numOfColumns) + sideLength,
i * (self.__height / numOfRows) + sideLength,
(j + 1) * (self.__width / numOfColumns) + sideLength,
(i + 1) * (self.__height / numOfRows) + sideLength,
fill="dimgrey")
self.__addPiecestoBoard()
self.__canvas.update
#The constructor for the Board object.
def __init__(self, root=None, width=600, height=600):
self.__root = root
self.__width = width
self.__height = height
self.__isWhitesTurn = True
self.__canvas = 0
if (not root == None):
self.__canvas = Canvas(root,
width=width + sideLength,
height=height + sideLength)
else:
self.__root = Tk()
self.__canvas = Canvas(self.__root,
width=width + sideLength,
height=height + sideLength)
self.__canvas.grid(row=0, column=0) # pack(expand = True)
self.__scale_h = 320 / (self.__height / numOfColumns)
self.__scale_h = int(
((self.__scale_h * 10) - ((self.__scale_h * 10) % 10)) / 10)
self.__initPieces()
self.__initBoardView()
#ILLEGAL MOVE
#self.movePiece(2,6,2,2)
#LEGAL MOVE
#self.movePiece(2,6,2,5)
#Clearer implementation to move a piece.
def movePiece(self, xOld, yOld, xNew, yNew):
if (not self.__tiles[xOld][yOld].getOwner() == None):
if (self.__isWhitesTurn == self.__tiles[xOld]
[yOld].getOwner().getIsWhite()):
if (self.isLegalMove(self.__tiles[xOld][yOld],
self.__tiles[xNew][yNew])):
if (not self.isCheckPrevented(xOld, yOld, xNew, yNew)):
return False
self.__tiles[xOld][yOld].getOwner().move(
self.__tiles[xOld][yOld], self.__tiles[xNew][yNew])
self.__isWhitesTurn = not self.__isWhitesTurn
image = ((self.__tiles[xNew][yNew]).getOwner()).getImage(
master=self.__canvas)
image = (image).subsample(self.__scale_h)
self.__images[(xOld,
yOld)] = self.__images[(xOld,
yOld)][0], None
self.__images[(xNew, yNew)] = (xNew, yNew), image
self.__canvas.create_image(
(self.__height / numOfRows) * xNew + 40 + sideLength,
(self.__width / numOfColumns) * yNew + 35 + sideLength,
image=image,
tags=str(xNew) + str(yNew))
self.__canvas.update
return True
elif (not self.__tiles[xNew][yNew].getOwner() == None):
if (self.isLegalCapture(self.__tiles[xOld][yOld],
self.__tiles[xNew][yNew])):
if (not self.isCheckPrevented(xOld, yOld, xNew, yNew)):
return False
self.__tiles[xOld][yOld].getOwner().move(
self.__tiles[xOld][yOld], self.__tiles[xNew][yNew])
self.__isWhitesTurn = not self.__isWhitesTurn
image = ((
self.__tiles[xNew][yNew]).getOwner()).getImage(
master=self.__canvas)
image = (image).subsample(self.__scale_h)
self.__images[(xOld,
yOld)] = self.__images[(xOld,
yOld)][0], None
self.__images[(xNew, yNew)] = (xNew, yNew), image
self.__canvas.create_image(
(self.__height / numOfRows) * xNew + 40 +
sideLength, (self.__width / numOfColumns) * yNew +
35 + sideLength,
image=image,
tags=str(xNew) + str(yNew))
self.__canvas.update
return True
else:
return False
else:
# print("This is not a legal movement.")
raise IllegalMovement()
else:
# print("This is not this player's piece.")
raise NotPlayersPiece()
else:
# print("No piece exists in that tile.")
raise EmptyHeadTile()
def scanPieces(self, isWhite):
tmpList = []
if (isWhite):
self.__whitePieces = []
tmpList = self.__whitePieces
else:
self.__blackPieces = []
tmpList = self.__blackPieces
for i in self.__tiles:
for j in i:
if (j.getOwner().getIsWhite == isWhite):
tmpList.append(j)
def promotePawnAt(self, x, y, typePromote):
if (not self.__tiles[x][y].getOwner() == None):
if (self.__tiles[x][y].getOwner().getIsWhite() ==
self.__isWhitesTurn):
if (self.__tiles[x][y].getOwner().promote(typePromote)):
self.__isWhitesTurn = not self.__isWhitesTurn
image = ((self.__tiles[x][y]).getOwner()).getImage(
master=self.__canvas)
image = (image).subsample(self.__scale_h)
self.__images[(x, y)] = (x, y), image
self.__canvas.create_image(
(self.__height / numOfRows) * x + 40 + sideLength,
(self.__width / numOfColumns) * y + 35 + sideLength,
image=image,
tags=str(x) + str(y))
self.__canvas.update
return True
else:
# print("This is not your piece.")
raise NotPlayersPiece()
else:
# print("You do not have a piece in that tile.")
raise EmptyHeadTile()
def getRoot(self):
return self.__root
def CastleRule(self, isWhite):
if (isWhite):
#kingside castle
if (not self.__whiteKing.getIsMovedBefore() and self.getFirstPiece(
self.__tiles[3][0], -1, 0).getType() == 4
and not self.__tiles[0][0].getIsMovedBefore()):
for i in range(1, 3):
if (self.VHEnemyControl(i, 0)
and self.diagonalEnemyControl(i, 0)):
return False
return True
else:
pass
#queenside castle
def isCheckPrevented(self, xOld, yOld, xNew, yNew):
if (self.isCheck(True) and self.__isWhitesTurn
and not self.isCheck(False)):
self.__tiles[xOld][yOld].getOwner().imagineMove(
self.__tiles[xOld][yOld], self.__tiles[xNew][yNew])
print("White has to prevent Check")
if (self.isCheck(True) and self.__isWhitesTurn
and not self.isCheck(False)):
self.__tiles[xNew][yNew].getOwner().imagineMove(
self.__tiles[xNew][yNew], self.__tiles[xOld][yOld])
return False
self.__tiles[xNew][yNew].getOwner().imagineMove(
self.__tiles[xNew][yNew], self.__tiles[xOld][yOld])
elif (self.isCheck(False) and not self.__isWhitesTurn
and not self.isCheck(True)):
print("Black has to prevent Check")
self.__tiles[xOld][yOld].getOwner().imagineMove(
self.__tiles[xOld][yOld], self.__tiles[xOld][yOld])
if (self.isCheck(False) and not self.__isWhitesTurn
and not self.isCheck(True)):
self.__tiles[xNew][yNew].getOwner().imagineMove(
self.__tiles[xNew][yNew], self.__tiles[xOld][yOld])
return False
self.__tiles[xNew][yNew].getOwner().imagineMove(
self.__tiles[xNew][yNew], self.__tiles[xOld][yOld])
elif (self.isCheck(True) and self.isCheck(False)):
print("Both are check , turn owner won")
elif (not self.isCheck(True) and self.__isWhitesTurn):
self.__tiles[xOld][yOld].getOwner().imagineMove(
self.__tiles[xOld][yOld], self.__tiles[xNew][yNew])
if (self.isCheck(True)):
self.__tiles[xNew][yNew].getOwner().imagineMove(
self.__tiles[xNew][yNew], self.__tiles[xOld][yOld])
return False
self.__tiles[xNew][yNew].getOwner().imagineMove(
self.__tiles[xNew][yNew], self.__tiles[xOld][yOld])
elif (not self.isCheck(False) and not self.__isWhitesTurn):
self.__tiles[xOld][yOld].getOwner().imagineMove(
self.__tiles[xOld][yOld], self.__tiles[xNew][yNew])
if (self.isCheck(False)):
self.__tiles[xNew][yNew].getOwner().imagineMove(
self.__tiles[xNew][yNew], self.__tiles[xOld][yOld])
return False
self.__tiles[xNew][yNew].getOwner().imagineMove(
self.__tiles[xNew][yNew], self.__tiles[xOld][yOld])
return True
def isVerticalPathEmpty(self, headTile, targetTile):
if (targetTile.getX() == headTile.getX()):
start = headTile.getY()
end = targetTile.getY()
if (start > end):
temp = end
end = start
start = temp
start = start + 1
for i in range(start, end):
if not ((self.__tiles[headTile.getX()][i]).getOwner() == None):
return False
return True
return False
def isHorizontalPathEmpty(self, headTile, targetTile):
if (targetTile.getY() == headTile.getY()):
start = headTile.getX()
end = targetTile.getX()
if (start > end):
temp = end
end = start
start = temp
start = start + 1
for i in range(start, end):
if not ((self.__tiles[i][headTile.getY()]).getOwner() == None):
return False
return True
return False
def isDiagonalPathEmpty(self, headTile, targetTile):
dx = targetTile.getX() - headTile.getX()
dy = targetTile.getY() - headTile.getY()
if (dx == dy or dx == -1 * dy):
xVector = int(dx / abs(dx))
yVector = int(dy / abs(dy))
for i in range(1, abs(dx)):
if not ((self.__tiles[headTile.getX() + xVector * i][
headTile.getY() + yVector * i]).getOwner() == None):
return False
return True
return False
def diagonalEnemyControl(self, headTile, isHeadWhite):
x = headTile.getX()
y = headTile.getY()
tmpPiece = None
for dx in range(-1, 2, 2):
for dy in range(-1, 2, 2):
tmpPiece = self.getFirstPiece(headTile, dx, dy)
if not tmpPiece == None:
if (tmpPiece.getIsWhite() != isHeadWhite and
(tmpPiece.getType() == 3 or tmpPiece.getType() == 5 or
(tmpPiece.getType() == 1
and headTile.getDiagonalDistance(
tmpPiece.getTile()) == 1))):
return True
return False
def VHEnemyControl(self, headTile, isHeadWhite):
tmpPiece = None
for i in range(-1, 2, 2):
tmpPiece = self.getFirstPiece(headTile, 0, i)
if not tmpPiece == None:
if (tmpPiece.getIsWhite() != isHeadWhite and
(tmpPiece.getType() == 4 or tmpPiece.getType() == 5)):
return True
tmpPiece = self.getFirstPiece(headTile, i, 0)
if not tmpPiece == None:
if ((tmpPiece.getType() == 4
and tmpPiece.getIsWhite() != isHeadWhite)
or (tmpPiece.getType() == 5
and tmpPiece.getIsWhite() != isHeadWhite)):
return True
return False
def getFirstPiece(self, headTile, xVector, yVector):
x = headTile.getX()
y = headTile.getY()
for i in range(1, 8):
if (x + xVector * i > 7 or y + yVector * i > 7
or x + xVector * i < 0 or y + yVector * i < 0):
return None
if ((self.__tiles[x + xVector * i][y + yVector * i]).getOwner() !=
None):
return (self.__tiles[x + xVector * i][y +
yVector * i]).getOwner()
return None
def knightEnemyControl(self, headTile, isHeadWhite):
x = headTile.getX()
y = headTile.getY()
tmpPiece = None
for dx in range(-2, 3, 1):
for dy in range(-2, 3, 1):
if (dx != 0 and dy != 0 and dx != dy):
if (x + dx >= 0 and x + dx <= 7 and y + dy >= 0
and y + dy <= 7):
tmpPiece = self.__tiles[x + dx][y + dy].getOwner()
if not tmpPiece == None:
if tmpPiece.getType(
) == 2 and tmpPiece.getIsWhite() != isHeadWhite:
return True
return False
def isReverseMove(self, headTile, targetTile):
if (headTile.getOwner().getIsWhite()):
return (((targetTile.getX() - headTile.getX()) >= 0)
and ((targetTile.getY() - headTile.getY()) >= 0))
return (((headTile.getX() - targetTile.getX()) >= 0)
and ((headTile.getY() - targetTile.getY()) >= 0))
def isLegalMove(self, headTile, targetTile):
if (not targetTile.isEmpty()):
return False
piece = headTile.getOwner()
if piece.getType() == 1:
return (piece.isLegalMovement(headTile, targetTile)
and (self.isVerticalPathEmpty(headTile, targetTile))
and self.isReverseMove(headTile, targetTile))
elif piece.getType() == 2:
return (piece.isLegalMovement(headTile, targetTile))
elif piece.getType() == 3:
return (piece.isLegalMovement(headTile, targetTile)
and self.isDiagonalPathEmpty(headTile, targetTile))
elif piece.getType() == 4:
if (piece.isLegalMovement(headTile, targetTile)):
if (headTile.isPathVertical(targetTile)):
return self.isVerticalPathEmpty(headTile, targetTile)
if (headTile.isPathHorizontal(targetTile)):
return self.isHorizontalPathEmpty(headTile, targetTile)
elif piece.getType() == 5:
if (piece.isLegalMovement(headTile, targetTile)):
if (headTile.isPathVertical(targetTile)):
return self.isVerticalPathEmpty(headTile, targetTile)
if (headTile.isPathHorizontal(targetTile)):
return self.isHorizontalPathEmpty(headTile, targetTile)
if (headTile.isPathDiagonal(targetTile)):
return self.isDiagonalPathEmpty(headTile, targetTile)
elif piece.getType() == 6:
return piece.isLegalMovement(headTile, targetTile)
def isCheck(self, isHeadWhite):
if (isHeadWhite):
tile = self.__whiteKing.getTile()
return self.VHEnemyControl(
tile, True) or self.diagonalEnemyControl(
tile, True) or self.knightEnemyControl(tile, True)
else:
tile = self.__blackKing.getTile()
return self.VHEnemyControl(
tile, False) or self.diagonalEnemyControl(
tile, False) or self.knightEnemyControl(tile, False)
return False
def isStaleMate(self):
pass
def isWinCondition(self, isHeadWhite):
tmpPiece = None
if (isHeadWhite):
tmpPiece = self.__whiteKing
else:
tmpPiece = self.__blackKing
if (self.isCheck(isHeadWhite)):
pass
return False
def isLegalCapture(self, headTile, targetTile):
piece = headTile.getOwner()
if piece.getType() == 1:
return (piece.isLegalCapturing(headTile, targetTile)
and self.isReverseMove(headTile, targetTile))
elif piece.getType() == 2:
return (piece.isLegalCapturing(headTile, targetTile))
elif piece.getType() == 3:
return (piece.isLegalCapturing(headTile, targetTile)
and self.isDiagonalPathEmpty(headTile, targetTile))
elif piece.getType() == 4:
if (piece.isLegalCapturing(headTile, targetTile)):
if (headTile.isPathVertical(targetTile)):
return self.isVerticalPathEmpty(headTile, targetTile)
if (headTile.isPathHorizontal(targetTile)):
return self.isHorizontalPathEmpty(headTile, targetTile)
elif piece.getType() == 5:
if (piece.isLegalCapturing(headTile, targetTile)):
if (headTile.isPathVertical(targetTile)):
return self.isVerticalPathEmpty(headTile, targetTile)
if (headTile.isPathHorizontal(targetTile)):
return self.isHorizontalPathEmpty(headTile, targetTile)
if (headTile.isPathDiagonal(targetTile)):
return self.isDiagonalPathEmpty(headTile, targetTile)
elif piece.getType() == 6:
return piece.isLegalCapturing(headTile, targetTile)
def __del__(self):
del self.__width
del self.__height
del self.__canvas
del self.__isWhitesTurn
del self.__tiles
del self.__images
class GameController:
def __init__(self, mode, dinos_per_gen = 10):
#can be either a train or a game
self.mode = mode
self.master = Tk()
self.width = 800
self.height = 800
self.canvas = Canvas(self.master, width=800, height=800, bg='#fff')
self.infoPanel = Frame(self.master, bg='#fff')
self.colisionMonitor = ColisionMonitor(self.master, self.canvas, self.stopGround)
self.dinos = []
self.dinosOnScreen = 0
self.obstacles = []
self.colisionMonitor = None
self.obstacleGenerator = None
self.initialDinoNum = dinos_per_gen
self.game_params = {'distance': 100, 'speed': 25, 'height': 0, 'width': 50}
self.master.bind('<r>', self.restart)
self.scoresCheckPoint = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 80, 110, 140, 200, 250]
self.imgs_pil_ground = [
Image.open("./assets/ground.png"),
Image.open("./assets/ground-1.png")]
self.ground = ImageTk.PhotoImage(self.imgs_pil_ground[0])
self.ground_1 = ImageTk.PhotoImage(self.imgs_pil_ground[1])
# display image on canvas
self.ground_id = self.canvas.create_image(0, 695, image=self.ground, anchor=NW)
self.ground_id_1 = self.canvas.create_image(400, 695, image=self.ground_1, anchor=NW)
self.ground_id_2 = self.canvas.create_image(800, 695, image=self.ground, anchor=NW)
self.ground_animation_id = None
self.interfaceObject = {}
self.score = 0
self.record = 0
try:
general_data = np.load('data/general/game.npy')
self.general_record = general_data[0]
except IOError as err:
self.general_record = 0
np.save('data/general/game.npy', np.array([0]))
self.n_generations = 0
self.game_modes = {
"train": "train",
"game": "game",
"simulation": "simulation"
}
self.nn_elements = {
'neurons': [],
'connections': []
}
def saveGeneralRecord(self):
if(self.general_record<=self.score):
print(self.general_record)
np.save('data/general/game.npy', np.array([self.general_record]))
def prepareInterface(self):
#l1.grid(row = 0, column = 0, sticky = W, pady = 2)
self.infoPanel.pack(fill='x')
speedLabel = Label(self.infoPanel, text="Speed: "+str(self.game_params['speed'])+"/"+str(len(self.scoresCheckPoint)), bg='#fff')
speedLabel.grid(row=0, column=0, pady=10, sticky = W)
self.interfaceObject['speedLabel'] = speedLabel
dinosAlive = Label(self.infoPanel, text="Dinos: "+str(self.initialDinoNum), bg='#fff')
dinosAlive.grid(row=1, column=0, pady=10, sticky = W)
self.interfaceObject['dinosAlive'] = dinosAlive
scoreLabel = Label(self.infoPanel, text="Score: "+str(self.score), bg='#fff')
scoreLabel.grid(row=2, column=0, pady=10, sticky = W)
self.interfaceObject['score'] = scoreLabel
record = Label(self.infoPanel, text="Record: "+str(self.record), bg='#fff')
record.grid(row=0, column=1, padx=20, pady=10, sticky = W)
self.interfaceObject['record'] = record
n_generation = Label(self.infoPanel, text="Generation: "+str(self.n_generations), bg='#fff')
n_generation.grid(row=1, column=1, padx=20, pady=10, sticky = W)
self.interfaceObject['n_generation'] = n_generation
general_record = Label(self.infoPanel, text="General record: "+str(self.general_record), bg='#fff')
general_record.grid(row=2, column=1, padx=20, pady=10, sticky = W)
self.interfaceObject['general_record'] = general_record
weights = np.load('data/brain/best_w.npy')
weights_flatten = weights.flatten()
biases = np.load('data/brain/best_b.npy').flatten()
self.nn_elements = draw_nn(width=self.width, height = self.height, nn_shape=[5, 2], weights = weights, weights_flatten = weights_flatten,biases = biases,
canvas = self.canvas, padding=[50, 10, 400, 300], neuron_size=10)
def animateGround(self):
self.canvas.move(self.ground_id, -9, 0)
self.canvas.move(self.ground_id_1, -9, 0)
self.canvas.move(self.ground_id_2, -9, 0)
#[left top right bottom]
if(self.canvas.coords(self.ground_id)[0]<-400):
self.canvas.move(self.ground_id, 1200, 0)
if(self.canvas.coords(self.ground_id_1)[0]<-400):
self.canvas.move(self.ground_id_1, 1200, 0)
if(self.canvas.coords(self.ground_id_2)[0]<-400):
self.canvas.move(self.ground_id_2, 1200, 0)
self.ground_animation_id = self.canvas.after(20, self.animateGround)
def run(self):
if(self.mode == self.game_modes["game"]):
self.prepareInterface()
self.canvas.pack()
self.prepareGame()
self.animateGround()
mainloop()
elif(self.mode == self.game_modes["train"]):
self.prepareInterface()
self.canvas.pack()
self.prepareTrain()
self.animateGround()
mainloop()
elif(self.mode == self.game_modes["simulation"]):
self.prepareInterface()
self.canvas.pack()
self.prepareSimulation()
self.animateGround()
mainloop()
def decreaseDinos(self):
self.dinosOnScreen-=1
self.colisionMonitor.dinosOnScreen = self.dinosOnScreen
self.updateLabels()
def updateGameParams(self, distance=None, speed=None, height=None, width=None):
if(not distance is None):
self.game_params['distance'] = distance
if(not speed is None):
self.game_params['speed'] = speed
if(not height is None):
self.game_params['height'] = height
if(not width is None):
self.game_params['width'] = width
#print(self.game_params)
def updateLabels(self):
self.interfaceObject['speedLabel'].config(text="Speed: "+str(25 - self.game_params['speed'])+"/"+str(len(self.scoresCheckPoint)))
self.interfaceObject['dinosAlive'].config(text="Dinos: "+str(self.dinosOnScreen)+"/"+str(self.initialDinoNum))
self.interfaceObject['score'].config(text="Score: "+str(self.score))
self.interfaceObject['record'].config(text="Record: "+str(self.record))
self.interfaceObject['n_generation'].config(text="Generation: "+str(self.n_generations))
self.interfaceObject['general_record'].config(text="General record: "+str(self.general_record))
# create game elements
def prepareGame(self):
self.dinos.append(Dino(self.master, self.canvas, DinoBrain(), self.game_params, self.decreaseDinos, mode=self.mode, game_modes=self.game_modes, color="black"))
self.dinos.append(Dino(self.master, self.canvas, DinoBrain(), self.game_params, self.decreaseDinos, mode="train", game_modes=self.game_modes, color="red"))
self.dinos[-1].brain.load()
self.dinosOnScreen = 2
self.obstacleGenerator = ObstacleGenerator(self.master, self.canvas, self.updateGameParams, self.increaseScore)
self.obstacleGenerator.updateObstaclesSpeed(self.game_params['speed'])
self.obstacleGenerator.run()
self.colisionMonitor = ColisionMonitor(self.master, self.canvas, self.stopGround, self.dinos, self.obstacleGenerator.obstacles, self.dinosOnScreen)
self.colisionMonitor.run()
# create train elements
def prepareTrain(self):
for i in range(self.initialDinoNum):
self.dinosOnScreen+=1
dino = Dino(self.master, self.canvas, DinoBrain(), self.game_params, self.decreaseDinos, mode=self.mode, game_modes=self.game_modes)
dino.brain.load()
self.dinos.append(dino)
for dino in self.dinos[1:]:
dino.brain.mutate()
self.obstacleGenerator = ObstacleGenerator(self.master, self.canvas, self.updateGameParams, self.increaseScore)
self.obstacleGenerator.updateObstaclesSpeed(self.game_params['speed'])
self.obstacleGenerator.run()
self.colisionMonitor = ColisionMonitor(self.master, self.canvas, self.stopGround, self.dinos, self.obstacleGenerator.obstacles, self.dinosOnScreen)
self.colisionMonitor.run()
# create simulation elements
def prepareSimulation(self):
for i in range(self.initialDinoNum):
self.dinosOnScreen+=1
dino = Dino(self.master, self.canvas, DinoBrain(), self.game_params, self.decreaseDinos, mode=self.mode, game_modes=self.game_modes)
self.dinos.append(dino)
self.obstacleGenerator = ObstacleGenerator(self.master, self.canvas, self.updateGameParams, self.increaseScore)
self.obstacleGenerator.updateObstaclesSpeed(self.game_params['speed'])
self.obstacleGenerator.run()
self.colisionMonitor = ColisionMonitor(self.master, self.canvas, self.stopGround, self.dinos, self.obstacleGenerator.obstacles, self.dinosOnScreen)
self.colisionMonitor.run()
def stopGround(self):
print("New gen")
if(self.general_record<=self.score):
self.general_record = self.score
np.save('data/general/game.npy', np.array([self.general_record]))
self.n_generations+=1
if(self.record<self.score):
self.record = self.score
self.resetGameParams()
self.canvas.after_cancel(self.ground_animation_id)
brain_index = None
for i, dino in enumerate(self.dinos):
if(dino.best):
brain_index = i
print("best: ", brain_index)
if(self.mode == "train"):
dino.brain.save()
self.obstacleGenerator.updateObstaclesSpeed(self.game_params['speed'])
self.obstacleGenerator.reset()
for i, dino in enumerate(self.dinos):
dino.reset()
if(i != brain_index):
dino.setBrain(self.dinos[brain_index].brain.getClone(True))
for i, dino in enumerate(self.dinos):
dino.game_params = self.game_params
dino.animate()
dino.run()
self.score = 0
self.dinosOnScreen = len(self.dinos)
self.colisionMonitor.dinosOnScreen = self.dinosOnScreen
self.updateLabels()
self.animateGround()
self.colisionMonitor.run()
self.obstacleGenerator.run()
def increaseScore(self, score):
self.score+=score
if(self.score in self.scoresCheckPoint):
self.game_params['speed']-=1
self.obstacleGenerator.updateObstaclesSpeed(self.game_params['speed'])
if(self.score==350 and self.mode == self.game_modes['train']):
for dino in self.dinos:
if(dino.onScreen):
dino.brain.save()
if(self.general_record<self.score):
self.general_record = self.score
self.updateLabels()
def resetGameParams(self):
self.game_params = {'distance': 100, 'speed': 25, 'height': 0, 'width': 50}
def restart(self, event):
for dino in self.dinos:
dino.reset()
self.resetGameParams()
self.animateGround()
self.obstacleGenerator.reset()
self.obstacleGenerator.run()
from PIL import Image, ImageTk
from game.game import Game
from settings import *
tk = Tk()
# Ініціалізація вінка Tkinter
tk.title(GAME_NAME)
tk.resizable(0, 0)
tk.wm_attributes('-topmost', 1)
# Ініціалізація Canvas, на якім ми можемо малювати
canvas = Canvas(tk, width=WIDTH, height=HEIGHT, highlightthickness=0)
bg = ImageTk.PhotoImage(Image.open('backgraund.jpg').resize((WIDTH, HEIGHT)))
canvas.create_image(WIDTH / 2, HEIGHT / 2, image=bg)
canvas.pack()
tk.update()
# Імпортуємо налаштування в словник, розуміючий класом гри
settings = {
'ball_size': BALL_SIZE,
'ball_color': BALL_COLOR,
'puddle_width': PUDDLE_WIDTH,
'puddle_height': PUDDLE_HEIGHT,
'puddle_color': PUDDLE_COLOR,
'score_size': SCORE_SIZE,
'score_color': SCORE_COLOR,
'end_text_size': END_TEXT_SIZE,
'end_text_color': END_TEXT_COLOR
class Visualizer(object):
def __init__(self):
rospy.init_node('visual_mpc_demo')
rospy.loginfo("init node visual mpc demo")
benchmark_name = rospy.get_param('~exp')
self.ndesig = rospy.get_param('~ndesig')
print('ndesig', self.ndesig)
self.base_dir = '/'.join(str.split(base_filepath, '/')[:-2])
cem_exp_dir = self.base_dir + '/experiments/cem_exp/benchmarks_sawyer'
bench_dir = cem_exp_dir + '/' + benchmark_name
if not os.path.exists(bench_dir):
raise ValueError('benchmark directory does not exist')
bench_conf = imp.load_source('mod_hyper', bench_dir + '/mod_hyper.py')
self.policyparams = bench_conf.policy
self.agentparams = bench_conf.agent
hyperparams = imp.load_source('hyperparams', self.policyparams['netconf'])
self.netconf = hyperparams.configuration
dataconf_file = self.base_dir + '/'.join(str.split(self.netconf['data_dir'], '/')[:-1]) + '/conf.py'
self.dataconf = imp.load_source('hyperparams', dataconf_file).configuration
self.num_predictions = 3
self.image_ratio = int((1. / self.dataconf['shrink_before_crop']) / 0.75)
if 'img_height' in self.netconf and 'img_width' in self.netconf:
self.prediction_height = self.netconf['img_height']
self.prediction_width = self.netconf['img_width']
else:
self.prediction_height = 64
self.prediction_width = 64
self.image_height = int(self.prediction_height * self.image_ratio)
self.image_width = int(self.prediction_width * self.image_ratio)
self.canvas_height = self.image_height + 100
self.canvas_width = self.image_width + 100
self.offset_y = (self.canvas_height - self.image_height) / 2
self.offset_x = (self.canvas_width - self.image_width) / 2
self.prediction_ratio = (self.prediction_height * self.image_ratio - 20) / (3. * self.prediction_height)
self.prediction_length = self.netconf['sequence_length'] - 1
# self.ndesig = args.ndesig
self.num_pairs = 0
# self.pairs = []
self.startPixels = []
self.goalPixels = []
self.pixel1, self.pixel2 = None, None
self.selPixels = True
self.receivingPreds = True
self.receivingDistribs = True
self.receivingScores = True
self.colors = ["#f11", "#05f", "#fb0"]
self.bridge = CvBridge()
self.display_publisher = rospy.Publisher('/robot/head_display', Image_msg, queue_size=2)
self.visual_mpc_cmd_publisher = rospy.Publisher('visual_mpc_cmd', numpy_msg(intarray), queue_size=10)
self.visual_mpc_reset_cmd_publisher = rospy.Publisher('visual_mpc_reset_cmd', numpy_msg(intarray), queue_size=10)
rospy.Subscriber("/kinect2/hd/image_color", Image_msg, self.update_image)
rospy.Subscriber('gen_image', numpy_msg(floatarray), self.update_pred_photos)
rospy.Subscriber('gen_pix_distrib', numpy_msg(floatarray), self.update_distrib_photos)
rospy.Subscriber('gen_score', numpy_msg(floatarray), self.update_score_texts)
self.assetsdir = '/'.join(str.split(python_visual_mpc.__file__, '/')[:-1]) + '/sawyer/visual_mpc_rospkg/src/assets'
self.ready_splash = cv2.imread(self.assetsdir + '/mpc_start.png')
self.exec_splash = cv2.imread(self.assetsdir + '/mpc_exec.png')
self.publish_to_head(self.ready_splash)
self.cmap = plt.cm.get_cmap('jet')
self.root = Tk.Tk()
self.root.config(bg="white")
self.left_panel = Frame(self.root)
self.left_panel.grid(row=0, column=0)
self.left_panel.config(bg="white")
self.right_panel = Frame(self.root)
self.right_panel.grid(row=0, column=1)
self.right_panel.config(bg="white")
self.create_widgets()
self.root.mainloop()
def create_widgets(self):
self.canvasPhoto = ImageTk.PhotoImage(Image.new("RGB", (self.image_width, self.image_height), "white"))
self.canvas = Canvas(self.left_panel)
self.canvas.bind("<Button-1>", self.input_pixel)
self.canvas.grid(row=0, column=0, columnspan=3, sticky=tkinter.constants.NSEW)
self.canvas.config(bg="white", width=self.canvas_width, height=self.canvas_height, borderwidth=0, highlightthickness=0)
self.canvasImage = self.canvas.create_image(self.canvas_width / 2, self.canvas_height / 2, image=self.canvasPhoto)
labelPhoto = ImageTk.PhotoImage(Image.open(self.assetsdir + "/label.png"))
self.label = Label(self.right_panel, image=labelPhoto)
self.label.image = labelPhoto
self.label.grid(row=0, column=0, columnspan=2, pady=(50, 0), padx=(0, 50))
self.label.config(bg="white", activebackground="white", borderwidth=0, highlightthickness=0)
self.predictionPhotos = []
self.distributionPhotos = []
self.scoreTexts = []
self.predictions = []
self.distributions = []
self.scores = []
self.emptyImage = Image.new("RGB", (int(self.prediction_width * self.prediction_ratio),
int(self.prediction_height * self.prediction_ratio)), "white")
self.emptyPhoto = ImageTk.PhotoImage(self.emptyImage)
for i in range(self.num_predictions):
predVideo = Label(self.right_panel, image=self.emptyPhoto)
predVideo.image = self.emptyPhoto
predVideo.grid(row=i+1, column=0, padx=(0, 10), pady=(10, 0))
predVideo.config(bg="white")
distributionPhotosCol = []
distributionsCol = []
for j in range(self.ndesig):
distribVideo = Label(self.right_panel, image=self.emptyPhoto)
distribVideo.image = self.emptyPhoto
distribVideo.grid(row=i+1, column=j+1, padx=(0, 10), pady=(10, 0))
distribVideo.config(bg="white")
distributionPhotosCol.append([self.emptyImage])
distributionsCol.append(distribVideo)
score = Label(self.right_panel, text="", font=("Helvetica", 20))
score.grid(row=i+1, column=3, padx=(50, 50), pady=(10, 0))
score.config(bg="white")
self.predictionPhotos.append([self.emptyImage])
self.predictions.append(predVideo)
self.distributionPhotos.append(distributionPhotosCol)
self.distributions.append(distributionsCol)
self.scoreTexts.append("")
self.scores.append(score)
self.predictions[0].grid(pady=(50, 0))
# self.distributions[0].grid(pady=(50, 0))
self.scores[0].grid(pady=(50, 0))
self.predictions[-1].grid(pady=(10, 45))
# self.distributions[-1].grid(pady=(10, 45))
self.scores[-1].grid(pady=(10, 45))
print(len(self.distributions), len(self.distributions[0]))
for j in range(self.ndesig):
self.distributions[0][j].grid(pady=(50, 0))
self.distributions[-1][j].grid(pady=(10, 45))
addPhoto = ImageTk.PhotoImage(Image.open(self.assetsdir + "/add.png"))
self.addButton = Button(self.left_panel, image=addPhoto, command=self.begin_input)
self.addButton.image = addPhoto
self.addButton.grid(column=2, row=1, pady=(0, 50), padx=(0, 50), sticky=tkinter.constants.E)
self.addButton.config(bg="white", activebackground="white", borderwidth=0, highlightthickness=0)
if self.ndesig == 1:
self.addButton.config(state=tkinter.constants.DISABLED)
startPhoto = ImageTk.PhotoImage(Image.open(self.assetsdir + "/start.png"))
self.startButton = Button(self.left_panel, image=startPhoto, command=self.start)
self.startButton.image = startPhoto
self.startButton.grid(column=0, row=1, pady=(0, 50), padx=(50, 0), sticky=tkinter.constants.W)
self.startButton.config(bg="white", activebackground="white", borderwidth=0, highlightthickness=0,
state=tkinter.constants.DISABLED)
resetPhoto = ImageTk.PhotoImage(Image.open(self.assetsdir + "/reset.png"))
self.resetButton = Button(self.left_panel, image=resetPhoto, command=self.reset_demo)
self.resetButton.image = resetPhoto
self.resetButton.grid(column=1, row=1, pady=(0, 50), sticky=tkinter.constants.W)
self.resetButton.config(bg="white", activebackground="white", borderwidth=0, highlightthickness=0)
self.iter = 0
self.video_loop()
def video_loop(self):
self.canvas.itemconfig(self.canvasImage, image=self.canvasPhoto)
self.canvas.copy_image = self.canvasPhoto
self.iter = (self.iter + 1) % len(self.predictionPhotos[0])
for i in range(self.num_predictions):
distributionPhotosCol = []
if len(self.distributionPhotos[i][-1]) < self.prediction_length or len(self.predictionPhotos[i]) < self.prediction_length:
predictionPhoto = self.emptyPhoto
for j in range(self.ndesig):
distributionPhotosCol.append(self.emptyPhoto)
else:
predictionPhoto = ImageTk.PhotoImage(self.predictionPhotos[i][self.iter])
for j in range(self.ndesig):
distributionPhotosCol.append(ImageTk.PhotoImage(self.distributionPhotos[i][j][self.iter]))
self.scores[i].config(text=self.scoreTexts[i])
self.predictions[i].config(image=predictionPhoto)
self.predictions[i].image = predictionPhoto
for j in range(self.ndesig):
self.distributions[i][j].config(image=distributionPhotosCol[j])
self.distributions[i][j].image = distributionPhotosCol[j]
self.root.after(200, self.video_loop)
def start(self):
if self.num_pairs == 0:
print("please select a pair of points")
elif self.pixel1 and not self.pixel2:
print("please select second pixel")
else:
print("starting")
self.visual_mpc_cmd_publisher.publish(np.array(self.startPixels + self.goalPixels, dtype=np.uint32))
self.publish_to_head(self.exec_splash)
def reset_demo(self):
# self.pairs = []
self.startPixels = []
self.goalPixels = []
self.pixel1, self.pixel2 = None, None
self.selPixels = True
self.canvas.delete("points")
self.receivingPreds = True
self.receivingDistribs = True
self.receivingScores = True
self.predictionPhotos = []
self.distributionPhotos = []
self.scoreTexts = []
self.num_pairs = 0
for i in range(self.num_predictions):
self.predictionPhotos.append([self.emptyImage])
distributionPhotosCol = []
for j in range(self.ndesig):
distributionPhotosCol.append([self.emptyImage])
self.distributionPhotos.append(distributionPhotosCol)
self.scoreTexts.append("")
self.scores[i].config(text="")
for i in range(self.num_predictions):
for j in range(self.ndesig):
self.distributions[i][j].config(highlightthickness=0)
self.startButton.config(state=tkinter.constants.DISABLED)
if self.ndesig == 1:
self.addButton.config(state=tkinter.constants.DISABLED)
else:
self.addButton.config(state=tkinter.constants.NORMAL)
self.visual_mpc_reset_cmd_publisher.publish(np.array([1]))
self.publish_to_head(self.ready_splash)
def update_image(self, data):
cv_image = self.bridge.imgmsg_to_cv2(data, "bgr8")
colstart = 180
rowstart = 0
endcol = colstart + 1500
endrow = rowstart + 1500
cv_image = copy.deepcopy(cv_image[rowstart:endrow, colstart:endcol])
cv_image = imutils.rotate_bound(cv_image, 180)
rowstart = self.dataconf['rowstart']
colstart = self.dataconf['colstart']
cv_image = cv_image[rowstart * self.image_ratio : (rowstart + self.prediction_height) * self.image_ratio,
colstart * self.image_ratio : (colstart + self.prediction_width) * self.image_ratio]
cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB)
pil_image = Image.fromarray(cv_image)
self.canvasPhoto = ImageTk.PhotoImage(pil_image)
def update_pred_photos(self, data):
if self.receivingPreds:
self.receivingPreds = False
data = 255 * data.data.reshape((self.num_predictions, self.prediction_length, self.prediction_height,
self.prediction_width, 3))
data = data.astype(np.uint8)
for i in range(self.num_predictions):
tempPhotos = []
for j in range(self.prediction_length):
pil_image = Image.fromarray(data[i, j]).resize([int(self.prediction_width * self.prediction_ratio),
int(self.prediction_height * self.prediction_ratio)],
resample=Image.LANCZOS)
tempPhotos.append(pil_image)
self.predictionPhotos[i] = tempPhotos
else:
self.receivingPreds = True
def update_distrib_photos(self, data):
if self.receivingDistribs:
self.receivingDistribs = False
data = data.data.reshape((self.num_predictions, self.prediction_length, self.num_pairs,
self.prediction_height, self.prediction_width))
for i in range(self.num_predictions):
for j in range(self.ndesig):
tempPhotos = []
for k in range(self.prediction_length):
renormalized_data = data[i, k, j]/np.max(data[i, k, j])
colored_distrib = 255 * self.cmap(np.squeeze(renormalized_data))[:, :, :3]
colored_distrib = colored_distrib.astype(np.uint8)
pil_image = Image.fromarray(colored_distrib).resize([int(self.prediction_width * self.prediction_ratio),
int(self.prediction_height * self.prediction_ratio)],
resample=Image.LANCZOS)
tempPhotos.append(pil_image)
self.distributionPhotos[i][j] = tempPhotos
for i in range(self.num_predictions):
for j in range(self.ndesig):
self.distributions[i][j].config(highlightbackground=self.colors[j], highlightthickness=2)
else:
self.receivingDistribs = True
def update_score_texts(self, data):
if self.receivingScores:
self.receivingScores = False
data = data.data
for i in range(self.num_predictions):
self.scoreTexts[i] = str(data[i])
else:
self.receivingScores = True
def input_pixel(self, event):
if self.selPixels and event.x >= self.offset_x and event.y >= self.offset_y and event.x <= self.offset_x + self.image_width and event.y <= self.offset_y + self.image_height:
x = int(round((self.canvas.canvasx(event.x) - self.offset_x) / self.image_ratio))
y = int(round((self.canvas.canvasy(event.y) - self.offset_y) / self.image_ratio))
if self.pixel1:
self.canvas.create_oval(event.x - 10, event.y - 10, event.x + 10, event.y + 10,
outline=self.colors[self.num_pairs % len(self.colors)],
width=8,
tags="points")
print("pixel 2: ", y, x)
self.pixel2 = [y, x]
# self.selPixels = False
self.goalPixels.extend(self.pixel2)
# self.pairs.extend(self.pixel1)
# self.pairs.extend(self.pixel2)
self.num_pairs += 1
self.pixel1 = None
self.pixel2 = None
if self.num_pairs == self.ndesig:
self.startButton.config(state=tkinter.constants.NORMAL)
self.selPixels = False
else:
self.canvas.create_oval(event.x - 10, event.y - 10, event.x + 10, event.y + 10,
outline=self.colors[self.num_pairs % len(self.colors)],
fill=self.colors[self.num_pairs % len(self.colors)],
width=8,
tags="points")
print("pixel 1: ", y, x)
self.pixel1 = [y, x]
self.startPixels.extend(self.pixel1)
self.startButton.config(state=tkinter.constants.DISABLED)
def begin_input(self):
print("ready for inputs")
# self.selPixels = True
if self.pixel1 and not self.pixel2:
print("please select second pixel")
if self.num_pairs + 1 >= self.ndesig:
self.addButton.config(state=tkinter.constants.DISABLED)
def publish_to_head(self, img):
num_rows, num_cols = img.shape[:2]
rotation_matrix = np.array([[0., 1., 0., ], [-1., 0., 1024., ]])
img = cv2.warpAffine(img, rotation_matrix, (num_rows, num_cols))[:, ::-1, :]
img = np.swapaxes(img, 0, 1)[::-1, ::-1, :]
# I don't know why the transforms above work either
img_message = self.bridge.cv2_to_imgmsg(img)
self.display_publisher.publish(img_message)
class ApplicationUI(tkinter.Frame):
def __init__(self, master = None):
master.minsize(width=550, height=450)
master.maxsize(width=550, height=450)
tkinter.Frame.__init__(self, master)
self.grid()
self.pack()
self.createWidgets()
def createWidgets(self):
self.title = Label(self, text="Image!", font=("Helvetica", 16))
self.title.grid(row=0, column=1, columnspan=2)
self.open_file = Button(self)
self.open_file['text'] = "OPEN"
self.open_file["command"] = self.openfile
self.open_file.grid(row=1, column=0)
self.save_button = Button(self, text='SAVE',
command=self.save_file)
self.save_button.grid(row=1, column=1)
self.canvas = Canvas(self, width=400, height=300)
self.canvas.grid(row=2, column=0, rowspan=5, columnspan=4)
self.convert_grayscale_button= Button(self)
self.convert_grayscale_button['text'] = "Convert to\n grayscale"
self.convert_grayscale_button["command"] = self.convert_grayscale
self.convert_grayscale_button.grid(row=7, column=0)
self.variable = StringVar(self)
self.variable.set("gray")
self.choose_color_menu = OptionMenu(self, self.variable,"gray", "blue", "green", "red")
self.choose_color_menu['text'] = "Choose Color"
self.choose_color_menu.grid(row=7, column=1)
self.color_button = Button(self, text="COLOR", command=self.color_image)
self.color_button.grid(row=7, column=2)
self.quit_button = Button(self, text="QUIT", command=self.quit)
self.quit_button.grid(row=7, column=3)
def openfile(self):
self.filename = askopenfilename()
self.pilImage = Image.open(self.filename)
width, height = self.pilImage.size
rate = 400/width
new_width = 400
new_height = int(height*rate)
print (new_width, new_height)
self.pilImage=self.pilImage.resize((new_width, new_height), Image.ANTIALIAS)
self.image = ImageTk.PhotoImage(self.pilImage)
self.canvas.create_image(250, 200, image=self.image, anchor='center')
def save_file(self):
self.filename=asksaveasfilename()
with open(self.filename, 'wb') as f:
self.backwards.export(f.name, format="png")
def quit(self):
if hasattr(self, 'player'):
os.remove(TEMP_FILE)
root.destroy()
def choose_color(self):
self.color = self.variable.get()
def color_image(self):
if hasattr(self, 'grayImage'):
self.choose_color()
if self.color == 'blue':
color = '#0000FF'
elif self.color == 'red':
color = '#FF0000'
elif self.color == 'green':
color = '#00FF00'
self.coloredImg = ImageOps.colorize(self.grayImage, (0,0,0,0), color)
self.image = ImageTk.PhotoImage(self.coloredImg)
self.canvas.create_image(250, 200, image=self.image, anchor='center')
else:
tkMessageBox.showinfo('Warning', "Convert the file to grayscale first")
def convert_grayscale(self):
self.grayImage = self.pilImage.convert('L')
self.image = ImageTk.PhotoImage(self.grayImage)
self.canvas.create_image(250, 200, image=self.image, anchor='center')
body_landed = None
dist_body_landed = None
closest_body = None
crash = False
center_shiftx = 0
center_shifty = 0
total_shiftx = 0
total_shifty = 0
contact_number = 0
gravity_constant = 6.67384 * (10**-11)
orbital_velocity_text = canvasstat.create_text(155, 100, text=None, font=('Courier', 10))
velocity_text = canvasstat.create_text(80, 150, text=None, font=('Courier', 10))
name_text = canvasstat.create_text(97, 50, text=None, font=('Courier', 10))
logo = PhotoImage(file='logo.gif')
bkgd = PhotoImage(file='bkgd.gif')
canvaslogo.create_image(0, 0, image=logo, anchor='nw')
canvas.create_image(0, 0, image=bkgd, anchor='nw')
class Body:
def __init__(self, canvas, mass, coords, color):
self.canvas = canvas
self.coords = np.array(coords)
self.radius = np.power(mass, 1/3) * .0008
if self.radius < 10:
self.radius = 10
self.velocity = np.zeros(2)
self.mass = mass
self.force = np.zeros(2)
self.acceleration = np.zeros(2)
self.id = canvas.create_oval(self.coords[0] - self.radius, self.coords[1] - self.radius,
#color string table in Photoimage format #RRGGBB
clr=[ ' #%02x%02x%02x' % (int(255*((i/255)**.25)),0,0) for i in range(256)]
clr.append(' #000000') #append the color of the centre as index 256
#calculate mandelbrot x,y coordinates for each screen pixel
xm=[xa + (xb - xa) * kx /x for kx in range(x)]
ym=[ya + (yb - ya) * ky /y for ky in range(y)]
#build the Photoimage string by calling mandel_pixel to index in the color table
return" ".join((("{"+" ".join(clr[mandel_pixel(complex(i,j))] for i in xm))+"}" for j in ym))
#window size
x=640
y=480
#corners of the mandelbrot plan to display
xa = -2.0; xb = 1.0
ya = -1.27; yb = 1.27
#Tkinter window
window = Tk()
canvas = Canvas(window, width = x, height = y, bg = "#000000");canvas.pack()
img = PhotoImage(width = x, height = y)
canvas.create_image((0, 0), image = img, state = "normal", anchor = NW)
#do the mandelbrot
t1=clock()
img.put(mandelbrot(xa,xb,ya,yb,x,y))
print(clock()-t1, ' seconds')
mainloop()
class Game:
gui_amp = 4
FPS = 20
def __init__(self, width, height, block_width, block_height,
*, task_type=TaskType.pick, human_play=False,
np_random=None):
self.width = width
self.height = height
self.block_width = block_width
self.block_height = block_height
self.frame_width = width * block_width
self.frame_height = height * block_height
self.image = Image.new('RGB', (self.frame_width, self.frame_height),
'black')
self.image_shape = (self.frame_height, self.frame_width, 3)
self.draw = ImageDraw.Draw(self.image)
self.state =None
self.first_pick = True
self.task_type = task_type
self.player_pos = None
self.obj_pos = None
self.mark_pos = None
if np_random is None:
np_random = np.random.RandomState()
self.randint = np_random.randint
self.human_play = human_play
if human_play:
self.last_act = None
self.tk = None
def _seed(self, np_random):
self.randint = np_random.randint
def _randpos(self, disables=[]):
pos = (self.randint(self.width), self.randint(self.height))
while pos in disables:
pos = (self.randint(self.width), self.randint(self.height))
return pos
def init(self, show_gui=False):
self.show_gui = show_gui
if show_gui:
if self.tk is not None:
self.tk.destroy()
self.tk = Tk()
self.canvas = Canvas(self.tk,
width=self.frame_width * self.gui_amp,
height=self.frame_height * self.gui_amp)
self.canvas.pack()
self.player_pos = self._randpos()
self.first_pick = True
self.state = State.start
if self.task_type & TaskType.pick:
self.obj_pos = self._randpos()
else:
self.state = State.picked
if self.task_type & TaskType.put:
self.mark_pos = self._randpos([self.obj_pos])
def _get_frame_pos(self, pos):
px = pos[0] * self.block_width + self.block_width // 2
py = pos[1] * self.block_height + self.block_height // 2
return px, py
def step(self, act):
if act is None:
return 0
rew = 0
if act in Movesets:
x, y = self.player_pos
nx, ny = self.player_pos
if act == Action.up:
(nx, ny) = (x, y-1)
elif act == Action.down:
(nx, ny) = (x, y+1)
elif act == Action.left:
(nx, ny) = (x-1, y)
elif act == Action.right:
(nx, ny) = (x+1, y)
real_pos = (
max(0, min(self.width-1, nx)),
max(0, min(self.height-1, ny)),
)
self.player_pos = real_pos
pen = 0 if real_pos == (nx, ny) else -1
rew += pen
elif act == Action.pick and self.state == State.start:
if self.obj_pos == self.player_pos:
self.state = State.picked
if self.first_pick:
self.first_pick = False
rew += 1
if (not self.task_type & TaskType.put):
self.state = State.end
elif act == Action.put and self.state == State.picked:
if self.mark_pos == self.player_pos:
self.state = State.end
rew += 1
else:
self.state = State.start
self.obj_pos = self.player_pos
if self.state == State.end:
rew += 5
return rew
def render(self):
# clear canvas
self.draw.rectangle((0, 0, self.frame_width, self.frame_height),
fill='black')
# draw obj
if self.obj_pos and self.state == State.start:
px, py = self._get_frame_pos(self.obj_pos)
self.draw.rectangle((px - 2, py - 2, px + 2, py + 2), fill='green')
# draw mark
if self.mark_pos:
px, py = self._get_frame_pos(self.mark_pos)
self.draw.rectangle((px - 2, py - 2, px + 2, py + 2), outline='white')
# draw player
px, py = self._get_frame_pos(self.player_pos)
loc = (px - 2, py - 2, px + 2, py + 2)
if self.state == State.picked:
self.draw.ellipse(loc, fill=(0, 255, 255, 0))
else:
self.draw.ellipse(loc, fill='blue')
if self.show_gui:
gui_img = self.image.resize((self.frame_width * self.gui_amp,
self.frame_height * self.gui_amp))
self.pi = ImageTk.PhotoImage(gui_img)
canvas_img = self.canvas.create_image(0, 0, anchor=NW,
image=self.pi)
# self.canvas.create_text((self.width*self.gui_amp-20, 5),
# fill='white', text=str(self.))
if not self.human_play:
self.tk.update()
def get_bitmap(self):
arr = np.array(self.image.getdata()).reshape(self.image_shape)
return arr.astype('float32') / 256.0
def gui_step(self):
if self.last_act is not None:
rew = self.step(self.last_act)
self.last_act = None
else:
rew = self.step(None)
if abs(rew) > 1e-9:
print('Get reward = %.2f' % rew)
self.render()
self.tk.after(1000//self.FPS, self.gui_step)
def gui_start(self):
self.canvas.bind("<Key>", self.gui_onkey)
self.canvas.focus_set()
self.tk.after(1000//self.FPS, self.gui_step)
self.tk.mainloop()
def gui_onkey(self, event):
if event.keycode == 111 or event.keycode == 8320768:
self.last_act = Action.up
elif event.keycode == 116 or event.keycode == 8255233:
self.last_act = Action.down
elif event.keycode == 113 or event.keycode == 8124162:
self.last_act = Action.left
elif event.keycode == 114 or event.keycode == 8189699:
self.last_act = Action.right
elif event.keycode == 53 or event.keycode == 458872:
self.last_act = Action.pick
elif event.keycode == 52 or event.keycode == 393338:
self.last_act = Action.put
class Monitor():
def __init__(self, parent):
# Set up the initial variables/frame stuff
self.parent = parent
self.parent.geometry("378x288")
self.frame = Frame(parent)
self.memory_listener = MemoryListener(self.mem_action)
self.print_listener = PrintListener(self.print_action)
self.width = 378
self.height = 288
self.img = PhotoImage(width=self.width, height=self.height)
self.canvas = None
self.number_of_chars = 0
self.x = 0
self.y = 0
self.initUI()
def draw_text(self, x, y, char):
#Height of each letter is around 10 pixels, so start there. Then their width is 7 pixels-ish, so increase by that much. So yeah.
self.canvas.create_text(x + 10 + (7 * self.number_of_chars), y + 10, text=char, fill="white")
self.number_of_chars += 1
def handle_close(self):
self.memory_listener.unregister()
self.parent.destroy()
def print_action(self, data):
self.draw_text(self.x, self.y, data)
self.x = (self.x + 1)%126
self.y = (self.y + 1)//126
def mem_action(self, data):
address = data[0]
# Video mem starts at 0x8000, and since the monitor is 120x90, and (120*90) = 0x2A30, so 0x8000 + 0x2A30 = 0xAA30
if(address >= 0x8000 and address <= 0xAA30):
pixel = address - 0x8000
color = data[1]
# I don't think I'm getting the RGB values correctly...
# rrrrrrgggggbbbbb
r = (color >> 10) & 0b111111
g = (color >> 5) & 0b11111
b = color & 0b11111
print("[VIDEO]: Pixel,", hex(pixel), "set to,", hex(data[1]), "(#%02x%02x%02x)" % (r,g,b))
#Calculate the x and y. Offset the y by 3, because the border takes up 3 pixels.
x = (pixel%126)*3
y = ((pixel//126)*3)+3
print("********************Y = ", y)
#Update the image with a static pink
#self.img.put("#FF00FF", (x,y))
#Update the image with the given RGB, upscale dat stuff.
#Row 1
self.img.put("#%02x%02x%02x" % (r*4,g*8,b*8), (x, y))
self.img.put("#%02x%02x%02x" % (r*4,g*8,b*8), (x + 1, y))
self.img.put("#%02x%02x%02x" % (r*4,g*8,b*8), (x + 2, y))
#Row 2
self.img.put("#%02x%02x%02x" % (r*4,g*8,b*8), (x, y + 1))
self.img.put("#%02x%02x%02x" % (r*4,g*8,b*8), (x + 1, y + 1))
self.img.put("#%02x%02x%02x" % (r*4,g*8,b*8), (x + 2, y + 1))
#Row 3
self.img.put("#%02x%02x%02x" % (r*4,g*8,b*8), (x, y + 2))
self.img.put("#%02x%02x%02x" % (r*4,g*8,b*8), (x + 1, y + 2))
self.img.put("#%02x%02x%02x" % (r*4,g*8,b*8), (x + 2, y + 2))
def initUI(self):
# Deal with the UI
self.parent.title("Monitor")
self.frame.pack(fill=BOTH, expand=1)
# Now less placeholder-y
self.canvas = Canvas(self.frame, width=self.width, height=self.height, bg="#000")
self.canvas.pack(fill=BOTH, expand=1)
# Need to create an image so we can place individual pixels
self.canvas.create_image((self.width/2, self.height/2), image=self.img, state="normal")
# Handle the closing event (unregister the event listener)
self.parent.protocol("WM_DELETE_WINDOW", self.handle_close)
class Application(object):
def __init__(self):
self.master = Tk()
self.master.geometry(newGeometry = '300x300')
# Fenêtre tkinter
self.menu = Menu(self.master)
self.filemenu = Menu(self.menu,
tearoff = 0)
self.filemenu.add_command(label = "Open", command = self.open)
self.filemenu.add_separator()
self.filemenu.add_command(label = "Exit", command = self.master.destroy)
self.menu.add_cascade(label = "File",
menu = self.filemenu)
self.master.config(menu = self.menu)
# On crée un menu
self.canvas = Canvas(master=self.master,
width=200,
height=200,
bg='#cccccc')
self.canvas.place(x=150,
y=100,
anchor='center')
Label(master=self.master,
text='Image',
font='YuMinchoDemibold',
foreground='white',
background='#535353').place(x=120,
y=190)
def open(self):
self.image_path = askopenfilename(initialdir = os.path.dirname(os.path.join(os.getcwd(), __file__)),
filetypes = (("png files",".png"),
("jpg files",".jpg"),
("all files (risk)", ".")),
defaultextension = ".png",
title = "Open picture file")
# on demande le fichier à ouvrir
if self.image_path == "":
# Si l'utilisateur choisit annuler
return None
else:
pass
self.pyimage = PhotoImage(file = self.image_path)
print(self.image_path)
self.PILimage = pil.open(self.image_path)
if self.PILimage.size[0] > 200 or\
self.PILimage.size[1] > 200:
if self.PILimage.size[0] >= self.PILimage.size[1]:
x = 200
pourcentage = int(((200*100)/self.PILimage.size[0]))
y = self.PILimage.size[1] - (self.PILimage.size[1]* (100 - pourcentage) /100)
else:
y = 200
pourcentage = int(((200 * 100) / self.PILimage.size[1]))
x = self.PILimage.size[0] - (self.PILimage.size[0] * (100 - pourcentage) / 100)
Label(master = self.master,
text = 'Image resized \nfor view ({}%)'.format(pourcentage),
font = 'YuMinchoDemibold 6',
fg = 'black').place(x=190,y=200)
print('cc3')
self.PILimage.resize((int(x),int(y)), pil.BILINEAR).save("tmp.png")
self.pyimage = PhotoImage(file="tmp.png")
os.remove('tmp.png')
# On redimensionne l'image pour la preview
self.image_tag = self.canvas.create_image(100,
100,
anchor = 'center',
image = self.pyimage)
# On affiche l'image
Label(master = self.master,
text = 'Image original size:',
font = 'YuMinchoDemibold 7',
relief = 'groove').place(x = 20, y = 230)
Label(master=self.master,
text='({},{})'.format(self.PILimage.size[0],self.PILimage.size[1]),
font='YuMinchoDemibold 8').place(x=37, y=250)
Label(master=self.master,
text='Choisir taille thumbnail:',
font='YuMinchoDemibold 7',
relief='groove').place(x=140, y=230)
liste_valeurs = (30,50,100)
self.taille_var = IntVar()
self.menu_taille = OptionMenu(self.master,
self.taille_var,
*liste_valeurs)
self.menu_taille.place(x=140, y=250)
Button(master = self.master,
text = 'Créer Thumbnail',
font = 'YuMinchoDemibold 8',
command = self.create_thumbnail).place(x=300,y=300,anchor='se')
def create_thumbnail(self):
if self.PILimage.size[0] >= self.PILimage.size[1]:
x = self.taille_var.get()
pourcentage = int(((x*100)/self.PILimage.size[0]))
y = int(self.PILimage.size[1] - (self.PILimage.size[1] * (100-pourcentage)/100))
else:
y = self.taille_var.get()
pourcentage = int(((y * 100) / self.PILimage.size[1]))
x = int(self.PILimage.size[0] - (self.PILimage.size[0] * (100-pourcentage)/100))
# On récupère les valeurs
name = self.image_path.split('/')[-1].split(".")
name = name[0] + 'THUMBNAIL.' + name[1]
self.PILimage.resize((x,y),pil.BILINEAR).save(name)
class SearchFrame:
def __init__(self, logicManger, root):
self.logicManager = logicManger
# images setup
self.backgroundImg = None
self.connectImg = None
self.backImg = None
self.initPictures()
# frame setup
self.frame = None
self.clients_list = None
self.connect_button = None
self.back_button = None
self.timeUpdateMobileList = 1000 # in ms
self.initFrame(root)
def initPictures(self):
self.backgroundImg = getPhoto('\\img\\ConnectScreen.png')
self.connectImg = getPhoto('\\img\\MouseButton.png')
self.backImg = getPhoto('\\img\\BackButton.png')
def initFrame(self, root):
self.frame = Canvas(root, bg=DARK_BLUE)
self.frame.create_image(0, 0, anchor=NW, image=self.backgroundImg)
self.frame.pack(expand="true", fill="both")
padyClients = (200, 0)
padyButtons = 4
padx = (35, 0)
y_grid = 0
y_grid = self.initClients(self.frame, y_grid, padyClients, padx)
self.initButtons(self.frame, y_grid, 0, padx, padyButtons)
self.frame.after(self.timeUpdateMobileList, self.addClient)
def initClients(self, frame, y_grid, pady, padx):
rapper_frame = Frame(frame, bg=GRAY_BLUE)
rapper_frame.grid(row=y_grid,
column=0,
rowspan=1,
columnspan=4,
padx=padx,
pady=pady)
label = Label(rapper_frame,
text='Select your Smartphone',
width=23,
font=("Calibri", 14),
bg=DARK_GRAY_BLUE,
fg=WHITE)
label.pack(side="top")
self.clients_list = Listbox(rapper_frame,
width=25,
height=9,
bd=0,
font=("Calibri", 12))
# set the listbox contains func
self.clients_list.contains = lambda x: x in self.clients_list.get(
0, "end")
self.clients_list.pack(side="left", fill="y", padx=(2, 0), pady=2)
scrollbar = Scrollbar(rapper_frame, orient="vertical")
scrollbar.config(command=self.clients_list.yview)
scrollbar.pack(side="right", fill="y", padx=(0, 2), pady=2)
self.clients_list.config(yscrollcommand=scrollbar.set)
return y_grid + 1
def initButtons(self, frame, y_grid, x_grid, padx, pady):
self.connect_button = Button(frame,
image=self.connectImg,
bg=GRAY,
font=SMALL_BUTTON_FONT)
self.connect_button.grid(row=y_grid,
column=x_grid,
rowspan=1,
padx=padx,
pady=pady)
x_grid = x_grid + 3
self.back_button = Button(frame,
image=self.backImg,
bg=GRAY,
font=SMALL_BUTTON_FONT)
self.back_button.grid(row=y_grid,
column=x_grid,
rowspan=1,
padx=5,
pady=pady)
def setBackButtonFunction(self, func):
self.back_button["command"] = func
def setConnectionSelectFunction(self, func):
def select():
index = self.clients_list.curselection()
connection = self.clients_list.get(index)
# empty tuple whike return false
if connection:
func(connection)
self.connect_button["command"] = select
def addClient(self):
connections = self.logicManager.getConnections()
for connection in connections.values():
if not self.clients_list.contains(connection):
index = self.clients_list.size()
self.clients_list.insert(index, str(connection))
self.frame.after(self.timeUpdateMobileList, self.addClient)
def hideFrame(self):
self.frame.pack_forget()
class Window(Tk):
def __init__(self, game: Game):
Tk.__init__(self)
# for 4k
self.tk.call('tk', 'scaling', '-displayof', '.', 1)
# setup variables
self.game = game
self.is_automoving = False
# create widgets
self.board_canvas = Canvas(self, background="white")
self.control_frame = Frame(self)
self.label_current_player = Label(self.control_frame,
text="Current Player: X")
self.button_next_turn = Button(self.control_frame,
text="Next Turn",
command=self.next_turn)
self.slider_automove_speed = scale = Scale(self.control_frame,
orient='horizontal',
from_=0,
to_=2000)
self.button_toggle_automove = Button(self.control_frame,
text="Start Automove",
command=self.toggle_automove)
self.checkbox_frame = Frame(self.control_frame)
# controls user input
self.user_controlled = []
for pick in ['X', 'A', 'B', 'C', 'D', 'E']:
var = IntVar()
chk = Checkbutton(self.checkbox_frame, text=pick, variable=var)
chk.pack(side=TOP, anchor=N, expand=YES)
self.user_controlled.append(var)
self.text_user_input = Entry(self.control_frame, text="move")
#self.text_user_input.grid(column=0, sticky='N')
drop_down_options = {"taxi", "bus", "underground", "black"}
self.drop_down_selected = StringVar(self.control_frame)
self.drop_down_selected.set("taxi")
self.drop_down_menu = OptionMenu(self.control_frame,
self.drop_down_selected,
*drop_down_options)
#self.drop_down_menu.grid(column=1, sticky='N')
self.button_send_action = Button(self.control_frame,
text="Send",
command=self.send_move)
#self.button_send_action.grid(column=2, sticky='N')
# layout widgets
self.board_canvas.pack(fill='both', expand=True, anchor='w')
self.control_frame.pack(before=self.board_canvas,
side='right',
anchor='e')
self.label_current_player.pack(fill='x')
self.button_next_turn.pack(fill='x')
self.slider_automove_speed.pack(fill='x')
self.button_toggle_automove.pack(fill='x')
Label(self.control_frame, text="\n\n\n").pack(fill='x')
self.checkbox_frame.pack(fill='x', expand=True, anchor='w')
self.text_user_input.pack(fill='y')
self.drop_down_menu.pack(fill='y')
self.button_send_action.pack(fill='y')
# setup canvas
self.board_img_pil = Image.open('board.jpg')
self.board_img = ImageTk.PhotoImage(self.board_img_pil)
self.img_id = self.board_canvas.create_image(300,
300,
image=self.board_img)
# move image on resize
self.bind("<Configure>", self.update_ui)
self.player_colors = [
"black", "red", "yellow", "green", "blue", "purple"
]
#random.shuffle(self.player_colors)
self.old_canvas_size = self.winfo_width(), self.winfo_height()
self.player_rects = [
self.board_canvas.create_rectangle(0,
0,
1,
1,
fill=self.player_colors[i])
for i in range(len(self.game.players))
]
self.player_txts = [
self.board_canvas.create_text(0, 0, text=plr.name)
for plr in self.game.players
]
# create data for node locations on image
self.node_locations = {}
with open("node_locations.txt", "r") as f:
for line in f:
l = line.split(" ")
self.node_locations[int(l[0])] = (float(l[1]), float(l[2]))
def next_turn(self, *_):
try:
# checks if move should be AI made or player-made
if self.user_controlled[self.game.turn].get() == 0:
self.game.next_turn()
self.label_current_player.configure(
text="Current Player: {}".format(self.game.players[
self.game.turn].name))
except:
w, h = self.board_canvas.winfo_width(
), self.board_canvas.winfo_height()
self.board_canvas.create_rectangle(w / 4,
h / 4,
w * 3 / 4,
h * 3 / 4,
fill="red")
self.board_canvas.create_text(w / 2,
h / 2,
text="EXCEPTION OCCURED; CHECK LOG",
font="Helvetica 36")
raise
self.update_ui()
def update_ui(self, *_):
width = self.board_canvas.winfo_width()
height = self.board_canvas.winfo_height()
if self.old_canvas_size != (
width, height): # don't update the image unless we *have* to
self.old_canvas_size = (width, height)
print("Resizing...")
tmp_pil = self.board_img_pil.resize((width, height))
self.board_canvas.delete(self.img_id)
self.board_img = ImageTk.PhotoImage(tmp_pil)
self.img_id = self.board_canvas.create_image(int(width / 2),
int(height / 2),
image=self.board_img)
for i, player in enumerate(self.game.players):
x, y = self.node_locations[player.pos]
x *= width
y *= height
self.board_canvas.coords(self.player_rects[i],
x + width * UNSCALED_RECT_SIZE,
y + width * UNSCALED_RECT_SIZE,
x - width * UNSCALED_RECT_SIZE,
y - width * UNSCALED_RECT_SIZE)
self.board_canvas.coords(self.player_txts[i], x, y)
self.board_canvas.lift(self.player_rects[i])
self.board_canvas.lift(self.player_txts[i])
def toggle_automove(self, *_):
if not self.is_automoving:
self.is_automoving = True
self.automove()
else:
self.is_automoving = False
def automove(self, *_):
if not self.is_automoving:
return
self.next_turn()
if self.slider_automove_speed.get() == 0:
self.board_canvas.update()
self.after(self.slider_automove_speed.get(), self.automove)
#sends user inputted move
def send_move(self, *_):
if self.user_controlled[self.game.turn].get() == 1:
print(self.text_user_input.get())
move = (int(self.text_user_input.get()),
self.drop_down_selected.get()) #should be changed
self.game.next_turn(move)
self.update_ui()
self.label_current_player.configure(
text="Current Player: {}".format(self.game.players[
self.game.turn].name))
class ImageViewer(Frame):
def __init__(self, master=None):
Frame.__init__(self, master=master, bg="gray", width=600, height=400)
self.shown_image = None
self.x = 0
self.y = 0
self.crop_start_x = 0
self.crop_start_y = 0
self.crop_end_x = 0
self.crop_end_y = 0
self.draw_ids = list()
self.rectangle_id = 0
self.ratio = 0
self.canvas = Canvas(self, bg="gray", width=600, height=400)
self.canvas.place(relx=0.5, rely=0.5, anchor=CENTER)
def show_image(self, img=None):
self.clear_canvas()
if img is None:
image = self.master.processed_image.copy()
else:
image = img
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
height, width, channels = image.shape
ratio = height / width
new_width = width
new_height = height
if height > self.winfo_height() or width > self.winfo_width():
if ratio < 1:
new_width = self.winfo_width()
new_height = int(new_width * ratio)
else:
new_height = self.winfo_height()
new_width = int(new_height * (width / height))
self.shown_image = cv2.resize(image, (new_width, new_height))
self.shown_image = ImageTk.PhotoImage(Image.fromarray(
self.shown_image))
self.ratio = height / new_height
self.canvas.config(width=new_width, height=new_height)
self.canvas.create_image(new_width / 2,
new_height / 2,
anchor=CENTER,
image=self.shown_image)
def activate_draw(self):
self.canvas.bind("<ButtonPress>", self.start_draw)
self.canvas.bind("<B1-Motion>", self.draw)
self.master.is_draw_state = True
def activate_crop(self):
self.canvas.bind("<ButtonPress>", self.start_crop)
self.canvas.bind("<B1-Motion>", self.crop)
self.canvas.bind("<ButtonRelease>", self.end_crop)
self.master.is_crop_state = True
def deactivate_draw(self):
self.canvas.unbind("<ButtonPress>")
self.canvas.unbind("<B1-Motion>")
self.master.is_draw_state = False
def deactivate_crop(self):
self.canvas.unbind("<ButtonPress>")
self.canvas.unbind("<B1-Motion>")
self.canvas.unbind("<ButtonRelease>")
self.master.is_crop_state = False
def start_draw(self, event):
self.x = event.x
self.y = event.y
def draw(self, event):
self.draw_ids.append(
self.canvas.create_line(self.x,
self.y,
event.x,
event.y,
width=2,
fill="red",
capstyle=ROUND,
smooth=True))
cv2.line(self.master.processed_image,
(int(self.x * self.ratio), int(self.y * self.ratio)),
(int(event.x * self.ratio), int(event.y * self.ratio)),
(0, 0, 255),
thickness=int(self.ratio * 2),
lineType=8)
self.x = event.x
self.y = event.y
def start_crop(self, event):
self.crop_start_x = event.x
self.crop_start_y = event.y
def crop(self, event):
if self.rectangle_id:
self.canvas.delete(self.rectangle_id)
self.crop_end_x = event.x
self.crop_end_y = event.y
self.rectangle_id = self.canvas.create_rectangle(self.crop_start_x,
self.crop_start_y,
self.crop_end_x,
self.crop_end_y,
width=1)
def end_crop(self, event):
if self.crop_start_x <= self.crop_end_x and self.crop_start_y <= self.crop_end_y:
start_x = int(self.crop_start_x * self.ratio)
start_y = int(self.crop_start_y * self.ratio)
end_x = int(self.crop_end_x * self.ratio)
end_y = int(self.crop_end_y * self.ratio)
elif self.crop_start_x > self.crop_end_x and self.crop_start_y <= self.crop_end_y:
start_x = int(self.crop_end_x * self.ratio)
start_y = int(self.crop_start_y * self.ratio)
end_x = int(self.crop_start_x * self.ratio)
end_y = int(self.crop_end_y * self.ratio)
elif self.crop_start_x <= self.crop_end_x and self.crop_start_y > self.crop_end_y:
start_x = int(self.crop_start_x * self.ratio)
start_y = int(self.crop_end_y * self.ratio)
end_x = int(self.crop_end_x * self.ratio)
end_y = int(self.crop_start_y * self.ratio)
else:
start_x = int(self.crop_end_x * self.ratio)
start_y = int(self.crop_end_y * self.ratio)
end_x = int(self.crop_start_x * self.ratio)
end_y = int(self.crop_start_y * self.ratio)
x = slice(start_x, end_x, 1)
y = slice(start_y, end_y, 1)
self.master.processed_image = self.master.processed_image[y, x]
self.show_image()
def clear_canvas(self):
self.canvas.delete("all")
def clear_draw(self):
self.canvas.delete(self.draw_ids)
coupe = PhotoImage(file='image/coupe.png')
titre = PhotoImage(file='image/titre.png')
images = PhotoImage(file='image/espace5.png')
fonds = Label(fenetre, image=images)
fonds.place(x=-205, y=-300)
canvas = Canvas(fenetre, width=768, height=576, bg="ivory")
fontStyle = tkFont.Font(family="Eras Demi ITC", size=20)
MeilleurScore = Label(fenetre, fg='#FFD700', bg="#404040")
Credit = Label(fenetre, fg="#FFD700", bg='#404040')
Titre = Label(fenetre, image=titre, bg="black")
Titre.place(x=400, y=620)
bg = PhotoImage(file='image/espace3.png')
background = canvas.create_image(370, 250, image=bg)
canvas.pack()
fenetre.attributes('-fullscreen', True)
#---------------------------#
#Création bouton#
#---------------------------#
bouton_quitter = Button(fenetre,
text="Quitter",
bg='#404040',
fg='#0c136d',
command=lambda n=0: son(n))
bouton_play = Button(fenetre,
text="Jouer",
bg='#404040',
"Earrings",
"Blonde hair",
"Ginger hair",
"Beard",
"Big nose",
]
computer_person_choice = r.choice(char_list)
window = Tk()
window.title("Guess Who")
window.geometry("920x800")
window.resizable(False, False)
canvas = Canvas(window, width=920, height=800)
canvas.pack()
img3 = ImageTk.PhotoImage(Image.open("characters2.png"))
canvas.create_image(0, 0, anchor=NW, image=img3)
player_choice_char = StringVar()
input_box1 = Entry(window, textvar=player_choice_char)
choose_person = Label(window,
text="Choose a person:",
font=("arial", 25, "bold"))
canvas.create_window(530, 650, window=input_box1)
canvas.create_window(320, 650, window=choose_person)
choose_person_button = Button(
window,
text="Choose person",
fg="black",
bg="white",
relief="groove",
font=("arial", 30, "bold"),
command=submit_player,
class Renderer(object):
def __init__(self, asset_path="assets/hex-tiles/"):
self.asset_path = asset_path
self.resources = [Wood, Wheat, Brick, Stone, Sheep, Desert]
self.create_window()
self.load_imgs()
#self.draw_img(
# self.hex[Water],
# self.width//2 - hex_width//2, self.height//2 - hex_height//2)
self.draw_hex_tiles()
self.player1_stat = Label(self.root, height=5, width=5)
self.player2_stat = Label(self.root, height=5, width=5)
self.player3_stat = Label(self.root, height=5, width=5)
self.player4_stat = Label(self.root, height=5, width=5)
self.player1_stat.grid(row=0, column=0, padx=0, pady=0)
self.player2_stat.grid(row=0, column=1, padx=0, pady=0)
self.player3_stat.grid(row=0, column=2, padx=0, pady=0)
self.player4_stat.grid(row=0, column=3, padx=0, pady=0)
"""
self.player1_stat.insert(END, "")
self.player2_stat.insert(END, "")
self.player3_stat.insert(END, "")
self.player4_stat.insert(END, "")
"""
self.trade_button = Button(self.root,
text="trade",
command=self.trade,
image=self.trade_icon,
compound=TOP)
self.settlement_button = Button(self.root,
text="build settlement",
command=self.build_settlement,
image=self.settlement_icon,
compound=TOP)
self.road_button = Button(self.root,
text="build road",
command=self.build_road)
self.city_button = Button(self.root,
text="build city",
command=self.build_city,
image=self.city_icon,
compound=TOP)
self.development_button = Button(self.root,
text="buy development card",
command=self.buy_development)
self.end_turn_button = Button(self.root,
text="end turn",
command=self.end_turn)
"""
self.close_button = Button(
self.root,
text="Close",
command=self.root.quit
)
"""
self.trade_button.grid(row=2, column=0, padx=0, pady=0)
self.settlement_button.grid(row=2, column=1, padx=0, pady=0)
self.road_button.grid(row=2, column=2, padx=0, pady=0)
self.city_button.grid(row=2, column=3, padx=0, pady=0)
self.development_button.grid(row=2, column=4, padx=50, pady=0)
self.end_turn_button.grid(row=2, column=5, padx=50, pady=0)
#self.close_button.grid(row = 1, column = 5, padx = 0, pady = 0)
self.root.mainloop()
def create_window(self):
self.root = Tk()
self.root.configure(bg='black')
self.root['bg'] = 'black'
self.width = 3 * self.root.winfo_screenwidth() // 5
self.height = 3 * self.root.winfo_screenheight() // 5
self.root.title("Catan")
self.canvas = Canvas(self.root,
width=self.width,
height=self.height,
highlightthickness=0)
self.canvas.create_rectangle(0,
0,
self.width,
self.height,
fill="lightblue")
self.canvas.grid(row=1, column=0, columnspan=10, padx=0, pady=0)
def draw_img(self, img, x, y):
self.canvas.create_image(x, y, anchor=NW, image=img)
def draw_hex_tiles(self):
centerX = self.width // 2 - self.hex_width // 2
centerY = self.height // 2 - self.hex_height // 2
for i in range(-6, 7):
for j in range(-5, 6):
self.draw_img(
self.hex[Water],
centerX + i * self.hex_width + j * self.hex_width // 2,
centerY + centerY * j // 2.46)
for i in range(-2, 1):
key = random.choice(self.resources)
self.draw_img(
self.hex[key],
centerX + i * self.hex_width + 2 * self.hex_width // 2,
centerY - centerY * 2 // 2.46)
for i in range(-2, 2):
key = random.choice(self.resources)
self.draw_img(
self.hex[key],
centerX + i * self.hex_width + 1 * self.hex_width // 2,
centerY - centerY * 1 // 2.46)
for i in range(-2, 3):
key = random.choice(self.resources)
self.draw_img(self.hex[key], centerX + i * self.hex_width, centerY)
for i in range(-2, 2):
key = random.choice(self.resources)
self.draw_img(
self.hex[key],
centerX + i * self.hex_width + 1 * self.hex_width // 2,
centerY + centerY * 1 // 2.46)
for i in range(-2, 1):
key = random.choice(self.resources)
self.draw_img(
self.hex[key],
centerX + i * self.hex_width + 2 * self.hex_width // 2,
centerY + centerY * 2 // 2.46)
def load_imgs(self):
self.trade_icon = PhotoImage(
file="assets/PNG/Pieces(Black)/pieceBlack.png")
self.settlement_icon = PhotoImage(
file="assets/PNG/Pieces(Black)/settlementBlack.png")
self.city_icon = PhotoImage(
file="assets/PNG/Pieces(Black)/cityBlack2.png")
self.wheat_hex = PhotoImage(file=self.asset_path + "wheatHex.png")
self.stone_hex = PhotoImage(file=self.asset_path + "oreHex.png")
self.sheep_hex = PhotoImage(file=self.asset_path + "sheepHex.png")
self.brick_hex = PhotoImage(file=self.asset_path + "clayHex.png")
self.water_hex = PhotoImage(file=self.asset_path + "waterHex.png")
self.desert_hex = PhotoImage(file=self.asset_path + "desertHex.png")
self.wood_hex = PhotoImage(file=self.asset_path + "woodHex.png")
self.hex_width = self.desert_hex.width()
self.hex_height = self.desert_hex.height()
width = self.width / self.hex_width
height = self.height / self.hex_height
self.wheat_hex = self.wheat_hex.subsample(width, height)
print("scaled image")
self.stone_hex = self.stone_hex.subsample(width, height)
print("scaled image")
self.sheep_hex = self.sheep_hex.subsample(width, height)
print("scaled image")
self.brick_hex = self.brick_hex.subsample(width, height)
print("scaled image")
self.water_hex = self.water_hex.subsample(width, height)
print("scaled image")
self.desert_hex = self.desert_hex.subsample(width, height)
print("scaled image")
self.wood_hex = self.wood_hex.subsample(width, height)
print("scaled image")
self.hex = {
Wood: self.wood_hex,
Stone: self.stone_hex,
Sheep: self.sheep_hex,
Brick: self.brick_hex,
Water: self.water_hex,
Desert: self.desert_hex,
Wheat: self.wheat_hex
}
self.hex_width = self.hex[Desert].width()
self.hex_height = self.hex[Desert].height()
def greet(self):
print("greet")
def trade(self):
print("Clicked Trade!")
def build_road(self):
print("Clicked Build Road!")
def build_settlement(self):
print("Clicked Build Settlement!")
def build_city(self):
print("Clicked Build City!")
def buy_development(self):
print("Clicked Buy Development!")
def end_turn(self):
print("Clicked End Turn!")
class DrawingEngine(Screen):
def __init__(self, window):
super().__init__(window, "gameEngine")
os.environ['SDL_WINDOWID'] = str(self.f.winfo_id())
if platform.system() == "Windows":
os.environ['SDL_VIDEODRIVER'] = 'windib'
self.usePygame = True
self.display = pygame.display.set_mode(
(self.window.width, self.window.height))
self.display.fill((255, 255, 255))
pygame.display.init()
pygame.font.init()
else:
self.usePygame = False
self.canvas = Canvas(self.window.root,
bg="white",
width=self.window.width,
height=self.window.height)
self.canvas.pack(in_=self.f)
self.tkImageList = [
] #images must maintain a reference in order to appear on the canvas
self.scale = self.window.width / 1280
def render(self):
self.scale = self.window.width / 1280
self.window.frameRate.startTimer("clear")
if self.usePygame:
self.display.fill((121, 202, 249))
else:
self.canvas.delete("all")
self.canvas.create_rectangle(0,
0,
self.window.width,
self.window.height,
fill="#%02x%02x%02x" %
(121, 202, 249))
self.tkImageList.clear()
self.window.frameRate.timeChange()
self.showCircles()
self.window.frameRate.startTimer("update")
if self.usePygame:
pygame.display.update()
self.window.root.update(
) #must update while in canvas in pygame but not in tkinter
else:
self.canvas.update()
self.window.frameRate.timeChange()
def showCircles(self):
self.showCircle(self.window.gameEngine.player.radius * self.scale,
(self.getScreenX(self.window.gameEngine.player.x),
self.getScreenY(self.window.gameEngine.player.y)),
self.window.gameEngine.player.color)
for circle in self.window.gameEngine.circleList:
self.showCircle(
circle.radius * self.scale,
(self.getScreenX(circle.x), self.getScreenY(circle.y)),
circle.color)
def showRectangle(self, x1, y1, x2, y2, color, width=0):
if self.usePygame:
pygame.draw.rect(self.display, color,
((x1, y1), (x2 - x1, y2 - y1)))
if width != 0:
pygame.draw.rect(self.display, (0, 0, 0),
((x1, y1), (x2 - x1, y2 - y1)), width)
else:
tk_rgb = "#%02x%02x%02x" % color
self.canvas.create_rectangle(x1,
y1,
x2,
y2,
fill=tk_rgb,
width=width)
def showLine(self, position1, position2, color, width):
if self.usePygame:
pygame.draw.line(self.display, color,
(int(position1[0]), int(position1[1])),
(int(position2[0]), int(position2[1])),
int(width))
else:
tk_rgb = "#%02x%02x%02x" % color
self.canvas.create_line(position1[0],
position1[1],
position2[0],
position2[1],
fill=tk_rgb,
width=width)
def showText(self,
text,
position,
color,
fontName="Times",
fontSize=12,
bold=False,
italic=False,
anchorCenter=False,
shadowWidth=0,
secondaryColor=(0, 0, 0),
outlineWidth=0):
if self.usePygame:
if outlineWidth != 0:
font = pygame.font.SysFont(fontName, fontSize, bold, italic)
screenText = font.render(text, 1, secondaryColor)
if anchorCenter:
textW = screenText.get_width()
textH = screenText.get_height()
else:
textW = 0
textH = 0
for angle in range(0, 361,
int(8 / math.sqrt(outlineWidth)) + 1):
x = outlineWidth * math.sin(angle)
y = outlineWidth * math.cos(angle)
self.display.blit(screenText,
(int(position[0] - textW / 2) + x,
int(position[1] - textH / 2) + y))
elif shadowWidth != 0:
font = pygame.font.SysFont(fontName, fontSize, bold, italic)
screenText = font.render(text, 1, secondaryColor)
if anchorCenter:
textW = screenText.get_width()
textH = screenText.get_height()
else:
textW = 0
textH = 0
for shift in range(shadowWidth):
self.display.blit(screenText,
(int(position[0] - textW / 2) + shift,
int(position[1] - textH / 2)))
font = pygame.font.SysFont(fontName, fontSize, bold, italic)
screenText = font.render(text, 1, color)
if anchorCenter:
textW = screenText.get_width()
textH = screenText.get_height()
else:
textW = 0
textH = 0
self.display.blit(
screenText,
(int(position[0] - textW / 2), int(position[1] - textH / 2)))
else:
tk_rgb = "#%02x%02x%02x" % color
fontString = fontName + " " + str(fontSize)
if bold:
fontString += " bold"
if italic:
fontString += " italic"
if anchorCenter:
if outlineWidth != 0:
secondary_tk_rgb = "#%02x%02x%02x" % secondaryColor
for angle in range(0, 361,
int(8 / math.sqrt(outlineWidth)) + 1):
x = outlineWidth * math.sin(angle)
y = outlineWidth * math.cos(angle)
self.canvas.create_text(position[0] + x,
position[1] + y,
fill=secondary_tk_rgb,
font=fontString,
text=text)
elif shadowWidth != 0:
secondary_tk_rgb = "#%02x%02x%02x" % secondaryColor
for shift in range(shadowWidth):
self.canvas.create_text(position[0] + shift,
position[1],
fill=secondary_tk_rgb,
font=fontString,
text=text)
self.canvas.create_text(position[0],
position[1],
fill=tk_rgb,
font=fontString,
text=text)
else:
if outlineWidth != 0:
secondary_tk_rgb = "#%02x%02x%02x" % secondaryColor
for angle in range(0, 361,
int(8 / math.sqrt(outlineWidth)) + 1):
x = outlineWidth * math.sin(angle)
y = outlineWidth * math.cos(angle)
self.canvas.create_text(position[0] + x,
position[1] + y,
fill=secondary_tk_rgb,
font=fontString,
text=text,
anchor=NW)
elif shadowWidth != 0:
secondary_tk_rgb = "#%02x%02x%02x" % secondaryColor
for shift in range(shadowWidth):
self.canvas.create_text(position[0] + shift,
position[1],
fill=secondary_tk_rgb,
font=fontString,
text=text,
anchor=NW)
self.canvas.create_text(position[0],
position[1],
fill=tk_rgb,
font=fontString,
text=text,
anchor=NW)
def showImage(self, image, position, anchorCenter=False):
if self.usePygame:
if anchorCenter:
imageW = image.get_width()
imageH = image.get_height()
else:
imageW = 0
imageH = 0
self.display.blit(
image,
(int(position[0] - imageW / 2), int(position[1] - imageH / 2)))
else:
image = ImageTk.PhotoImage(image)
self.tkImageList.append(image)
if not anchorCenter:
imageW = image.width()
imageH = image.height()
else:
imageW = 0
imageH = 0
self.canvas.create_image(
(position[0] + imageW / 2, position[1] + imageH / 2),
image=image)
def showPolygon(self, pointList, color, position=(0, 0)):
points = []
for index in range(len(pointList)):
points.append((pointList[index][0] + position[0],
pointList[index][1] + position[1]))
if self.usePygame:
pygame.draw.polygon(self.display, color, points)
pygame.draw.polygon(self.display, (0, 0, 0), points, 2)
else:
tk_rgb = "#%02x%02x%02x" % color
self.canvas.create_polygon(points,
outline='black',
fill=tk_rgb,
width=2)
def showCircle(self, radius, position, color):
try:
if self.usePygame:
pygame.draw.circle(self.display, color,
(int(position[0]), int(position[1])),
int(radius))
pygame.draw.circle(self.display, (0, 0, 0),
(int(position[0]), int(position[1])),
int(radius), 2)
else:
tk_rgb = "#%02x%02x%02x" % color
self.canvas.create_oval(position[0] - radius,
position[1] - radius,
position[0] + radius,
position[1] + radius,
fill=tk_rgb)
except ValueError:
pass
def update(self):
self.f.config(width=self.window.width, height=self.window.width)
if self.usePygame:
self.diplay = pygame.display.set_mode(
(self.window.width, self.window.height))
else:
self.canvas.config(width=self.window.width,
height=self.window.height)
def scaleImage(self, image, scale):
newWidth = image.size[0] * scale
wPercent = (newWidth / float(image.size[0]))
hSize = int((float(image.size[1]) * float(wPercent)))
scaledImage = image.resize((int(newWidth), int(hSize)),
PIL.Image.ANTIALIAS)
return scaledImage
def rotate(self, image, angle):
if self.usePygame:
return pygame.transform.rotate(image, angle)
else:
return self.rotatePIL(image, angle)
def rotatePIL(self, image, angle):
startSize = image.size
imageString = image.convert('RGBA')
rotatedImage = imageString.rotate(angle, expand=0).resize(startSize)
finalImage = Image.new("RGBA", startSize, (255, 255, 255, 0))
finalImage.paste(rotatedImage, (0, 0), rotatedImage)
return finalImage
def convertToDisplayFormat(self, image):
if self.usePygame:
imageBytes = image.convert('RGBA').tobytes("raw", 'RGBA')
convertedImage = pygame.image.fromstring(imageBytes, image.size,
'RGBA')
else:
convertedImage = image
return convertedImage
def manipulateImage(self, image, scale, angle):
scaledImage = self.scaleImage(image, scale)
rotatedImage = self.rotatePIL(scaledImage, angle)
finalImage = self.convertToDisplayFormat(rotatedImage)
return finalImage
def getScreenX(self, x):
return x * self.scale
def getScreenY(self, y):
return (self.window.height - y) * self.scale
y_start = row * SWATCH_SIZE
for x in range(x_start, x_start + SWATCH_SIZE - 1):
for y in range(y_start, y_start + SWATCH_SIZE - 1):
image.put("#%02x%02x%02x" % color, (x, y))
window = Tk()
window.title('Skin & Hair Palette')
canvas = Canvas(window,
width=PALETTE_WIDTH,
height=PALETTE_HEIGHT,
bg='#000000')
canvas.pack()
img = PhotoImage(width=PALETTE_WIDTH, height=PALETTE_HEIGHT)
canvas.create_image((PALETTE_WIDTH // 2, PALETTE_HEIGHT // 2),
image=img,
state='normal')
canvas.image = img # To prevent garbage collection
for scale in (pale_chroma, dark_chroma):
file = PALE_FILE if scale == pale_chroma else DARK_FILE
for row in range(len(hues)):
hue = hues[row]
for value in range(1, 10):
if row != PALETTE_ROWS - 1:
chroma = scale[value]
else:
chroma = 0
column = value - 1
rgb_color = munsell.to_rgb(hue, value, chroma)
paint_swatch(img, row, column, rgb_color)
#création de l'entée et positionnement
commande_joueur = Entry (fenetre , width = 30)
commande_joueur.bind('<Return>' , clavier) #"écoute" le clavier du joueur et execute la fonction clavier
commande_joueur.grid (row = 3 , column = 2 , padx = 10)
#création de du bouton et positionnement
bouton_valider = Button (fenetre , text = "valider la lettre" , bg = "white" , fg = "black" , command = Bouton_Princ )
bouton_valider.grid(row = 4 , column = 1 , columnspan = 2 )
#création du canvas et de la liste d'image positionné dedans et positionnement dans la fenetre
canvas = Canvas ( fenetre , width = 300 , height = 300 , bg = "#3c3e43")
image_pendu = []
for i in range (1,9):
image_pendu.append(PhotoImage(file = "Image_pendu/bonhomme" + str(i) + ".gif")) #créé une liste d'image
image_pendu.reverse() #on l'inverse
affich_image = canvas.create_image(0,0,anchor = 'nw' , image = image_pendu[7] ) #on créé la premiere image
canvas.grid ( row = 1 , column = 3 ,rowspan = 5, padx = 100 , pady = 50 , sticky = 'nesw') #on affiche premiere image et canvas
class LayerManager(ttk.LabelFrame):
def __init__(self, canvas_window, project, *args, **kwargs):
ttk.LabelFrame.__init__(self, *args, **kwargs)
self.project = project
self.canvas_window = canvas_window
self.thumbnails = []
self.tiles = []
self.canvas_height = 700
self.trash_image = load_tk_image_from_bytes_array(trash_bytes)
self.copy_image = load_tk_image_from_bytes_array(copy_bytes_wide)
self.up_image = load_tk_image_from_bytes_array(up_arrow_bytes)
self.down_image = load_tk_image_from_bytes_array(down_arrow_bytes)
self.name_image = load_tk_image_from_bytes_array(name_symbol_bytes)
self.merge_image = load_tk_image_from_bytes_array(
merge_down_symbol_bytes)
self.new_image = load_tk_image_from_bytes_array(plus_symbol_bytes)
self.new_from_image_image = load_tk_image_from_bytes_array(
new_layer_from_image_bytes)
self.up_carret_image = load_tk_image_from_bytes_array(up_carret_bytes)
self.down_carret_image = load_tk_image_from_bytes_array(
down_carret_bytes)
self.nextid = 0
self.configure(text="Frames")
frame_tools_frame = Frame(self)
frame_tools_frame.pack(side="top", fill="x", expand="False")
self.new_frame_symbol = load_tk_image_from_bytes_array(
plus_symbol_bytes)
l = Label(frame_tools_frame, image=self.new_frame_symbol)
l.pack(side="left")
l.bind("<Button-1>", self.new_frame)
self.canvas = Canvas(self, relief="sunken")
self.canvas.config(width=200, height=700, highlightthickness=0)
self.scrollbar = Scrollbar(self)
self.scrollbar.config(command=self.on_scroll_bar)
self.canvas.config(yscrollcommand=self.scrollbar.set)
self.scrollbar.pack(side="right", fill="y")
self.canvas.pack(side="right", expand=True, fill="both")
self.canvas_frame = Frame(self.canvas, border=0, highlightthickness=0)
self.canvas_frame.bind("<MouseWheel>", self._on_mouse_wheel)
self.canvas.create_window(0, 0, window=self.canvas_frame, anchor='nw')
self.canvas.bind("<MouseWheel>", self._on_mouse_wheel)
self.canvas_frame.config(width=200, height=self.winfo_height())
self.canvas.config(scrollregion=(0, 0, 200, self.canvas_height))
self.canvas.bind("<Enter>", self.mouse_enter)
self.canvas.bind("<Leave>", self.mouse_leave)
self.canvas.bind("<Motion>", self.on_mouse_move)
self.canvas.bind("<Button-1>", self.on_click)
self.canvas.after_idle(self.canvas_window.refresh)
self.bind("<MouseWheel>", self._on_mouse_wheel)
def new_frame(self, event=None):
self.project.new_frame()
self.canvas_window.refresh()
def rename_frame(self, frame):
name = simpledialog.askstring(
"Rename Frame",
f"What would you like to rename Frame: {frame.id} to?")
if name:
frame.set_id(name)
self.canvas_window.refresh()
def ask_delete_frame(self):
if len(self.project.frames) == 1:
messagebox.showwarning("Warning", "Cannot delete last frame.")
return
return messagebox.askyesno(
"Delete",
"Are you sure you wish to delete this frame?\nThis cannot be undone."
)
def delete_frame(self, frame):
if self.ask_delete_frame():
self.project.del_frame(frame)
self.project.selected_frame = self.project.frames[0]
self.canvas.after_idle(self.canvas_window.refresh)
def copy_frame(self, frame):
self.project.copy_frame(frame)
self.canvas.after_idle(self.canvas_window.refresh)
def promote_frame(self, frame):
self.project.promote_frame(frame)
self.canvas.after_idle(self.canvas_window.refresh)
def demote_frame(self, frame):
self.project.demote_frame(frame)
self.canvas.after_idle(self.canvas_window.refresh)
def toggle_collapsed(self, frame):
self.project.toggle_collapsed(frame)
self.canvas.after_idle(self.canvas_window.refresh)
def rename_layer(self, frame, layer):
name = simpledialog.askstring(
"Rename Layer",
f"What would you like to rename Layer: {layer.id} to?")
if name:
layer.set_id(name)
self.canvas.after_idle(self.canvas_window.refresh)
def new_layer_from_image(self, frame):
path = filedialog.askopenfilename()
if path:
image = Image.open(path)
layer = frame.new_layer_from_image(image)
self.canvas.after_idle(self.canvas_window.refresh)
def new_layer(self, frame):
layer = frame.new_layer()
frame.selected_layer = layer
self.canvas.after_idle(self.canvas_window.refresh)
def ask_delete_layer(self, frame, layer):
if len(frame.layers) == 1:
messagebox.showwarning("Warning", "Cannot delete last layer.")
return
return messagebox.askyesno(
"Delete Layer?",
f"Are you sure you wish to delete this layer?\n{layer.id}")
def delete_layer(self, frame, layer):
if self.ask_delete_layer(frame, layer):
frame.del_layer(layer)
frame.selected_layer = frame.layers[0]
self.canvas.after_idle(self.canvas_window.refresh)
def copy_layer(self, frame, layer):
frame.copy_layer(layer)
self.canvas.after_idle(self.canvas_window.refresh)
def promote_layer(self, frame, layer):
frame.promote_layer(layer)
self.canvas.after_idle(self.canvas_window.refresh)
def demote_layer(self, frame, layer):
frame.demote_layer(layer)
self.canvas.after_idle(self.canvas_window.refresh)
def merge_layer_down(self, frame, layer):
frame.merge_layer_down(layer)
self.canvas.after_idle(self.canvas_window.refresh)
def mouse_enter(self, event):
pass
def mouse_leave(self, event):
pass
def on_click(self, event):
y = int(event.y + (float(self.canvas.yview()[0]) * self.canvas_height))
x = event.x
for t in self.tiles:
if t.is_in_row(y):
mode = t.on_click(x, y)
if not mode:
t.activate()
if type(t) is FrameTile:
self.project.selected_frame = t.frame
elif type(t) is LayerTile:
self.project.selected_frame = t.frame
t.frame.selected_layer = t.layer
self.canvas_window.refresh()
else:
t.deactivate()
def on_mouse_move(self, event):
y = int(event.y + (float(self.canvas.yview()[0]) * self.canvas_height))
x = event.x
for t in self.tiles:
if t.active:
if t.is_in_row(y): continue
else: t.deactivate()
elif t.is_in_row(y): t.activate()
def refresh(self, event=None):
self.winfo_toplevel().update_idletasks()
self.canvas.delete("all")
self.thumbnails = []
self.tiles = []
if self.project.frames:
i = 0
y_offset = 10
y_padding = 10
tile_height = 80
x = 10
width = 80
height = tile_height
child_offset = 0.5 * tile_height
for f in self.project.frames:
y = i * tile_height + y_offset + i * y_padding
t = FrameTile(self, f)
self.tiles.append(t)
t.set_dimensions(x, y, width, height)
self.place_tile(t)
i += 1
firstlayer = True
layers = []
if f.layers:
if f.collapsed:
continue
for l in f.layers:
floffset = x + 0.5 * child_offset
flyoffset = y + tile_height
if firstlayer:
firstlayer = False
self.canvas.create_line(
floffset, flyoffset, floffset,
flyoffset + y_padding + 0.5 * tile_height)
else:
self.canvas.create_line(
floffset, y + 0.5 * child_offset, floffset,
flyoffset + y_padding + 0.5 * tile_height)
self.canvas.create_line(
floffset,
flyoffset + y_padding + 0.5 * tile_height,
x + child_offset,
flyoffset + y_padding + 0.5 * tile_height,
)
y = i * tile_height + y_offset + i * y_padding
L = LayerTile(self, l, f)
L.set_dimensions(x + child_offset, y, width, height)
self.place_tile(L)
self.tiles.append(L)
i += 1
height = i * (tile_height + y_padding) + y_offset
frameheight = self.canvas_frame.winfo_height()
height = height if height > frameheight else frameheight
self.canvas_height = height
self.canvas_frame.config(width=200, height=self.winfo_height())
self.canvas.config(scrollregion=(0, 0, 200, self.canvas_height))
else:
print("No frames")
def place_tile(self, tile):
tn = ImageTk.PhotoImage(tile.get_thumbnail(tile.height - 8))
self.thumbnails.append(tn)
tile.references.append(
self.canvas.create_image(tile.x + 0.5 * tile.width,
tile.y + 0.5 * tile.height,
image=tn))
if type(tile) is FrameTile:
if tile.frame is self.project.selected_frame:
tile.references.append(
self.canvas.create_rectangle(tile.x,
tile.y,
tile.x + tile.width,
tile.y + tile.height,
outline="#000000",
width=3))
else:
tile.references.append(
self.canvas.create_rectangle(tile.x,
tile.y,
tile.x + tile.width,
tile.y + tile.height,
outline="#000000",
width=1))
elif type(tile) is LayerTile:
if tile.layer is self.project.selected_frame.selected_layer:
tile.references.append(
self.canvas.create_rectangle(tile.x,
tile.y,
tile.x + tile.width,
tile.y + tile.height,
outline="#000000",
width=3))
else:
tile.references.append(
self.canvas.create_rectangle(tile.x,
tile.y,
tile.x + tile.width,
tile.y + tile.height,
outline="#000000",
width=1))
if tile.active: self.activate_tile()
tile.references.append(
self.canvas.create_text(tile.x + tile.width + 10,
tile.y,
font="CourierNew 8",
text=tile.id,
anchor="nw"))
def activate_tile(self, tile):
tile.active_references.extend([
self.canvas.create_image(tile.trash_x,
tile.trash_y,
anchor="nw",
image=self.trash_image),
self.canvas.create_image(tile.copy_x,
tile.copy_y,
anchor="nw",
image=self.copy_image),
self.canvas.create_image(tile.up_x,
tile.up_y,
anchor="nw",
image=self.up_image),
self.canvas.create_image(tile.down_x,
tile.down_y,
anchor="nw",
image=self.down_image),
self.canvas.create_image(tile.name_x,
tile.name_y,
anchor="nw",
image=self.name_image),
])
if type(tile) is FrameTile:
if tile.frame.collapsed: carret_image = self.down_carret_image
else: carret_image = self.up_carret_image
tile.active_references.extend([
self.canvas.create_image(tile.new_x,
tile.new_y,
anchor="nw",
image=self.new_image),
self.canvas.create_image(tile.new_from_image_x,
tile.new_from_image_y,
anchor="nw",
image=self.new_from_image_image),
self.canvas.create_image(tile.carret_x,
tile.carret_y,
anchor="nw",
image=carret_image),
])
elif type(tile) is LayerTile:
tile.active_references.append(
self.canvas.create_image(tile.merge_x,
tile.merge_y,
anchor="nw",
image=self.merge_image))
def deactivate_tile(self, tile):
self.canvas.create_rectangle(tile.x,
tile.y,
tile.x + tile.width,
tile.y + tile.height,
outline="#000000",
width=1)
for r in tile.active_references:
self.canvas.delete(r)
def _on_mouse_wheel(self, event):
if platform.system() == 'Windows':
self.canvas.yview_scroll(-1 * int(event.delta / 120), 'units')
elif platform.system() == 'Darwin':
self.canvas.yview_scroll(-1 * int(event.delta), 'units')
else:
if event.num == 4:
self.canvas.yview_scroll(-1, 'units')
elif event.num == 5:
self.canvas.yview_scroll(1, 'units')
def on_scroll_bar(self, move_type, move_units, __=None):
if move_type == "moveto":
self.canvas.yview("moveto", move_units)
def draw(self, canvas: Canvas):
"""Draws object's picture on given canvas"""
canvas.create_image(self.x - (self.size[0] / 2), \
self.y - (self.size[1] / 2), anchor = NW, image = self.image)
crp_img = ImageTk.PhotoImage(Image.fromarray(crop1))
innercanvas.itemconfig(area, image=crp_img)
label1 = label_list[j]
innercanvas1.itemconfig(area, text=label1)
current_img = cnt[j]
tkimg2 = ImageTk.PhotoImage(resize_img(Image.fromarray(current_img)))
canvas.itemconfig(area, image=tkimg2)
w = tk.Tk()
img = ImageTk.PhotoImage(resize_img(Image.open(path0)))
#frame = Frame(w, ,width = 700, height = 250, bd = 1)
#frame.pack()
w.geometry('900x900')
canvas = Canvas(w, width=c, height=r)
area = canvas.create_image(20, 20, anchor=NW, image=img)
canvas.pack(side=LEFT)
crop = cv2.imread(path0)[:60, :300, :]
crop[crop != 217] = 0
r_c, c_c = crop.shape[:2]
crop = ImageTk.PhotoImage(resize_img(Image.fromarray(crop)))
innercanvas = Canvas(w, width=c_c, height=r_c)
canvas.create_window(350, 200, anchor=NW, window=innercanvas)
innerarea = innercanvas.create_image(0, 0, anchor=NW)
innercanvas.pack(side=LEFT)
innercanvas1 = Canvas(w, width=c_c, height=r_c)
canvas.create_window(650, 200, anchor=NW, window=innercanvas1)
innerarea1 = innercanvas1.create_text(0, 0, anchor=NW)
innercanvas1.pack(side=LEFT)
from tkinter import Tk, Canvas, PhotoImage, mainloop
WIDTH, HEIGHT, ITERATIONS = 400, 400, 400
window = Tk()
canvas = Canvas(window, width=WIDTH, height=HEIGHT, bg="#000000")
canvas.pack()
img = PhotoImage(width=WIDTH, height=HEIGHT)
canvas.create_image((WIDTH/2, HEIGHT/2), image=img, state="normal")
def mandlebrot(c):
z = complex(0,0)
for i in range(ITERATIONS):
z = z*z + c
if (z.real*z.real + z.imag*z.imag) >= 4:
return i
return ITERATIONS
for x in range(WIDTH):
for y in range(HEIGHT):
color = mandlebrot(complex((4*x/WIDTH) - 2.5,(4*y/HEIGHT) - 2))
color = color if color <= 255 else 255
img.put('#%02x%02x%02x' % (color%255,(40*(color//255))%4,10*((40*(color//255))//4)),(x,y))
mainloop()
class ConnectedFrame:
def __init__(self, logicManager, root):
self.logicManger = logicManager
self.deviceName = self.logicManger.getDeviceName()
self.battery = self.logicManger.getBattery()
# images setup
self.backgroundImg = None
self.batteryImg = None
self.logoutImg = None
self.initPictures()
# frame setup
self.frame = None
self.nameLabel = None
self.batteryLabel = None
self.moveLabel = None
self.files_list = None
self.logout_button = None
self.timeUpdate = 1000 # in ms
self.initFrame(root)
def initPictures(self):
self.backgroundImg = getPhoto('\\img\\MainScreen.png')
self.batteryImg = getPhoto('\\img\\battery.png')
self.logoutImg = getPhoto('\\img\\LogoutButton.png')
def initFrame(self, root):
self.frame = Canvas(root, bg=BLACK)
self.frame.create_image(0, 0, anchor=NW, image=self.backgroundImg)
self.frame.pack(expand="true", fill="both")
y_grid = 1
x_grid = 0
pady = (45, 20)
padx = 20
y_grid = self.initHeader(self.frame, y_grid, x_grid, pady, padx)
pady = 0
y_grid = self.initMainBlock(self.frame, y_grid, x_grid, pady, padx)
pady = 15
padx = 10
self.initButton(self.frame, y_grid, pady, padx)
self.frame.after(self.timeUpdate, self.updateFrame)
def initHeader(self, frame, y_grid, x_grid, pady, padx):
rapper_frame = Frame(frame, bg=WHITE)
inner_frame = Frame(rapper_frame, bg=DARK_GRAY_BLUE, height=100)
inner_frame.pack()
devicename = self.deviceName
if devicename is not None and len(devicename) > 12:
devicename = devicename[0:14] + '\n' + devicename[14:]
self.nameLabel = Label(inner_frame,
text=devicename,
width=16,
font=DEVICE_HEADER_FONT,
bg=DARK_GRAY_BLUE,
fg=WHITE)
self.nameLabel.grid(row=0, column=0)
battery = str(self.battery) + '% '
self.batteryLabel = Label(inner_frame,
text=battery,
width=85,
font=BATTERY_HEADER_FONT,
bg=DARK_GRAY_BLUE,
image=self.batteryImg,
fg=BLACK,
compound="center")
self.batteryLabel.grid(row=0, column=1, padx=(15, 0))
rapper_frame.grid(row=y_grid,
column=x_grid,
rowspan=1,
columnspan=1,
padx=padx,
pady=pady)
return y_grid + 1
def initMainBlock(self, frame, y_grid, x_grid, pady, padx):
rapper_frame = Frame(frame, bg=WHITY_BLUE)
rapper_frame.grid(row=y_grid, column=x_grid, rowspan=1, columnspan=2)
self.initMouseMovementView(rapper_frame, y_grid, 0, pady, padx)
self.initFilesView(rapper_frame, y_grid + 1, 0, pady, 0)
return y_grid + 2
def initMouseMovementView(self, frame, y_grid, x_grid, pady, padx):
inner_frame = Frame(frame, bg=WHITY_BLUE)
inner_frame.grid(row=y_grid,
column=x_grid,
rowspan=1,
columnspan=1,
padx=(4, 11))
label = Label(inner_frame,
text='Last Mouse Move:',
width=18,
font=BATTERY_HEADER_FONT,
bg=DARK_GRAY_BLUE,
fg=WHITE)
label.pack(side="left")
self.moveLabel = Label(inner_frame,
text='',
width=7,
font=BATTERY_HEADER_FONT,
bg=WHITY_BLUE,
fg=BLACK)
self.moveLabel.pack(side="right")
return y_grid + 2
def initFilesView(self, frame, y_grid, x_grid, pady, padx):
inner_frame = Frame(frame, bg=BLACK)
inner_frame.grid(row=y_grid,
column=x_grid,
rowspan=2,
columnspan=2,
padx=padx,
pady=pady)
title = Label(inner_frame,
text='Recived Files:',
width=26,
font=BATTERY_HEADER_FONT,
bg=DARK_GRAY_BLUE,
fg=WHITE)
title.pack()
def open(event):
file = self.files_list.curselection()
file = self.files_list.get(file)
self.logicManger.openFile(file)
self.files_list = Listbox(inner_frame,
bd=0,
font=LISTBOX_FONT,
width=29,
height=10)
self.files_list.pack(side="left", fill="y", padx=(1, 0), pady=1)
self.files_list.contains = lambda x: x in self.files_list.get(0, "end")
self.files_list.bind('<Double-1>', open)
scrollbar = Scrollbar(inner_frame, orient="vertical")
scrollbar.config(command=self.files_list)
scrollbar.pack(side="right", fill="y", padx=(0, 2), pady=1)
self.files_list.config(yscrollcommand=scrollbar.set)
return y_grid + 2
def initButton(self, frame, y_grid, pady, padx):
rapper_frame = Frame(frame, bg=WHITE)
self.logout_button = Button(rapper_frame,
image=self.logoutImg,
bg=GRAY,
font=SMALL_BUTTON_FONT)
self.logout_button.pack(anchor=E)
rapper_frame.grid(row=y_grid, column=0, columnspan=2, pady=pady)
def setLogoutButtonFunction(self, func):
self.logout_button["command"] = func
def hideFrame(self):
self.frame.pack_forget()
def updateFrame(self):
self.getFiles()
self.getDirection()
self.getBattery()
self.frame.after(self.timeUpdate, self.updateFrame)
def getFiles(self):
files = self.logicManger.getFiles()
for file in files:
if not self.files_list.contains(file):
name = self.logicManger.getFileName(file)
arr = name.split('.')
print('name recived ', name)
path = filedialog.asksaveasfilename(initialfile=name,
filetypes=[(arr[-1],
'*.' + arr[-1])
])
arr_p = path.split('/')
if name != arr_p[-1]:
path += '.' + arr[-1]
self.logicManger.saveFileWithPath(file, path)
index = self.files_list.size()
self.files_list.insert(index, file)
def getDirection(self):
direction = self.logicManger.getDirection()
self.moveLabel['text'] = direction
def getBattery(self):
battery = self.logicManger.getBattery()
battery = str(battery) + '% '
self.batteryLabel['text'] = battery
class gui_view_tk(Tkinter.Tk):
"""
Class to manage the display of a saved text based
grid map in a GUI - useful for large grids
Grid text sample is below:
..#......2#XXXXX.............X.X......X.
..#......A#XXXX.............XX.......X..
..#.A0000A#XXXX...X.XX......XXT......XXX
......111A#XXXX....X..X...XXXXX........X
.....A1...#X..X..XXXXXXX...X.XX........X
"""
def __init__(self,parent):
"""
initialise tkinter with default parameters
"""
Tkinter.Tk.__init__(self,parent)
self.parent = parent
self.appWidth = 1900 # initial values
self.appHeight = 1000
self.cell_width = 4
self.cell_height = 3
self.fname = ''
self.screenWidth = self.winfo_screenwidth()
self.screenHeight = self.winfo_screenheight()
self.configure(bg='black')
self.geometry('%dx%d+%d+%d' % (self.appWidth, self.appHeight, self.screenWidth - self.appWidth - 0, self.screenHeight - self.appHeight - 0))
WIDTH = self.appWidth
HEIGHT = self.appHeight
self.canvas = Canvas(self, width=WIDTH, height=HEIGHT, bg="#000000")
self.canvas.pack()
self.img = PhotoImage(width=WIDTH, height=HEIGHT)
self.canvas.create_image(( WIDTH/2, HEIGHT/2), image=self.img, state="normal")
#self.TEST_sin() # testing - draws a sin wave
self.appWidth = 1900 # canvas.width
self.appHeight = 1000
self.canvas.pack()
def TEST_sin(self):
for x in range(4 * self.appWidth):
y = int(self.appHeight/2 + self.appHeight/4 * math.sin(x/80.0))
self.img.put("#ffffff", (x//4,y))
self.canvas.pack()
def add_file(self, fname):
self.fname = fname
def show_grid_from_file(self, fname):
"""
reads a saved grid file and paints it on the canvas
"""
with open(fname, "r") as f:
for y, row in enumerate(f):
for x, val in enumerate(row):
self.draw_cell(y, x, val)
def draw_cell(self, row, col, val):
"""
draw a cell as position row, col containing val
"""
if val == 'T':
self.paint_target(row,col)
elif val == '#':
self.paint_block(row,col)
elif val == 'X':
self.paint_hill(row,col)
elif val == '.':
self.paint_land(row,col)
elif val in ['A']:
self.paint_agent_location(row,col)
elif val in ['1','2','3','4','5','6','7','8','9']:
self.paint_agent_trail(row,col, val)
def put_standard_block(self, y, x, val):
"""
prints a block, packing out around the y/x location
with pixels up to cell width and cell height
"""
for j in range(0,self.cell_height):
for i in range(0,self.cell_width):
self.img.put(val, (x*self.cell_width+i, y*self.cell_height+j))
def paint_land(self, y, x):
self.put_standard_block(y,x,'bisque')
def paint_block(self, y, x):
self.put_standard_block(y,x,'gray9')
def paint_hill(self, y, x):
self.put_standard_block(y,x,'green4')
def paint_target(self, y, x):
self.put_standard_block(y,x,'yellow')
self.img.put('black', (x*self.cell_width+1, y*self.cell_height+1))
self.img.put('black', (x*self.cell_width+0, y*self.cell_height+1))
self.img.put('black', (x*self.cell_width+1, y*self.cell_height+0))
self.img.put('black', (x*self.cell_width+0, y*self.cell_height+0))
def paint_agent_trail(self, y, x, val):
"""
paint an agent trail as ONE pixel to allow for multiple agent
trails to be seen in the same cell
"""
for j in range(1,self.cell_height-1):
for i in range(1,self.cell_width-1):
self.img.put(self.agent_color(val), (x*self.cell_width+i, y*self.cell_height+j))
#self.paint_agent_location(y,x,self.agent_color(val))
# old version - try to paint a single pixel trail but it looks too small
#self.paint_land(y,x) # needed otherwise shows up black under dots - todo - fix this
#self.img.put(self.agent_color(val), (x*self.cell_width, y*self.cell_height)) # +int(val)
def paint_agent_location(self, y, x):
self.put_standard_block(y,x,'red')
def agent_color(self, val):
"""
gets a colour for agent 0 - 9
"""
if val == '0':
colour = 'blue'
elif val == '1':
colour = 'navy'
elif val == '2':
colour = 'firebrick'
elif val == '3':
colour = 'blue'
elif val == '4':
colour = 'blue2'
elif val == '5':
colour = 'blue4'
elif val == '6':
colour = 'gray22'
elif val == '7':
colour = 'gray57'
elif val == '8':
colour = 'red4'
elif val == '9':
colour = 'red3'
return colour
def __init__(self):
super().__init__()
# Initialisation des pions à la valeur initiale.
self.pion1 = "X"
self.pion2 = "O"
# Titre de la fenêtre
self.title("Ultimate TIC-TAC-TOE")
# Pour changer taille minimum de fenêtre et taille centrer,
# changer variable self.width_fen, self.height_fen.
self.width_fen, self.height_fen = 430, 500
# Taille minimum de la fenêtre
self.minsize(self.width_fen, self.height_fen)
# Centrer la fenêtre.
centreFen(self, self.width_fen, self.height_fen)
# Création d'un canvas avec l'image "logo.gif"
canvas = Canvas(self, width=280, height=100)
self.img = PhotoImage(file="logo.gif")
canvas.create_image(280, 100, anchor=SE, image=self.img)
canvas.grid(row=0, columnspan=5, pady=10)
# Libellé - Nouvelle Partie
Label(self, text="Nouvelle partie", font=("Arial", 16), fg="#0080FF", justify=CENTER).grid(
row=1, columnspan=5, padx = 20, pady = 5)
separateur(20).grid(row=10,columnspan=5)
# Sélection du type de partie avec bouton radio
self.choixJoueur = IntVar()
r1 = Radiobutton(self, text="Jouer avec l'ordinateur",
variable = self.choixJoueur, value = 1, command=self.define_choix)
r1.select()
r1.grid(row=20, column=0)
r2 = Radiobutton(self, text="Jouer avec un autre joueur",
variable = self.choixJoueur, value = 2, command=self.define_choix)
r2.grid(row=20, column=1)
# Saisie du nom du joueur 1.
f_j1 = Frame(self, borderwidth=1, padx=5, pady=5, relief=SUNKEN)
f_j1.grid(row=30, columnspan=5, padx=5, pady=5)
Label(f_j1, text="Nom joueur 1:").grid(row=1, column=0, sticky=E, padx = 5, pady = 5)
self.nom_joueur1 = Entry(f_j1)
self.nom_joueur1.grid(row=1,column=1)
# Sélection du pion joueur 1. Le pion restant est automatiquement attribué au joueur 2.
Label(f_j1, text="Choix de pion:").grid(row=1, column=2, padx=5)
self.sel_pion=IntVar()
p1 = Radiobutton(f_j1, indicatoron=0, width=5, text="X",
variable=self.sel_pion, value=1, command=self.choix_pion)
p1.grid(row=1, column=3, padx=2)
p1.select()
Radiobutton(f_j1, indicatoron=0, width=5, text="O", variable=self.sel_pion, value=2,
command=self.choix_pion).grid(row=1, column=4, padx=2)
# Saisie du nom du joueur 2. Apparaît seulement si on sélection 2 joueurs. Voir define_choix
self.f_j2 = Frame(self, width=420, borderwidth=1, padx=5, pady=5, relief=SUNKEN)
Label(self.f_j2, text="Nom joueur 2").grid(row=1, column=0, sticky=E, padx = 5, pady = 5)
self.nom_joueur2 = Entry(self.f_j2, state="disabled")
self.nom_joueur2.grid(row=1, column=1)
self.label_pion2 = Label(self.f_j2, text="Pion Joueur 2 = O")
self.label_pion2.grid(row=1, column=2, padx=5)
# Information sur l'ordinateur. Disparaît si on choisi 2 joueurs.
self.f_ordi = Frame(self, width=420, borderwidth=1, padx=5, pady=5, relief=SUNKEN)
self.f_ordi.grid(row=40, columnspan=5, padx=5, pady=5)
Label(self.f_ordi, text="Ordinateur = Colosse", font=("Arial", 12), fg="#0080FF")\
.grid(row=1, column=0, sticky=E, padx = 5, pady = 5)
self.pion_ordi = Label(self.f_ordi, text="| Pion de l'ordinateur = O",
font=("Arial", 12), fg="#0080FF")
self.pion_ordi.grid(row=1, column=2)
separateur(20).grid(row=50,columnspan=5)
# Sélection de la force de l'ordinateur
self.choixForce = IntVar()
self.f1 = Radiobutton(self, indicatoron=0, width = 20,
padx = 20, text="Facile", variable=self.choixForce, value=1, command=self.define_choix)
self.f1.select()
self.f1.grid(row=60, columnspan=5)
self.f2 = Radiobutton(self, indicatoron=0, width = 20,
padx = 20, text="Moyen", variable=self.choixForce, value=2, command=self.define_choix)
self.f2.grid(row=61, columnspan=5)
self.f3 = Radiobutton(self, indicatoron=0, width = 20,
padx = 20, text="Difficile", variable=self.choixForce, value=3, command=self.define_choix)
self.f3.grid(row=62, columnspan=5)
separateur(40).grid(row=70, column=0)
#Button pour démarrer la partie
self.bt_start = Button(text="Démarrer", font=("Arial", 12), fg="green", command=self.demarrer_jeu)
self.bt_start.grid(row=80, columnspan=5)
def jouluvana(aken, vana_pilt):
"""Create santa, a message and make both move with another function."""
vana = Canvas(aken, width=90, height=70, bg="blue", highlightthickness=0)
vana.create_image(45, 35, image=vana_pilt)
vana.pack()
tekst = Label(aken, text="Kõik kingid kuni 50% allahinnatud!", bg="blue", font=("Helvetica", 16), fg="white")
tekst.pack()
vana_liikuma(vana, 650, 200, tekst)
class CameraView(View):
def __init__(self, params):
super(CameraView, self).__init__(params)
self._multiplier = int(params["multiplier"]) if "multiplier" in params else 1
self._multiplier = max(self._multiplier, 1)
self._tk = Tk()
self._canvas = Canvas(self._tk, width=80 * self._multiplier, height=60 * self._multiplier)
self._tk.title("Camera view")
self._tk.resizable(width=False, height=False)
self._canvas.pack(side=tkinter.LEFT, fill=tkinter.BOTH, expand=True)
self._tk.protocol("WM_DELETE_WINDOW", self.on_press_close)
self._base_dir = "camera_" + str(int(time.time() * 1000))
os.makedirs(self._base_dir)
def run(self):
super(CameraView, self).run()
self._tk.mainloop()
def on_new_input(self):
try:
hex_str = self.get_input()
img = self._get_image(hex_str)
except Exception as e:
logging.debug(str(e))
return
if img is None:
return
bmp = ImageTk.BitmapImage(image=img, foreground="white", background="black")
self._canvas.create_image(0, 0, image=bmp, anchor=tkinter.NW)
self._tk_image = bmp
img.save(self._base_dir + "/" + str(int(time.time() * 1000)) + ".png")
def on_dismiss(self):
self._tk.after_idle(self.on_press_close)
def on_press_close(self):
self._tk.destroy()
self.join_io_thread()
def _get_image(self, hex_str) -> Image:
try:
hex_data = binascii.unhexlify(hex_str)
# Invert data from MCU
hex_data = bytes([~h & 0xFF for h in hex_data])
except TypeError as e:
logging.debug(str(e))
return
img = Image.frombytes(mode="1", size=(80, 60), data=hex_data)
img = img.resize((80 * self._multiplier, 60 * self._multiplier))
return img
