def Pintar_caras():
for c in range(0, 6):
cara = ncara[c]
for npunto in range(1, 10):
punto = cv2.imread('Fotos_caras\Puntos\cara_' + ncara[c] + '\C_' +
ncara[c] + '_P_' + str(npunto) + '.jpg')
frameHSV = cv2.cvtColor(punto, cv2.COLOR_BGR2HSV)
colors, count = np.unique(punto.reshape(-1, punto.shape[-1]),
axis=0,
return_counts=True)
Primer_color = colors[np.argsort(-count)][:1]
ArrayHSV = Primer_color[0]
(DataNorm, MRange) = Agente.NormalData(Agente.DatabaseRead())
r = Agente.Agente(ArrayHSV, DataNorm, MRange)
colores = [Blanco, Amarillo, Azul, Verde, Rojo, Naranja]
find = False
t = 1
while find == False:
if t == r:
caras.modificar_caras(cara, npunto, colores[t - 1])
find = True
elif t >= 7:
find = True #Solo es para salir del bucle while en caso de no encontrar
else:
t = t + 1
def insertar(self):
agente = Agente()
agente.insertar(self.Hostname.get(), self.Version.get(), self.Puerto.get(), self.Comunidad.get(), self.usuario)
self.Hostname.set("")
self.Version.set("")
self.Puerto.set("")
self.Comunidad.set("")
messagebox.showinfo("Registro exitoso", "Agente registrado correctamente")
self.mostrarDispositivos()
def agregar():
"""Agrega un agente al monitoreo"""
limpiar()
print('\t\tAgregar dispositivo')
age = Agente.Agente()
print('Inserte el nombre del host o dirección IP: ')
age.ip = input()
print('Inserte la versión de SNMP; 1 o 2: ')
age.snmpver = input()
print('Inserte el nombre de la comunidad: ')
age.comun = input()
print('Inserte el número de puerto: ')
age.port = input()
#Crear rrd para empezar a monitorear
age.crearRRDTOOL()
#BD para los CPU
"""
crearBDRRD(age, 'CPU0')
#BD para los CPU
crearBDRRD(age, 'CPU1')
#BD para los CPU
crearBDRRD(age, 'CPU2')
#BD para los CPU
crearBDRRD(age, 'CPU3')
#BD para la RAM
crearBDRRD(age, 'RAM')
#BD para la HDD
crearBDRRD(age, 'HDD')
"""
#Registrar agente
agentes.append(age)
#Persistencia
salvarEstructura(agentes, 'agentes')
def Pintar_caras():
for c in range(0, 6):
cara = ncara[c]
for npunto in range(1, 10):
punto = cv2.imread('Fotos_caras\Puntos\cara_' + ncara[c] + '\C_' +
ncara[c] + '_P_' + str(npunto) + '.jpg')
#Se va a leer el color más frecuente de la imagen para compararlo con alguno de la base de datos
colors, count = np.unique(punto.reshape(-1, punto.shape[-1]),
axis=0,
return_counts=True)
Primer_color = colors[np.argsort(-count)][:1]
ArrayBGR = Primer_color[0]
#Se normalizan los valores de la base de datos
(DataNorm, MRange) = Agente.NormalData(Agente.DatabaseRead())
#se manda al Agente para que encuentre una coicidencia, y desnormaliza el resultado para encontrar una coicidencia del 1-6
#Los cuales, cada uno hace referencia a un color
r = Agente.Agente(ArrayBGR, DataNorm, MRange)
#Matices de la cara digitales
colores = [Blanco, Amarillo, Azul, Verde, Rojo, Naranja]
#Color en formato string
String_Colores = [
"Blanco", "Amarillo", "Azul", "Verde", "Rojo", "Naranja"
]
#Se buscara la coicidencia del color del punto con la base, y se procedera a colorear el punto
find = False
t = 1
while find == False:
if t == r:
modificar_caras(cara, npunto, colores[t - 1])
#Se va a hacer una lista de 55 elementos, sonde el primero no va a contar.
#Cada p colores serán los correspondientes cada cara.
Colores_puntos.append(String_Colores[t - 1])
find = True
elif t >= 7:
find = True #Solo es para salir del bucle while en caso de no encontrar
else:
t = t + 1
return Colores_puntos
def main():
MapaNuevo = Mapa.Mapa()
if (MapaNuevo.cargar_mapa()):
#Esta es una instancia del agente que creamos.
posicion_inicial = [2, 12]
Bichito = Agente.Agente(posicion_inicial, '0')
#Ciclo de movimiento del agente a través del mapa, con el método del agente
#, el print del mapa y un sleep del time, todo esto para crear una simulación de
# interfaz.
explorar = True
while explorar:
MapaNuevo.print_mapa(Bichito.ubicacion)
MapaNuevo.actualizar_contador(Bichito.ubicacion)
explorar = Bichito.moverse(
MapaNuevo.ver_campos_continuos(Bichito.ubicacion))
#MapaNuevo.print_contadores()
time.sleep(1)
else:
print("¡Mapa con errores!")
def estadoDispositivo(self):
agente = Agente()
return agente.mostrarEstados(self.usuario)
def mostrarDispositivos(self):
agente = Agente()
return agente.mostrarDispositivos(self.usuario)
def eliminar(self):
agente = Agente()
agente.eliminar(self.Comunidad.get(), self.usuario)
self.Comunidad.set("")
messagebox.showinfo("Eliminado exitoso", "Agente eliminado correctamente")
def runAG(self,numPopulacao,PopElite,PopMutante,geracoes,probCruzamento,jogosPorAgente):
geracaoAtual = 0
#cria a população inicial aleatoria
for i in range(numPopulacao):
agente = Agente()
populacao.append(agente)
#codição de parada do AG por numero de gerações
while geracaoAtual <= geracoes:
#coloca os agentes para jogar(incompleto)
threadLock = threading.Lock()
threads = []
#calcula o desepenho dos agentes com a media de tetrises pela quantidade de jogos
quantidade = 0
for agente in self.populacao:
for tetrises in agente.tetrisesFeitas:
quantidade += tetrises;
agente.desempenho = quantidade/jogosPorAgente
#ordena a populacao do melhor agente para o pior
self.populacao.sort(Key=operator.attrgetter('desempenho'),reverse=True)
#seleciona o melhor agente
self.melhorAgente = populacao[0]
Elite = []
N_Elite = []
Mutante = []
#seleciona a populacao elite e a n_elite
for i in range(numPopulacao):
if(i < PopElite):
Elite[i] = populacao[i]
else:
N_Elite[i] = populacao[i]
#gera a um populacao de mutantes
for i in range(PopMutante):
agente = Agente()
Mutante.append(agente)
#adiciona os elites e os mutantes a nova populacao
novaPopulacao = []
novaPopulacao += Elite
novaPopulacao += Mutante
filhos = []
#gera o resto da nova populacao atraves do cruzamento de um pai elite e um não elite
for i in range(numPopulacao - PopElite - PopMutante):
paiElite = random.choice(Elite)
paiNaoElite = random.choice(N_Elite)
filhos = Agente()
for i in range(Agente.Agente.qtGenes):
if(random.random() < probCruzamento ):
filho.genes[i] = paiElite.genes[i]
else:
filho.genes[i] = paiNaoElite.genes[i]
filhos.append(filho)
novaPopulacao+=filhos
self.populacao = novaPopulacao
print("geracao: "+geracaoAtual+"\n"+self.melhorAgente.genes)
geracaoAtual+=1
Puntos(77, 40, 440), Puntos(79, 160, 440), Puntos(81, 280, 440),
Puntos(83, 400, 440), Puntos(85, 520, 440), Puntos(87, 640, 440),
Puntos(89, 100, 500), Puntos(91, 220, 500), Puntos(93, 340, 500),
Puntos(95, 460, 500), Puntos(97, 580, 500),
Puntos(99, 40, 560), Puntos(101, 160, 560), Puntos(103, 280, 560),
Puntos(105, 400, 560), Puntos(107, 520, 560), Puntos(109, 640, 560),
Puntos(111, 100, 620), Puntos(113, 220, 620), Puntos(115, 340, 620),
Puntos(117, 460, 620), Puntos(119, 580, 620)]
encola = []
turn = "Rojo"
a = Agente("Azul")
tablero = {
0: ' ', 1: '1', 2: ' ', 3: '1', 4: ' ', 5: '1', 6: ' ', 7: '1', 8: ' ', 9: '1', 10: ' ',
11: '2', 12: ' ', 13: '2', 14: ' ', 15: '2', 16: ' ', 17: '2', 18: ' ', 19: '2', 20: ' ', 21: '2',
22: ' ', 23: '1', 24: ' ', 25: '1', 26: ' ', 27: '1', 28: ' ', 29: '1', 30: ' ', 31: '1', 32: ' ',
33: '2', 34: ' ', 35: '2', 36: ' ', 37: '2', 38: ' ', 39: '2', 40: ' ', 41: '2', 42: ' ', 43: '2',
44: ' ', 45: '1', 46: ' ', 47: '1', 48: ' ', 49: '1', 50: ' ', 51: '1', 52: ' ', 53: '1', 54: ' ',
55: '2', 56: ' ', 57: '2', 58: ' ', 59: '2', 60: ' ', 61: '2', 62: ' ', 63: '2', 64: ' ', 65: '2',
66: ' ', 67: '1', 68: ' ', 69: '1', 70: ' ', 71: '1', 72: ' ', 73: '1', 74: ' ', 75: '1', 76: ' ',
77: '2', 78: ' ', 79: '2', 80: ' ', 81: '2', 82: ' ', 83: '2', 84: ' ', 85: '2', 86: ' ', 87: '2',
88: ' ', 89: '1', 90: ' ', 91: '1', 92: ' ', 93: '1', 94: ' ', 95: '1', 96: ' ', 97: '1', 98: ' ',
99: '2', 100: ' ', 101: '2', 102: ' ', 103: '2', 104: ' ', 105: '2', 106: ' ', 107: '2', 108: ' ', 109: '2',
110: ' ', 111: '1', 112: ' ', 113: '1', 114: ' ', 115: '1', 116: ' ', 117: '1', 118: ' ', 119: '1'}
a.mundo = tablero
p1 = None
p2 = None
import Agente
import Ambiente
carro = Agente.Agente()
estado = Ambiente.Ambiente()
estado.AddRua(0, 1, 4)
estado.AddRua(0, 2, 2)
estado.AddRua(1, 2, 3)
estado.AddRua(2, 1, 1)
estado.AddRua(1, 3, 2)
estado.AddRua(1, 4, 3)
estado.AddRua(2, 3, 4)
estado.AddRua(2, 4, 5)
estado.AddRua(4, 3, 1)
#recomendo adicionar usando a funcao AddRua o caminho de todas as cidade para todas
menorCam = carro.EncontrarMenorCaminho(estado, 0, 2)
print('ok')
print(menorCam
) # onde tem 999999 eh porque nao tem caminho entre as duas cidades