def menu():
while True:
print("1.- Ingresar Nuevo Contacto")
print("2.- Buscar Contacto")
print("3.- Visualizar Agenda")
print("Q para salir")
print("-----Elija una opcion-----")
opcion = input()
if int(opcion) == 1:
print("Ingrese los datos del Contacto:")
NewContact()
elif int(opcion) == 2:
searchContact()
elif int(opcion) == 3:
print("Visualizando Agenda...")
print("---------------")
VisulizarAgenda()
Graphic.grafico(ListaContactos)
print("---------------")
elif opcion == 'Q' or opcion == 'q':
break
else:
print("ingrese una opcion valida")
def main():
"""
Main func.
"""
while 1:
source_page = page_grab()
if checking(source_page):
params_list = page_parsing(source_page)
Graphic.main(params_list)
time.sleep(10)
else:
time.sleep(10)
def coinToss():
again = 'y'
while again == 'y':
nTosses = int(input("\nHow many tosses should I make? "))
Graphic.toss(nTosses)
for x in range(nTosses):
lToss = r.randint(1, 2)
if lToss == 1:
print(x + 1, ":", "\tHeads", sep=(""))
elif lToss == 2:
print(x + 1, ":", "\tTails", sep=(""))
again = input("\nWould you like to flip the coin again? (y = yes): ")
Graphic.close()
def start_game():
start_button.config(state=DISABLED) # no accidental presses while play
game = Gamelogic(34, 34)
game.add_rand()
graphic = Graphic(34, 34, game, root)
graphic.init_graphic(320, 20)
while True:
graphic.root.after(50)
graphic.game.update_field()
graphic.game.found_piece()
graphic.update_graphic()
score_label.config(text="Score: " + str(graphic.game.score))
score_label.place(x=20, y=460)
graphic.root.update_idletasks()
graphic.root.update()
if graphic.game.is_lost() is True:
break
graphic.root.after(500, graphic.end())
start_button.config(state="normal")
if graphic.game.score > int(highscore):
highscore_label.config(text="Highscore: " + str(graphic.game.score))
highscore_label.place(x=20, y=500)
with open("highscore.txt", "w") as f:
f.write(str(graphic.game.score))
f.close()
def __init__(self, zurich=None, line=None, axes=None, fig=None):
# format will be #1 : device id when connected
# #2 : scope taken to read the data
# line : matplotlib Line issued when you plot axis
self.path1 = '/{}/inputpwas/{}/wave'
self.path2 = '/{}/boxcars/{}/wave'
self.line = line
self.axes = axes
self.fig = fig
self.zurich = zurich
self.xfactor = 360 / (2 * np.pi)
self.frequency = None
self.ugraph = 'phase'
self.line_list = []
self.line_list.append(
Graphic.VerticalDraggableLine(self, axes=self.axes))
self.line_list.append(
Graphic.VerticalDraggableLine(self, axes=self.axes, x=150))
self.window_start = min(self.line_list[0].x, self.line_list[1].x)
self.window_length = abs(self.line_list[1].x - self.line_list[1].x)
def thuatToan_3(self):
#Tao ma tran rong
map = Map()
#Lay cac gia tri input tu file input.txt
print("Nhap file input:\n(input1_1.txt, input1_2.txt, input1_3.txt)")
string = input("Ten file: ")
A = Input(string, map)
print(A)
#Tao ma tran va canvas theo input
g = Graphic(map.ngang, map.doc)
#To mau cac da giac
for i in range(map.ngang):
for j in range(map.doc):
if A[i][j] == 1:
g.Rectangle(i, j, "lightpink")
listDaGiac = map.getDaGiac()
for i in range(0, len(listDaGiac), 2):
g.Rectangle(listDaGiac[i], listDaGiac[i + 1], "lightcoral")
ids(A, map.xStart, map.yStart, map.xEnd, map.yEnd)
print(A)
g.Pack()
g.Display()
return 1
def thuatToan_1(self):
#Tao ma tran rong
map = Map()
#Lay cac gia tri input tu file input.txt
print("Nhap file input:\n(input1_1.txt, input1_2.txt, input1_3.txt)")
string = input("Ten file: ")
A = Input(string, map)
#Tao ma tran va canvas theo input
g = Graphic(map.ngang, map.doc)
#To mau cac da giac
for i in range(map.ngang):
for j in range(map.doc):
if A[i][j] == 1:
g.Rectangle(i, j, "lightpink")
listDaGiac = map.getDaGiac()
for i in range(0, len(listDaGiac), 2):
g.Rectangle(listDaGiac[i], listDaGiac[i + 1], "lightcoral")
paths = astar(A, (map.xStart, map.yStart), (map.xEnd, map.yEnd))
paths.reverse()
print("Chi phi: ", len(paths))
del paths[len(paths) - 1]
g.Rectangle(map.xStart, map.yStart, "lightskyblue")
g.Rectangle(map.xEnd, map.yEnd, "lightskyblue")
g.Pack()
for i in paths:
y, x = i
wait = 1
while wait:
g.Rectangle(y, x, "lightsteelblue")
g.windown.update_idletasks()
g.windown.update()
time.sleep(0.1)
g.Pack()
wait = 0
g.Pack()
return 1
def switch_graphics(self, variable, frame):
"""
Change the graphic disposition to allow to pass from one to two
graphics. Thus it allows you to go from wavelengths to wavelengths +
fft.
Parameters:
variable : This is linked to the FFT+Wave checkbox it is updated
when you check it.
frame : Tkinter frame that contains the frame.
"""
state = variable.get()
# Destroy all the element unwanted and create the double graph
if state == 'enable':
self.wv_graphic.destroy_graph()
self.dual = Graphic.SubGraphFrame(
parent=frame,
subplots={
'WV': ['Wavelength [nm]', 'Intensities [counts]'],
'FFT': ['Time [fs]', 'Intensities [counts]']
},
figsize=[9, 6])
self.fft_graphic = self.dual.graph[1]
self.wv_graphic = self.dual.graph[0]
self.adjust_wavelength_range()
# Destroy all the element unwanted from the dual graph and recreate the
# wv_graphic
elif state == 'disable':
if not self.dual:
return
self.dual.destroy_graph()
self.dual = None
self.wv_graphic = Graphic.GraphicFrame(
frame,
axis_name=['Wavelength [nm]', 'Intensity [counts]'],
figsize=[9, 6])
self.fft_graphic = None
self.fft_centered = False
def __init__(self, domain, equation, dt, u0, dtype=None):
# iterator
self.domain = domain
self.dt = dt
u0 = domain.to_points(u0)
self.PDE = Core.euler(domain, equation, dt, u0, dtype=dtype)
# figure:
self.fig = plt.figure(facecolor="#000000")
self.fig.labelcolor = '#FFFFFF'
self.ax1 = self.fig.add_subplot()
self.ax1.axis('off')
self.im1 = self.ax1.imshow(np.zeros(domain.shape))
# cspace
self.cspace = Graphic.ComplexMappable()
def __init__(self):
self.Wuerfel = [] # enthält beide Würfelinstanzen
self.Wuerfel.append(Wuerfel(-10.0, 6, 0.0, 1))
self.Wuerfel.append(Wuerfel(-20.0, 6, 3.0, 0))
self.Spielsteine = [] # Liste der Spielsteininstanzen
self.Spielfelder = [] # Liste der Spielfeldinstanzen
self.Spielbrett = Spielbrett() # Erzeugung des Spielbretts
self.Graphic = Graphic(self) # Erzeugung der Graphikinstanz
self.initGame() # Spiel wird initialisiert
self.spieler = {"black": Spieler(), "white": Spieler()}
self.actSpieler = "black"
self.wuerfeln()
self.Graphic.initGL() # Initialiserung der OpenGL-Komponente
from Graphic import * app = Graphic() app.run()
d = euclideanDistance(x[best], y[best], x[j], y[j])
h = np.exp((-1*(d**2))/(2*(S**2)))
board[j].setWeight(board[j].getWeight() + N*h*(trX[i]-board[j].getWeight()))
cost = difWeight(prev, board)
print("Cost: {}".format(cost))
costV.append(cost)
prev = deepcopy(board)
bestNeurons = []
for i in range(len(trX)):
index = getBest(distance(trX[i], board))
bestNeurons.append((x[index], y[index]))
return bestNeurons, costV
trX, labels = Persistence.getTrxPaises()
# #Parameters
neuronNumber = 20 #neuronNumber^2
nIterations = 100
S = neuronNumber/2
N = 0.001
N_limit = 0.01
S_limit = 1
T1 = nIterations*len(trX)/math.log(S)
T2 = T1
board = initBoard(neuronNumber*neuronNumber, len(trX[0]))
bestNeurons, costV = train(board, trX)
Graphic.showCost(costV)
Graphic.showBoard(bestNeurons, labels, neuronNumber)
class Pygammon:
def __init__(self):
self.Wuerfel = [] # enthält beide Würfelinstanzen
self.Wuerfel.append(Wuerfel(-10.0, 6, 0.0, 1))
self.Wuerfel.append(Wuerfel(-20.0, 6, 3.0, 0))
self.Spielsteine = [] # Liste der Spielsteininstanzen
self.Spielfelder = [] # Liste der Spielfeldinstanzen
self.Spielbrett = Spielbrett() # Erzeugung des Spielbretts
self.Graphic = Graphic(self) # Erzeugung der Graphikinstanz
self.initGame() # Spiel wird initialisiert
self.spieler = {"black": Spieler(), "white": Spieler()}
self.actSpieler = "black"
self.wuerfeln()
self.Graphic.initGL() # Initialiserung der OpenGL-Komponente
# self.gameRound()
def initGame(self):
# Wir legen nun erstmal alle nötigen Spielobjekte an
# self.Spielbrett.laenge=20
self.einspiel = {}
self.einspiel["black"] = Spielfeld(-1.75, 0.0, 9.0, 0)
self.einspiel["white"] = Spielfeld(-1.75, 0.0, -9.0, 24)
self.ausspiel = {}
self.ausspiel["black"] = Spielfeld(7.75, 0.0, -9.0, 24)
self.ausspiel["black"].breite = 2.5
self.ausspiel["white"] = Spielfeld(7.75, 0.0, 9.0, 0)
self.ausspiel["white"].breite = 2.5
self.Spielfelder.append(self.einspiel["white"])
for i in range(6):
self.Spielfelder.append(Spielfeld(5.4 + i * -1.20, 0.0, 9.0, len(self.Spielfelder)))
for i in range(6):
self.Spielfelder.append(Spielfeld(-2.9 + i * -1.20, 0.0, 9.0, len(self.Spielfelder)))
for i in range(6):
self.Spielfelder.append(Spielfeld(-8.95 + i * 1.20, 0.0, -9.0, len(self.Spielfelder)))
for i in range(6):
self.Spielfelder.append(Spielfeld(-0.6 + i * 1.20, 0.0, -9.0, len(self.Spielfelder)))
self.Spielfelder.append(self.einspiel["black"])
weisse = []
schwarze = []
for i in range(15):
x = Spielstein(0.0, 0.0, 0.0, "black")
self.Spielsteine.append(x)
schwarze.append(x)
for i in range(15):
x = Spielstein(0.0, 0.0, 0.0, "white")
self.Spielsteine.append(x)
weisse.append(x)
def giveWhite():
i = weisse[0]
weisse.remove(i)
self.Graphic.weisseSteine.append(i)
return i
def giveBlack():
i = schwarze[0]
schwarze.remove(i)
self.Graphic.schwarzeSteine.append(i)
return i
for i in range(2):
self.Spielfelder[24].insertStein(giveWhite())
for i in range(5):
self.Spielfelder[19].insertStein(giveBlack())
for i in range(3):
self.Spielfelder[17].insertStein(giveBlack())
for i in range(5):
self.Spielfelder[13].insertStein(giveWhite())
for i in range(5):
self.Spielfelder[12].insertStein(giveBlack())
for i in range(3):
self.Spielfelder[8].insertStein(giveWhite())
for i in range(5):
self.Spielfelder[6].insertStein(giveWhite())
for i in range(2):
self.ausspiel["black"].insertStein(giveBlack())
def whichField(self, stein):
# Diese Methode prüft anhand der Koordinaten des gedraggten Spielsteins, über welchem Spielfeld er gerade liegt.
# Die Prüfung, ob der Zug auf dieses Feld erlaubt ist, findet anderswo statt
# Übergeben wird eine Spielsteininstanz
print stein.koordinaten
print stein.X
for i in self.Spielfelder:
if stein.Z < 0 and i.Z < 0:
if stein.X - 0.2 < i.X and stein.X - 0.2 > i.X - i.breite:
return i
elif stein.Z > 0 and i.Z > 0:
if stein.X - 0.2 < i.X and stein.X - 0.2 > i.X - i.breite:
return i
"""
i=self.ausspiel['black']
if stein.Z>0 and i.Z>0:
if stein.X-0.2<i.X and stein.X-0.2>i.X-i.breite:
return i
i=self.ausspiel['white']
if stein.Z<0 and i.Z<0:
if stein.X-0.2<i.X and stein.X-0.2>i.X-i.breite:
return i
"""
print "Stein wurde über keinem Spielfeld abgelegt"
def gameRound(self):
# Diese Methode wird nach jedem Spielzug aufgerufen und prüft diverse Spielbedingungen
# Checken wir, ob jemand gewonnen hat
if self.spieler[self.actSpieler].wievielAusgespielt >= 15:
# der Kerl hat gewonnen
pass
# Die Runde ist erst zuende, wenn beide Würfel benutzt wurden
if self.Wuerfel[0].zahl == 0 and self.Wuerfel[1].zahl == 0 and not self.Graphic.gewurfelt:
pass
else:
print "Gewuerfelt sind " + str(self.Wuerfel[0].zahl) + " und " + str(self.Wuerfel[1].zahl)
return 0
self.wuerfeln()
if self.actSpieler == "black":
self.actSpieler = "white"
print "Spieler Weiss ist am Zug"
else:
self.actSpieler = "black"
print "Spieler Schwarz ist am Zug"
def checkAll(self, stein, feld):
# Diese Methode wird aufgerufen, bevor ein Spielzug vom System akzeptiert wird.
# Sie prüft, ob das Setzen des Steins nach den Spielregeln erlaubt ist
if feld == None:
return 0
if (
feld.size() >= 2
): # checkt, ob das Zielfeld belegt ist; dazu muss nur der letzte Stein geprüft werden, wenn das Feld mehr oder gleich zwei Steine bereits beinhaltet
if feld.Spielsteine[feld.size() - 1].farbe != stein.farbe:
print "Spielfeld von anderem Spieler blockiert"
return 0
if (
self.actSpieler == "black"
): # je nachdem welcher spieler am zug ist durch negieren links-oder rechtsherum gehen
wuerfel = [-self.Wuerfel[0].zahl, -self.Wuerfel[1].zahl]
else:
wuerfel = [self.Wuerfel[0].zahl, self.Wuerfel[1].zahl]
zug = [stein.spielfeld.nr, feld.nr]
print "Zug von Spielfeld " + str(stein.spielfeld.nr) + " nach Spielfeld " + str(feld.nr)
weg = [] # liste mit moeglichen kombinationen die mit den gewuerfelten zahlen moeglich sind
lenwuerfel = len(wuerfel)
if lenwuerfel == 1: ###
weg.append([wuerfel[0]]) #
elif lenwuerfel == 2: #
weg.append([wuerfel[0]]) #
weg.append([wuerfel[1]]) # erstellen der liste weg, doppelte kombinationen werden nicht
weg.append([wuerfel[0], wuerfel[1]]) # ausgeschlossen, dies wird spaeter behandelt
weg.append([wuerfel[1], wuerfel[0]]) #
else: # wenn len(wuerfel)>2 ist wird von einem pasch ausgegangen
for i in range(1, len(wuerfel) + 1): #
weg.append(wuerfel[0:i])
zuglaenge = zug[0] - zug[1] # betrag der laenge des weges von start nach ziel
nWeg = []
for i in wuerfel: #
if (
i == zuglaenge
): # wegkombinationen mit denen das ziel von der laenge her nciht zu erreichen ist entfernen
nWeg.append(i) #
weg = nWeg
if len(weg): ###
for i in weg: # sind immer noch erlaubte kombinationen uebrig, so werden die noetigen zuege fuer die
if self.Wuerfel[0].zahl == abs(i):
self.Wuerfel[0].zahl = 0
else:
self.Wuerfel[1].zahl = 0
break
else:
print "Zielfeld nicht mit diesen Würfelzahlen erreichbar"
return 0
self.gameRound()
return 1
def wuerfeln(self):
zahl1 = self.Wuerfel[0].wuerfeln()
zahl2 = self.Wuerfel[1].wuerfeln()
start_new_thread(wurfel_timer, (self.Graphic,))
self.Graphic.gewurfelt = 1
print "Gewuerfelt wurden " + str(zahl1) + " und " + str(zahl2)
def checkAfter(self, stein):
# Diese Methode soll einige Fälle prüfen, die nach dem Ziehen eines Steins eintreten können
# Wir prüfen, ob ein Stein rausgeschubst wurde
if stein.spielfeld.size() == 2:
first = stein.spielfeld.Spielsteine[0]
if first.farbe != stein.farbe:
first.spielfeld.removeStein(first)
self.einspiel[first.farbe].insertStein(first)
def isDragable(self, stein): # Diese Funktion überpüft, ob ein Stein bewegt werden kann
if not stein.isDragable():
return 0
if not self.actSpieler == stein.farbe:
return 0
return 1
def muc_1(self):
#Tao ma tran rong
map = Map()
#Lay cac gia tri input tu file input.txt
print("Nhap file input:\n(input1_1.txt, input1_2.txt, input1_3.txt)")
string = input("Ten file: ")
A = Input(string, map)
#Tao ma tran va canvas theo input
g = Graphic(map.ngang, map.doc)
#To mau cac da giac
for i in range(map.ngang):
for j in range(map.doc):
if A[i][j] == 1:
g.Rectangle(i, j, "lightpink")
listDaGiac = map.getDaGiac()
for i in range(0, len(listDaGiac), 2):
g.Rectangle(listDaGiac[i], listDaGiac[i + 1], "lightcoral")
#chay bang BFS
bfs = BFSItem(A, (map.xStart, map.yStart), (map.xEnd, map.yEnd))
path = bfs.BFS()
print("Chi phi: ", len(path) - 1, "\n")
g.Rectangle(map.xStart, map.yStart, "lightskyblue")
g.Rectangle(map.xEnd, map.yEnd, "lightskyblue")
g.Pack()
for j in range(1, len(path) - 1):
r = path[j][0]
c = path[j][1]
wait = 1
while wait:
g.Rectangle(r, c, "lightsteelblue")
g.windown.update_idletasks()
g.windown.update()
time.sleep(0.1)
g.Pack()
wait = 0
g.Pack()
g.Display()
return 1 #Gia tri de chay tiep
def main():
graphic = Graphic.Graphic()
# -*- coding: utf-8 -*-
import AG
import Graphic
# Parámetros del algoritmo.
Npob = 200
chromosomeWidth = 12
generations = 50
mutationProbability = 30
selectionPercentage = 30
# Algoritmo principal
pop = AG.ini_pob(Npob, chromosomeWidth)
bestFitness = []
average = []
for i in range(generations):
print 'Iteracion: {}'.format(i)
fitPop = AG.fitness(pop)
maxFitness = max(fitPop)
averageFit = sum(fitPop)/len(pop)
bestFitness.append(maxFitness)
average.append(averageFit)
print 'Mejor fitness: {}\nMedia: {}'.format(maxFitness, averageFit)
selPop = AG.truncateSelection(fitPop, pop, selectionPercentage)
pop = AG.uniformCrossover(Npob, selPop, mutationProbability)
Graphic.fitness_average(bestFitness, average)
def muc_3(self):
#Tao ma tran rong
map = Map()
#Lay cac gia tri input tu file input.txt
print("Nhap file input:\n(input1_1.txt, input1_2.txt, input1_3.txt)")
string = input("Ten file: ")
A = Input(string, map)
#Tao ma tran va canvas theo input
g = Graphic(map.ngang, map.doc)
#To mau cac da giac
for i in range(map.ngang):
for j in range(map.doc):
if A[i][j] == 1:
g.Rectangle(i, j, "lightpink")
listDaGiac = map.getDaGiac()
for i in range(0, len(listDaGiac), 2):
g.Rectangle(listDaGiac[i], listDaGiac[i + 1], "lightcoral")
chiPhi = xuatDuongDi(A, map)
print("Chi phi: ", chiPhi)
#Gia tri to mau: Start, end: 3 Diem don: 4 Duong di: 2 Rong: 0 Tuong: 1
A[map.xStart][map.yStart] = 3
A[map.xEnd][map.yEnd] = 3
g.Rectangle(map.xStart, map.yStart, "lightskyblue")
g.Rectangle(map.xEnd, map.yEnd, "lightskyblue")
for i in map.danhSachDon:
x, y = i
A[x][y] = 4
g.Rectangle(x, y, "lightgreen")
g.Pack()
for i in range(map.ngang):
for j in range(map.doc):
if A[i][j] == 2:
wait = 1
while wait:
g.Rectangle(i, j, "lightsteelblue")
g.windown.update_idletasks()
g.windown.update()
time.sleep(0.1)
g.Pack()
wait = 0
g.Pack()
g.Display()
return 1
for i in range(8):
nx = x + dx[i]
ny = y + dy[i]
if (nx >= 0 and ny >= 0 and nx < n and ny < m):
if (d[nx][ny] == -1 and map[nx][ny] != 1):
heappush(pq,(l[nx][ny],i))
while (len(pq) > 0):
(p,t) = heappop(pq)
kx = x + dx[t]
ky = y + dy[t]
dfs(kx, ky, d, count + 1)
if (foundPath): return
step +=1
stack.append((x,y,step))
dfs(seekerRowPos,seekerColPos,d,0)
for i in range (len(stack)):
print(stack[i])
graphic = Graphic.Graphic(map, seekerRowPos, seekerColPos, hiderList, stack)
# point = graphic.heuristic()
# for i in range(15):
# print(point[i])
graphic.run()
#graphic.observed()
#graphic.printBoard()
#graphic.printChecked()
import GeneticAlgorithm as GA
import Fitness
import Ordenation
import Graphic
time = 720
chromosomeSize = time/10
generations = 50
mutationPercentage = 40
populationSize = 20
numberOfSelectedIndividuals = 12
pltBestFitness = []
pltFitnessAverage = []
# Main
population = GA.initialize_population(populationSize,chromosomeSize)
for i in range(generations):
print "Generation: "+ str(i)
fitnessvalues = Fitness.fitness(population,time)
fitnessvalues,population = Ordenation.selectionsort(fitnessvalues,population)
print " Best fitness: "+str(fitnessvalues[0])
print " Fitness average: "+str(sum(fitnessvalues)/len(fitnessvalues))
pltBestFitness.append(fitnessvalues[0])
pltFitnessAverage.append(sum(fitnessvalues)/len(fitnessvalues))
population = GA.selection(population, numberOfSelectedIndividuals)
population = GA.uniformCrossover(population, populationSize, chromosomeSize)
population = GA.mutation(population, mutationPercentage)
Graphic.printGraphic(pltBestFitness,pltFitnessAverage,generations)
"""
Copyright 2020 Patrick Müller
Tetris
"""
# check tkinter for design and to do the menu and pause option
# sometimes placed tetriminos disappeared
from Gamelogic import *
from Graphic import *
from time import time
state = 0
previous_state = 0
game = GameLogic()
g = Graphic(game, state)
while g.state != -1:
while g.state == 0:
# start menu
previous_state = 0
g.state = 1
if g.state == 1 and previous_state == 0:
g.init_canvas()
g.update_canvas()
g.next_tetrimino()
g.init_score()
g.root.bind("<Up>", g.event_handler)
g.root.bind("x", g.event_handler)
g.root.bind("<Right>", g.event_handler)
g.root.bind("<Left>", g.event_handler)
g.root.bind("<Down>", g.event_handler)
import pygame as pg
import core
import Graphic
import Objet
import Variable
ligne = 0
colonne = 0
taille_jeton = 40
Joueur1 = Objet.Joueur()
Joueur2 = Objet.Joueur()
Fenetre = Graphic.GUI()
list_cases = []
pions_rouge = Objet.Pions()
pions_jaune = Objet.Pions()
Partie = Objet.Partie()
pions_jaune.Set_Case(Variable.jaune)
pions_rouge.Set_Case(Variable.rouge)
def setup():
global Info, Variable
core.WINDOW_SIZE = Variable.Taille_fenetre
Joueur1.Set_Couleur(Variable.rouge)
Joueur2.Set_Couleur(Variable.jaune)
for i in range(42):
list_cases.append(Objet.Case())
