def __init__(self):
self.resolucion = (320, 240)
self.frames = 10
self.prob_min = 0.5 # probabilidad minima de deteccion
self.log = self.__log_default
self.cv = cv2
self.vs = Webcam() # webcam
self.net = '' # red neuronal
self.frame = '' # imagen capturada
self.frameshow = None # imagen a mostrar
self.ancho = 0
self.alto = 0
self.th_detect = ThreadAdmin()
self.th_show = ThreadAdmin()
self.activo = False # Estado de ejecucion
#
self.show = False # Para visualizar o no (Tests)
self.func_detect = '' # llama la funcion con deteccion
self.func_cuadro = '' # retorna coordenadas de cuadro rostro
self.func_vista = '' # retorna punto de vista de rostro
self.func_cent_vis = '' # funcion q retorna valores para centrar la vista
self.func_unica = '' # funcion q retorna valor unico de angulo de centrado de vista (tomando rangos de min y max)
#
self.ang_x = 0 # ultimo angulo
self.ang_y = 0 # ultimo angulo
self.min_x = 4 # valor diferencia minimo para funcion unica
self.min_y = 4 # valor diferencia minimo para funcion unica
self.x = 0
self.y = 0
self.elementos = []
def __init__(self):
self.camara = Webcam()
self.tcp = Comunicacion()
self.host = "127.0.0.1"
self.reintentos = 10 # cantidad de reintentos de conexion de la camara
self.th_cam = ThreadAdmin() # Thread para la camara
self.tiempo = Timer() # Control de fps
self.log = self.__log_default # Para configurar log
class Image_Send(object):
def __init__(self):
self.camara = Webcam()
self.tcp = Comunicacion()
self.host = "127.0.0.1"
self.reintentos = 10 # cantidad de reintentos de conexion de la camara
self.th_cam = ThreadAdmin() # Thread para la camara
self.tiempo = Timer() # Control de fps
self.log = self.__log_default # Para configurar log
def config(self, host, port):
self.host = host
self.camara.config(Ancho=200, Alto=150)
self.tcp.config(host, puerto=port, cliente=False, binario=True, callback=self.__call_conexion)
def config_log(self, Log):
'''posibilidad de configurar clase Log(Texto, Modulo)'''
self.log = Log.log
self.camara.config_log(Log) # enviamos el log configurado a la camara tambien
def iniciar(self):
self.camara.start()
if self.camara.activo: # CONEXION EXITOSA
self.log("CAMARA CONECTADA","IMAGE-SEND")
self.tcp.iniciar()
else:
self.log("CAMARA SIN CONEXION", "IMAGE-SEND")
# Recepcion de datos de la conexion
def __call_conexion(self, codigo, mensaje):
if codigo == 2: # Conexion
self.th_cam.start(self.__th_camara, '', 'CAMARA ENVIO', callback=self.__log_th, enviar_ejecucion=True)
elif codigo == 4: # Recepcion de datos
self.log("RECEPCION INCORRECTA - COD: " + str(codigo) + " Men: " + str(mensaje), "IMAGE-SEND")
elif codigo != 3: # 3 es envio de datos
self.log("COD: " + str(codigo) + " Men: " + str(mensaje), "IMAGE-SEND")
def __th_camara(self, run):
self.tiempo.iniciar()
while self.tcp.conexion and run.value:
frame = self.camara.read() # Lectura de cuadro de camara
self.tcp.enviar(frame) # Enviar cuadro
# print(self.tiempo.fps()) # ver los fps que enviamos (solo envia 5 cuadros la raspberry)
self.tiempo.delay(6)
# Log por defecto
def __log_default(self, Texto, Modulo):
print(Texto)
# Log que devuelve el thread
def __log_th(self, Codigo, Mensaje):
self.log(Mensaje, "IMAGE-SEND")
def __init__(self, C_Form):
super().__init__(C_Form) # instanciamos la clase padre
# superficie interna - fondo y 4 capas
self.superficie_fondo = '' # type: pygame.Surface
self.superficie_capa1 = '' # type: pygame.Surface
self.superficie_capa2 = '' # type: pygame.Surface
self.superficie_capa3 = '' # type: pygame.Surface
self.superficie_capa4 = '' # type: pygame.Surface
self.superficie_capa5 = '' # type: pygame.Surface
self.list_puntos = []
self.th_punto = ThreadAdmin()
self.area = 0, 0, 0, 0
def __init__(self):
self.tcp = Comunicacion()
self.fdetect = Face_Detect2()
self.th_detect = ThreadAdmin()
self.host = ''
self.port = ''
self.ob_imagen = '' # type: Imagen
self.ob_label_fps = '' # type: Label
self.cola_imagen = queue.LifoQueue()
self.conexion = False # Estado de la conexion
self.tiempo = Timer()
self.evento_conexion = '' # Evento que devuelve el estado de la conexion
self.fun_envio = '' # Evento para movimiento de la vista
def __init__(self):
#inicializar y leer el primer cuadro
self.captura = '' # cv2 video captura
self.procesado = False
self.frame = ''
self.activo = False # Estado de la camara
self.th_capturar = ThreadAdmin()
self.log = self.__log_default # Para configurar log
self.src = 0
self.sleeptime = 0.01
self.modo_activo = True # Metodo activo donde la camara queda en loop constante // False solo captura en la peticion
self.ancho = 0 # devuelve valores por defecto
self.alto = 0 # devuelve valores por defecto
self.reintento = 10 # reintento de conexion
def __init__(self):
self.soc = ""
self.conexion = False # Estado de la conexion
self.estado = 0 # Valor de utlimo estado
self.cola_codigo = queue.Queue() # Cola de devolucion de codigo
self.cola_mensaje = queue.Queue(
) # Cola de devolucion de detalle del codigo
self.mensaje_velocidad = 0.001 # delay en ms entre el loop de mensajes
self.th_conexion = ThreadAdmin()
self.th_mensajes = ThreadAdmin()
# self.th_recepcion = '' # hilo de recepcion
self.host = ''
self.puerto = ''
self.buffer = 1024
self.callback = ''
self.binario = False
self.timeout = 1 # 1 segundo
def __init__(self):
# Variable local de conexion
self.conexion = False # Estado de la conexion
self.estado = 0 # Valor de utlimo estado
self.salir = False # Variable de salida
# self.cola_recepcion = queue.Queue() # Cola de datos # no usada al momento
self.cola_codigo = queue.Queue() # Cola de devolucion de codigo
self.cola_mensaje = queue.Queue() # Cola de devolucion de detalle del codigo
self.mensaje_velocidad = 0.001 # delay en ms entre el loop de mensajes
self.conexiones = 1 # Cantidad de conexiones admitidas
self.sc = '' # Socket
self.sock = '' # Socket
# variables de configuracion
self.ip = ''
self.puerto = ''
self.tam_buffer = '' # el tamano se usa para la recepcion
self.binario = False # utilizado para enviar imagenes // se debe cambiar el tamaño del buffer
self.th_conexion = ThreadAdmin()
self.th_cola = ThreadAdmin()
self.reintento = 50
self.binario = False # para enviar datos binarios
class DrawBox(ObjetoGral):
def __init__(self, C_Form):
super().__init__(C_Form) # instanciamos la clase padre
# superficie interna - fondo y 4 capas
self.superficie_fondo = '' # type: pygame.Surface
self.superficie_capa1 = '' # type: pygame.Surface
self.superficie_capa2 = '' # type: pygame.Surface
self.superficie_capa3 = '' # type: pygame.Surface
self.superficie_capa4 = '' # type: pygame.Surface
self.superficie_capa5 = '' # type: pygame.Surface
self.list_puntos = []
self.th_punto = ThreadAdmin()
self.area = 0, 0, 0, 0
def config(self, x, y, ancho, alto):
super().config(x, y, ancho, alto)
# posicion sobre superficie
self.area = 0, 0, self.ancho, self.alto
# crear la superficie interna fondo
self.superficie_fondo = pygame.Surface((self.ancho, self.alto))
def dibujar(self):
"""Dibuja fisicamente el objeto en la superficie interna
y en la sup general, posteriormente se requiere update de la sup
"""
self.superficie_fondo.fill(self.color)
# Dibujar la superficie interna en la general
self.superficie.blit(self.superficie_fondo, (self.x, self.y), self.area)
# pygame.draw.rect(self.superficie, self.color, self.rectangulo, 0) # dibujamos
def __obt_capa__(self, capa_num):
if capa_num == 0:
return self.superficie_fondo
elif capa_num == 1:
return self.superficie_capa1
elif capa_num == 2:
return self.superficie_capa2
elif capa_num == 3:
return self.superficie_capa3
elif capa_num == 4:
return self.superficie_capa4
elif capa_num == 5:
return self.superficie_capa5
###################################
### METODOS ###
###################################
def nueva_capa(self, capa_num):
# crear la superficie interna fondo
capa = pygame.Surface((self.ancho, self.alto))
capa.fill(self.color)
capa.set_colorkey(self.color) # capa con mascara oculta
if capa_num == 1:
self.superficie_capa1 = capa
elif capa_num == 2:
self.superficie_capa2 = capa
elif capa_num == 3:
self.superficie_capa3 = capa
elif capa_num == 4:
self.superficie_capa4 = capa
elif capa_num == 5:
self.superficie_capa5 = capa
def limpiar_capa(self, capa_num):
if capa_num == 0:
self.superficie_fondo.fill(self.color)
elif capa_num == 1:
self.superficie_capa1.fill(self.color)
elif capa_num == 2:
self.superficie_capa2.fill(self.color)
elif capa_num == 3:
self.superficie_capa3.fill(self.color)
elif capa_num == 4:
self.superficie_capa4.fill(self.color)
elif capa_num == 5:
self.superficie_capa5.fill(self.color)
def draw_punto(self, x, y, tamano, color, capa_num=0):
capa = self.__obt_capa__(capa_num)
pygame.draw.circle(capa, color, (int(x), int(y)), tamano)
def draw_punto_temporal(self, x, y, tamano, color, tiempo, capa_num=0):
tiempo_act = 0
color_act = color
parametros = int(x), int(y), tamano, color, color_act, tiempo, tiempo_act, capa_num
self.list_puntos.append(parametros)
if not self.th_punto.state:
self.th_punto.start(self.__hilo_punto__, '', "PUNTOS")
def __hilo_punto__(self):
indice = 0
lista = self.list_puntos.copy()
self.list_puntos.clear()
lista_tmp = []
while len(lista) > 0:
lista_tmp.clear()
lista.sort(reverse=True, key=self.__funcion_sort__)
for punto in lista:
x, y, tamano, color, color_act, tiempo, tiempo_act, capa_num = punto
tiempo_act += 1
color_act = color_a_color(color_act, color, self.color, tiempo * 10)
self.draw_punto(x, y, tamano, color_act, capa_num)
punto = x, y, tamano, color, color_act, tiempo, tiempo_act, capa_num
if tiempo_act < tiempo * 10:
lista_tmp.append(punto)
else:
self.draw_punto(x, y, tamano, self.color, capa_num)
time.sleep(0.1)
self.list_puntos.extend(lista_tmp)
lista = self.list_puntos.copy()
self.list_puntos.clear()
def __funcion_sort__(self, punto):
x, y, tamano, color, color_act, tiempo, tiempo_act, capa_num = punto
r, g, b = color_act
return r + g + b
def draw_punto_distante(self, x, y, angulo, distancia, color, tamano, capa_num=0):
x1, y1 = posLineRadio(x, y, angulo, distancia)
capa = self.__obt_capa__(capa_num)
pygame.draw.circle(capa, color, (int(x1), int(y1)), tamano)
def draw_linea(self, x1, y1, ancho, alto, color, ancho_linea=1, capa_num=0):
x2 = x1 + ancho
y2 = y1 + alto
capa = self.__obt_capa__(capa_num)
pygame.draw.line(capa, color, (x1, y1), (x2, y2), ancho_linea)
def draw_linea_angular(self, x, y, angulo, longitud, color, ancho=1, capa_num=0):
x2, y2 = posLineRadio(x, y, angulo, longitud)
capa = self.__obt_capa__(capa_num)
pygame.draw.line(capa, color, (x, y), (x2, y2), ancho)
def draw_flecha(self, x, y, angulo, longitud, color, ancho=1, capa_num=0):
x2, y2 = posLineRadio(x, y, angulo, longitud)
angulo_flecha1 = sumar_angulo(angulo, 200)
angulo_flecha2 = sumar_angulo(angulo, 160)
self.draw_linea_angular(x, y, angulo, longitud, color, ancho, capa_num)
self.draw_linea_angular(x2, y2, angulo_flecha1, (longitud/2), color, ancho, capa_num)
self.draw_linea_angular(x2, y2, angulo_flecha2, (longitud/2), color, ancho, capa_num)
def arco(self, x, y, angulo, longitud, arco, color, ancho=1):
pass
#pygame.draw.arc(self.superficie, color, rect, )
def pintar(self):
"""Actualizar el dibujo, llamar luego de terminar dibujo
"""
self.superficie.blit(self.superficie_fondo, (self.x, self.y), self.area)
if self.superficie_capa1:
self.superficie.blit(self.superficie_capa1, (self.x, self.y), self.area)
if self.superficie_capa2:
self.superficie.blit(self.superficie_capa2, (self.x, self.y), self.area)
if self.superficie_capa3:
self.superficie.blit(self.superficie_capa3, (self.x, self.y), self.area)
if self.superficie_capa4:
self.superficie.blit(self.superficie_capa4, (self.x, self.y), self.area)
if self.superficie_capa5:
self.superficie.blit(self.superficie_capa5, (self.x, self.y), self.area)
self.actualizar()
class Face_Comp(object):
def __init__(self):
self.tcp = Comunicacion()
self.fdetect = Face_Detect2()
self.th_detect = ThreadAdmin()
self.host = ''
self.port = ''
self.ob_imagen = '' # type: Imagen
self.ob_label_fps = '' # type: Label
self.cola_imagen = queue.LifoQueue()
self.conexion = False # Estado de la conexion
self.tiempo = Timer()
self.evento_conexion = '' # Evento que devuelve el estado de la conexion
self.fun_envio = '' # Evento para movimiento de la vista
def config(self, host, puerto, ob_imagen, ob_label_fps, fun_envio):
# type: (str, int, Imagen, Label, object)->None
""" Se requiere IP del Servidor y Objeto Imagen
Devuelve la imagen y los fps en un objeto label
fun envio = fun(modulo, comando, valor)
"""
self.host = host
self.port = puerto
self.ob_imagen = ob_imagen
self.ob_label_fps = ob_label_fps
self.tcp.config(host,
puerto,
binario=True,
callback=self.__call_conexion)
self.fdetect.config(Callback_Imagen=self.__call_imagen)
self.fdetect.config_callback(Func_Unica=self.__call_posdetect)
self.fun_envio = fun_envio
def config_eventos(self, evento_conexion=''):
"""evento_conexion: Funcion que devuelve True o False cuando conecta o desconecta
Ej: def evento(Estado)
"""
self.evento_conexion = evento_conexion
def iniciar(self):
self.tiempo.iniciar()
self.tcp.iniciar()
def desconectar(self):
self.tcp.desconectar()
self.th_detect.close()
def __call_conexion(self, codigo, mensaje):
""" recepcion de datos binarios del servidor tcp"""
# Conectado
if codigo == 2:
self.conexion = True
self.th_detect.start(self.__th_detector,
'',
'DETECTOR',
enviar_ejecucion=True)
self.evento_conexion(True) # Devolvemos conectado
# Desconecado
elif codigo == 0:
self.conexion = False
self.evento_conexion(False) # Devolvemos desconectado
# Recepcion de datos
elif codigo == 4:
self.cola_imagen.put(mensaje) # encolamos la imgen recibida
# Errores
elif codigo == -1:
self.conexion = False
self.evento_conexion(False) # Devolvemos desconectado
# Otros mensajes
else:
if codigo != 3: # 3 es envio de mensajes
print("MEN: " + str(codigo) + " " + str(mensaje))
def __call_imagen(self, cv_imagen):
""" recepcion de imagen procesada por el detector para insertar en el objeto imagen"""
self.ob_imagen.imagen_cv(cv_imagen)
def __th_detector(self, run):
""" envia a analizar las imagenes que entran en cola """
while run.value:
if self.cola_imagen.qsize() > 0:
# print(tiempo.fps())
self.ob_label_fps.set_text("FPS: " +
str(round(self.tiempo.fps(), 2)))
imag = self.cola_imagen.get()
self.fdetect.imagen(imag)
time.sleep(0.01)
def __call_posdetect(self, x, y):
modulo = "FACE"
comando = "CENTRAR"
valor = str(x) + "/" + str(y) # separador de valores /
self.fun_envio(modulo, comando, valor)
from componentes.thread_admin import ThreadAdmin
import time
from queue import Queue
from componentes.comunicacion import Comunicacion
from compuesto.image_send import Image_Send
from compuesto.robot_cara import Robot_Cara
from compuesto.robot_cuerp import Robot_Cuerpo
# Sensores
from sensores.ultrasonido import UltraSonido
from ia.tts import TTS
COLA_SONICO = Queue()
TH_SONICO = ThreadAdmin()
class Gestor(object):
def __init__(self):
self.tcp_gestor = Comunicacion()
self.host = "127.0.0.1"
self.log = self.__log_default # Para configurar log
# Elementos de gestion
self.im_send = Image_Send()
self.cara = Robot_Cara()
self.cuerpo = Robot_Cuerpo()
self.voz = '' # type: TTS
self.sonico_cent = UltraSonido()
def config(self, host, voz):
class Cliente_TCP(object):
def __init__(self):
self.soc = ""
self.conexion = False # Estado de la conexion
self.estado = 0 # Valor de utlimo estado
self.cola_codigo = queue.Queue() # Cola de devolucion de codigo
self.cola_mensaje = queue.Queue(
) # Cola de devolucion de detalle del codigo
self.mensaje_velocidad = 0.001 # delay en ms entre el loop de mensajes
self.th_conexion = ThreadAdmin()
self.th_mensajes = ThreadAdmin()
# self.th_recepcion = '' # hilo de recepcion
self.host = ''
self.puerto = ''
self.buffer = 1024
self.callback = ''
self.binario = False
self.timeout = 1 # 1 segundo
def config(self,
Host="127.0.0.1",
Puerto=50001,
Callback='',
Buffer=1024,
Binario=False):
''' Funcion callback devuelve (Codigo, Mensaje)
Codigos: -1: Error 0: Desconectado 1: Conectando 2: Conectado
3: Envio de Datos 4: Recepcion de Datos
Calback funcion ej: calback(codigo, mensaje): / calback(self, codigo, mensaje):
'''
self.host = Host
self.puerto = int(Puerto)
self.buffer = Buffer
self.binario = Binario # Solo puede recibir binario (cambia el buufer automatico), envia texto
self.callback = Callback # Funcion de rellamada de estados
if Binario:
self.buffer = 4096
def conectar(self):
# control de mensajes si ya se encuentra en ejecucion
if not self.th_mensajes.state:
self.th_mensajes.start(self.__th_mensajes, '', 'MENSAJES-TCP', 3,
self.__callaback_th, True)
if not self.conexion:
self.th_conexion.start(self.__th_conectar, '', 'CONEXION-TCP', 3,
self.__callaback_th, True)
else:
self.__estado(-1, "Conexion actualmente establecida")
def __th_conectar(self, run):
try:
self.conexion = True
self.__estado(1, "Estableciendo conexion")
self.soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.soc.settimeout(self.timeout)
conectar = self.soc.connect(
(self.host, self.puerto)) # si tiene que usarse
self.__estado(2, "Conexion establecida")
# ejecuta la recepcion segun binario o texto
if self.binario:
self.__recibir_bin(run) # recepcion binaria
else:
self.__recibir(run) # recepcion texto
except Exception:
self.conexion = False
self.__estado(-1, "Error en conexion")
def enviar(self, mensaje):
if self.conexion:
try:
self.soc.sendall(mensaje.encode('utf-8'))
self.__estado(3, "Enviado: " + mensaje)
except:
self.desconectar()
self.__estado(-1,
"Problemas al enviar datos. Conexion Cerrada")
else:
try:
self.__estado(-1, "Sin Conexion: " + mensaje)
except:
print("Sin Conexion: " + mensaje)
def __recibir(self, run):
self.soc.settimeout(
self.timeout) # time out de escucha // posiblementa innecesario
while self.conexion and run.value:
try:
recibido = self.soc.recv(
self.buffer
) # leer del puerto - posible bloqueo hasta recepcion (con timeout no hay)
if recibido == b'':
self.__estado(-1, "Servidor Desconectado")
self.desconectar()
else:
self.__estado(4, recibido.decode()) # Recepcion de datos
except socket.timeout as err:
pass # time out continua con el loop
except Exception as err:
self.__estado(-1, "Error SOC: " + str(err))
self.desconectar()
# Espera antes de leer nuevamente el puerto // elimanda la espera ya que la lectura es bloqueante
# time.sleep(0.1)
# recepcion binaria
def __recibir_bin(self, run):
self.soc.settimeout(
3) # time out de escucha // posiblementa innecesario
recibido = b'' # tipo de dato binario
payload_size = struct.calcsize("Q")
while self.conexion and run.value:
try:
# recibir el tama�o del mensaje
while len(recibido) < payload_size:
recibido += self.soc.recv(
self.buffer
) # leer del puerto - posible bloqueo hasta recepcion (con timeout no hay)
# obtener el tama�o del mensaje
packed_msg_size = recibido[:payload_size]
recibido = recibido[payload_size:]
msg_size = struct.unpack("Q", packed_msg_size)[0]
# Recibir todos los datos segun el tama�o
while len(recibido) < msg_size:
recibido += self.soc.recv(
self.buffer
) # leer del puerto - posible bloqueo hasta recepcion (con timeout no hay)
# print("len (recibido): ", len(recibido))
frame_data = recibido[:msg_size]
recibido = recibido[msg_size:]
# extrar el frame
frame = pickle.loads(frame_data)
# Recibido (datos binarios en frame)
# cv2.imshow('frame',frame)
# cv2.waitKey(1)
self.__estado(4, frame) # Recepcion de datos
except socket.timeout as err:
pass # time out continua con el loop
except Exception as err:
self.__estado(-1, "Error SOC: " + str(err))
self.desconectar()
def desconectar(self):
try:
self.conexion = False
self.th_conexion.close()
self.soc.close()
self.__estado(0, "Conexion Cerrada")
except Exception:
self.__estado(-1, "Error al cerrar conexion")
# codificacion y envio de estados y mensaje
def __estado(self, Estado, Mensaje):
self.estado = Estado
self.cola_codigo.put(Estado)
self.cola_mensaje.put(Mensaje)
# loop de lectura de mensajes
def __th_mensajes(self, run):
while run.value:
if self.cola_mensaje.qsize() > 0:
codigo = self.cola_codigo.get()
mensaje = self.cola_mensaje.get()
self.callback(codigo, mensaje)
time.sleep(self.mensaje_velocidad)
# Callback de TH
def __callaback_th(self, Codigo, Mensaje):
print(Mensaje)
class Servidor_TCP(object):
def __init__(self):
# Variable local de conexion
self.conexion = False # Estado de la conexion
self.estado = 0 # Valor de utlimo estado
self.salir = False # Variable de salida
# self.cola_recepcion = queue.Queue() # Cola de datos # no usada al momento
self.cola_codigo = queue.Queue() # Cola de devolucion de codigo
self.cola_mensaje = queue.Queue(
) # Cola de devolucion de detalle del codigo
self.mensaje_velocidad = 0.001 # delay en ms entre el loop de mensajes
self.conexiones = 1 # Cantidad de conexiones admitidas
self.sc = '' # Socket
self.sock = '' # Socket
# variables de configuracion
self.ip = ''
self.puerto = ''
self.tam_buffer = '' # el tamano se usa para la recepcion
self.binario = False # utilizado para enviar imagenes // se debe cambiar el tamaño del buffer
self.th_conexion = ThreadAdmin()
self.th_cola = ThreadAdmin()
self.reintento = 50
self.binario = False # para enviar datos binarios
def config(self,
Host="127.0.0.1",
Puerto=50001,
Buffer=1024,
Callback='',
Binario=False): # Con parametros opcionales
self.ip = Host
self.puerto = Puerto
self.tam_buffer = Buffer
self.binario = Binario # utilizado para enviar imagenes // solo envia binario - no recibe
self.callback = Callback # Funcion de rellamada de estados
# Mensajes de callback: 0 Desconectado| 1 Conectando| 2 Conectado
# 3 Envio de datos| 4 Recepcion de datos|-1 Error
def iniciar(self):
# control de mensajes si ya se encuentra en ejecucion
if not self.th_cola.state:
self.th_cola.start(self.__th_mensajes, '', 'MENSAJES-TCP', 3,
self.__callaback_th, True)
# inicio de intento de escucha
if not self.conexion:
self.th_conexion.start(self.__th_reintento_escucha, '', 'SERV-TCP',
3, self.__callaback_th, True)
else:
self.__estado(-1, "Conexion actualmente establecida")
# Servidor (re-intentos de escucha de conexiones)
def __th_reintento_escucha(self, run):
if not self.conexion:
intento = 0
while (intento < self.reintento) and run.value:
self.__intento_conexion(run)
if self.estado == -1:
intento += 1 # no pudo conectarse
if self.estado == 2:
self.__interno_escuchar(
run
) # conecto pasamos a escuchar y liberamos los reintentos
intento = 0
# en cuanto se corta la conexion vuelve a este loop para los reintentos de conexion
time.sleep(
5) # espera de 5 segundos antes de reintentar conexion
# Servidor (intento de conexion)
def __intento_conexion(self, run):
# INTENTO DE CONEXION
try:
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(3) # timeout de conexion
self.sock.bind((self.ip, self.puerto))
self.sock.listen(self.conexiones)
self.__estado(
1, "Esperando conexion remota en: " + str(self.ip) + " " +
str(self.puerto))
except:
self.__estado(
-1, "No es posible asignar el puerto: " + str(self.ip) + " " +
str(self.puerto))
# BLOQUE DE ESPERA DE CONEXION
while self.estado == 1 and run.value:
try:
self.sc, addr = self.sock.accept(
) # Bloquea hasta que se conectan o por timeout
self.conexion = True
self.__estado(2, "Conexion establecida")
except socket.timeout as err:
pass # time out continua con el loop
except Exception as err:
self.conexion = False
self.__estado(-1, "Error SOC: " + str(err))
# loop de escucha de mensajes una vez establecida la conexion
def __interno_escuchar(self, run):
# LOOP DE ESCUCHA
recibido = ""
self.sc.settimeout(3) # time out de escucha
while self.conexion and run.value:
try:
recibido = self.sc.recv(
self.tam_buffer
) # leer del puerto - posible bloqueo hasta recepcion
if recibido == b'':
self.desconectar()
self.__estado(0, "Cliente Desconectado - Reception end")
else:
self.__estado(
4, recibido.decode()) # Recepcion CORRECTA de datos
except socket.timeout as err:
pass # time out continua con el loop
except:
self.desconectar()
self.__estado(0, "Cliente Desconectado - Reception error")
# antes de salir cerrar para liberar puertos
def enviar(self, mensaje):
if self.conexion:
try:
if self.binario: # datos binarios // ej: imagenes
datos = pickle.dumps(
mensaje
) # para datos binarios (serializacion de datos)
# Send message length first
message_size = struct.pack(
"Q", len(datos)) # tamaño "Q" 8 bytes
# envio
self.sc.sendall(message_size + datos)
# Envio de info local
self.__estado(3, "SEND: DATOS BINARIOS")
else:
datos = str(mensaje)
self.sc.sendall(datos.encode('utf-8'))
# Envio de info local
self.__estado(3, "SEND: " + datos)
except:
self.desconectar()
self.__estado(-1,
"Problemas al enviar datos - Conexion Cerrada")
def desconectar(self):
if self.conexion:
self.conexion = False
self.sc.close()
self.sock.close()
self.estado = 0
self.__estado(0, "Conexion Cerrada")
else:
self.estado = 0
self.__estado(0, "Conexion previamente Cerrada")
# codificacion y envio de estados y mensaje
def __estado(self, Estado, Mensaje):
self.estado = Estado
self.cola_codigo.put(Estado)
self.cola_mensaje.put(Mensaje)
# loop de lectura de mensajes
def __th_mensajes(self, run):
# while self.conexion:
while run.value:
if self.cola_mensaje.qsize() > 0:
codigo = self.cola_codigo.get()
mensaje = self.cola_mensaje.get()
self.callback(codigo, mensaje)
time.sleep(self.mensaje_velocidad)
# Callback de TH
def __callaback_th(self, Codigo, Mensaje):
self.callback(Codigo, Mensaje)
class Face_Detect(object):
def __init__(self):
self.resolucion = (320, 240)
self.frames = 10
self.prob_min = 0.5 # probabilidad minima de deteccion
self.log = self.__log_default
self.cv = cv2
self.vs = Webcam() # webcam
self.net = '' # red neuronal
self.frame = '' # imagen capturada
self.frameshow = None # imagen a mostrar
self.ancho = 0
self.alto = 0
self.th_detect = ThreadAdmin()
self.th_show = ThreadAdmin()
self.activo = False # Estado de ejecucion
#
self.show = False # Para visualizar o no (Tests)
self.func_detect = '' # llama la funcion con deteccion
self.func_cuadro = '' # retorna coordenadas de cuadro rostro
self.func_vista = '' # retorna punto de vista de rostro
self.func_cent_vis = '' # funcion q retorna valores para centrar la vista
self.func_unica = '' # funcion q retorna valor unico de angulo de centrado de vista (tomando rangos de min y max)
#
self.ang_x = 0 # ultimo angulo
self.ang_y = 0 # ultimo angulo
self.min_x = 4 # valor diferencia minimo para funcion unica
self.min_y = 4 # valor diferencia minimo para funcion unica
self.x = 0
self.y = 0
self.elementos = []
def config(self, Resolucion=(320, 240), Frames=10, Show=False):
self.resolucion = Resolucion
self.frames = Frames
self.show = Show
#
proto = Path_Actual(
__file__) + '/face_detect_files/deploy.prototxt.txt'
model = Path_Actual(
__file__
) + '/face_detect_files/res10_300x300_ssd_iter_140000.caffemodel'
self.net = self.cv.dnn.readNetFromCaffe(proto, model)
#
#self.vs.config()
if self.show:
self.log("Iniciando video show", "FACE_DETECT")
self.th_show.start(self.__th_show,
'',
'FACE_SHOW',
callback=self.__callaback_th)
def config_callback(self,
Func_Detect='',
Func_Cuadro='',
Func_Vista='',
Func_Cent_Vista='',
Func_Unica=''):
# Func_Detect = Funcion()
# Func_Cuadro = Funcion(X,Y,Ancho,Alto)
# Func_Vista = Funcion(X,Y)
# Func_Cent_Vista = Funcion(X,Y)
# Func_Unica = Funcion(X,Y)
self.func_detect = Func_Detect
self.func_cuadro = Func_Cuadro
self.func_vista = Func_Vista
self.func_cent_vis = Func_Cent_Vista
self.func_unica = Func_Unica
def config_log(self, Log):
#posibilidad de configurar clase Log(Texto, Modulo)
self.log = Log.log
self.vs.config_log(Log)
def check(self, source=0):
return self.vs.check()
def iniciar(self):
# inicializar video
self.vs.start()
self.activo = True
self.log("Iniciando video stream", "FACE_DETECT")
self.th_detect.start(self.__th_loop,
'',
'FACE_DETECT',
callback=self.__callaback_th)
def stop(self):
self.activo = False
def __th_show(self):
while True:
if (self.frameshow is not None):
time.sleep(0.01)
self.cv.imshow("Frame", self.frameshow)
## Salir con Q
key = self.cv.waitKey(1) & 0xFF
if key == ord("q"):
break
def __th_loop(self):
self.log("Loop de deteccion", "FACE_DETECT")
# Loop
while self.activo:
# Lectura de frame
self.frame = self.vs.read()
# Ajuste de tamaño
self.frame = imutils.resize(self.frame,
width=self.resolucion[0],
height=self.resolucion[1])
#h y w devuelve la resolucion real
(self.alto, self.ancho) = self.frame.shape[:2]
# conversion a blob en 300 x 300
blob = self.cv.dnn.blobFromImage(
self.cv.resize(self.frame, (300, 300)), 1.0, (300, 300),
(104.0, 177.0, 123.0))
# enviar el blob a la red neuronal y obtener deteccion
self.net.setInput(blob)
detections = self.net.forward()
# loop sobre las detecciones encntradas
for i in range(0, detections.shape[2]):
confidence = detections[0, 0, i, 2] # extraer la probabilidad
if confidence > self.prob_min:
# detectado
self.__deteccion(detections, i)
# revisamos si es vista unica una vez q reviso todo
if self.func_unica != '':
#pass
self.__funcion_unica()
#dibujamos
self.frameshow = self.frame
#fin de streaming
self.vs.stop()
def __funcion_unica(self):
if self.elementos:
maximos = max(self.elementos)
self.elementos.clear()
# contruir
x = maximos[1]
y = maximos[2]
box = maximos[3]
xc = maximos[4]
yc = maximos[5]
# determinar angulo de desplazamiento (30 es el grado focal de la camara)
angulo_x = int((xc / (self.resolucion[0] / 2)) * 30)
angulo_y = int((yc / (self.resolucion[1] / 2)) * 30)
if (abs(angulo_x) > self.min_x) or (abs(angulo_y) > self.min_y):
if (self.ang_x != angulo_x) or (self.ang_y != angulo_y):
self.func_unica(angulo_x, angulo_y)
self.ang_x = angulo_x
self.ang_y = angulo_y
else:
if (self.ang_x != 0) or (self.ang_y != 0):
self.func_unica(0, 0)
self.ang_x = 0
self.ang_y = 0
# dibuja rectangulo
if (self.show):
(startX, startY, endX, endY) = box.astype("int")
self.cv.rectangle(self.frame, (startX, startY), (endX, endY),
(0, 0, 255), 2)
# dibujar el centro de vista
self.cv.circle(self.frame, (x, y), 10, (0, 0, 255), 2)
def __deteccion(self, detections, elemento):
# envelementoar detectado
if self.func_detect != '':
# llamar funcion
self.func_detect()
# enviar cuadro o vista
if (self.func_cuadro != '') or (self.func_vista != '') or (
self.func_cent_vis != '') or ((self.func_unica != '')):
#generar coordenadas al rededor del rostro
box = detections[0, 0, elemento, 3:7] * np.array(
[self.ancho, self.alto, self.ancho, self.alto])
(startX, startY, endX, endY) = box.astype("int")
y = startY - 10 if startY - 10 > 10 else startY + 10
# devolvemos la funcion cuadro
if (self.func_cuadro != ''):
self.func_cuadro(startX, startY, endX, endY)
# calculamos la funcion vista
if (self.func_vista != '') or ((self.func_cent_vis != '')) or (
(self.func_unica != '')):
x = int(startX + ((endX - startX) / 2))
y = int(startY + ((endY - startY) / 3))
# devolvemos la funcion vista
if (self.func_vista != ''):
self.func_vista(x, y)
if (self.func_cent_vis != '') or (self.func_unica != ''):
xc = x - (self.ancho / 2)
yc = y - (self.alto / 2)
# devolvemos la funcion centrado
if (self.func_cent_vis != ''):
self.func_cent_vis(xc, yc)
# identificar un unico rostro
if (self.func_unica != ''):
taman = (box[2] - box[0]) * (box[3] - box[1])
#self.elementos[elemento] = taman
resul = [taman, x, y, box, xc, yc]
self.elementos.append(resul)
# solo si no esta la funcion unica
if (self.show) and (self.func_unica == ''):
# dibuja rectangulo
if self.func_cuadro != '':
self.cv.rectangle(self.frame, (startX, startY),
(endX, endY), (0, 0, 255), 2)
# dibujar el centro de vista
if self.func_vista != '':
self.cv.circle(self.frame, (x, y), 10, (0, 0, 255), 2)
# Log por defecto
def __log_default(self, Texto, Modulo):
print(Texto)
def __callaback_th(self, Codigo, Mensaje):
self.log(Mensaje, "FACE_DETECT")
""" Prueba de uso de binarios """
import time
# Esto es para poder hacer el from desde un nivel atras y funciona con launch.json
import os, sys
BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_PATH)
from componentes.comunic.servidor_tcp import Servidor_TCP
from componentes.webcam import Webcam
from componentes.thread_admin import ThreadAdmin
th_cam = ThreadAdmin()
tcp = Servidor_TCP()
cam = Webcam()
cam.config(0, ModoActivo=True)
cam.start()
time.sleep(1)
def fun_calback(Codigo, Mensaje):
if Codigo != 3:
print("COD: ", Codigo, "Men: ", Mensaje)
if Codigo == 2:
th_cam.start(th_camara, '', 'CAMARA ENVIO')
def th_camara():
time.sleep(2)
while True:
frame = cam.read()
""" Prueba de uso de binarios """
import time
# Esto es para poder hacer el from desde un nivel atras y funciona con launch.json
import os, sys
BASE_PATH = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_PATH)
from componentes.comunic.servidor_tcp import Servidor_TCP
from componentes.webcam import Webcam
from componentes.thread_admin import ThreadAdmin
from componentes.timer import Timer
th_cam = ThreadAdmin()
tcp = Servidor_TCP()
cam = Webcam()
tiempo = Timer()
cam.config(0,ModoActivo=True)
cam.start()
time.sleep(1)
def fun_callback(Codigo, Mensaje):
if Codigo != 3:
print("COD: ", Codigo, "Men: ", Mensaje)
if Codigo == 2:
pass
th_cam.start(th_camara,'','CAMARA ENVIO',enviar_ejecucion=True)
def th_camara(run):
class Webcam(object):
def __init__(self):
#inicializar y leer el primer cuadro
self.captura = '' # cv2 video captura
self.procesado = False
self.frame = ''
self.activo = False # Estado de la camara
self.th_capturar = ThreadAdmin()
self.log = self.__log_default # Para configurar log
self.src = 0
self.sleeptime = 0.01
self.modo_activo = True # Metodo activo donde la camara queda en loop constante // False solo captura en la peticion
self.ancho = 0 # devuelve valores por defecto
self.alto = 0 # devuelve valores por defecto
self.reintento = 10 # reintento de conexion
def config(self, src=0, ModoActivo=True, Ancho=0, Alto=0, reint_conex=10):
''' reint_conex: Reintentos de conexion con la camara
ModoActivo: Camara capturando en segundo plano (mas rapido en raspberry)
'''
self.src = src
self.modo_activo = ModoActivo
self.ancho = Ancho
self.alto = Alto
self.reintento = reint_conex
def config_log(self, Log):
'''posibilidad de configurar clase Log(Texto, Modulo)'''
self.log = Log.log
def start(self):
# reintento de conexion a la camara
for intento in range(0, self.reintento):
self.log("Inicializando Webcam", "WEBCAM")
if Windows():
self.captura = cv2.VideoCapture(self.src, cv2.CAP_DSHOW)
else:
self.captura = cv2.VideoCapture(self.src)
# Revisar si conecto la camara
if self.captura.isOpened():
self.log("Webcam Inicializada", "WEBCAM")
(self.procesado, self.frame) = self.captura.read()
self.activo = True
if self.modo_activo:
self.th_capturar.start(self.__th_loop,'','WEBCAM', callback=self.__callaback_th, enviar_ejecucion=True)
# Salimos del reintento
break
else:
self.log("Webcam (Falla en conexion)", "WEBCAM")
time.sleep(2) # pausa de 2 segundos para reintentar conexion
def stop(self):
if not self.modo_activo:
self.captura.release()
self.activo = False
if self.modo_activo:
self.th_capturar.close()
self.log("Webcam Stop", "WEBCAM")
def read(self):
if self.modo_activo:
return self.frame # devuelve imagen previamente capturada en el loop
else:
self.__captura()
return self.frame # devuelve imagen capturada
def check(self):
''' Controla si la webcam esta disponible
'''
if Windows():
self.captura = cv2.VideoCapture(self.src, cv2.CAP_DSHOW)
else:
self.captura = cv2.VideoCapture(self.src)
if self.captura.isOpened():
self.captura.release()
self.log("Webcam disponible", "WEBCAM")
return True
else:
self.captura.release()
self.log("Webcam no disponible", "WEBCAM")
return False
def __th_loop(self, run):
while self.activo and run.value:
self.__captura()
time.sleep(self.sleeptime) # descansar
# cierre
self.captura.release()
self.log("Webcam Stoped", "WEBCAM")
def __captura(self):
if self.captura.isOpened():
# leer cuadro
(self.procesado, tmp_frame) = self.captura.read()
if self.procesado:
if self.ancho == 0:
self.frame = tmp_frame # tamaño original
else:
# tamaño ajustado
# print("ajustar tam")
self.frame = imutils.resize(tmp_frame, width=self.ancho, height=self.alto)
# print("ajustar tam ok")
else:
self.log("Frame Error", "WEBCAM")
self.log("Posible camara desconectada", "WEBCAM")
self.stop() # Frenar la camara para que no entre en loop
else:
self.log("Camara desconectada", "WEBCAM")
self.activo = False # desactivamos la camara.
# Log por defecto
def __log_default(self, Texto, Modulo):
print(Texto)
# Callback de TH
def __callaback_th(self, Codigo, Mensaje):
self.log(Mensaje, "WEBCAM")