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))