def conectorKmedias(self, datos, iteraciones, clases, c1X, d1X, c2X, d2X,
                     c1Y, d1Y, c2Y, d2Y):
     #Conseguir cantidad de datos
     valor_datos = int(datos.get())
     #Consigue iteraciones
     valor_iteraciones = int(iteraciones.get())
     #Consigue cantidad de clases
     valor_clases = int(clases.get())
     #Consigue centroide en X de K = 1
     valor_c1X = int(c1X.get())
     #Consigue desviación en X de K = 1
     valor_c1Y = int(c1Y.get())
     #Consigue centroide en Y de K = 1
     valor_c2X = int(c2X.get())
     #Consigue desviación en Y de K = 1
     valor_c2Y = int(c2Y.get())
     #Consigue centroide en X de K = 2
     valor_d1X = int(d1X.get())
     #Consigue desviación en X de K = 2
     valor_d1Y = int(d1Y.get())
     #Consigue centroide en Y de K = 2
     valor_d2X = int(d2X.get())
     #Consigue desviación en Y de K = 2
     valor_d2Y = int(d2Y.get())
     #Se llama a la clase Controlador con todos los datos recibidos
     controlador = Controlador(valor_datos, valor_clases, valor_iteraciones,
                               valor_c1X, valor_d1X, valor_c2X, valor_d2X,
                               valor_c1Y, valor_d1Y, valor_c2Y, valor_d2Y)
     #Ejecuta el iterador en la clase Controlador
     controlador.iteradorKmedias()
예제 #2
0
 def run(self):
     # time.sleep(random.random()/10)
     print("Starting " + self.name)
     controlador = Controlador()
     while True:
         controlador.adicionaBufferElfo(self)
         time.sleep(2)
     print("Exiting " + self.name)
예제 #3
0
    def run(self):
        controlador = Controlador()
        while True:
            if (not self.dormindo):
                controlador.ajuda()

        print("Starting " + self.name)
        print("Exiting " + self.name)
예제 #4
0
 def run(self):
     print("Starting " + self.name)
     controlador = Controlador()
     while True:
         if not self.estaDeFerias:
             controlador.adicionaBufferRena(self)
             time.sleep(2)
     print("Exiting " + self.name)
예제 #5
0
파일: Vista.py 프로젝트: berrio97/TFG_NBA
 def __init__(self, master, modelo):
     Frame.__init__(self, master)
     self.pack()
     self.master = master
     self.modelo = modelo
     self.controlador = Controlador(self.modelo, self)
     self.col1 = 'khaki1'
     self.col2 = 'snow'
     self.font = 'Helvetica'
     self.init_components()
     return
예제 #6
0
def main():
    idThread = 0
    papaiNoel = PapaiNoel(idThread, "Papai Noel")

    listaElfo = []
    for j in range(0, QUANTIDADE_ELFOS):
        elfo = Elfo(idThread, "Elfo" + str(j))
        listaElfo.append(elfo)
        idThread += 1

    listaRena = []
    for j in range(0, QUANTIDADE_RENAS):
        rena = Rena(idThread, "Rena" + str(j))
        idThread += 1
        listaRena.append(rena)

    controlador = Controlador(papaiNoel, listaElfo, listaRena,
                              TAMANHO_GRUPO_ELFOS)

    papaiNoel.start()

    # for elfo in listaElfo:
    #     elfo.start()

    for rena in listaRena:
        rena.start()
예제 #7
0
def main():
    # Sirve para que se muestre mi icono en vez de el de python en la taskbar
    import ctypes
    myappid = u'CaponeraRomolo.TFG.QLearning.final'  # arbitrary string
    ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
        myappid)  # Para que se muestre el icon en la task bar
    ctypes.windll.user32.ShowWindow(
        ctypes.windll.kernel32.GetConsoleWindow(),
        6)  # Para que se minimice la consola al iniciarlo
    # miedito me da lo que pueda hacer esto honestly

    c = Controlador()
    c.registrar_algoritmo(SoftMax)
    c.registrar_algoritmo(UpperConfidenceBound)
    c.start()
예제 #8
0
class GUI:
	"""Clase encargada del manejo de la interfaz"""
	def __init__(self, tk):
		"""Constructor"""
		self.ui = tk;
		self.ctrl = Controlador();
	def initGUI(self):
		"""Inicializa la interfaz grafica"""
		for campo in campos:
			cad = campo + ":"
			l = Label(self.ui, text=cad);
			l.pack();
			campos[campo] = Entry(self.ui);
			campos[campo].pack();
		for cb in checkBox:
			cbRefs[cb] = IntVar();
			checkBox[cb] = Checkbutton(self.ui, text=cb, var=cbRefs[cb]);
			checkBox[cb].pack();
		checkBox["Aval"].toggle();
	def boton(self):
		"""Accion de pulsado de boton"""
		try:
			for campo in campos:
				valores[campo] = int(campos[campo].get());
			for cb in checkBox:
				valores[cb] = cbRefs[cb].get();
			concedido = self.ctrl.procesar(valores);
			if concedido: #Prestamo concedido
				interes = str(self.ctrl.getInteres());
				tkMessageBox.showinfo("Enhorabuena", "Su prestamo ha sido concedido con un interes del "+ interes + "%" +"\n"
									+"Mensualidad: " + str(self.ctrl.getMensualidad()) + "Euros")
			else: #Prestamo denegado:
				tkMessageBox.showinfo("Lo sentimos", "Su prestamo ha sido denegado \n Motivo: " + self.ctrl.getMotivo())

		except exceptions.ValueError: #En caso de campo vacio o tipos erroneos:
			tkMessageBox.showinfo("Error", "Algun campo esta vacio o es de un tipo erroneo")
예제 #9
0
# -*- coding= utf-8 -*-
'''
Tarea 2
Autor: Rodrigo Llull Torres
La estructura está basada en la de la clase auxiliar
'''

# Importación de los modelos
from Modelos import Modelos
from Vista import Vista
from Controlador import Controlador

# Creación de objetos
# Se crea un contenedor de modelos (una escena, en este caso)
modelo = Modelos()
# Se crea la vista
vista = Vista(modelo)
# Se crea el controlador de la aplicación
controlador = Controlador(modelo, vista)

# Bucle de aplicación
while True:
    controlador.chequearInput()
    vista.dibujar()

pygame.quit()
예제 #10
0
# coding=utf-8
"""
Simulador, versión 2
Aplica concepto y separa claramente entre vista, modelo y controlador
"""

"""
Importación de objetos
"""
from Modelo import Modelos
from Vista import Vista
from Controlador import Controlador

"""
Crea los objetos
"""
modelo = Modelos()  # Crea un contenedor de modelos (Universo)
vista = Vista(modelo)  # Crea la vista
controlador = Controlador(modelo, vista)  # Crea el controlador de la aplicación

"""
Bucle de la aplicación
"""
while True:
    controlador.chequear_input()
    vista.dibujar()
예제 #11
0
# -*- coding: utf-8 -*-
'''
Programa principal.
'''

import sys
import time
from PyQt4 import QtGui
from JanelaPrincipal import JanelaPrincipal

print 'aqui-1'
from app_config import config

print 'aqui-0'
from Controlador import Controlador

print 'aqui1'
app = QtGui.QApplication(sys.argv)
print 'aqui2'
dialog = JanelaPrincipal()
print 'aqui3'
dialog.adicionarConfiguracoes(config)

dialog.show()

controlador = Controlador(dialog, dialog.janelaCalibracao)

val = app.exec_()
config.save()
controlador.destruir()
sys.exit(val)
예제 #12
0
 def __init__(self):
     v = Aplicacion()
     c = Controlador(v)
예제 #13
0
파일: main.py 프로젝트: jemartins/DrDAQ
from PyQt4 import QtGui
from JanelaPrincipal import JanelaPrincipal
from app_config import config
from Controlador import Controlador

app = QtGui.QApplication(sys.argv)

dialog = JanelaPrincipal()
dialog.adicionarConfiguracoes(config)

dialog.show()

my_name = 'nome_nada'

for arg in sys.argv[1:]:
    # Da forma --name=NOME
    if arg.startswith('--'):
        key, sep, value = arg[2:].partition('=')
        if not key or not sep:
            continue
        my_name = value

controlador = Controlador(dialog, dialog.janelaCalibracao, my_name=my_name)
controlador.inicializar()

val = app.exec_()
config.save()
controlador.destruir()
sys.exit(val)
예제 #14
0
from weather import Tiempo
from VistaProvincia import ProvinciasView
from Controlador import Controlador
from Mprovincias import ManejaProvincia
from ObjectEncoder import ObjectEncoder
if __name__ == "__main__":
    encoder = ObjectEncoder()
    try: 
        aux=encoder.Leer("datos.json")
        aux=encoder.Decoder(aux)

    except FileNotFoundError:
        aux=ManejaProvincia()

    vista=ProvinciasView()
    control=Controlador(vista, aux)
    vista.setControlador(control)
    control.start()
    encoder.Guardar(control.salir(), "datos.json") 
    
 def __init__(self):
     v = Ventana()
     m = Modelo()
     c = Controlador(v, m)
예제 #16
0
파일: main.py 프로젝트: mecomontes/Python
from Controlador import Controlador
from Downloader import Downloader

if __name__ == '__main__':
    control = Controlador()
    Vista = Downloader(control)
    control.iniciar()
예제 #17
0
from Controlador import Controlador
from Downloader import Downloader

if __name__ == '__main__':
    control = Controlador()
    Vista = Downloader(control)
    control.setVista(Vista)
    control.iniciar()
예제 #18
0
	def __init__(self, tk):
		"""Constructor"""
		self.ui = tk;
		self.ctrl = Controlador();
예제 #19
0
파일: Vista.py 프로젝트: berrio97/TFG_NBA
class Vista(Frame):
    # Inicializa el controlador y algunas variables globales
    # Params:
    #   master: instancia de Window
    #   modelo: Modelo
    def __init__(self, master, modelo):
        Frame.__init__(self, master)
        self.pack()
        self.master = master
        self.modelo = modelo
        self.controlador = Controlador(self.modelo, self)
        self.col1 = 'khaki1'
        self.col2 = 'snow'
        self.font = 'Helvetica'
        self.init_components()
        return

    #Inicializa los componentes de la Vista y los coloca
    def init_components(self):
        self.label_model = Label(self.master,
                                 text='Modelo',
                                 font=(self.font, 14),
                                 relief=GROOVE,
                                 bg=self.col2)
        self.label_data = Label(self.master,
                                text='Datos',
                                font=(self.font, 14),
                                relief=GROOVE,
                                bg=self.col2)
        self.label_pred = Label(self.master,
                                text='Predicción',
                                font=(self.font, 14),
                                relief=GROOVE,
                                bg=self.col2)
        self.label_res = Label(self.master,
                               text='Resultados',
                               font=(self.font, 14),
                               relief=GROOVE,
                               bg=self.col2)

        self.variable = StringVar()
        self.variable.set('Modelo 1')
        self.variable.trace("w", self.change_model)

        self.model_selector = OptionMenu(self.master, self.variable,
                                         *list(self.modelo.modelos.keys()))

        self.frame = Frame(self.master)

        self.alg_label = Label(self.frame,
                               text='Algoritmo',
                               font=(self.font, 8, 'bold'),
                               bg=self.col2,
                               relief='raised',
                               width=20)
        self.seas_label = Label(self.frame,
                                text='Temporadas',
                                font=(self.font, 8, 'bold'),
                                bg=self.col2,
                                relief='raised',
                                width=20)
        self.columns_label = Label(self.frame,
                                   text='Selección columnas',
                                   font=(self.font, 8, 'bold'),
                                   bg=self.col2,
                                   relief='raised',
                                   width=20)
        self.pca_label = Label(self.frame,
                               text='PCA',
                               font=(self.font, 8, 'bold'),
                               bg=self.col2,
                               relief='raised',
                               width=20)
        self.params_label = Label(self.frame,
                                  text='Parámetros',
                                  bg=self.col2,
                                  font=(self.font, 8, 'bold'),
                                  relief='raised',
                                  width=20)

        self.alg_value = Label(self.frame,
                               text='',
                               font=(self.font, 8),
                               bg=self.col2,
                               relief='raised',
                               width=30)
        self.seas_value = Label(self.frame,
                                text='',
                                font=(self.font, 8),
                                bg=self.col2,
                                relief='raised',
                                width=30)
        self.columns_value = Label(self.frame,
                                   text='',
                                   font=(self.font, 8),
                                   bg=self.col2,
                                   relief='raised',
                                   width=30)
        self.pca_value = Label(self.frame,
                               text='',
                               font=(self.font, 8),
                               bg=self.col2,
                               relief='raised',
                               width=30)
        self.params_value = Label(self.frame,
                                  text='',
                                  font=(self.font, 8),
                                  bg=self.col2,
                                  relief='raised',
                                  width=30)

        self.load_model_but = Button(self.master,
                                     text='Cargar modelo',
                                     state='disabled',
                                     command=self.load_model,
                                     bg=self.col2)

        self.train_model_but = Button(self.master,
                                      text='Entrenar modelo',
                                      state='disabled',
                                      command=self.train_model,
                                      bg=self.col2)

        self.load_data_but = Button(self.master,
                                    text='Cargar datos',
                                    command=self.load_data,
                                    bg=self.col2)

        self.ref_but = Button(self.master,
                              text='Actualizar datos',
                              command=self.refresh,
                              bg=self.col2)

        self.home_label = Label(self.master, text='Equipo local', bg=self.col1)
        self.away_label = Label(self.master,
                                text='Equipo visitante',
                                bg=self.col1)

        self.home = StringVar()
        self.home.set(self.modelo.teams[0])
        self.homeOptionMenu = OptionMenu(self.master, self.home,
                                         *list(self.modelo.teams))
        self.homeOptionMenu.config(state='disabled')

        self.away = StringVar()
        self.away.set(self.modelo.teams[0])
        self.awayOptionMenu = OptionMenu(self.master, self.away,
                                         *list(self.modelo.teams))
        self.awayOptionMenu.config(state='disabled')

        self.calendar = Calendar(self.master, state='disabled')

        self.pred_but = Button(self.master,
                               text='Hallar predicciones',
                               state='disabled',
                               command=self.exec_prediction,
                               bg=self.col2)

        self.result = Label(self.master,
                            text='',
                            bg=self.col1,
                            font=(self.font, 10, 'bold'))
        self.pred = Label(self.master,
                          text='',
                          bg=self.col1,
                          font=(self.font, 10, 'bold'))
        self.team_win = Label(self.master,
                              text='',
                              bg=self.col1,
                              font=(self.font, 10, 'bold'))

        self.sep1 = Separator(self.master, orient=HORIZONTAL)
        self.sep2 = Separator(self.master, orient=HORIZONTAL)
        self.sep3 = Separator(self.master, orient=VERTICAL)

        self.label_error = Label(self.master,
                                 text='',
                                 font=('device', 10),
                                 fg='red',
                                 bg=self.col1)

        ### PACKING & PLACING
        self.label_model.pack()
        self.label_model.place(relx=0.05, rely=0.05, anchor=W)
        self.label_data.pack()
        self.label_data.place(relx=0.05, rely=0.4, anchor=W)
        self.label_pred.pack()
        self.label_pred.place(relx=0.05, rely=0.6, anchor=W)

        self.model_selector.pack()
        self.model_selector.place(relx=0.15, rely=0.15, anchor=CENTER)

        self.frame.pack()
        self.frame.place(relx=0.25, rely=0.05)

        self.alg_label.grid(row=0, rowspan=1, column=0, columnspan=1)
        self.seas_label.grid(row=1, rowspan=1, column=0, columnspan=1)
        self.columns_label.grid(row=2, rowspan=1, column=0, columnspan=1)
        self.pca_label.grid(row=3, rowspan=1, column=0, columnspan=1)
        self.params_label.grid(row=4,
                               rowspan=1,
                               column=0,
                               columnspan=1,
                               sticky=N + E + S + W)

        self.alg_value.grid(row=0, rowspan=1, column=1, columnspan=1)
        self.seas_value.grid(row=1, rowspan=1, column=1, columnspan=1)
        self.columns_value.grid(row=2, rowspan=1, column=1, columnspan=1)
        self.pca_value.grid(row=3, rowspan=1, column=1, columnspan=1)
        self.params_value.grid(row=4, rowspan=1, column=1, columnspan=1)
        self.change_model()

        self.load_model_but.pack()
        self.load_model_but.place(relx=0.1, rely=0.48, anchor=CENTER)

        self.train_model_but.pack()
        self.train_model_but.place(relx=0.24, rely=0.48, anchor=CENTER)

        self.load_data_but.pack()
        self.load_data_but.place(relx=0.38, rely=0.48, anchor=CENTER)

        self.ref_but.pack()
        self.ref_but.place(relx=0.52, rely=0.48, anchor=CENTER)

        self.home_label.pack()
        self.home_label.place(relx=0.1, rely=0.7, anchor=CENTER)

        self.away_label.pack()
        self.away_label.place(relx=0.25, rely=0.7, anchor=CENTER)

        self.homeOptionMenu.pack()
        self.homeOptionMenu.place(relx=0.1, rely=0.75, anchor=CENTER)

        self.awayOptionMenu.pack()
        self.awayOptionMenu.place(relx=0.25, rely=0.75, anchor=CENTER)

        self.calendar.pack()
        self.calendar.place(relx=0.45, rely=0.75, anchor=CENTER)

        self.pred_but.pack()
        self.pred_but.place(relx=0.17, rely=0.82, anchor=CENTER)

        self.label_res.pack()
        self.label_res.place(relx=0.7, rely=0.05, anchor=CENTER)

        self.result.pack()
        self.result.place(relx=0.8, rely=0.15, anchor=CENTER)

        self.pred.pack()
        self.pred.place(relx=0.8, rely=0.85, anchor=CENTER)

        self.team_win.pack()
        self.team_win.place(relx=0.8, rely=0.89, anchor=CENTER)

        self.sep1.place(relx=0.05, rely=0.33, relwidth=0.55)
        self.sep2.place(relx=0.05, rely=0.53, relwidth=0.55)
        self.sep3.place(relx=0.61, rely=0.05, relheight=0.9)

        self.label_error.place(relx=0.8, rely=0.93, anchor=CENTER)

    # Evento de cambiar el modelo que se esta seleccionando
    def change_model(self, *args):
        self.controlador.evento_change_model()
        if self.modelo.model_read is not None:
            self.alg_value['text'] = self.modelo.algorithms[
                self.modelo.model_read.alg]
            if self.modelo.model_read.seasons == '2015':
                seas = 'Desde 2014/2015'
            elif self.modelo.model_read.seasons == '2005':
                seas = 'Desde 2004/2005'
            else:
                seas = 'Desde 2000/2001'
            self.seas_value['text'] = seas
            self.columns_value['text'] = self.modelo.model_read.col
            self.pca_value[
                'text'] = 'Sí' if self.modelo.model_read.pca_analysis else 'No'

            if not pd.isnull(self.modelo.model_read.params):
                aux = ''
                for key in list(eval(self.modelo.model_read.params).keys()):
                    aux += str(key) + ': ' + str(
                        eval(self.modelo.model_read.params)[key]) + '\n'
                self.params_value['text'] = aux[:-1]
            else:
                self.params_value['text'] = ''

    # Evento de cargar los datos de los partidos
    def load_data(self):
        self.controlador.evento_load()
        if self.modelo.file is not None:
            self.load_model_but['state'] = 'active'
            self.calendar['state'] = 'normal'
            self.label_error.config(fg='green')
            self.label_error['text'] = 'Datos cargados con éxito'

    # Evento de actualizar los datos
    def refresh(self):
        self.controlador.evento_refresh()
        self.load_data()
        self.label_error.config(fg='green')
        self.label_error['text'] = 'Datos actualizados con éxito'

    # Evento de cargar el modelo predictivo seleccionado
    def load_model(self):
        self.label_error['text'] = ''
        self.train_model_but['state'] = 'active'
        self.controlador.evento_load_model()
        performance = self.modelo.modelo_prediccion.ac
        self.result['text'] = 'TASA DE ACIERTO: ' + str(
            performance.round(4) * 100) + '%'
        self.roc()
        self.pred_but['state'] = 'active'
        self.homeOptionMenu.config(state='active')
        self.awayOptionMenu.config(state='active')
        self.label_error.config(fg='green')
        self.label_error['text'] = 'Modelo cargado con éxito'

    # Evento de entrenar el modelo predictivo seleccionado
    def train_model(self):
        self.label_error['text'] = ''
        self.controlador.evento_train_model()
        self.load_model()

    # Evento de crear una curva ROC sobre los resultados del modelo predictivo seleccionado
    def roc(self):
        fpr, tpr, thres = roc_curve(self.modelo.modelo_prediccion.Y_test,
                                    self.modelo.modelo_prediccion.scores)
        auc_roc = auc(fpr, tpr)

        fig = Figure(figsize=(3.2, 3.2))
        a = fig.add_subplot(111)
        a.plot(fpr, tpr, color='blue', label='AUC %0.2f' % auc_roc)
        a.legend(loc="lower right")

        a.set_position([0.15, 0.12, 0.8, 0.8])
        a.set_xticks(ticks=np.arange(0, 1.5, 0.5))
        a.set_yticks(ticks=np.arange(0, 1.5, 0.5))
        a.set_xticklabels(labels=np.arange(0, 1.5, 0.5),
                          fontdict={'fontsize': 8})
        a.set_yticklabels(labels=np.arange(0, 1.5, 0.5),
                          fontdict={'fontsize': 8})
        a.set_title("Curva ROC " +
                    self.modelo.algorithms[self.modelo.model_read.alg],
                    fontsize=10)
        a.set_ylabel("TPR", fontsize=8)
        a.set_xlabel("FPR", fontsize=8)

        canvas = FigureCanvasTkAgg(fig, master=self.master)
        canvas.get_tk_widget().pack(expand=True)
        canvas.get_tk_widget().place(relx=0.8, rely=0.5, anchor=CENTER)
        canvas.draw()

    # Evento de crear las predicciones para un partido determinado
    def exec_prediction(self):
        date = datetime.strptime(self.calendar.get_date(), '%m/%d/%y')
        game_id = str(
            date.year
        ) + '%02d' % date.month + '%02d' % date.day + '0' + self.home.get()

        if self.home.get() != self.away.get() and self.home.get(
        ) != 'No seleccionado' and self.away.get() != 'No seleccionado':
            aux = self.modelo.modelo_prediccion.predictions_test
            game_true = game_id in aux.game_id.values
            if date < datetime.today() and game_true and aux[
                    aux.game_id == game_id]['a_team_id'].values[
                        0] == self.away.get() or date > datetime.today():
                self.controlador.evento_exec_prediction()
                predres = self.modelo.prediction
                aux = self.home.get() if predres else self.away.get()
                self.label_error['text'] = ''
                self.pred['text'] = str(self.home.get()) + ': ' + str(
                    predres.round(2)) + '\t' + str(
                        self.away.get()) + ': ' + str((1 - predres).round(2))
                if date < datetime.today():
                    self.team_win['text'] = 'Victoria real: ' + str(aux)
            else:
                self.label_error.config(fg='red')
                self.label_error[
                    'text'] = 'ERROR: Ese partido no se ha disputado.'
                self.pred['text'] = ''
                self.team_win['text'] = ''
        elif self.home.get() == 'No seleccionado' and self.away.get(
        ) == 'No seleccionado':
            self.label_error.config(fg='red')
            self.pred['text'] = ''
            self.team_win['text'] = ''
            self.label_error['text'] = 'ERROR: Hay que determinar los equipos'
        elif self.home.get() == 'No seleccionado' or self.away.get(
        ) == 'No seleccionado':
            self.label_error.config(fg='red')
            self.pred['text'] = ''
            self.team_win['text'] = ''
            self.label_error['text'] = 'ERROR: Falta un equipo por determinar'
        elif self.home.get() == self.away.get():
            self.label_error.config(fg='red')
            self.pred['text'] = ''
            self.team_win['text'] = ''
            self.label_error[
                'text'] = 'ERROR: Los equipos deben ser diferentes.'
예제 #20
0
    def iniciar_MARDA(self):
        controlador = Controlador()
        controlador.iniciar_framework()

        if (controlador.m_tablero):
            controlador.mostrar_tablero()