def iniciar(self): log.info("iniciar") # sistema: self.sistema = Sistema() self.sistema.iniciar() self.sistema.cargar_parametros_iniciales() self.sistema.update(0.0, self.sistema.posicion_cursor) Sistema.establecer_instancia(self.sistema) # fisica: self._configurar_fisica() # mundo: self._establecer_material() # quitarlo, optimizacion? no, al reves! self._establecer_shader() # componentes: self.input_mapper = InputMapperTecladoMouse(self.base) self.controlador_camara = ControladorCamara(self.base) self.controlador_camara.iniciar() # self._cargar_terreno() # self._cargar_personajes() # self._cargar_objetos() # #self._cargar_obj_voxel() # gui: self._cargar_debug_info() self._cargar_gui() # ShowBase self.base.cam.node().setCameraMask(DrawMask(1)) self.base.render.node().adjustDrawMask(DrawMask(5), DrawMask(0), DrawMask(0)) # self.base.accept("l-up", self._hacer, [0]) self.base.accept("m-up", self._hacer, [1]) self.base.accept("v-up", self._hacer, [2]) # self.base.taskMgr.add(self._update, "mundo_update")
def main(): """Programa principal para el sistema de consultas.""" if len(argv) != 2: print USO else: try: s = Sistema(argv[1]) except SistemaError, e: print e return 1 s.ejecutar()
def Ingresar(self): if self.validacion.validar_usuario( ) and self.validacion.validar_contrasena(): self.db.open() consulta = QtSql.QSqlQuery() consulta.exec_("select Usuario, Contrasena from Registro") while consulta.next(): if self.window.leUsuario.text() == consulta.value( 0) and self.window.leContrasena.text( ) == consulta.value(1): self.setVisible(False) self.db.close() sistema = Sistema(self, self.db) sistema.show() elif self.window.leUsuario.text() != consulta.value( 0) and self.window.leContrasena.text( ) != consulta.value(1): QMessageBox.warning(self, "Acceso Denegado", "Usuario y contraseña incorrectos!!!", QMessageBox.Ok) elif self.window.leUsuario.text() != consulta.value(0): QMessageBox.warning(self, "Acceso Denegado", "El usuario no existe!!!", QMessageBox.Ok) else: QMessageBox.warning(self, "Acceso Denegado", "La contraseña es incorrecta!!!", QMessageBox.Ok) else: if not self.window.leUsuario.text( ) and not self.window.leContrasena.text(): QMessageBox.warning(self, "Error!!!", "No ha llenado ninguno de los campos!!!", QMessageBox.Ok) else: if not self.window.leContrasena.text(): QMessageBox.warning(self, "Error!!!", "Falta la contraseña!!!", QMessageBox.Ok) else: QMessageBox.warning(self, "Error!!!", "Falta el usuario!!!", QMessageBox.Ok)
def iniciar(self): log.info("iniciar") # self.sistema = Sistema.obtener_instancia() # self.directorio_cache = os.path.join( self.sistema.directorio_general_cache, Terreno.DirectorioCache) if not os.path.exists(self.directorio_cache): log.warning("se crea directorio_cache: %s" % self.directorio_cache) os.mkdir(self.directorio_cache) # self._establecer_shader() # self.dibujar_normales = config.valbool("terreno.dibujar_normales")
def terminar(self): log.info("terminar") # self.base.ignore("l-up") self.base.ignore("m-up") self.base.ignore("v-up") # self.controlador_camara.terminar() # for _personaje in self._personajes: _personaje.terminar() if self.objetos: self.objetos.terminar() if self.agua: self.agua.terminar() if self.sol: self.sol.terminar() if self.cielo: self.cielo.terminar() if self.terreno: self.terreno.terminar() # self.sistema = None Sistema.remover_instancia()
def iniciar(self, parent_node_path, bullet_world, partes=list()): log.info("iniciar") # sistema self.sistema = Sistema.obtener_instancia() # recursos ruta_dir = os.path.join(os.getcwd(), self.directorio_recursos, self.clase) if not os.path.exists(ruta_dir): raise Exception("no existe el directorio '%s'" % (ruta_dir)) archivos = [ archivo for archivo in os.listdir(ruta_dir) if archivo[-4:].lower() == ".egg" or archivo[-4:].lower() == ".bam" ] archivo_actor = "" dict_animaciones = dict() for archivo in archivos: if archivo[:-4] == "actor": archivo_actor = archivo else: dict_animaciones[archivo[:-4]] = Filename.fromOsSpecific( os.path.join(ruta_dir, archivo)) if archivo_actor == "": raise Exception( "no se encontró ningún archivo de actor (actor.[egg|bam]) en '%s'" % ruta_dir) # cuerpo self.bullet_world = bullet_world rb = self._generar_cuerpo_fisica() self.bullet_world.attach(rb) self.cuerpo = parent_node_path.attachNewNode(rb) self.cuerpo.setCollideMask(BitMask32.bit(2)) # actor self.actor = Actor( Filename.fromOsSpecific(os.path.join(ruta_dir, archivo_actor)), dict_animaciones) self.actor.reparentTo(self.cuerpo) self.actor.setZ(-self._ajuste_altura) # partes for parte in partes: self.actor.makeSubpart(parte[0], parte[1], parte[2]) self._partes_actor.append(parte[0]) # shader GestorShader.aplicar(self.actor, GestorShader.ClasePersonaje, 2)
def __init__(self, texec, numUsuario, url, password_metricas, transitorio, sufijo, path_estadisticas): self.path_estadisticas = path_estadisticas self._clients = [] self._last_id = 1 self._tactual = time() self._texec = self._tactual+(60*texec) self._domain = url self._cola = Queue.PriorityQueue(0) self._lastKill = 1 self._estadistica = Estadistica(numUsuario) self._responseTime = 0 self._npeticions = 0 self._infoTimeClient = [] self._alive_clients = [] self.password_metricas = password_metricas self._sistema = Sistema(1, self._estadistica._obtain_path(), sufijo) self.nclients = 0 self.clientsAc = 0 self.timeLastEvent = 0 self.timeStart = 0 self.ficheroClientes = open(path_estadisticas+'num_clientes_acumulado_'+sufijo+'.txt', 'w') self.transitorio = transitorio self.regimenEstacionario = False self.sufijoMetricas = sufijo #Variables de la traza self.mediaSesion = 0 self.mediaPeticion = 0 self.mediaLlegadas = 0 self.lastAcumulateClient = 0 #Variables muestrales self.muestraMediaSesion = [] self.muestraMediaPeticion = [] self.muestraMediaLlegadas = [] self.muestraTRespuesta = [] #Cluster de tiempo de respuesta para self.mediaTRcentroides = [0.45, 8.7, 16.4, 32.2] self.clusterTRespuesta = [[], [], [], []] self.ficheroTRRespuesta = open(path_estadisticas+'tr_paginas_'+sufijo+'.csv', 'w')
class Master(object): def __init__(self, texec, numUsuario, url, password_metricas, transitorio, sufijo, path_estadisticas): self.path_estadisticas = path_estadisticas self._clients = [] self._last_id = 1 self._tactual = time() self._texec = self._tactual+(60*texec) self._domain = url self._cola = Queue.PriorityQueue(0) self._lastKill = 1 self._estadistica = Estadistica(numUsuario) self._responseTime = 0 self._npeticions = 0 self._infoTimeClient = [] self._alive_clients = [] self.password_metricas = password_metricas self._sistema = Sistema(1, self._estadistica._obtain_path(), sufijo) self.nclients = 0 self.clientsAc = 0 self.timeLastEvent = 0 self.timeStart = 0 self.ficheroClientes = open(path_estadisticas+'num_clientes_acumulado_'+sufijo+'.txt', 'w') self.transitorio = transitorio self.regimenEstacionario = False self.sufijoMetricas = sufijo #Variables de la traza self.mediaSesion = 0 self.mediaPeticion = 0 self.mediaLlegadas = 0 self.lastAcumulateClient = 0 #Variables muestrales self.muestraMediaSesion = [] self.muestraMediaPeticion = [] self.muestraMediaLlegadas = [] self.muestraTRespuesta = [] #Cluster de tiempo de respuesta para self.mediaTRcentroides = [0.45, 8.7, 16.4, 32.2] self.clusterTRespuesta = [[], [], [], []] self.ficheroTRRespuesta = open(path_estadisticas+'tr_paginas_'+sufijo+'.csv', 'w') def _escribirClientAc(self,ac): self.lastAcumulateClient = ac self.ficheroClientes.write(str(ac) + "\n") def _escribirTr(self, tr, pagina, operacion): self.ficheroTRRespuesta.write(str(tr)+','+str(pagina[:-1])+','+str(operacion)+'\n') def _build_message(self, operation, parameter): return {'operation': operation, 'parameter': parameter} def _message_to_client(self, threadID, msg): """ Send Message to a Client """ client = self.get_client(threadID) client['thread'].set_message(msg) def _obtain_client_response_time(self, threadID): client = self.get_client(threadID) self._escribirTr(client['thread'].responseTime, client['thread'].lastPage, client['thread'].lastOperation) return client['thread'].responseTime def add_client(self, threadID, url, sesionTime, consumptionTime): """ Create new Client Thread """ self._alive_clients.append(threadID) c = Client(threadID, url, sesionTime, consumptionTime) self._clients.append({'id': threadID, 'thread': c}) c.start() def get_client(self, threadID): """ Return a client Thread """ client = [client for client in self._clients if client['id'] == threadID] return client[0] def get_last_client(self): """ Return a last client thread """ if self._last_id > 1: return (self._last_id-1) else: return 0 def remove_client(self, threadID): """ Terminate with Client Thread """ self._message_to_client(threadID, self._build_message('shutdown', None)) def wait_client(self, threadID, seconds): """ Client Thread wait x seconds """ self._message_to_client(threadID, self._build_message('wait', seconds)) def open_path_client(self, threadID, path): """ Client Thread wait x seconds """ peticion = self._estadistica.obtenerPeticionEsc() d = {'thread': threadID, 'url':path, 'action':peticion[:-1], #Quitamos \n 'time': 0 } self._infoTimeClient.append(d) self._message_to_client(threadID, self._build_message('openPath', self._infoTimeClient[-1])) def print_message(self, threadID, msg): """ Print a Message in console """ self._message_to_client(threadID, self._build_message('print', msg)) def setConsumptionTime_client(self, threadID, consumptionTime): """ Set Consumption Time for a one Client """ self._message_to_client(threadID, self._build_message('setConsumptionTime', consumptionTime)) def rutina_inicializacion(self,sufix=""): """ Init Simulation """ # Inicializamos todos los eventos tactual = self._tactual tiempoLlegada = self._estadistica.obtenerLlegada(sufix) # Funcion estadistica de t.llegada self.muestraMediaLlegadas.append(tiempoLlegada) tactual = tiempoLlegada + tactual evento1 = Evento("LlegadaCliente", tactual, self._last_id) self._cola.put((tactual, evento1)) self._last_id = self._last_id + 1 def insert_tRespuesta(self, tr): last = 0 index = len(self.mediaTRcentroides)-1 for i,centroide in enumerate(self.mediaTRcentroides): if tr >= last and tr < centroide: index = i break self.clusterTRespuesta[index].append(tr) def rutina_llegadas(self, evento,sufix=""): """ Routine arrivals """ print "El cliente : "+str(evento.numCliente) + " ha llegado en el tiempo " + str((evento.tiempo-self.timeStart)/60) self._sistema.numeroClientes = self._sistema.numeroClientes + 1 ts = self._estadistica.obtenerSesion() self.muestraMediaSesion.append(ts) tep = self._estadistica.obtenerPeticion() self.muestraMediaPeticion.append(tep) tactual = evento.tiempo self.clientsAc = self.clientsAc + self.nclients*(evento.tiempo - self.timeLastEvent) self.nclients = self.nclients + 1 if evento.tiempo-self.timeStart > 0: self.timeLastEvent = evento.tiempo print "Nclientes: " + str(self.nclients) + " Nacumulat: " + str(self.clientsAc/(evento.tiempo-self.timeStart)) self._escribirClientAc(self.clientsAc/(evento.tiempo-self.timeStart)) tiempoLlegada = self._estadistica.obtenerLlegada(sufix) # Funcion estadistica de t.llegada self.muestraMediaLlegadas.append(tiempoLlegada) tactual = tiempoLlegada + tactual evento1 = Evento("LlegadaCliente", tactual, self._last_id) self._cola.put((tactual, evento1)) self._last_id = self._last_id + 1 # Anyade un evento de salida if tep < ts: evento1 = Evento("SalidaCliente", tactual + tep, evento.numCliente) temps = tactual+tep else: evento1 = Evento("SalidaCliente", tactual + ts, evento.numCliente) temps = tactual+ts self._cola.put((temps, evento1)) domini = self._domain path = self._estadistica.obtenerPopularidad() self.add_client(evento1.numCliente, domini, ts, tep) self.open_path_client(evento1.numCliente, path) def rutina_salida(self, evento): """ exit routine """ print "El cliente : "+str(evento.numCliente) + " vuelve a entrar en el tiempo " + str((evento.tiempo-self.timeStart)/60) self.clientsAc = self.clientsAc + self.nclients*(evento.tiempo - self.timeLastEvent) print "Nclientes: " + str(self.nclients) + " Nacumulat: " + str(self.clientsAc/(evento.tiempo-self.timeStart)) self._escribirClientAc(self.clientsAc/(evento.tiempo-self.timeStart)) if evento.tiempo-self.timeStart > 0: self.timeLastEvent = evento.tiempo tep = self._estadistica.obtenerPeticion() self.muestraMediaPeticion.append(tep) client = self.get_client(evento.numCliente) clientActual = client['thread'] tactual = evento.tiempo #sessionActual = sessiones[str(p.numCliente)] path = self._estadistica.obtenerPopularidad() if clientActual.consumptionTime + tep < clientActual.sesionTime: evento1 = Evento("SalidaCliente", tactual + tep, evento.numCliente) temps = tactual+tep self.open_path_client(evento1.numCliente, path) newComsuptionTime = clientActual.consumptionTime+tep else: tr = clientActual.sesionTime - clientActual.consumptionTime if tr < 0: temps = tactual + 1 else: temps = tactual+tr evento1 = Evento("SalidaClienteTotal", temps, evento.numCliente) newComsuptionTime = tr if self.regimenEstacionario: self._npeticions = self._npeticions + 1 responseTime = self._obtain_client_response_time(evento.numCliente) self.muestraTRespuesta.append(responseTime) self.insert_tRespuesta(responseTime) self._responseTime = self._responseTime + responseTime self._cola.put((temps, evento1)) self.setConsumptionTime_client(evento.numCliente, newComsuptionTime) def rutina_salida_sistema(self, evento): """ routine system exit """ print "El cliente : "+str(evento.numCliente) + " ha salido del sistema en el tiempo " + str((evento.tiempo-self.timeStart)/60) self.clientsAc = self.clientsAc + self.nclients*(evento.tiempo - self.timeLastEvent) self.nclients = self.nclients - 1 print "Nclientes: " + str(self.nclients) + " Nacumulat: " + str(self.clientsAc/(evento.tiempo-self.timeStart)) self._escribirClientAc(self.clientsAc/(evento.tiempo-self.timeStart)) if evento.tiempo-self.timeStart > 0: self.timeLastEvent = evento.tiempo self._sistema.numeroClientes = self._sistema.numeroClientes - 1 if self.regimenEstacionario: self._npeticions = self._npeticions + 1 responseTime = self._obtain_client_response_time(evento.numCliente) self.muestraTRespuesta.append(responseTime) self.insert_tRespuesta(responseTime) self._responseTime = self._responseTime + responseTime self.remove_client(evento.numCliente) self._alive_clients.remove(evento.numCliente) self._lastKill = evento.numCliente def kill_threads(self): for thread in self._alive_clients: print "Killing thread "+str(thread) self.remove_client(thread) def _start_metricas(self): urllib2.urlopen('http://130.206.134.123/exec_metrica.php?pw='+self.password_metricas+'&nom='+self.sufijoMetricas).read() self._sistema.start() def _end_metricas(self): close_metricas = False while not close_metricas: try: urllib2.urlopen('http://130.206.134.123/exec_metrica.php?pw='+self.password_metricas+'&stop=1').read() close_metricas = True except urllib2.URLError: print "Servidor Colapsado. Esperando 30 segundos para finalizar las metricas" sleep(0.5) #Esperamos 1 minuto a realizar la operacion ya que el servidor esta saturado close_metricas = False except: close_metricas = True self._sistema.shutdown() def _write_t_respuesta(self): trespFichero = "" trespFichero = open(self.path_estadisticas+'tRespuesta_'+self.sufijoMetricas+'.csv', 'w') trespFichero.write("Tiempo_de_respuesta\n") #Imprimimos el t.respuesta generico for m in self.muestraTRespuesta: trespFichero.write(str(m)+"\n") trespFichero.close() #Imprimimos los grupos de trespuesta en un fichero trespFichero = open(self.path_estadisticas+'clustertRespuesta_'+self.sufijoMetricas+'.csv', 'w') cabecera = '' for centroide in self.mediaTRcentroides: cabecera = cabecera + "Centroide " + str(centroide)+',' line = '' for cluster in self.clusterTRespuesta: if len(line) > 0: line = line + str(np.mean(cluster))+',' else: line = line + '0,' trespFichero.write(cabecera[:-1]+'\n') trespFichero.write(line[:-1]+'\n') trespFichero.close() self.ficheroTRRespuesta.close() def _print_resultado_simulacion(self, meanLlegadas, meanPeticiones, meanSesion, tRespuesta, stdRespuesta, cvRespuesta): tResultado = open(self.path_estadisticas+'resultado_simulacion_'+self.sufijoMetricas+'.csv', 'w') s = "" s = s + "NUM PETICIONES PROCESADAS: " + str(self._npeticions) + "\n" s = s + "NUM MEDIO DE CLIENTES ACUMULADOS: " + str(self.lastAcumulateClient) + "\n" s = s + "" + "\n" s = s + "TIEMPO ENTRE LLEGADA:" + "\n" s = s + " Media Traza " + str(self.mediaLlegadas) + "\n" s = s + " Media Muestral "+ str(meanLlegadas) + " segundos" + "\n" s = s + "TIEMPO ENTRE PETICIONES:" + "\n" s = s + " Media Traza " + str(self.mediaSesion) + "\n" s = s + " Media Muestral "+ str(meanPeticiones) + " segundos" + "\n" s = s + "TIEMPO DURACION SESION:" + "\n" s = s + " Media Traza " + str(self.mediaPeticion) + "\n" s = s + " Media Muestral "+ str(meanSesion) + " segundos" + "\n" s = s + "TIEMPO DE RESPUESTA:" + "\n" s = s + " Media Muestral "+ str(tRespuesta) + " segundos" + "\n" s = s + " Desviacion Estandar "+ str(stdRespuesta) + " segundos" + "\n" s = s + " Coeficiente de Variacion "+ str(cvRespuesta) + " segundos" + "\n" s = s + "" + "\n" print s tResultado.write(s) tResultado.close() def simular(self): """ Main method for run the simulation """ self.ficheroTRRespuesta.write('TR,PAGINA,OPERACION\n') error = False tactual = self._tactual self.rutina_inicializacion(self.sufijoMetricas) self.mediaSesion,self.mediaPeticion,self.mediaLlegadas = self._estadistica.obtenerMedias(self.sufijoMetricas) ejecutar = True self.timeStart = time() try: while (not self._cola.empty()) and tactual < self._texec and ejecutar: evento = self._cola.get()[1] # Coge el evento clientsAcumults = self.clientsAc/(evento.tiempo-self.timeStart) if (clientsAcumults > self.transitorio) and (not self.regimenEstacionario): self._start_metricas() self.regimenEstacionario = True while (tactual < evento.tiempo) and (tactual < self._texec) and ejecutar: if tactual < evento.tiempo: tactual = time() else: ejecutar = False if ejecutar: tactual = evento.tiempo if evento.tipoEvento == "LlegadaCliente": self.rutina_llegadas(evento,self.sufijoMetricas) elif evento.tipoEvento == "SalidaCliente": self.rutina_salida(evento) else: self.rutina_salida_sistema(evento) except KeyboardInterrupt: self.kill_threads() error = True if not error: self.kill_threads() tRespuesta = 0 stdRespuesta = 0 cvRespuesta = 0 if self.regimenEstacionario: self._end_metricas() tRespuesta = np.mean(self.muestraTRespuesta) stdRespuesta = np.std(self.muestraTRespuesta) cvRespuesta = stdRespuesta/tRespuesta meanLlegadas = np.mean(self.muestraMediaLlegadas) meanPeticiones = np.mean(self.muestraMediaPeticion) meanSesion = np.mean(self.muestraMediaSesion) self.ficheroClientes.close() self._write_t_respuesta() self._print_resultado_simulacion(meanLlegadas, meanPeticiones, meanSesion, tRespuesta, stdRespuesta, cvRespuesta)
break def elegir(mapa, lista): try: imp = "" for i in range(len(lista)): imp += "{} --> {}\n".format(str(i), lista[i].__class__.__name__) print("Mapa del {}".format(mapa.tipo)) linea = leer( "{} ingrese vehiculo a agregar:\n".format(mapa.tipo) + imp) return lista.pop(int(linea)) except Exception as e: print("[ERROR] {}".format(type(e).__name__)) return None mapear(mapa_1, lista_1) mapear(mapa_2, lista_2) sistema_1 = Sistema(player, mapa_1, mapa_2, lista_1, lista_2, radar_1, estadisticas_1, estadisticas_2, n) sistema_2 = Sistema(otro, mapa_2, mapa_1, lista_2, lista_1, radar_2, estadisticas_2, estadisticas_1, n) while True: sistema_1.turno() sistema_2.turno() # Se terminara el proceso con un exit(0) desde sistema
from sistema import Sistema ElSistema = Sistema() ElSistema.cargar_archivos('datos.json') print('Punto 1') for item in ElSistema.listaVuelos: print('Vuelo: ' + str(item.fecha) + ' ' + item.hora + ' ' + 'desde ' + item.origen + ' hasta ' + item.destino) for item2 in item.getPasajeros(): print(item2.nombre + ' ' + item2.apellido) print('\n') print('Punto 2') for item in ElSistema.listaVuelos: print('Vuelo: ' + str(item.fecha) + ' ' + item.hora + ' ' + 'desde ' + item.origen + ' hasta ' + item.destino) print(item.PasajeroMasJovenPorVuelo()) print('Punto 3') print(ElSistema.VuelosQueNoAlcanzenLaTripMinima()) for item in ElSistema.listaVuelos: for item2 in item.listaTripulacion: print(item2.nombre + ' ' + item2.DNI) for item3 in item2.avionesHabilitados: print(item3.codigo) print('\n') print('Punto 4')
''' Esse arquivo é responsável por chamar as funções de acordo com o input dos usuários. ''' # Importando bibliotecas necessárias para funcionamento do aplicativo from tela import Tela #Importando arquivo para exibição from sistema import Sistema #Importando arquivo que roda sistema import os # Instanciando classes sistema = Sistema() tela = Tela() # Exibe tela inicial sistema.carregar_conteudo() tela.exibirBemVindo() input("[Enter]") os.system('cls') acesso = False # Exibe tela de login while acesso == False: login = tela.exibirLogin() if login: acesso = Sistema().autenticacao() input("\n[Enter]") else: acesso = Sistema().cadastro() input("\n[Enter]") # Exibe menu inicial
def mover(self, vector): Sistema.mover(self, vector)
def main(): RECOMENDAR = "recomendar" DIFUNDIR = "difundir" CENTRALIDAD = "centralidad" CAMINO = "camino" DISTANCIAS = "distancias" SUBGRUPOS = "subgrupos" programa = Sistema() programa.inicializar("grafo_chico.txt") linea = raw_input() while linea: palabras = linea.split() try: if palabras[0] == RECOMENDAR: if len(palabras) == 3: programa.recomendar(palabras[1], palabras[2]) else: raise RuntimeError("(!)Los parámetros son incorrectos.\n\ (!)Se espera 'comando musico cantidad'") elif palabras[0] == DIFUNDIR: if len(palabras) > 1: programa.difundir(palabras[1:]) else: raise RuntimeError("(!)Inserte al menos un musico con el \ cual difundir la información") elif palabras[0] == CENTRALIDAD: if len(palabras) == 2: programa.centralidad(palabras[1]) else: raise RuntimeError( "(!)Debe insertar la cantidad de musico \ populares que desea conocer") elif palabras[0] == DISTANCIAS: if len(palabras) == 2: programa.distancias(palabras[1]) else: raise RuntimeError("(!)Debe insertar un músicos para \ conocer a que distancia se encuentran los demás artistas") elif palabras[0] == CAMINO: musicos = palabras[1].split(",") if len(musicos) != 2: raise RuntimeError("(!)Debe insertar un músico del cual \ partir (primero) y uno al cual llegar (segundo) separados por una coma (,)") programa.camino(musicos[0], musicos[1]) elif palabras[0] == SUBGRUPOS: if len(palabras) == 1: programa.subgrupos() else: raise RuntimeError("(!)Este comando no recibe parámetros \ extra") else: raise RuntimeError("(!)Comando desconocido. Por favor ingrese \ alguno de los siguiente comandos:\n\t-recomendar\n\t-difundir\n\t-centralidad\n\ \t-distancias\n\t-camino\n\t-subgrupo") except RuntimeError, e: print e linea = raw_input()
class Mundo: def __init__(self, base): # referencias: self.base = base self.sistema = None # componentes: self.nodo = self.base.render.attachNewNode("mundo") self.input_mapper = None self.controlador_camara = None self.terreno = None self.cielo = None self.sol = None self.agua = None self.objetos = None self.hombre = None self.nave = None # variables internas: self._counter = 50 # forzar terreno.update antes de hombre.update self._personajes = [] self._periodo_dia_actual = 0 def iniciar(self): log.info("iniciar") # sistema: self.sistema = Sistema() self.sistema.iniciar() self.sistema.cargar_parametros_iniciales() self.sistema.update(0.0, self.sistema.posicion_cursor) Sistema.establecer_instancia(self.sistema) # fisica: self._configurar_fisica() # mundo: self._establecer_material() # quitarlo, optimizacion? no, al reves! self._establecer_shader() # componentes: self.input_mapper = InputMapperTecladoMouse(self.base) self.controlador_camara = ControladorCamara(self.base) self.controlador_camara.iniciar() # self._cargar_terreno() # self._cargar_personajes() # self._cargar_objetos() # #self._cargar_obj_voxel() # gui: self._cargar_debug_info() self._cargar_gui() # ShowBase self.base.cam.node().setCameraMask(DrawMask(1)) self.base.render.node().adjustDrawMask(DrawMask(5), DrawMask(0), DrawMask(0)) # self.base.accept("l-up", self._hacer, [0]) self.base.accept("m-up", self._hacer, [1]) self.base.accept("v-up", self._hacer, [2]) # self.base.taskMgr.add(self._update, "mundo_update") # def terminar(self): log.info("terminar") # self.base.ignore("l-up") self.base.ignore("m-up") self.base.ignore("v-up") # self.controlador_camara.terminar() # for _personaje in self._personajes: _personaje.terminar() if self.objetos: self.objetos.terminar() if self.agua: self.agua.terminar() if self.sol: self.sol.terminar() if self.cielo: self.cielo.terminar() if self.terreno: self.terreno.terminar() # self.sistema = None Sistema.remover_instancia() def _hacer(self, que): if que == 0: log.debug(self.sistema.obtener_info()) elif que == 1: self.nodo.analyze() elif que == 2: self.base.bufferViewer.toggleEnable() elif que == 3: if not self.nave: return if not self.hombre.conduciendo: self.nave.setPos(self.sistema.posicion_cursor) self.hombre.cuerpo.reparentTo(self.nave.cuerpo) self.hombre.setPos(Vec3(0, 0, -0.5)) self.hombre.conduciendo = True self.controlador_camara.seguir(self.nave.cuerpo) else: self.hombre.cuerpo.reparentTo(self.nodo) self.hombre.setPos(self.sistema.posicion_cursor) self.hombre.conduciendo = False self.controlador_camara.seguir(self.hombre.cuerpo) def _establecer_material(self): log.info("_establecer_material") intensidades = (0.20, 0.35, 0.0) # (a,d,s) material = Material("material_mundo") material.setAmbient( (intensidades[0], intensidades[0], intensidades[0], 1.0)) material.setDiffuse( (intensidades[1], intensidades[1], intensidades[1], 1.0)) material.setSpecular( (intensidades[2], intensidades[2], intensidades[2], 1.0)) material.setShininess(0) self.nodo.setMaterial(material, 1) def _establecer_shader(self): log.info("_establecer_shader") GestorShader.iniciar(self.base, Sistema.TopoAltitudOceano, Vec4(0, 0, 1, Sistema.TopoAltitudOceano)) # # ¿esto habra solucionado el problema del clipping caprichoso? self.nodo.setShaderInput("altitud_agua", Sistema.TopoAltitudOceano, 0.0, 0.0, 0.0, priority=1) # #GestorShader.aplicar(self.nodo, GestorShader.ClaseGenerico, 1) # quitarlo, optimizacion? #GestorShader.aplicar(self, GestorShader.ClaseDebug, 1000) def _cargar_obj_voxel(self): hm = HeightMap(id=66) N = 64 self.obj = voxels.Objeto("volumen", N, N, N, 0) for x in range(N - 2): for y in range(N - 2): h = int(hm.getHeight(x, y) * N) print("%s,%s->%i" % (str(x), str(y), h)) for z in range(h): self.obj.establecer_valor(x + 1, y + 1, z + 1, 255) model_root = ModelRoot("volumen") self.objN = self.nodo.attachNewNode(model_root) self.objN.attachNewNode(self.obj.iniciar_smooth()) self.objN.setColor(0.4, 0.4, 0.4, 1) self.objN.setTwoSided(True, 1) self.objN.setShaderAuto() self.objN.setScale(1) self.objN.setPos(-N / 2, -N / 2, -9.5) def _configurar_fisica(self): self.bullet_world = BulletWorld() #return # debug_fisica = BulletDebugNode("debug_fisica") debug_fisica.showNormals(True) self.debug_fisicaN = self.nodo.attachNewNode(debug_fisica) self.debug_fisicaN.hide() self.base.accept("f3", self._toggle_debug_fisica) # self.bullet_world.setGravity(Vec3(0.0, 0.0, -9.81)) self.bullet_world.setDebugNode(debug_fisica) return # _shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5)) _cuerpo = BulletRigidBodyNode("caja_rigid_body") _cuerpo.setMass(1.0) _cuerpo.addShape(_shape) _cuerpoN = self.nodo.attachNewNode(_cuerpo) _cuerpoN.setPos(0.0, 0.0, 100.0) _cuerpoN.setCollideMask(BitMask32.bit(3)) self.bullet_world.attachRigidBody(_cuerpo) _cuerpoN.reparentTo(self.nodo) caja = self.base.loader.loadModel("box.egg") caja.reparentTo(_cuerpoN) def _cargar_debug_info(self): Negro = Vec4(0.0, 0.0, 0.0, 1.0) #Blanco=Vec4(1.0, 1.0, 1.0, 1.0) self.texto1 = OnscreenText(text="mundo", pos=(-1.2, 0.9), scale=0.045, align=TextNode.ALeft, fg=Negro, mayChange=True) def _cargar_gui(self): self.lblHora = DirectLabel(text="00:00", text_fg=(0.15, 0.15, 0.9, 1.0), text_bg=(1.0, 1.0, 1.0, 1.0), scale=0.1, pos=(1.2, 0.0, -0.8), color=(1, 1, 1, 1)) self.lblTemperatura = DirectLabel(text="0º", text_fg=(0.15, 0.15, 0.9, 1.0), text_bg=(1.0, 1.0, 1.0, 1.0), scale=0.1, pos=(1.2, 0.0, -0.93), color=(1, 1, 1, 1)) def _cargar_personajes(self): # personajes self.hombre = Hombre() self._personajes.append(self.hombre) # nave self.nave = Nave() self._personajes.append(self.nave) # for _personaje in self._personajes: _personaje.input_mapper = self.input_mapper _personaje.altitud_agua = Sistema.TopoAltitudOceano _personaje.iniciar(self.nodo, self.bullet_world) # posicionar self.hombre.setPos(self.sistema.posicion_cursor) pos = self.sistema.posicion_cursor + Vec3(-3, -3, 0) self.nave.setPos( Vec3(pos[0], pos[1], self.sistema.obtener_altitud_suelo(pos))) # self.controlador_camara.seguir(self.hombre.cuerpo) def _cargar_objetos(self): # self.palo = self.base.loader.loadModel("objetos/palof") self.palo.reparentTo(self.nodo) self.palo.setPos(self.sistema.obtener_posicion_3d(Vec3(12, 12, 0))) # luz_omni = self.nodo.attachNewNode(PointLight("luz_omni")) luz_omni.setPos(Vec3(0, -2, 152.5)) luz_omni.node().setColor(Vec4(1, 0, 0, 1)) luz_omni.node().setAttenuation(Vec3(0, 1.1, 0)) self.nodo.setShaderInput("luz_omni[0]", luz_omni, priority=4) # luz_omni.reparentTo(self.palo) # luz_omni.setPos(0, 0, 1) # self.spot_light = self.nodo.attachNewNode(Spotlight("spot_light")) self.spot_light.setPos(self.hombre.cuerpo.getPos() + Vec3(0, -5, 6)) self.spot_light.node().setColor((1, 1, 0.7, 1)) self.spot_light.node().setAttenuation(Vec3(0.04, 0.025, 0.01)) self.spot_light.node().setLens(PerspectiveLens()) #self.spot_light.node().setShadowCaster(True, 256, 256) self.spot_light.lookAt(self.hombre.cuerpo) self.nodo.setLight(self.spot_light) self.spot_light.reparentTo(self.palo) self.spot_light.setPos(0, 0, 1) self.spot_light.setHpr(0, 15, 0) # self.nubes = self.base.loader.loadModel("objetos/plano") self.nubes.reparentTo(self.nodo) #self.nubes.setTwoSided(True) self.nubes.setPos(self.hombre.cuerpo.getPos() + Vec3(0, -16, 2.5)) self.nubes.setP(-90) #noise=StackedPerlinNoise2(1, 1, 8, 2, 0.5, 256, 18) ts0 = TextureStage("ts_nubes") tamano = 512 imagen = PNMImage(tamano, tamano) #imagen.perlinNoiseFill(noise) for x in range(tamano): for y in range(tamano): #v=noise(x, y)*0.5+0.5 imagen.setXelA(x, y, 1, 0, 0, 0.5) tex0 = self.base.loader.loadTexture( "texturas/white_noise.png") #Texture("tex_nubes") # tex0.load(imagen) self.nubes.setTexture(ts0, tex0) # pelota = self.base.loader.loadModel("objetos/pelota.egg") pelota.reparentTo(self.nodo) pelota.setZ( self.sistema.obtener_altitud_suelo(self.sistema.posicion_cursor) + 3.0) material_pelota = Material("material_pelota") intensidades = (0.3, 0.2, 0.2) material_pelota.setAmbient( (intensidades[0], intensidades[0], intensidades[0], 1.0)) material_pelota.setDiffuse( (intensidades[1], intensidades[1], intensidades[1], 1.0)) material_pelota.setSpecular( (intensidades[2], intensidades[2], intensidades[2], 1.0)) material_pelota.setShininess(20) pelota.setMaterial(material_pelota, priority=2) GestorShader.aplicar(pelota, GestorShader.ClaseGenerico, 3) # plano_vertical = self.base.loader.loadModel( "objetos/plano_vertical.egg") plano_vertical.reparentTo(self.nodo) plano_vertical.setPos(0, -6, self.sistema.obtener_altitud_suelo((0, -6, 0))) #plano_vertical.setTwoSided(True) plano_vertical.setBillboardAxis() GestorShader.aplicar(plano_vertical, GestorShader.ClaseGenerico, 3) # nodo_flatten = self.nodo.attachNewNode("nodo_flatten") for x in range(4): p = self.base.loader.loadModel("objetos/pelota.egg") p.clearModelNodes() p.reparentTo(nodo_flatten) p.setPos(6, 0, 153 + x) p.setScale(0.2) nodo_flatten.flattenStrong() # cant = 3 prisma = self.base.loader.loadModel("objetos/prisma_tri.egg") prisma_geomnode = prisma.find("**/+GeomNode") for i_geom in range(prisma_geomnode.node().getNumGeoms()): prisma_geom = prisma_geomnode.node().getGeom(i_geom) ## prisma_vdata = prisma_geom.getVertexData() consolidado_prismas_vdata = GeomVertexData( "vertex_data", prisma_vdata.getFormat(), Geom.UHStatic) consolidado_prismas_vdata.setNumRows(cant * prisma_vdata.getNumRows()) offset = prisma_vdata.getNumRows() ## prisma_prims = list() consolidado_prismas_prims = list() for i_prim in range(prisma_geom.getNumPrimitives()): prim = prisma_geom.getPrimitive(i_prim).decompose() prisma_prims.append(prim) consolidado_prismas_prim = GeomTriangles(Geom.UHStatic) consolidado_prismas_prims.append(consolidado_prismas_prim) for i_cant in range(cant): vdata = GeomVertexData(prisma_vdata) vdata.transformVertices( LMatrix4f.translateMat(3 * i_cant, 0.0, 0.0)) for i_row in range(vdata.getNumRows()): consolidado_prismas_vdata.copyRowFrom( i_cant * offset + i_row, vdata, i_row, Thread.getCurrentThread()) for i_prim in range(len(prisma_prims)): consolidado_prismas_prim = consolidado_prismas_prims[ i_prim] prim_verts = prisma_prims[i_prim].getVertexList() for vert in prim_verts: consolidado_prismas_prim.addVertex(vert + i_cant * offset) consolidado_prismas_geom = Geom(consolidado_prismas_vdata) consolidado_prismas_geom.addPrimitive(consolidado_prismas_prim) # consolidado_prismas_geomnode = GeomNode("copia_geomnode") consolidado_prismas_geomnode.addGeom(consolidado_prismas_geom) self.nodo_prismas = self.nodo.attachNewNode("nodo_prismas") self.nodo_prismas.setPos( 20, 6, 2 + self.sistema.obtener_altitud_suelo((20, 6, 0))) self.nodo_prismas.attachNewNode(consolidado_prismas_geomnode) # def _cargar_terreno(self): # terreno self.terreno = Terreno(self.base, self.bullet_world) self.terreno.iniciar() self.terreno.nodo.reparentTo(self.nodo) self.terreno.update() # cielo self.cielo = Cielo(self.base, Sistema.TopoAltitudOceano - 20.0) self.cielo.nodo.reparentTo(self.nodo) # agua self.agua = Agua(self.base, Sistema.TopoAltitudOceano) self.agua.nodo.reparentTo(self.nodo) # estaba self.base.render self.agua.generar() # self.agua.mostrar_camaras() # sol self.sol = Sol(self.base, Sistema.TopoAltitudOceano - 20.0) self.sol.pivot.reparentTo(self.nodo) # self.cielo.nodo # self.sol.mostrar_camaras() self.nodo.setLight(self.sol.luz) # objetos # self.objetos=Objetos(self.base) # self.objetos.iniciar() # self.objetos.nodo.reparentTo(self.nodo) # self.objetos.update() # # self.cielo.nodo.setBin("background", 0) # self.agua.nodo.setBin("background", 1) # self.sol.nodo.setBin("background", 2) # self.terreno.nodo.setBin("opaque", 0) # self.objetos.nodo.setBin("transparent", 0) # self.controlador_camara.altitud_agua = Sistema.TopoAltitudOceano # def _update(self, task): if self._counter == 50: info = "" info += self.sistema.obtener_info() + "\n" #info+=self.terreno.obtener_info()+"\n" info += self.hombre.obtener_info() + "\n" #info+=self.agua.obtener_info()+"\n" #info+=self.objetos.obtener_info()+"\n" #info+=self.input_mapper.obtener_info()+"\n" #info+=self.cielo.obtener_info() #info+=self.sol.obtener_info()+"\n" self.texto1.setText(info) # tiempo dt = self.base.taskMgr.globalClock.getDt() # input self.input_mapper.update() # fisica self.bullet_world.doPhysics(dt) # controlador cámara self.controlador_camara.altitud_suelo = self.sistema.obtener_altitud_suelo( self.controlador_camara.pos_camara.getXy()) self.controlador_camara.update(dt) pos_pivot_camara = self.controlador_camara.pivot.getPos(self.nodo) self.nodo.setShaderInput("pos_pivot_camara", pos_pivot_camara, priority=10) # sistema self.sistema.update(dt, pos_pivot_camara) # cielo if self.cielo: offset_periodo = self.sistema.calcular_offset_periodo_dia() self.cielo.nodo.setX( self.controlador_camara.target_node_path.getPos().getX()) self.cielo.nodo.setY( self.controlador_camara.target_node_path.getPos().getY()) self.cielo.update(pos_pivot_camara, self.sistema.hora_normalizada, self.sistema.periodo_dia_actual, offset_periodo) self.nodo.setShaderInput("color_luz_ambiental", self.cielo.color_luz_ambiental, priority=10) self.nodo.setShaderInput("offset_periodo_cielo", self.cielo.offset_periodo, priority=10) self.nodo.setShaderInput("color_cielo_base_inicial", self.cielo.color_cielo_base_inicial, priority=10) self.nodo.setShaderInput("color_cielo_base_final", self.cielo.color_cielo_base_final, priority=10) self.nodo.setShaderInput("color_halo_sol_inicial", self.cielo.color_halo_sol_inicial, priority=10) self.nodo.setShaderInput("color_halo_sol_final", self.cielo.color_halo_sol_final, priority=10) # sol if self.sol: self.sol.update(pos_pivot_camara, self.sistema.hora_normalizada, self.sistema.periodo_dia_actual, offset_periodo) self.nodo.setShaderInput("posicion_sol", self.sol.nodo.getPos(self.nodo), priority=10) # personajes for _personaje in self._personajes: _personaje.update(dt) # contador 1/50 if self._counter == 50: self._counter = 0 # if self.terreno: self.terreno.update( ) #pos_pivot_camara)#self.controlador_camara.target_node_path.getPos()) ? if self.objetos: self.objetos.update() #pos_pivot_camara) # gui self.lblHora["text"] = self.sistema.obtener_hora() self.lblTemperatura[ "text"] = "%.0fº" % self.sistema.obtener_temperatura_actual_grados( ) # agua if self.agua: self.agua.nodo.setX( self.controlador_camara.target_node_path.getPos().getX()) self.agua.nodo.setY( self.controlador_camara.target_node_path.getPos().getY()) self.agua.update(dt, self.sol.luz.getPos(self.cielo.nodo), self.sol.luz.node().getColor()) # self._counter += 1 return task.cont def _toggle_debug_fisica(self): if self.debug_fisicaN.isHidden(): self.debug_fisicaN.show() else: self.debug_fisicaN.hide()
def __init__(self): # super(Tester, self).__init__() self.disableMouse() self.win.setClearColor(Vec4(0.95, 1.0, 1.0, 1.0)) # bullet_world = BulletWorld() # self.cam_pitch = 30.0 self.escribir_archivo = False # cada update # config.iniciar() self.sistema = Sistema() self.sistema.radio_expansion_parcelas = 1 self.sistema.iniciar() Sistema.establecer_instancia(self.sistema) # GestorShader.iniciar(self, Sistema.TopoAltitudOceano, Vec4(0, 0, 1, Sistema.TopoAltitudOceano)) GestorShader.aplicar(self.render, GestorShader.ClaseGenerico, 1) self.render.setShaderInput("distancia_fog_maxima", 3000.0, 0, 0, 0, priority=3) # self.terreno = Terreno(self, bullet_world) self.terreno.iniciar() #self.terreno.nodo.setRenderModeWireframe() # plano = CardMaker("plano_agua") r = Sistema.TopoTamanoParcela * 6 plano.setFrame(-r, r, -r, r) plano.setColor((0, 0, 1, 1)) self.plano_agua = self.render.attachNewNode(plano.generate()) self.plano_agua = self.loader.loadModel("objetos/plano_agua") self.plano_agua.reparentTo(self.render) self.plano_agua.setScale(0.5) #self.plano_agua.setP(-90.0) #self.plano_agua.hide() # self.cam_driver = self.render.attachNewNode("cam_driver") self.camera.reparentTo(self.cam_driver) self.camera.setPos(Sistema.TopoTamanoParcela / 2, 500, 100) self.camera.lookAt(self.cam_driver) self.cam_driver.setP(self.cam_pitch) # self.luz_ambiental = self.render.attachNewNode( AmbientLight("luz_ambiental")) self.luz_ambiental.node().setColor(Vec4(0.1, 0.1, 0.1, 1)) # self.sun = self.render.attachNewNode(DirectionalLight("sun")) self.sun.node().setColor(Vec4(1, 1, 1, 1)) self.sun.setPos(self.terreno.nodo, 100, 100, 100) self.sun.lookAt(self.terreno.nodo) # self.render.setLight(self.luz_ambiental) self.render.setLight(self.sun) # self.texturaImagen = None self.imagen = None self.zoom_imagen = 1 # self.tipo_imagen = Tester.TipoImagenTopo # self.taskMgr.add(self.update, "update") self.accept("wheel_up", self.zoom, [1]) self.accept("wheel_down", self.zoom, [-1]) # self._cargar_ui() #self._actualizar_terreno() self._generar_imagen()
from sistema import Sistema sistema = Sistema() opcao = '' while opcao != 'x': opcao = sistema.menu()
#Bernardo Gomes Duarte e Eduardo Borges Siqueira #turma 1208A from sistema import Sistema from voo import Voo from vooComercial import VooComercial from vooFretado import VooFretado from vooTransporte import VooTransporte from reserva import Reserva from equipeDeBordo import EquipeDeBordo from random import randint sistema = Sistema() #Menu de gerenciamento de voos def gerenciarVoos(): escolha = -1 while escolha != 0: print('-------------------------------------------------------') print('Digite a opcção desejada:') print('1.Cadastrar Voo') print('2.Cancelar Voo') print('0.Retornar ao menu principal') print('-------------------------------------------------------') escolha = int(input('')) #Retorna ao menu principal if (escolha == 0): return #Cadastro de voo
import json import datetime from persona import Persona from tripulacion import Tripulacion from servicio import Servicio from pasajeros import Pasajeros from sistema import Sistema from vuelos import Vuelos from avion import Avion a = Sistema() a.cargar() f = open('datos.json', r) diccionario = json.loads(f.read())
from sistema import Sistema sistema = Sistema() sistema.executar()
def receber_dados(): quantidade_programas = int(input("qual a quantidade de programas?")) quantidade_tipo_recursos = int( input("qual a quantidade de tipos recursos?")) flag = True while flag: recursos_totais_str = input( "digite a matriz de recursos totais(Ex: 1,2,3,4): ").split(",") if len(recursos_totais_str) == quantidade_tipo_recursos: flag = False else: print("digite separado por virgulas e/ou com {} recursos".format( quantidade_tipo_recursos)) recursos_totais = [int(i) for i in recursos_totais_str] flag = True while flag: recursos_disponiveis_str = input( "digite a matriz de recursos disponiveis(Ex: 1,2,3,4): ").split( ",") if len(recursos_disponiveis_str) == quantidade_tipo_recursos: flag = False else: print("digite separado por virgulas e/ou com {} recursos".format( quantidade_tipo_recursos)) recursos_disponiveis = [int(i) for i in recursos_disponiveis_str] matriz_alocados = [] matriz_requisitos = [] for i in range(quantidade_programas): flag = True while flag: recursos_alocados_programa = input( "digite os recursos alocados do programa {} (Ex: 1,2,3,4): ". format(i + 1)).split(",") if len(recursos_alocados_programa) == quantidade_tipo_recursos: flag = False else: print( "digite separado por virgulas e/ou com {} recursos".format( quantidade_tipo_recursos)) matriz_alocados.append([int(i) for i in recursos_alocados_programa]) flag = True while flag: recursos_requisitados_programa = input( "digite os recursos requisitados do programa {} (Ex: 1,2,3,4): " .format(i + 1)).split(",") if len(recursos_requisitados_programa) == quantidade_tipo_recursos: flag = False else: print( "digite separado por virgulas e/ou com {} recursos".format( quantidade_tipo_recursos)) matriz_requisitos.append( [int(i) for i in recursos_requisitados_programa]) print(matriz_alocados) print(matriz_requisitos) print(recursos_totais) print(recursos_disponiveis) return Sistema(recursos_totais, recursos_disponiveis, matriz_alocados, matriz_requisitos)
def main(): RECOMENDAR = "recomendar" DIFUNDIR = "difundir" CENTRALIDAD = "centralidad" CAMINO = "camino" DISTANCIAS = "distancias" SUBGRUPOS = "subgrupos" programa = Sistema() programa.inicializar("grafo_chico.txt") linea = raw_input() while linea: palabras = linea.split() try: if palabras[0] == RECOMENDAR: if len(palabras) == 3: programa.recomendar(palabras[1], palabras[2]) else: raise RuntimeError("(!)Los parámetros son incorrectos.\n\ (!)Se espera 'comando musico cantidad'") elif palabras[0] == DIFUNDIR: if len(palabras) > 1: programa.difundir(palabras[1:]) else: raise RuntimeError("(!)Inserte al menos un musico con el \ cual difundir la información") elif palabras[0] == CENTRALIDAD: if len(palabras) == 2: programa.centralidad(palabras[1]) else: raise RuntimeError("(!)Debe insertar la cantidad de musico \ populares que desea conocer") elif palabras[0] == DISTANCIAS: if len(palabras) == 2: programa.distancias(palabras[1]) else: raise RuntimeError("(!)Debe insertar un músicos para \ conocer a que distancia se encuentran los demás artistas") elif palabras[0] == CAMINO: musicos = palabras[1].split(",") if len(musicos) != 2: raise RuntimeError("(!)Debe insertar un músico del cual \ partir (primero) y uno al cual llegar (segundo) separados por una coma (,)") programa.camino(musicos[0], musicos[1]) elif palabras[0] == SUBGRUPOS: if len(palabras) == 1: programa.subgrupos() else: raise RuntimeError("(!)Este comando no recibe parámetros \ extra") else: raise RuntimeError("(!)Comando desconocido. Por favor ingrese \ alguno de los siguiente comandos:\n\t-recomendar\n\t-difundir\n\t-centralidad\n\ \t-distancias\n\t-camino\n\t-subgrupo") except RuntimeError, e: print e linea = raw_input()
class Tester(ShowBase): TipoImagenNulo = 0 TipoImagenTopo = 1 TipoImagenRuido = 2 TipoImagenRuidoContinuo = 3 def __init__(self): # super(Tester, self).__init__() self.disableMouse() self.win.setClearColor(Vec4(0.95, 1.0, 1.0, 1.0)) # bullet_world = BulletWorld() # self.cam_pitch = 30.0 self.escribir_archivo = False # cada update # config.iniciar() self.sistema = Sistema() self.sistema.radio_expansion_parcelas = 1 self.sistema.iniciar() Sistema.establecer_instancia(self.sistema) # GestorShader.iniciar(self, Sistema.TopoAltitudOceano, Vec4(0, 0, 1, Sistema.TopoAltitudOceano)) GestorShader.aplicar(self.render, GestorShader.ClaseGenerico, 1) self.render.setShaderInput("distancia_fog_maxima", 3000.0, 0, 0, 0, priority=3) # self.terreno = Terreno(self, bullet_world) self.terreno.iniciar() #self.terreno.nodo.setRenderModeWireframe() # plano = CardMaker("plano_agua") r = Sistema.TopoTamanoParcela * 6 plano.setFrame(-r, r, -r, r) plano.setColor((0, 0, 1, 1)) self.plano_agua = self.render.attachNewNode(plano.generate()) self.plano_agua = self.loader.loadModel("objetos/plano_agua") self.plano_agua.reparentTo(self.render) self.plano_agua.setScale(0.5) #self.plano_agua.setP(-90.0) #self.plano_agua.hide() # self.cam_driver = self.render.attachNewNode("cam_driver") self.camera.reparentTo(self.cam_driver) self.camera.setPos(Sistema.TopoTamanoParcela / 2, 500, 100) self.camera.lookAt(self.cam_driver) self.cam_driver.setP(self.cam_pitch) # self.luz_ambiental = self.render.attachNewNode( AmbientLight("luz_ambiental")) self.luz_ambiental.node().setColor(Vec4(0.1, 0.1, 0.1, 1)) # self.sun = self.render.attachNewNode(DirectionalLight("sun")) self.sun.node().setColor(Vec4(1, 1, 1, 1)) self.sun.setPos(self.terreno.nodo, 100, 100, 100) self.sun.lookAt(self.terreno.nodo) # self.render.setLight(self.luz_ambiental) self.render.setLight(self.sun) # self.texturaImagen = None self.imagen = None self.zoom_imagen = 1 # self.tipo_imagen = Tester.TipoImagenTopo # self.taskMgr.add(self.update, "update") self.accept("wheel_up", self.zoom, [1]) self.accept("wheel_down", self.zoom, [-1]) # self._cargar_ui() #self._actualizar_terreno() self._generar_imagen() def update(self, task): nueva_pos_foco = Vec3(self.sistema.posicion_cursor) # mwn = self.mouseWatcherNode if mwn.isButtonDown(KeyboardButton.up()): nueva_pos_foco[1] -= Sistema.TopoTamanoParcela elif mwn.isButtonDown(KeyboardButton.down()): nueva_pos_foco[1] += Sistema.TopoTamanoParcela elif mwn.isButtonDown(KeyboardButton.left()): nueva_pos_foco[0] += Sistema.TopoTamanoParcela elif mwn.isButtonDown(KeyboardButton.right()): nueva_pos_foco[0] -= Sistema.TopoTamanoParcela # if nueva_pos_foco != self.sistema.posicion_cursor: log.info("update pos_foco=%s" % str(nueva_pos_foco)) self.sistema.posicion_cursor = nueva_pos_foco self._actualizar_terreno() return task.cont def zoom(self, dir): dy = 25 * dir self.camera.setY(self.camera, dy) def analizar_altitudes(self, pos_foco, tamano=1024): log.info("analizar_altitudes en %ix%i" % (tamano, tamano)) i = 0 media = 0 vals = list() min = 999999 max = -999999 for x in range(tamano): for y in range(tamano): a = self.sistema.obtener_altitud_suelo( (pos_foco[0] + x, pos_foco[1] + y)) vals.append(a) if a > max: max = a if a < min: min = a media = ((media * i) + a) / (i + 1) i += 1 sd = 0 for val in vals: sd += ((val - media) * (val - media)) sd /= (tamano * tamano) sd = math.sqrt(sd) log.info("analizar_altitudes rango:[%.3f/%.3f] media=%.3f sd=%.3f" % (min, max, media, sd)) def _actualizar_terreno(self): log.info("_actualizar_terreno pos=%s" % (str(self.sistema.posicion_cursor))) # self.sistema.update(0, self.sistema.posicion_cursor) self.terreno.update() if self.escribir_archivo: log.info("escribir_archivo") self.terreno.nodo.writeBamFile("terreno.bam") self.plano_agua.setPos( Vec3(self.sistema.posicion_cursor[0], self.sistema.posicion_cursor[1], Sistema.TopoAltitudOceano)) # self.cam_driver.setPos( Vec3( self.sistema.posicion_cursor[0] + Sistema.TopoTamanoParcela / 2, self.sistema.posicion_cursor[1] - Sistema.TopoTamanoParcela, Sistema.TopoAltitudOceano)) # self.lblInfo["text"] = self.terreno.obtener_info() # self._generar_imagen() def _ruido(self, position, imagen_ruido, tamano_imagen_ruido): octaves = 8 persistance = 0.55 value = 0.0 amplitude = 1.0 total_amplitude = 0.0 for i_octave in range(octaves): amplitude *= persistance total_amplitude += amplitude period = 1 << (octaves - i_octave) offset_periodo_x, cant_periodos_x = math.modf(position[0] / period) offset_periodo_y, cant_periodos_y = math.modf(position[1] / period) periodo_x0 = (cant_periodos_x * period) % tamano_imagen_ruido periodo_y0 = (cant_periodos_y * period) % tamano_imagen_ruido periodo_x1 = (periodo_x0 + period) % tamano_imagen_ruido periodo_y1 = (periodo_y0 + period) % tamano_imagen_ruido c00 = imagen_ruido.getGray(int(periodo_x0), int(periodo_y0)) c10 = imagen_ruido.getGray(int(periodo_x1), int(periodo_y0)) c01 = imagen_ruido.getGray(int(periodo_x0), int(periodo_y1)) c11 = imagen_ruido.getGray(int(periodo_x1), int(periodo_y1)) interp_x0 = (c00 * (1.0 - offset_periodo_x)) + (c10 * offset_periodo_x) interp_x1 = (c01 * (1.0 - offset_periodo_x)) + (c11 * offset_periodo_x) interp_y = (interp_x0 * (1.0 - offset_periodo_y)) + (interp_x1 * offset_periodo_y) value += interp_y * amplitude #info="_ruido\tposition=%s tamano_imagen_ruido=%i i_octave=%i periodo=%i offset_periodo=%s\n"%(str(position), tamano_imagen_ruido, i_octave, period, str((offset_periodo_x, offset_periodo_y))) #info+="\tpx0=%.1f px1=%.1f offset_x=%.2f py0=%.1f py1=%.1f offset_y=%.2f interp_y=%.3f"%(periodo_x0, periodo_x1, offset_x, periodo_y0, periodo_y1, offset_y, interp_y) #print(info) #print("cxx=%s a=%.4f p=%i v=%.4f"%(str((c00, c10, c01, c11)), amplitude, period, value)) if total_amplitude > 1.0: value /= total_amplitude return value def _limpiar_imagen(self): if self.imagen: self.texturaImagen.releaseAll() self.texturaImagen.clear() self.texturaImagen = None self.imagen.clear() self.imagen = None def _generar_imagen(self): log.info("_generar_imagen") self._limpiar_imagen() if self.tipo_imagen == Tester.TipoImagenTopo: self._generar_imagen_topo() elif self.tipo_imagen == Tester.TipoImagenRuido: self._generar_imagen_ruido() elif self.tipo_imagen == Tester.TipoImagenRuidoContinuo: self._generar_imagen_ruido_continuo() def _generar_imagen_ruido_continuo(self): log.info("_generar_imagen_ruido_continuo") # tamano = 512 # # perlin_noise_scale=64 # perlin=StackedPerlinNoise2(perlin_noise_scale, perlin_noise_scale, 6, 2.0, 0.50, 256, 1069) perlin = self.sistema.ruido_terreno # if not self.imagen: type = PNMFileTypeRegistry.getGlobalPtr().getTypeFromExtension( "*.png") self.imagen = PNMImage(tamano, tamano, 4, 255, type, CS_linear) self.texturaImagen = Texture() self.frmImagen["image"] = self.texturaImagen self.frmImagen["image_scale"] = 0.4 # zoom = self.zoom_imagen log.info("zoom: %.2f" % (zoom)) # range_x, range_y=tamano, tamano # factor_x, factor_y=range_x/tamano, range_y/tamano for x in range(tamano): for y in range(tamano): # _x=x*factor_x # _y=y*factor_y # c00=perlin(_x, _y ) # c10=perlin((_x+range_x) ,_y ) # c01=perlin(_x, (_y+range_y) ) # c11=perlin((_x+range_x) ,(_y+range_y) ) # mix_x, mix_y=1.0-_x/range_x, 1.0-_y/range_y # if mix_x<0.0 or mix_y<0.0 or mix_x>1.0 or mix_y>1.0: # print("error mix_x,mix_y") # interp_x0=(c00*(1.0-mix_x))+(c10*mix_x) # interp_x1=(c01*(1.0-mix_x))+(c11*mix_x) # interp_y=(interp_x0*(1.0-mix_y))+(interp_x1*mix_y) # interp_y=interp_y*0.5+0.5 # interp_y=interp_y if interp_y<1.0 else 1.0 # interp_y=interp_y if interp_y>0.0 else 0.0 # c=interp_y # if c<0.0 or c>1.0: # print("error c") c = self.sistema.calcular_ruido_continuo(perlin, x, y, tamano) self.imagen.setXelA(x, y, c, c, c, 1.0) # # self.imagen.write("texturas/white_noise.png") image_tiled = PNMImage(2 * tamano, 2 * tamano) image_tiled.copySubImage(self.imagen, 0, 0, 0, 0, tamano, tamano) image_tiled.copySubImage(self.imagen, tamano, 0, 0, 0, tamano, tamano) image_tiled.copySubImage(self.imagen, 0, tamano, 0, 0, tamano, tamano) image_tiled.copySubImage(self.imagen, tamano, tamano, 0, 0, tamano, tamano) self.imagen.clear() self.imagen = None self.imagen = image_tiled self.texturaImagen.load(self.imagen) def _generar_imagen_ruido(self): # http://devmag.org.za/2009/04/25/perlin-noise/ log.info("_generar_imagen_ruido") return # tamano = 128 # if not self.imagen: self.imagen = PNMImage(tamano + 1, tamano + 1) self.texturaImagen = Texture() self.frmImagen["image"] = self.texturaImagen self.frmImagen["image_scale"] = 0.4 # zoom = self.zoom_imagen log.info("zoom: %.2f" % (zoom)) imagen_ruido = PNMImage("texturas/white_noise.png") n = 0 vals = list() tamano_imagen_ruido = imagen_ruido.getReadXSize() for x in range(tamano_imagen_ruido): vals.append(list()) for y in range(tamano_imagen_ruido): _x = self.sistema.posicion_cursor[0] + zoom * (tamano / 2.0) - zoom * x _y = self.sistema.posicion_cursor[1] - zoom * (tamano / 2.0) + zoom * y a = self._ruido((_x, _y), imagen_ruido, tamano_imagen_ruido) vals[x].append(a) n += 1 media = 0.0 sd = 0.0 for fila in vals: for val in fila: media += val media /= n for fila in vals: for val in fila: sd += (val - media)**2 sd = math.sqrt(sd / (n - 1)) vals2 = list() k = 7 for x in range(tamano_imagen_ruido): vals2.append(list()) for y in range(tamano_imagen_ruido): val = vals[x][y] val -= (media - 0.5) val += (0.5 - val) * (-(1.0 + (2**k) * sd)) val2 = min(1.0, max(0.0, val)) vals2[x].append(val2) for x in range(tamano_imagen_ruido): for y in range(tamano_imagen_ruido): self.imagen.setXel(x, y, vals2[x][y]) print("_generar_imagen_ruido media=%.4f sd=%.4f" % (media, sd)) # self.texturaImagen.load(self.imagen) def _generar_imagen_topo(self): log.info("_generar_imagen_topo") # tamano = 128 if not self.imagen: self.imagen = PNMImage(tamano + 1, tamano + 1) self.texturaImagen = Texture() self.frmImagen["image"] = self.texturaImagen self.frmImagen["image_scale"] = 0.4 # zoom = self.zoom_imagen log.info("zoom: %.2f" % (zoom)) for x in range(tamano + 1): for y in range(tamano + 1): _x = self.sistema.posicion_cursor[0] + zoom * (tamano / 2.0) - zoom * x _y = self.sistema.posicion_cursor[1] - zoom * (tamano / 2.0) + zoom * y a = self.terreno.sistema.obtener_altitud_suelo( (_x, _y)) / Sistema.TopoAltura if x == tamano / 2 or y == tamano / 2: self.imagen.setXel(x, y, 1.0) else: if a > (Sistema.TopoAltitudOceano / Sistema.TopoAltura): self.imagen.setXel(x, y, a, a, 0.0) else: self.imagen.setXel(x, y, 0.0, 0.0, a) # self.texturaImagen.load(self.imagen) def _ir_a_idx_pos(self): log.info("_ir_a_idx_pos") try: idx_x = int(self.entry_x.get()) idx_y = int(self.entry_y.get()) pos = self.sistema.obtener_pos_parcela((idx_x, idx_y)) tam = self.sistema.obtener_temperatura_anual_media_norm(pos) prec_f = self.sistema.obtener_precipitacion_frecuencia_anual(pos) log.info("idx_pos:(%i,%i); pos:%s; tam=%.4f prec_f=%.4f" % (idx_x, idx_y, str(pos), tam, prec_f)) self.sistema.posicion_cursor = Vec3(pos[0], pos[1], 0.0) self._actualizar_terreno() except Exception as e: log.exception(str(e)) def _cargar_ui(self): # frame self.frame = DirectFrame(parent=self.aspect2d, pos=(0, 0, -0.85), frameSize=(-1, 1, -0.15, 0.25), frameColor=(1, 1, 1, 0.5)) # info self.lblInfo = DirectLabel(parent=self.frame, pos=(-1, 0, 0.15), scale=0.05, text="info terreno?", frameColor=(1, 1, 1, 0.2), frameSize=(0, 40, -2, 2), text_align=TextNode.ALeft, text_pos=(0, 1, 1)) # idx_pos idx_pos = self.sistema.obtener_indice_parcela( self.sistema.posicion_cursor) DirectLabel(parent=self.frame, pos=(-1, 0, 0), scale=0.05, text="idx_pos_x", frameColor=(1, 1, 1, 0), frameSize=(0, 2, -1, 1), text_align=TextNode.ALeft) DirectLabel(parent=self.frame, pos=(-1, 0, -0.1), scale=0.05, text="idx_pos_y", frameColor=(1, 1, 1, 0), frameSize=(0, 2, -1, 1), text_align=TextNode.ALeft) self.entry_x = DirectEntry(parent=self.frame, pos=(-0.7, 0, 0), scale=0.05, initialText=str(idx_pos[0])) self.entry_y = DirectEntry(parent=self.frame, pos=(-0.7, 0, -0.1), scale=0.05, initialText=str(idx_pos[1])) DirectButton(parent=self.frame, pos=(0, 0, -0.1), scale=0.075, text="actualizar", command=self._ir_a_idx_pos) # self.frmImagen = DirectFrame(parent=self.frame, pos=(0.8, 0, 0.2), state=DGG.NORMAL, frameSize=(-0.4, 0.4, -0.4, 0.4)) self.frmImagen.bind(DGG.B1PRESS, self._click_imagen) DirectButton(parent=self.frame, pos=(0.500, 0, 0.65), scale=0.1, text="acercar", command=self._acercar_zoom_imagen, frameSize=(-1, 1, -0.4, 0.4), text_scale=0.5) DirectButton(parent=self.frame, pos=(0.725, 0, 0.65), scale=0.1, text="alejar", command=self._alejar_zoom_imagen, frameSize=(-1, 1, -0.4, 0.4), text_scale=0.5) DirectButton(parent=self.frame, pos=(0.950, 0, 0.65), scale=0.1, text="cambiar", command=self._cambiar_tipo_imagen, frameSize=(-1, 1, -0.4, 0.4), text_scale=0.5) def _cambiar_tipo_imagen(self): log.info("_cambiar_tipo_imagen a:") if self.tipo_imagen == Tester.TipoImagenTopo: log.info("TipoImagenRuido") self.tipo_imagen = Tester.TipoImagenRuido elif self.tipo_imagen == Tester.TipoImagenRuido: log.info("TipoImagenRuidoContinuo") self.tipo_imagen = Tester.TipoImagenRuidoContinuo elif self.tipo_imagen == Tester.TipoImagenRuidoContinuo: log.info("TipoImagenTopo") self.tipo_imagen = Tester.TipoImagenTopo self._generar_imagen() def _click_imagen(self, *args): log.info("_click_imagen %s" % str(args)) def _acercar_zoom_imagen(self): log.info("_acercar_zoom_imagen") self.zoom_imagen -= 4 if self.zoom_imagen < 1: self.zoom_imagen = 1 self._generar_imagen() def _alejar_zoom_imagen(self): log.info("_alejar_zoom_imagen") self.zoom_imagen += 4 if self.zoom_imagen > 4096: self.zoom_imagen = 4096 self._generar_imagen()
def __init__(self, n_procesadores): Sistema.__init__(self) for n in range(n_procesadores): self.procesadores.append(Procesador("Procesador %d" % (n+1), RoundRobin()))
def __init__(self, n_procesadores): Sistema.__init__(self) for n in range(n_procesadores): self.procesadores.append(Procesador("Procesador %d" % (n+1), PrioridadNoApropiativo()))
from autenticavel import Autenticavel from funcionario import Funcionario, Gerente from sistema import Sistema Autenticavel.register(Gerente) gerente = Gerente('weliton', '1234') funcionario = Funcionario('weliton') print(Sistema().login(gerente)) print(Sistema().login(funcionario))