def __main_function__():
# Import some global varialbes
global archivoDeVideo
global acaboDeIniciarNuevoCiclo
acaboDeIniciarNuevoCiclo = False
global tuveInfracciones
tuveInfracciones = False
# Creamos el reporte inicial
miReporte = MiReporte(levelLogging=logging.INFO,nombre=__name__) # Se crea por defecto con nombre de la fecha y hora actual
miReporte.info('Programa iniciado exitosamente con ingreso de senal video '+archivoDeVideo+entradaReal+' con semaforo '+semaforoSimuladoTexto+str(periodoDeSemaforo) +', corriendo a '+str(mifps)+' Frames por Segundo')
# Si no existe el directorio de reporte lo creo
if not os.path.exists(directorioDeReporte):
os.makedirs(directorioDeReporte)
# Vector de inicio:
# vector de inicio = [tiempo, periodo semaforo, cruce, giro, infraccion, otros]
vectorDeInicio = [[datetime.datetime.now(),0,0,0,0,0]]
if os.path.isfile(reporteDiario):
miReporte.info('Continuando reporte')
np.save(reporteDiario,np.append(np.load(reporteDiario),vectorDeInicio,0))
else:
miReporte.info('Creando reporte desde cero')
np.save(reporteDiario,vectorDeInicio)
# Is statements
if generarArchivosDebug:
miReporte.info('Generando Archivos de Debug')
else:
miReporte.info('Generando infracciones unicamente (No debug video)')
# If mostrar Imagenes
if mostrarImagen:
miReporte.info('Pantalla de muestra de funcionamiento en tiempo real encendida')
else:
miReporte.info('Pantalla de muestra de funcionamiento en tiempo real apagada')
# El directorio de reporte debe crearse al inicio del programa
# Variables de control:
numeroDeFrame = 0
maximoInfraccionesPorFrame = 20
#colores = np.random.randint(0,100,(maximoInfraccionesPorFrame,3))
# Cargando los parametros de instalacion:
# El archivo de video debe tener como minimo 5 caracteres para estar trnajando en modo simulado, de lo contrario estamos trabajando en modo real
if len(archivoDeVideo) > 4:
archivoParametrosACargar = archivoDeVideo[:-4]+'.npy'
else:
archivoParametrosACargar = 'datos.npy'
parametrosInstalacion = np.load(folderDeInstalacion+'/'+archivoParametrosACargar)
miReporte.info('Datos de Instalacion de: '+folderDeInstalacion+'/'+archivoParametrosACargar)
poligonoSemaforo = parametrosInstalacion[0]
verticesPartida = parametrosInstalacion[1]
verticesLlegada = parametrosInstalacion[2]
indicesSemaforo = obtenerIndicesSemaforo(np.array(poligonoSemaforo))
angulo = parametrosInstalacion[3]
poligonoEnAlta = parametrosInstalacion[4]
miReporte.info('Cargado exitosamente parametros de instalacion ')#+str(parametrosInstalacion))
# Arrancando camara
if len(archivoDeVideo) == 0:
conVideoGrabado = False # modo real
miCamara = cv2.VideoCapture(0)
miCamara.set(3,640)
miCamara.set(4,480)
time.sleep(1)
miReporte.info('Activada Exitosamente cámara en tiempo real')
else:
conVideoGrabado = True
try:
miCamara = cv2.VideoCapture(directorioDeVideos+'/'+archivoDeVideo)
time.sleep(1)
miReporte.info('Archivo de video cargado exitosamente: '+directorioDeVideos+'/'+archivoDeVideo)
except Exception as currentException:
miReporte.error('No se pudo cargar el video por '+str(currentException))
# Se captura la imagen de flujo inicial y se trabaja con la misma
ret, frameVideo = miCamara.read()
frameFlujo = cv2.resize(frameVideo,(320,240))
# Creación de objetos:
if os.uname()[1] == 'raspberrypi':
trabajoConPiCamara = True
else:
trabajoConPiCamara = False
miPoliciaReportando = PoliciaInfractor(frameFlujo,verticesPartida,verticesLlegada)
miGrabadora = GeneradorEvidencia(directorioDeReporte,mifps,False)
miFiltro = IRSwitch()
miAcetatoInformativo = Acetato()
miSemaforo = CreateSemaforo(periodoDeSemaforo)
miAcetatoInformativo.colocarPoligono(np.array(poligonoSemaforo)//2)
miAcetatoInformativo.colocarPoligono(np.array(verticesPartida))
miAcetatoInformativo.colocarPoligono(np.array(verticesLlegada))
miAcetatoInformativo.colocarPoligono(miPoliciaReportando.carrilValido)
# El historial sera una lista de la siguiente forma:
# {numeroFrame: {'frame':np.array((320,240)),'data':{"info"}}}
historial = {}
frame_number = 0
tiempoAuxiliar = time.time()
periodoDeMuestreo = 1.0/mifps
grupo = [0]
try:
while True:
# LEEMOS LA CAMARA DE FLUJO
if conVideoGrabado:
for i in range(videofps//mifps):
ret, frameVideo = miCamara.read()
else:
ret, frameVideo = miCamara.read()
pixeles = np.array([frameVideo[indicesSemaforo[0][1],indicesSemaforo[0][0]]])
#print('IndicesPixel: ',indicesSemaforo[0][0],indicesSemaforo[0][1])
#print('La longitud semaforo: ',len(indicesSemaforo),' inicial ',pixeles.shape)
#print('La longitud interna: ',len(indicesSemaforo[0]),' inicial ',pixeles.shape)
for indiceSemaforo in indicesSemaforo[1:]:
pixeles = np.append(pixeles,[frameVideo[indiceSemaforo[1],indiceSemaforo[0]]], axis=0)
#cv2.circle(frameVideo, (indiceSemaforo[0],indiceSemaforo[1]), 1, (100,100,100), -1)
#print('Pixeles: ',pixeles)
wtf = pixeles.reshape((24,8,3))
#cv2.imshow('Semaforo', cv2.resize(wtf, (240,320)))
#print('La longitud pixels: ',pixeles.shape)
senalSemaforo, semaforoLiteral, flanco, periodo = miSemaforo.obtenerColorEnSemaforo(pixeles)
frameFlujo = cv2.resize(frameVideo,(320,240))
if periodo != 0:
miReporte.info('SEMAFORO EN VERDE, EL PERIODO ES '+str(periodo))
miReporte.info('DateTime '+datetime.datetime.now().strftime('%Y%m%d_%H%M'))
cruce = miPoliciaReportando.estadoActual['cruzo']
giro = miPoliciaReportando.estadoActual['giro']
infraccion = miPoliciaReportando.estadoActual['infraccion']
otro = miPoliciaReportando.estadoActual['ruido']
vectorDeInicio = [[datetime.datetime.now(),periodo,cruce,giro,infraccion,otro]]
np.save(reporteDiario,np.append(np.load(reporteDiario),vectorDeInicio,0))
else:
pass
# Si tengo infracciones pendientes las evoluciono
velocidadEnBruto, velocidadFiltrada, pulsoVehiculos, momentumAEmplear = miPoliciaReportando.seguirImagen(frame_number,frameFlujo,colorSemaforo = senalSemaforo)
if senalSemaforo >= 1 : # Si estamos en rojo, realizamos una accion
if flanco == 1: # esto se inicia al principio de este estado
miReporte.info('SEMAFORO EN ROJO')
if senalSemaforo == 0: # Si estamos en verde realizamos otra accion
if flanco == -1: # Si estamos en verde y en flanco, primer verde, realizamos algo
miReporte.info('INICIANDO REPORTE DE: '+str(miPoliciaReportando.numeroInfraccionesConfirmadas())+' INFRACCIONES')
acaboDeIniciarNuevoCiclo = True
ultimoNumeroInfraccion = miPoliciaReportando.numeroInfraccionesConfirmadas()
if acaboDeIniciarNuevoCiclo:
if miPoliciaReportando.numeroInfraccionesConfirmadas() > 0:
tuveInfracciones = True
infraccionEnRevision = miPoliciaReportando.popInfraccion()
miGrabadora.generarReporteInfraccion(historial, infraccionEnRevision)
else:
if (tuveInfracciones):
if generarArchivosDebug:
miGrabadora.generarReporteInfraccion(historial, False,ultimoNumeroInfraccion)
tuveInfracciones = False
miPoliciaReportando.purgarInfraccionesRemanentes()
del historial
historial = {}
frame_number = 0
acaboDeIniciarNuevoCiclo = False
else:
#Si no hay infracciones a reportar me fijo el estado del filtro:
tiempoAhora = datetime.datetime.now().hour*60 + datetime.datetime.now().minute
if (tiempoAhora > amaneciendo) & (miFiltro.ultimoEstado != 'Filtro Activado'):
miFiltro.colocarFiltroIR()
if (tiempoAhora < amaneciendo) & (miFiltro.ultimoEstado != 'Filtro Desactivado'):
miFiltro.quitarFiltroIR()
# Draw frame number into image on top
for infraction in miPoliciaReportando.listaVehiculos:
for puntos in infraction['desplazamiento']:
puntosExtraidos = puntos.ravel().reshape(puntos.ravel().shape[0]//2,2)
miAcetatoInformativo.colocarObjeto(puntosExtraidos,infraction['estado'])
#for punto in puntosExtraidos:
# if infraction['estado'] == 'Confirmado':
# miAcetatoInformativo.colocarPunto(tuple(punto),0)
# else:
# miAcetatoInformativo.colocarPunto(tuple(punto),1)
#for puntoResguardo in miPoliciaReportando.obtenerLineasDeResguardo(False):
miAcetatoInformativo.colocarObjeto(miPoliciaReportando.obtenerLineasDeResguardo(True),'Referencia')
# Configs and displays for the MASK according to the semaforo
#miAcetatoInformativo.agregarTextoEn("I{}".format(miPoliciaReportando.infraccionesConfirmadas), 2)
miAcetatoInformativo.colorDeSemaforo(senalSemaforo)
historial[frame_number] = {'captura':frameFlujo.copy()}
frameFlujo = miAcetatoInformativo.aplicarAFrame(frameFlujo)
if mostrarImagen:
#cv2.imshow('Visual', miAcetatoInformativo.aplicarAFrame(frameFlujo)[120:239,60:360])
cv2.imshow('Visual',frameFlujo)
if generarArchivosDebug:
historial[frame_number]['frame'] = frameFlujo.copy()
else:
historial[frame_number]['frame'] = historial[frame_number]['captura']
historial[frame_number]['data'] = [velocidadEnBruto, velocidadFiltrada, pulsoVehiculos, momentumAEmplear]
miAcetatoInformativo.inicializar()
tiempoEjecucion = time.time() - tiempoAuxiliar
if tiempoEjecucion>periodoDeMuestreo:
miReporte.warning('\t[f{}'.format(frame_number)+']'+' Periodo Excedido {0:2f}'.format(tiempoEjecucion)+ '[s]')
#sys.stdout.write("\033[F")
while time.time() - tiempoAuxiliar < periodoDeMuestreo:
True
tiempoAuxiliar = time.time()
porcentajeDeMemoria = psutil.virtual_memory()[2]
if (porcentajeDeMemoria > 80)&(os.uname()[1] == 'raspberrypi'):
miReporte.info('Estado de Memoria: '+str(porcentajeDeMemoria)+'/100')
"""
if porcentajeDeMemoria > 96:
miReporte.warning('Alcanzado 96/100 de memoria, borrando todo e inicializando')
del historial
historial = {}
frame_number = 0
"""
frame_number += 1
if (frame_number >= topeEjecucion) &(topeEjecucion!=0):
miReporte.info('ABANDONANDO LA EJECUCION DE PROGRAMA por indice de auto acabado predeterminado')
miPoliciaReportando.apagarCamara()
break
if senalSemaforo == -2:
miReporte.critical('ABANDONANDO LA EJECUCION DE PROGRAMA El semaforo ya no obtuvo señal, necesito recalibrar, abandonando la ejecución del programa')
break
ch = 0xFF & cv2.waitKey(5)
if ch == ord('q'):
miReporte.info('ABANDONANDO LA EJECUCION DE PROGRAMA por salida manual')
miPoliciaReportando.apagarCamara()
break
if ch == ord('s'):
cv2.imwrite(datetime.datetime.now().strftime('%Y-%m-%d_%H:%M:%S')+'.jpg',frameFlujo)
except KeyboardInterrupt as e:
miReporte.info('Salida forzada')
miPoliciaReportando.apagarCamara()
class PoliciaInfractor():
"""
Esta clase recibe una imagen, el estado del semaforo y determina flujo vehicular e infracciones
"""
def __init__(self,
imagenParaInicializar,
poligonoPartida,
poligonoLlegada,
segundaCamara=False):
# Tomo la imagen de inicialización y obtengo algunas caracteristicas de la misma
self.miReporte = MiReporte(levelLogging=logging.DEBUG, nombre=__name__)
self.imagenAuxiliar = cv2.cvtColor(imagenParaInicializar,
cv2.COLOR_BGR2GRAY)
try:
height, width = self.imagenAuxiliar.shape
except:
self.miReporte.error(
'No pude obtener data, es una imagen el objeto de inicializacion?'
)
self.areaDeResguardo = np.array(poligonoPartida)
self.areaDeConfirmacion = np.array(poligonoLlegada)
# En si un punto sale del carril valido (ensanchado debidamente) se descarta el punto individual
self.carrilValido = np.array([
poligonoPartida[0], poligonoPartida[1], poligonoPartida[2],
poligonoPartida[3], poligonoLlegada[2], poligonoLlegada[3],
poligonoLlegada[0], poligonoLlegada[1]
])
# la linea de referencia para tamanio sera del largo del paso de cebra, su longitud servira para descartar puntos que se alejen del resto
self.lineaReferenciaTamanio = np.array(poligonoPartida[0]) - np.array(
poligonoPartida[1])
self.maximaDistanciaEntrePuntos = math.sqrt(
self.lineaReferenciaTamanio[0]**2 +
self.lineaReferenciaTamanio[1]**2)
# La linea de pintado LK y trasera son los puntos del paso de cebra
self.lineaDePintadoLK = np.array(
[poligonoPartida[0], poligonoPartida[3]])
self.lineaTraseraLK = np.array(
[poligonoPartida[1], poligonoPartida[2]])
self.miFiltro = AnalisisOnda()
ditanciaEnX = self.lineaDePintadoLK[1][0] - self.lineaDePintadoLK[0][0]
ditanciaEnY = self.lineaDePintadoLK[1][1] - self.lineaDePintadoLK[0][1]
vectorParalelo = self.lineaDePintadoLK[1] - self.lineaDePintadoLK[0]
self.vectorParaleloUnitario = (vectorParalelo) / math.sqrt(
vectorParalelo[0]**2 + vectorParalelo[1]**2)
self.vectorPerpendicularUnitario = np.array(
[self.vectorParaleloUnitario[1], -self.vectorParaleloUnitario[0]])
self.numeroDePuntos = 9
self.stepX = ditanciaEnX // self.numeroDePuntos
self.stepY = ditanciaEnY // self.numeroDePuntos
self.lk_params = dict(winSize=(15, 15),
maxLevel=7,
criteria=(cv2.TERM_CRITERIA_EPS
| cv2.TERM_CRITERIA_COUNT, 10, 0.03))
# erase 4 lines featureparams
self.lineaDeResguardoDelantera = np.array([self.lineaDePintadoLK[0]])
self.lineaFijaDelantera = np.zeros((self.numeroDePuntos + 1, 1, 2))
self.lineaEmpuje = np.zeros((self.numeroDePuntos + 1, 1, 2))
self.restablecerLineaLK()
self.listaDeInfracciones = []
self.maximoNumeroFramesParaDescarte = 100
self.segundaCamara = segundaCamara
self.ultimaCarpetaGuardado = ''
if self.segundaCamara:
self.camaraAlta = ControladorCamara()
def establecerRegionInteresAlta(self, cutPoly):
if self.segundaCamara:
pass
#self.camaraAlta.establecerRegionInteres(cutPoly)
else:
pass
# No longer needed
def inicializarAgente(self, ):
"""
Resets the starting line to get ready to the next frame
"""
self.restablecerLineaLK()
del self.listaDeInfracciones
self.listaDeInfracciones = []
def restablecerLineaLK(self, ):
self.lineaDeResguardoDelantera = np.array([[self.lineaDePintadoLK[0]]])
for numeroDePunto in range(1, self.numeroDePuntos + 1):
self.lineaDeResguardoDelantera = np.append(
self.lineaDeResguardoDelantera, [[
self.lineaDePintadoLK[0] +
numeroDePunto * np.array([self.stepX, self.stepY])
]],
axis=0)
self.lineaFijaDelantera = self.lineaDeResguardoDelantera
def seguirObjeto(self, numeroDeFrame, informacion):
"""
Se organiza la información acorde al algoritmo de seguimiento
"""
# la imagen introducida esta en RGB, 240,320,3
imagenActual = informacion['frame']
cambiosImportantes, ondaFiltrada, flanco, flujoTotal = self.seguirImagen(
numeroDeFrame, imagenActual, informacion)
for rectangulo in informacion[
'rectangulos']: # Para todos los rectangulos
estado = 2
x, y, w, h = rectangulo[0]
centroid = rectangulo[1]
for infraccion in self.listaDeInfracciones:
for punto in infraccion['desplazamiento']:
if self.puntoEstaEnRectangulo((punto[0][0], punto[0][1]),
(x, y, w, h)):
estado = 0
break
else:
estado = 1
if estado != 0:
try:
informacion['recortados'][informacion['rectangulos'].index(
rectangulo)] = np.zeros((0))
except Exception as e:
#self.miReporte.error('No pude eliminar imagen en frame'+str(informacion['rectangulos']))
print('this error:, ', e)
rectangulo[2] = estado
return cambiosImportantes
def puntoEstaEnRectangulo(self, punto, rectangulo):
estadoARetornar = False
if (punto[0] >
rectangulo[0]) & (punto[0] < rectangulo[0] + rectangulo[2]) & (
punto[1] > rectangulo[1]) & (
punto[1] < rectangulo[1] + rectangulo[3]):
estadoARetornar = True
return estadoARetornar
def seguirImagen(self,
numeroDeFrame,
imagenActual,
informacion=False,
colorSemaforo=1):
"""
Get into the new frame, updates the flow and follows the item as required
"""
# la imagen introducida esta en RGB, 240,320,3
cambiosImportantes = False
imagenActualEnGris = cv2.cvtColor(imagenActual, cv2.COLOR_BGR2GRAY)
self.lineaDeResguardoDelantera = np.array(
self.lineaDeResguardoDelantera, dtype=np.float32
) # This solved the problem although the array seemed to ve in float32, adding this specification to this line solved the problem
self.lineaFijaDelantera = np.array(self.lineaFijaDelantera,
dtype=np.float32)
# Se compara las lineas anterior y nueva para obtener el flujo en dirección deseada
arrayAuxiliarParaVelocidad, activo, err = cv2.calcOpticalFlowPyrLK(
self.imagenAuxiliar, imagenActualEnGris, self.lineaFijaDelantera,
None, **self.lk_params)
self.lineaEmpuje = arrayAuxiliarParaVelocidad
flujoTotal = self.obtenerMagnitudMovimiento(
self.lineaFijaDelantera, arrayAuxiliarParaVelocidad)
ondaFiltrada, flanco = self.miFiltro.obtenerOndaFiltrada(flujoTotal)
if colorSemaforo >= 1:
if flanco == 1:
puntosMasMoviles = self.obtenerPuntosMoviles(
self.lineaFijaDelantera, arrayAuxiliarParaVelocidad,
informacion)
nombreInfraccionYFolder = datetime.datetime.now().strftime(
'%Y-%m-%d_%H:%M:%S')
nuevaInfraccion = {
'name': nombreInfraccionYFolder,
'momentum': numeroDeFrame,
'frameInicial': numeroDeFrame,
'frameFinal': 0,
'desplazamiento': puntosMasMoviles,
'estado': 'Candidato',
'foto': False
}
if self.segundaCamara:
self.camaraAlta.encenderCamaraEnSubDirectorio(
nombreInfraccionYFolder)
self.ultimaCarpetaGuardado = os.getenv(
'HOME') + '/casosReportados/' + nombreInfraccionYFolder
cambiosImportantes = True
self.listaDeInfracciones.append(nuevaInfraccion)
for infraccion in self.listaDeInfracciones:
# Si es candidato evoluciona:
if infraccion['estado'] == 'Candidato':
# Al principio descarto los puntos negativos o en los bordes (0,0), -(x,y)
nuevoArrayAActualizar, activo, err = cv2.calcOpticalFlowPyrLK(
self.imagenAuxiliar, imagenActualEnGris,
infraccion['desplazamiento'], None, **self.lk_params)
for otroIndice in range(len(infraccion['desplazamiento'])):
controlVector = infraccion['desplazamiento'][
otroIndice]
if not self.puntoEstaEnRectangulo(
(controlVector[0][0], controlVector[0][1]),
(0, 0, 320, 240)):
nuevoArrayAActualizar[otroIndice] = infraccion[
'desplazamiento'][otroIndice]
# Si es candidato y duro demasiado se descarta
if (numeroDeFrame - infraccion['frameInicial']
) > self.maximoNumeroFramesParaDescarte:
infraccion['estado'] = 'Descartado'
# Si es candidato y algun punto llego al final se confirma
for indiceVector in range(len(nuevoArrayAActualizar)):
vector = nuevoArrayAActualizar[indiceVector]
xTest, yTest = vector[0][0], vector[0][1]
if cv2.pointPolygonTest(
self.carrilValido, (xTest, yTest), True
) <= 0: # Si esta fuera del carril valido se descarta
nuevoArrayAActualizar[indiceVector] = -np.abs(
nuevoArrayAActualizar[indiceVector])
if cv2.pointPolygonTest(
self.areaDeConfirmacion, (xTest, yTest), True
) >= 0: # Si esta dentro del espacio de llegada se confirma
infraccion['estado'] = 'Confirmado'
cambiosImportantes = True
infraccion['frameFinal'] = numeroDeFrame
self.miReporte.info(
'Conf: ' + infraccion['name'] + ' de ' +
str(infraccion['frameInicial']) + ' a ' +
str(infraccion['frameFinal']) + ' es ' +
infraccion['estado'])
break
infraccion['desplazamiento'] = nuevoArrayAActualizar
infraccionesConfirmadas = self.numeroInfraccionesConfirmadas()
self.imagenAuxiliar = imagenActualEnGris
return cambiosImportantes, ondaFiltrada, flanco, flujoTotal
def numeroInfraccionesConfirmadas(self):
contadorInfraccionesConfirmadas = 0
for infraccion in self.listaDeInfracciones:
if infraccion['estado'] == 'Confirmado':
contadorInfraccionesConfirmadas += 1
return contadorInfraccionesConfirmadas
def numeroInfraccionesTotales(self):
contadorInfracciones = 0
for infraccion in self.listaDeInfracciones:
contadorInfracciones += 1
return contadorInfracciones
def purgeInfractions(self):
indicesABorrar = []
# Tomo los indices que contienen infracciones no confirmadas
for indiceInfraccion in range(len(self.listaDeInfracciones)):
infraccion = self.listaDeInfracciones[indiceInfraccion]
if infraccion['estado'] != 'Confirmado':
indicesABorrar.append(indiceInfraccion)
self.eliminoCarpetaDeSerNecesario(infraccion)
# Itero sobre las infracciones
def eliminoCarpetaDeSerNecesario(self, infraccion):
try:
carpetaABorrar = directorioDeReporte + '/' + infraccion['name']
self.miReporte.info('> Borrando: ', carpetaABorrar)
shutil.rmtree(carpetaABorrar)
except:
self.miReporte.warning(
'No pude borrar posible carpeta fantasma: ' +
infraccion['name'])
def popInfraccion(self):
if self.numeroInfraccionesConfirmadas() != 0:
variableARetornar = self.listaDeInfracciones.pop()
while variableARetornar['estado'] != 'Confirmado':
variableARetornar = self.listaDeInfracciones.pop()
return variableARetornar
else:
return {}
return variableARetornar
def reporteActual(self):
self.miReporte.info('Infracciones Sospechosas:')
for infraccion in self.listaDeInfracciones:
self.miReporte.info(infraccion['frameInicial'] + ' a ' +
str(infraccion['frameFinal']) +
' con estado: ' + infraccion['estado'])
self.miReporte.info('Infracciones Confirmadas:')
for infraccion in self.listaDeInfracciones:
self.miReporte.info(infraccion['name'] + ' de ' +
str(infraccion['frameInicial']) + ' a ' +
str(infraccion['frameFinal']) +
' con estado: ' + infraccion['estado'])
def obtenerLinea(self):
"""
Returns the starting line in tuple format, ready to read or plot with opencv
"""
aDevolver = []
for infraccion in self.listaDeInfracciones:
if infraccion['estado'] == 'Candidato':
for punto in infraccion['desplazamiento']:
aDevolver.append(tuple(punto[0]))
return aDevolver
def obtenerVectorMovimiento(self, vectorAntiguo, nuevoVector):
"""
Gets the movement vector of all points in the starting line, this is used more like an internal method
"""
x = 0
y = 0
for numeroDePunto in range(1, self.numeroDePuntos + 1):
x += nuevoVector[numeroDePunto][0][0] - vectorAntiguo[
numeroDePunto][0][0]
y += nuevoVector[numeroDePunto][0][1] - vectorAntiguo[
numeroDePunto][0][1]
x = 10 * x / (self.numeroDePuntos + 1)
y = 10 * y / (self.numeroDePuntos + 1)
return (x, y)
def obtenerPuntosMoviles(self,
vectorAntiguo,
nuevoVector,
informacion=False):
"""
Gets center of movement as a tuple of three vectors
"""
puntosOptimizados = False
try:
misRectangulos = informacion['rectangulos']
puntosOptimizados = True
except:
puntosOptimizados = False
if puntosOptimizados:
lineaInterna = []
for punto in self.lineaFijaDelantera:
lineaInterna.append(punto[0].tolist())
contadorDeRectangulos = 0
lineaParaRectangulo = {}
for rectangulo in misRectangulos:
lineaParaRectangulo[contadorDeRectangulos] = lineaInterna.copy(
)
for punto in lineaParaRectangulo[contadorDeRectangulos]:
if (punto[0] < rectangulo[0][0]) | (
punto[0] > rectangulo[0][0] + rectangulo[0][1]
) | (punto[1] < rectangulo[0][1]) | (
punto[1] > rectangulo[0][1] + rectangulo[0][2]):
lineaParaRectangulo[contadorDeRectangulos].pop(
lineaParaRectangulo[contadorDeRectangulos].index(
punto))
lineaParaRectangulo[contadorDeRectangulos].pop()
lineaParaRectangulo[contadorDeRectangulos].pop(0)
contadorDeRectangulos += 1
maximaLongitud = 0
lineaRespuesta = []
for index, linea in lineaParaRectangulo.items():
if len(linea) > maximaLongitud:
maximaLongitud = len(linea)
lineaRespuesta = linea
try:
extremoInferior = lineaRespuesta[0]
except:
extremoInferior = lineaInterna[self.numeroDePuntos // 2]
self.miReporte.error(
'No pude detectar puntos a seguir en el rectangulo')
extremoSuperior = extremoInferior
if len(lineaRespuesta) > 2:
extremoInferior = lineaRespuesta.pop(0)
extremoSuperior = lineaRespuesta.pop()
if len(lineaRespuesta) > 2:
extremoInferior = lineaRespuesta.pop(0)
extremoSuperior = lineaRespuesta.pop()
extremoMedio = (np.array(extremoInferior) +
np.array(extremoSuperior)) // 2
extremoMedio = extremoMedio.tolist()
return np.array([[np.array(extremoInferior, dtype=np.float32)],
[np.array(extremoMedio, dtype=np.float32)],
[np.array(extremoSuperior, dtype=np.float32)]])
else:
dif2 = []
for numeroDePunto in range(1, self.numeroDePuntos + 1):
x = nuevoVector[numeroDePunto][0][0] - vectorAntiguo[
numeroDePunto][0][0]
y = nuevoVector[numeroDePunto][0][1] - vectorAntiguo[
numeroDePunto][0][1]
dif2.append(x**2 + y**2)
indiceDeMayores = []
indice = dif2.index(max(dif2))
indiceDeMayores.append(indice)
dif2.pop(indice)
indice = dif2.index(max(dif2))
indiceDeMayores.append(indice)
dif2.pop(indice)
indice = dif2.index(max(dif2))
indiceDeMayores.append(indice)
dif2.pop(indice)
return np.array([[nuevoVector[indiceDeMayores[0]][0]],
[nuevoVector[indiceDeMayores[1]][0]],
[nuevoVector[indiceDeMayores[2]][0]]])
def obtenerMagnitudMovimiento(self, vectorAntiguo, nuevoVector):
"""
Gets the real magnitud of movement perpendicular to the starting point
"""
(x, y) = self.obtenerVectorMovimiento(vectorAntiguo, nuevoVector)
moduloPerpendicular = self.vectorPerpendicularUnitario[
0] * x + self.vectorPerpendicularUnitario[1] * y
return moduloPerpendicular
def apagarCamara(self):
self.camaraAlta.apagarControlador()
def __main_function__():
# Import some global varialbes
global archivoDeVideo
global cambiosImportantes
cambiosImportantes = False
global numeroDeObjetos
numeroDeObjetos = 0
shapeUR = (3296,2512)
shapeMR = (640,480)
shapeLR = (320,240)
# Creamos el reporte inicial
miReporte = MiReporte(levelLogging=logging.INFO,nombre=__name__) # Se crea por defecto con nombre de la fecha y hora actual
miReporte.info('Programa iniciado exitosamente con ingreso de senal video '+archivoDeVideo+entradaReal+' con semaforo '+semaforoSimuladoTexto+str(periodoDeSemaforo) +', corriendo a '+str(mifps)+' Frames por Segundo')
# Si no existe el directorio de reporte lo creo
if not os.path.exists(directorioDeReporte):
os.makedirs(directorioDeReporte)
# Is statements
if generarArchivosDebug:
miReporte.info('Generando Archivos de Debug')
else:
miReporte.info('Generando infracciones unicamente (No debug video)')
# If mostrar Imagenes
if mostrarImagen:
miReporte.info('Pantalla de muestra de funcionamiento en tiempo real encendida')
else:
miReporte.info('Pantalla de muestra de funcionamiento en tiempo real apagada')
# El directorio de reporte debe crearse al inicio del programa
# Variables de control:
numeroDeFrame = 0
maximoInfraccionesPorFrame = 20
#colores = np.random.randint(0,100,(maximoInfraccionesPorFrame,3))
# Cargando los parametros de instalacion:
# El archivo de video debe tener como minimo 5 caracteres para estar trnajando en modo simulado, de lo contrario estamos trabajando en modo real
if len(archivoDeVideo) > 4:
archivoParametrosACargar = archivoDeVideo[:-4]+'.npy'
else:
archivoParametrosACargar = 'datos.npy'
parametrosInstalacion = np.load(folderDeInstalacion+'/'+archivoParametrosACargar)
miReporte.info('Datos de Instalacion de: '+folderDeInstalacion+'/'+archivoParametrosACargar)
poligonoSemaforo = parametrosInstalacion[0]
verticesPartida = parametrosInstalacion[1]
verticesLlegada = parametrosInstalacion[2]
angulo = parametrosInstalacion[3]
miReporte.info('Cargado exitosamente parametros de instalacion: '+str(parametrosInstalacion))
# Arrancando camara
if len(archivoDeVideo) == 0: # modo real
if os.uname()[1] == 'alvarohurtado-305V4A':
miCamara = cv2.VideoCapture(1)
else:
miCamara = cv2.VideoCapture(0)
miCamara.set(3,3280)
miCamara.set(4,2464)
#miCamara.set(3,2592)
#miCamara.set(4,1944)
miReporte.info('Activada Exitosamente cámara en tiempo real')
else:
try:
miCamara = miCamara = cv2.VideoCapture(directorioDeVideos+'/'+archivoDeVideo)
miReporte.info('Archivo de video cargado exitosamente: '+directorioDeVideos+'/'+archivoDeVideo)
except Exception as currentException:
miReporte.error('No se pudo cargar el video por '+str(currentException))
# Se captura la imagen de flujo inicial y se trabaja con la misma
ret, capturaEnAlta = miCamara.read()
capturaEnBaja = cv2.resize(capturaEnAlta,(320,240))
# Creación de objetos:
miPoliciaReportando = PoliciaInfractor( capturaEnBaja, verticesPartida, verticesLlegada)
miGrabadora = GeneradorEvidencia(directorioDeReporte,mifps,guardarRecortados)
miFiltro = IRSwitch()
miAcetatoInformativo = Acetato()
miAcetatoInformativo.colocarPoligono(np.array(poligonoSemaforo)//2)
miAcetatoInformativo.colocarPoligono(np.array(verticesPartida))
miAcetatoInformativo.colocarPoligono(np.array(verticesLlegada))
frame_number = 0
tiempoAuxiliar = time.time()
periodoDeMuestreo = 1.0/mifps
periodoReal = time.time()
# Create BGSUBCNT object
backgroundsub = BGSUBCNT()
# Create Semaphro
periodo = 0
semaforo = CreateSemaforo(periodoSemaforo = periodo)
periodoReal = time.time()
### HERRAMIENTAS MULTIPROCESSING:
imagenes = Queue()
procesoDeAcondicionado = Process(name = 'Acondicionado',target = procesoAcondicionado,args = (imagenes,estadoDeEjecucionDePrograma))
procesoDeAcondicionado.start()
while True:
tiempoAuxiliar = time.time()
ret, capturaEnAlta = miCamara.read()
print('0 Tiempo de captura: ',time.time()-tiempoAuxiliar)
tiempoAuxiliar = time.time()
capturaEnBaja = cv2.resize(capturaEnAlta,(320,240))
print('0 Tiempo de Resize: ',time.time()-tiempoAuxiliar)
tiempoAuxiliar = time.time()
imagenes.put(capturaEnBaja)
print('0 Tiempo de Colocado: ',time.time()-tiempoAuxiliar)
#print('Put: ',time.time()-tiempoAuxiliar)
if mostrarImagen:
tiempoAuxiliar = time.time()
cv2.imshow('Camara', capturaEnBaja)
print('0 Show: ',time.time()-tiempoAuxiliar)
print('0 Periodo total: ',time.time()-periodoReal)
periodoReal = time.time()
frame_number +=1
ch = 0xFF & cv2.waitKey(5)
if ch == ord('q'):
miReporte.info('ABANDONANDO LA EJECUCION DE PROGRAMA por salida manual')
terminarProcesos()
break
if (frame_number >= topeEjecucion) &(topeEjecucion!=0):
miReporte.info('ABANDONANDO LA EJECUCION DE PROGRAMA por indice de auto acabado predeterminado')
terminarProcesos()
break
def main():
# Import some global varialbes
global archivoDeVideo
global acaboDeIniciarNuevoCiclo
acaboDeIniciarNuevoCiclo = False
global tuveInfracciones
tuveInfracciones = False
global tiempoEnPuntoParaNormalVideo
tiempoEnPuntoParaNormalVideo = 7
global minuto
global miReporte
minuto = 0
if not os.path.exists(directorioDeReporte):
os.makedirs(directorioDeReporte)
# Creamos el reporte inicial
if generarArchivosDebug:
miReporte = MiReporte(
levelLogging=logging.DEBUG,
nombre=__name__,
directorio=directorioDeReporte
) # Se crea por defecto con nombre de la fecha y hora actual
miReporte.info('Generando DEBUG')
else:
miReporte = MiReporte(
levelLogging=logging.INFO,
nombre=__name__,
directorio=directorioDeReporte
) # Se crea por defecto con nombre de la fecha y hora actual
miReporte.info(
'Programa iniciado exitosamente con ingreso de senal video ' +
archivoDeVideo + entradaReal + ' con semaforo ' +
semaforoSimuladoTexto + str(periodoDeSemaforo) + ', corriendo a ' +
str(mifps) + ' Frames por Segundo')
vectorDeInicio = [[datetime.datetime.now(), 0, 0, 0, 0, 0]]
if os.path.isfile(reporteDiario):
miReporte.info('Continuando reporte')
#np.save(reporteDiario,np.append(np.load(reporteDiario),vectorDeInicio,0))
else:
miReporte.info('Creando reporte desde cero')
#np.save(reporteDiario,vectorDeInicio)
# If mostrar Imagenes
if mostrarImagen:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real encendida')
else:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real apagada')
# Cargando los parametros de instalacion:
# El archivo de video debe tener como minimo 5 caracteres para estar trnajando en modo simulado, de lo contrario estamos trabajando en modo real
if len(archivoDeVideo) > 4:
archivoParametrosACargar = archivoDeVideo[:-4] + '.npy'
else:
archivoParametrosACargar = 'datos.npy'
parametrosInstalacion = np.load(folderDeInstalacion + '/' +
archivoParametrosACargar)
miReporte.info('Datos de Instalacion de: ' + folderDeInstalacion + '/' +
archivoParametrosACargar)
indicesSemaforo = parametrosInstalacion[0]
poligonoSemaforo = np.array([
indicesSemaforo[0], indicesSemaforo[184], indicesSemaforo[191],
indicesSemaforo[7]
])
verticesPartida = parametrosInstalacion[1]
verticesLlegada = parametrosInstalacion[2]
verticesDerecha = parametrosInstalacion[3]
verticesIzquierda = parametrosInstalacion[4]
angulo = parametrosInstalacion[5][0]
poligonoEnAlta = parametrosInstalacion[6]
miReporte.info('Cargado exitosamente parametros de instalacion '
) #+str(parametrosInstalacion))
# Arrancando camara
if len(archivoDeVideo) == 0:
conVideoGrabado = False # modo real
miCamara = cv2.VideoCapture(0)
miCamara.set(3, 640)
miCamara.set(4, 480)
time.sleep(1)
miReporte.info('Activada Exitosamente cámara en tiempo real')
else:
conVideoGrabado = True
try:
miCamara = cv2.VideoCapture(directorioDeVideos + '/' +
archivoDeVideo)
time.sleep(1)
miReporte.info('Archivo de video cargado exitosamente: ' +
directorioDeVideos + '/' + archivoDeVideo)
except Exception as currentException:
miReporte.error('No se pudo cargar el video por ' +
str(currentException))
# Se captura la imagen de flujo inicial y se trabaja con la misma
ret, frameVideo = miCamara.read()
frameFlujo = cv2.resize(frameVideo, (320, 240))
# Creación de objetos:
if os.uname()[1] == 'raspberrypi':
trabajoConPiCamara = True
else:
trabajoConPiCamara = False
miPoliciaReportando = PoliciaInfractor(frameFlujo,
verticesPartida,
verticesLlegada,
verticesDerecha,
verticesIzquierda,
mifps,
directorioDeReporte,
generarArchivosDebug,
flujoAntiguo=oldFlow,
anguloCarril=angulo)
miFiltro = IRSwitch()
miFiltro.paralelizar()
# Prueba sin filtro todo el dia
miAcetatoInformativo = Acetato()
miSemaforo = CreateSemaforo(periodoDeSemaforo)
miAcetatoInformativo.colocarPoligono(np.array(poligonoSemaforo) // 2)
miAcetatoInformativo.colocarPoligono(np.array(verticesPartida))
miAcetatoInformativo.colocarPoligono(np.array(verticesLlegada))
miAcetatoInformativo.colocarPoligono(np.array(verticesDerecha))
miAcetatoInformativo.colocarPoligono(np.array(verticesIzquierda))
miAcetatoInformativo.colocarPoligono(miPoliciaReportando.carrilValido)
miAcetatoInformativo.establecerLogo(directorioDeLogo + '/dems.png')
# El historial sera una lista de la siguiente forma:
# {numeroFrame: {'frame':np.array((320,240)),
# 'data':{"info"}}}
global historial
historial = {}
frame_number = 0
tiempoAuxiliar = time.time()
periodoDeMuestreo = 1.0 / mifps
try:
while True:
try:
# Load configs for stream to server if needed
configs_server = np.load(directorioDeConfigsServer)
except:
print('error trying to read configs_server in /web folder')
# LEEMOS LA CAMARA DE FLUJO
if conVideoGrabado:
for i in range(videofps // mifps):
ret, frameVideo = miCamara.read()
else:
ret, frameVideo = miCamara.read()
# Discretise 2-D array to 1-D and feed
pixeles = np.array(
[frameVideo[indicesSemaforo[0][1], indicesSemaforo[0][0]]])
for indiceSemaforo in indicesSemaforo[1:]:
pixeles = np.append(
pixeles,
[frameVideo[indiceSemaforo[1], indiceSemaforo[0]]],
axis=0)
tiempoAhora = datetime.datetime.now(
).hour * 60 + datetime.datetime.now().minute
if (tiempoAhora > horaInicioInfraccion) & (tiempoAhora <
horaFinalInfraccion):
senalSemaforo, semaforoLiteral, flanco, periodo = miSemaforo.obtenerColorEnSemaforo(
pixeles)
else:
senalSemaforo, semaforoLiteral, flanco, periodo = 0, 'MODO CONTEO', 0, 60
if datetime.datetime.now().minute > minuto:
minuto = datetime.datetime.now().minute
flanco = -1
frameFlujo = cv2.resize(frameVideo, (320, 240))
velocidadEnBruto, velocidadFiltrada, pulsoVehiculos, momentumAEmplear = miPoliciaReportando.seguirImagen(
frame_number, frameFlujo, colorSemaforo=senalSemaforo)
if senalSemaforo >= 1: # Si estamos en rojo, realizamos una accion
if flanco == 1: # esto se inicia al principio de este estado
miReporte.info('SEMAFORO EN ROJO')
if senalSemaforo <= 0: # Si estamos en verde realizamos otra accion
if flanco == -1: # Si estamos en verde y en flanco, primer verde, realizamos algo
miReporte.info(
'SEMAFORO EN VERDE, EL PERIODO ES ' + str(periodo) +
' a ' +
datetime.datetime.now().strftime('%Y%m%d_%H%M'))
cruce = miPoliciaReportando.estadoActual['cruzo']
salio = miPoliciaReportando.estadoActual['salio']
derecha = miPoliciaReportando.estadoActual['derecha']
izquierda = miPoliciaReportando.estadoActual['izquierda']
infraccion = miPoliciaReportando.estadoActual['infraccion']
otro = miPoliciaReportando.estadoActual['ruido']
vectorDeInicio = [[
datetime.datetime.now(), periodo, infraccion, cruce,
derecha, izquierda, salio, otro
]]
if os.path.isfile(reporteDiario):
np.save(
reporteDiario,
np.append(np.load(reporteDiario), vectorDeInicio,
0))
else:
np.save(reporteDiario, vectorDeInicio)
miReporte.info(
'GLOBAL STATE: prev:' +
str(miPoliciaReportando.estadoActual['previo']) +
', cru:' +
str(miPoliciaReportando.estadoActual['cruzo']) +
', der:' +
str(miPoliciaReportando.estadoActual['derecha']) +
', izq:' +
str(miPoliciaReportando.estadoActual['izquierda']) +
', out:' +
str(miPoliciaReportando.estadoActual['salio']) +
', inf:' +
str(miPoliciaReportando.estadoActual['infraccion']))
miPoliciaReportando.reestablecerEstado()
miPoliciaReportando.reportarPasoAPaso(historial)
if generarArchivosDebug:
if datetime.datetime.now(
).hour > tiempoEnPuntoParaNormalVideo:
miPoliciaReportando.generarVideoMuestra(historial)
tiempoEnPuntoParaNormalVideo = datetime.datetime.now(
).hour
if datetime.datetime.now().hour == 7:
tiempoEnPuntoParaNormalVideo = 7
# Si el tiempo es el adecuado y el filtro no esta actualizado se actualiza
tiempoAhora = datetime.datetime.now(
).hour * 60 + datetime.datetime.now().minute
if (tiempoAhora > amaneciendo) & (tiempoAhora < anocheciendo) & (
(miFiltro.ultimoEstado == 'Filtro Desactivado') |
(miFiltro.ultimoEstado == 'Inicializado')):
miFiltro.colocarFiltroIR()
miReporte.info('Active Filtro a horas ' +
datetime.datetime.now().strftime('%H:%M:%S'))
if ((tiempoAhora < amaneciendo) | (tiempoAhora > anocheciendo)) & (
(miFiltro.ultimoEstado == 'Filtro Activado') |
(miFiltro.ultimoEstado == 'Inicializado')):
miFiltro.quitarFiltroIR()
miReporte.info('Desactive Filtro a horas ' +
datetime.datetime.now().strftime('%H:%M:%S'))
if len(
historial
) > 2 * 60 * mifps: # Si es mayor a dos minutos en el pasado
del historial[min(historial)]
# Draw frame number into image on top
for infraction in miPoliciaReportando.listaVehiculos:
puntos = infraction['desplazamiento'].ravel()
puntosExtraidos = puntos.reshape(puntos.shape[0] // 2, 2)
miAcetatoInformativo.colocarObjeto(puntosExtraidos,
infraction['estado'])
#for puntoResguardo in miPoliciaReportando.obtenerLineasDeResguardo(False):
miAcetatoInformativo.colocarPuntos(
miPoliciaReportando.obtenerLineasDeResguardo(True),
'Referencia')
# Configs and displays for the MASK according to the semaforo
#miAcetatoInformativo.agregarTextoEn("I{}".format(miPoliciaReportando.infraccionesConfirmadas), 2)
miAcetatoInformativo.colorDeSemaforo(senalSemaforo)
frameFlujo = miAcetatoInformativo.aplicarConstantes(frameFlujo)
if generarArchivosDebug:
#historial[frame_number]['debug'] = frameFlujo.copy()
frameFlujo = miAcetatoInformativo.aplicarAFrame(frameFlujo)
historial[frame_number] = {'video': frameFlujo.copy()}
else:
historial[frame_number] = {'video': frameFlujo.copy()}
if mostrarImagen:
frameFlujo = miAcetatoInformativo.aplicarAFrame(frameFlujo)
if mostrarImagen:
#cv2.imshow('Visual', miAcetatoInformativo.aplicarAFrame(frameFlujo)[120:239,60:360])
cv2.imshow('Visual', frameFlujo)
# if can read configs_server then check state to send image
try:
if configs_server[0] == True:
if not mostrarImagen: # Para no escribir dos veces sobre el mismo lienzo
frameFlujo = miAcetatoInformativo.aplicarAFrame(
frameFlujo)
try:
_, img_encoded = cv2.imencode('.jpg', frameFlujo)
r = requests.post(test_url,
data=img_encoded.tostring(),
headers=headers)
except Exception as e:
print(
'<SERVER ERROR> Cannot send images to server, This happen ,',
e)
else:
pass
except:
print('Cannot read configs_server..passing')
# historial[frame_number]['frame'] = historial[frame_number]['captura']
historial[frame_number]['data'] = [
velocidadEnBruto, velocidadFiltrada, pulsoVehiculos,
momentumAEmplear
]
miAcetatoInformativo.inicializar()
tiempoEjecucion = time.time() - tiempoAuxiliar
if tiempoEjecucion > periodoDeMuestreo:
miReporte.warning(
'\t[f{}'.format(frame_number) + ']' +
' Periodo Excedido {0:2f}'.format(tiempoEjecucion) + '[s]')
#sys.stdout.write("\033[F")
while time.time() - tiempoAuxiliar < periodoDeMuestreo:
True
tiempoAuxiliar = time.time()
#miReporte.info('python3 '+ str(__file__)+' '+str( *sys.argv[1:]))
if (int(nombreCarpeta[8:10]) != datetime.datetime.now().day):
miReporte.info('Actualizando por cambio de dia a ' +
str(datetime.datetime.now().day)
) # el script por cambio de día')
exportarInformacionDeHoyO(-1)
# Esto tiene que estar antes del metodo nuevoDia():
miReporte.info('Informacion exportada, borrando: ' +
nombreCarpeta)
os.system('python3 cleanfolders.py -folder ' + nombreCarpeta)
nuevoDia()
miReporte.info('Cambio de día exitoso')
#miPoliciaReportando.apagarCamara()
#os.execl(sys.executable, 'python3', __file__, *sys.argv[1:])
# As bug continues we reboot the system:
#os.system('sudo reboot')
porcentajeDeMemoria = psutil.virtual_memory()[2]
if (porcentajeDeMemoria > 85) & (os.uname()[1] == 'raspberrypi'):
miReporte.info('Estado de Memoria: ' +
str(porcentajeDeMemoria) + '/100')
"""
if porcentajeDeMemoria > 96:
miReporte.warning('Alcanzado 96/100 de memoria, borrando todo e inicializando')
del historial
historial = {}
frame_number = 0
"""
frame_number += 1
if (frame_number >= topeEjecucion) & (topeEjecucion != 0):
miReporte.info(
'ABANDONANDO LA EJECUCION DE PROGRAMA por indice de auto acabado predeterminado'
)
miPoliciaReportando.apagarCamara()
break
ch = 0xFF & cv2.waitKey(5)
if ch == ord('q'):
miReporte.info(
'ABANDONANDO LA EJECUCION DE PROGRAMA por salida manual')
miPoliciaReportando.apagarCamara()
break
if ch == ord('s'):
cv2.imwrite(
datetime.datetime.now().strftime('%Y-%m-%d_%H:%M:%S') +
'.jpg', frameFlujo)
except KeyboardInterrupt as e:
miReporte.info('Salida forzada')
miPoliciaReportando.apagarCamara()
def __main_function__():
# Import some global varialbes
global archivoDeVideo
global cambiosImportantes
cambiosImportantes = False
global numeroDeObjetos
numeroDeObjetos = 0
# Creamos el reporte inicial
miReporte = MiReporte(
levelLogging=logging.INFO, nombre=__name__
) # Se crea por defecto con nombre de la fecha y hora actual
miReporte.info(
'Programa iniciado exitosamente con ingreso de senal video ' +
archivoDeVideo + entradaReal + ' con semaforo ' +
semaforoSimuladoTexto + str(periodoDeSemaforo) + ', corriendo a ' +
str(mifps) + ' Frames por Segundo')
# Si no existe el directorio de reporte lo creo
if not os.path.exists(directorioDeReporte):
os.makedirs(directorioDeReporte)
# Is statements
if generarArchivosDebug:
miReporte.info('Generando Archivos de Debug')
else:
miReporte.info('Generando infracciones unicamente (No debug video)')
# If mostrar Imagenes
if mostrarImagen:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real encendida')
else:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real apagada')
# El directorio de reporte debe crearse al inicio del programa
# Variables de control:
numeroDeFrame = 0
maximoInfraccionesPorFrame = 20
#colores = np.random.randint(0,100,(maximoInfraccionesPorFrame,3))
# Cargando los parametros de instalacion:
# El archivo de video debe tener como minimo 5 caracteres para estar trnajando en modo simulado, de lo contrario estamos trabajando en modo real
if len(archivoDeVideo) > 4:
archivoParametrosACargar = archivoDeVideo[:-4] + '.npy'
else:
archivoParametrosACargar = 'datos.npy'
parametrosInstalacion = np.load(folderDeInstalacion + '/' +
archivoParametrosACargar)
miReporte.info('Datos de Instalacion de: ' + folderDeInstalacion + '/' +
archivoParametrosACargar)
poligonoSemaforo = parametrosInstalacion[0]
verticesPartida = parametrosInstalacion[1]
verticesLlegada = parametrosInstalacion[2]
angulo = parametrosInstalacion[3]
miReporte.info('Cargado exitosamente parametros de instalacion: ' +
str(parametrosInstalacion))
# Arrancando camara
if len(archivoDeVideo) == 0: # modo real
if os.uname()[1] == 'alvarohurtado-305V4A':
miCamara = VideoStream(src=1,
resolution=(640, 480),
poligono=poligonoSemaforo,
debug=saltarFrames,
fps=mifps,
periodo=periodoDeSemaforo,
gamma=gamma).start()
time.sleep(1)
else:
miCamara = VideoStream(src=0,
resolution=(3296, 2512),
poligono=poligonoSemaforo,
debug=saltarFrames,
fps=mifps,
periodo=periodoDeSemaforo,
gamma=gamma).start()
#miCamara = VideoStream(src = 0, resolution = (1920,1080),poligono = poligonoSemaforo, debug = saltarFrames,fps = mifps, periodo = periodoDeSemaforo, gamma = gamma).start()
#miCamara = VideoStream(src = 0, resolution = (1280,960),poligono = poligonoSemaforo, debug = saltarFrames,fps = mifps, periodo = periodoDeSemaforo, gamma = gamma).start()
time.sleep(1)
miReporte.info('Activada Exitosamente cámara en tiempo real')
else:
try:
miCamara = VideoStream(src=directorioDeVideos + '/' +
archivoDeVideo,
resolution=(640, 480),
poligono=poligonoSemaforo,
debug=saltarFrames,
fps=mifps,
periodo=periodoDeSemaforo,
gamma=gamma).start()
time.sleep(1)
miReporte.info('Archivo de video cargado exitosamente: ' +
directorioDeVideos + '/' + archivoDeVideo)
except Exception as currentException:
miReporte.error('No se pudo cargar el video por ' +
str(currentException))
# Se captura la imagen de flujo inicial y se trabaja con la misma
informacion = miCamara.read()
# Creación de objetos:
miPoliciaReportando = PoliciaInfractor(informacion['frame'],
verticesPartida, verticesLlegada)
miGrabadora = GeneradorEvidencia(directorioDeReporte, mifps,
guardarRecortados)
miFiltro = IRSwitch()
miAcetatoInformativo = Acetato()
miAcetatoInformativo.colocarPoligono(np.array(poligonoSemaforo) // 2)
miAcetatoInformativo.colocarPoligono(np.array(verticesPartida))
miAcetatoInformativo.colocarPoligono(np.array(verticesLlegada))
fps = FPS().start()
informacionTotal = {}
frame_number = 0
tiempoAuxiliar = time.time()
periodoDeMuestreo = 1.0 / mifps
grupo = [0]
while True:
# LEEMOS LA CAMARA DE FLUJO
# Ways to access to the information
# information['frame'] ; numpy array containing the low res frame
# information['semaforo'] ; list like [self.senalColor, self.colorLiteral, self.flancoSemaforo, self.totalperiodo]
# information['recortados'] ; list like of tuples representing listaderecortados from hd frame [(_numpy arrays_)n+1]
# information['rectangulos'] ; list like of tuples representing listaderectangulos and centroids in frame [((x,y,h,w),(p1,p2))n+1]
# n+1 ; represent the 1 by 1 correspndencia de los rectangulos encontrados y imagenes recortadas
informacion = miCamara.read() # Ways to access
# Asign number rfame to the information from miCamara.read()
#informacion['index'] = frame_number
informacionTotal[frame_number] = informacion.copy(
) #<------ ese .copy() faltaba
print('Out: ', informacion['semaforo'][2])
# Si forzamos por entrada o si estamos en verde botamos la información de los rectangulos:
if (guardarRecortados == False) | (
informacionTotal[frame_number]['semaforo'][0] == 0):
del informacionTotal[frame_number]['recortados']
informacionTotal[frame_number]['recortados'] = {}
# Se reporta el periodo del semaforo si es necesario:
if informacion['semaforo'][3] != 0:
miReporte.info('SEMAFORO EN VERDE, EL PERIODO ES ' +
str(informacion['semaforo'][3]))
else:
pass
# Si tengo infracciones pendientes las evoluciono
if informacion['semaforo'][
0] >= 1: # Si estamos en rojo, realizamos una accion
if informacion['semaforo'][
2] == 1: # esto se inicia al principio de este estado
miReporte.info('SEMAFORO EN ROJO')
miPoliciaReportando.inicializarAgente()
del informacionTotal
informacionTotal = {}
frame_number = 0
else:
pass
cambiosImportantes = miPoliciaReportando.seguirObjeto(
frame_number, informacion)
else:
pass
if informacion['semaforo'][
0] == 0: # Si estamos en verde realizamos otra accion
if informacion['semaforo'][
2] == -1: # Si estamos en verde y en flanco, primer verde, realizamos algo
miReporte.info(
'Infracciones: ' +
str(miPoliciaReportando.numeroInfraccionesConfirmadas()))
if generarArchivosDebug:
miGrabadora.generarReporteInfraccion(
informacionTotal, False,
miPoliciaReportando.numeroInfraccionesConfirmadas())
if miPoliciaReportando.numeroInfraccionesConfirmadas() > 0:
infraccionEnRevision = miPoliciaReportando.popInfraccion()
miGrabadora.generarReporteInfraccion(informacionTotal,
infraccionEnRevision)
else:
#Si no hay infracciones a reportar me fijo el estado del filtro:
tiempoAhora = datetime.datetime.now(
).hour * 60 + datetime.datetime.now().minute
if (tiempoAhora > amaneciendo) & (miFiltro.ultimoEstado !=
'Filtro Activado'):
miFiltro.colocarFiltroIR()
if (tiempoAhora < amaneciendo) & (miFiltro.ultimoEstado !=
'Filtro Desactivado'):
miFiltro.quitarFiltroIR()
pass
# Draw frame number into image on top
for infraction in miPoliciaReportando.listaDeInfracciones:
for puntos in infraction['desplazamiento']:
puntosExtraidos = puntos.ravel().reshape(
puntos.ravel().shape[0] // 2, 2)
for punto in puntosExtraidos:
if infraction['estado'] == 'Confirmado':
miAcetatoInformativo.colocarPunto(tuple(punto), 0)
else:
miAcetatoInformativo.colocarPunto(tuple(punto), 1)
# Configs and displays for the MASK according to the semaforo
#miAcetatoInformativo.agregarTextoEn("I{}".format(miPoliciaReportando.infraccionesConfirmadas), 2)
miAcetatoInformativo.colorDeSemaforo(informacion['semaforo'][0])
# Draw the rectangles
for rectangulo in informacion['rectangulos']:
miAcetatoInformativo.colocarObjetivo(rectangulo[0], rectangulo[2])
if mostrarImagen:
#cv2.imshow('Visual', miAcetatoInformativo.aplicarAFrame(informacion['frame'])[120:239,60:360])
cv2.imshow(
'Visual',
miAcetatoInformativo.aplicarAFrame(informacion['frame']))
miAcetatoInformativo.inicializar()
tiempoEjecucion = time.time() - tiempoAuxiliar
#if tiempoEjecucion>periodoDeMuestreo:
miReporte.warning('Tiempo Afuera {0:2f}'.format(tiempoEjecucion) +
'[s] en frame {}'.format(frame_number))
#sys.stdout.write("\033[F")
while time.time() - tiempoAuxiliar < periodoDeMuestreo:
True
tiempoAuxiliar = time.time()
if (cambiosImportantes) | (numeroDeObjetos != len(
informacion['rectangulos'])):
miReporte.info(
'F{} Sema: '.format(frame_number) +
informacion['semaforo'][1] + ' I: ' +
str(miPoliciaReportando.numeroInfraccionesConfirmadas()) +
'/' + str(miPoliciaReportando.numeroInfraccionesTotales()) +
' Objetos: {}'.format(len(informacion['rectangulos'])))
numeroDeObjetos = len(informacion['rectangulos'])
porcentajeDeMemoria = psutil.virtual_memory()[2]
if porcentajeDeMemoria > 80:
miReporte.info('Estado de Memoria: ' + str(porcentajeDeMemoria) +
'/100')
if porcentajeDeMemoria > 92:
frameAOptimizar = min(informacionTotal)
miReporte.warning('Alcanzado 92/100 de memoria, borrando frame: ' +
str(frameAOptimizar))
del informacionTotal[frameAOptimizar]['recortados']
informacionTotal[frameAOptimizar]['recortados'] = {}
if porcentajeDeMemoria > 96:
miReporte.warning(
'Alcanzado 96/100 de memoria, borrando todo e inicializando')
del informacionTotal
informacionTotal = {}
frame_number = 0
frame_number += 1
if (frame_number >= topeEjecucion) & (topeEjecucion != 0):
miReporte.info(
'ABANDONANDO LA EJECUCION DE PROGRAMA por indice de auto acabado predeterminado'
)
break
if informacion['semaforo'][0] == -2:
miReporte.critical(
'ABANDONANDO LA EJECUCION DE PROGRAMA El semaforo ya no obtuvo señal, necesito recalibrar, abandonando la ejecución del programa'
)
break
ch = 0xFF & cv2.waitKey(5)
if ch == ord('q'):
miReporte.info(
'ABANDONANDO LA EJECUCION DE PROGRAMA por salida manual')
break
if ch == ord('s'):
cv2.imwrite(
datetime.datetime.now().strftime('%Y-%m-%d_%H:%M:%S') + '.jpg',
informacion['frame'])
fps.update()
# stop the timer and display FPS information
fps.stop()
class GeneradorEvidencia():
def __init__(self, carpetaReporte, mifps=10, guardoRecortados=True):
self.miReporte = MiReporte(levelLogging=logging.DEBUG, nombre=__name__)
self.carpetaDeReporteActual = carpetaReporte
self.framesPorSegundoEnVideo = mifps
self.ventana = 5
self.height, self.width = 240, 320
self.guardoRecortados = guardoRecortados
self.dicts_by_name = defaultdict(list)
self.fourcc = cv2.VideoWriter_fourcc(*'XVID')
def nuevoDia(self, carpetaReporte):
self.carpetaDeReporteActual = carpetaReporte
self.miReporte.setDirectory(directorioDeReporte)
def inicializarEnCarpeta(self, carpetaReporte):
self.carpetaDeReporteActual = carpetaReporte
def generarVideo(self,
informacionTotal,
nombreInfraccion,
directorioActual,
nombreFrame,
inicio,
final,
observacion=''):
aEntregar = cv2.VideoWriter(
directorioActual + '/' + nombreInfraccion + '_' + nombreFrame +
'_' + observacion + '.avi', self.fourcc,
self.framesPorSegundoEnVideo, (self.width, self.height))
excepcion = ''
for indiceVideo in range(inicio, final):
conteoErrores = 0
try:
aEntregar.write(informacionTotal[indiceVideo][nombreFrame])
except Exception as e:
conteoErrores += 1
excepcion = e
if conteoErrores >= 1:
self.miReporte.warning('Tuve ' + str(conteoErrores) +
' missing al generar el video ' +
str(excepcion))
aEntregar.release()
self.miReporte.info('\t\t' + 'Generada infr de: ' + nombreInfraccion +
' de ' + str(inicio) + ' a ' + str(final))
def generarReporteEnVideoDe(self,
informacionTotal,
infraccion,
debug=False):
nombreInfraccion = infraccion['name']
estado = infraccion['infraccion']
directorioActual = self.carpetaDeReporteActual + '/' + nombreInfraccion
if not os.path.exists(directorioActual):
os.makedirs(directorioActual)
inicio = infraccion['frameInicial'] - self.ventana
final = infraccion['frameFinal'] + self.ventana
self.generarVideo(informacionTotal, estado + '_' + infraccion['name'],
directorioActual, 'video', inicio, final,
infraccion['observacion'])
#if debug:
# self.generarVideo(informacionTotal,infraccion['name'],directorioActual,'debug',inicio,final,infraccion['observacion'])
def generarVideoDebugParaPruebas(self, informacionTotal):
nombreInfraccion = datetime.datetime.now().strftime(
'%Y-%m-%d_%H-%M-%S')
directorioActual = self.carpetaDeReporteActual + '/' + nombreInfraccion
if not os.path.exists(directorioActual):
os.makedirs(directorioActual)
inicio = min(informacionTotal)
final = max(informacionTotal)
self.generarVideo(informacionTotal, nombreInfraccion, directorioActual,
'video', inicio, final, 'debug')
def generarReporteInfraccion(self,
informacionTotal,
infraccion=True,
numero=0,
debug=False):
generandoDebugGlobal = False
generarDobleVideo = debug
try:
nombreInfraccion = infraccion['name']
generandoDebugGlobal = False
except:
nombreInfraccion = datetime.datetime.now().strftime(
'%Y-%m-%d_%H-%M-%S') + '_{}i'.format(numero)
if (numero == 0) & (len(informacionTotal) < 20):
return 0
generandoDebugGlobal = True
directorioActual = self.carpetaDeReporteActual + '/' + nombreInfraccion
if not os.path.exists(directorioActual):
os.makedirs(directorioActual)
if generandoDebugGlobal == False:
frameInferior = infraccion['frameInicial'] - self.ventana
frameSuperior = infraccion['frameFinal'] + self.ventana
if generarDobleVideo:
prueba = cv2.VideoWriter(
directorioActual + '/' + nombreInfraccion + '_debug.avi',
self.fourcc, self.framesPorSegundoEnVideo,
(self.width, self.height))
entrega = cv2.VideoWriter(
directorioActual + '/' + nombreInfraccion + '.avi',
self.fourcc, self.framesPorSegundoEnVideo,
(self.width, self.height))
# Check valid frame
if frameInferior < 1:
inicio = 1
else:
inicio = frameInferior
if frameSuperior > len(informacionTotal):
final = len(informacionTotal)
else:
final = frameSuperior
self.miReporte.info('\t\t' + 'Generada infr de: ' +
nombreInfraccion + ' de ' + str(inicio) +
' a ' + str(final))
if self.guardoRecortados:
directorioRecorte = directorioActual + '/recorte'
if not os.path.exists(directorioRecorte):
os.makedirs(directorioRecorte)
for indiceVideo in range(inicio, final):
if generarDobleVideo:
prueba.write(informacionTotal[indiceVideo]['debug'])
entrega.write(informacionTotal[indiceVideo]['video'])
if generarDobleVideo:
prueba.release()
entrega.release()
# Vuelvo a iterar por la imagen mas grande:
return 1
else:
prueba = cv2.VideoWriter(
directorioActual + '/' + nombreInfraccion + '.avi',
self.fourcc, self.framesPorSegundoEnVideo,
(self.width, self.height))
inicio = min(informacionTotal)
final = max(informacionTotal)
self.miReporte.info('Generado DEBUG de: ' + nombreInfraccion +
' de ' + str(inicio) + ' ' + str(final) +
' total lista: ' + str(len(informacionTotal)))
for indiceVideo in range(inicio, final):
try:
prueba.write(informacionTotal[indiceVideo]['debug'])
except:
self.miReporte.error('No pude guardar frame: ' +
str(indiceVideo))
prueba.release()
return 0
class GeneradorEvidencia():
def __init__(self, carpetaReporte, mifps=10, guardoRecortados=True):
self.miReporte = MiReporte(levelLogging=logging.DEBUG, nombre=__name__)
self.carpetaDeReporteActual = carpetaReporte
self.framesPorSegundoEnVideo = mifps
self.ventana = 5
self.height, self.width = 240, 320
self.guardoRecortados = guardoRecortados
self.dicts_by_name = defaultdict(list)
def inicializarEnCarpeta(self, carpetaReporte):
self.carpetaDeReporteActual = carpetaReporte
def generarReporteInfraccion(self,
informacionTotal,
infraccion=True,
numero=0):
fourcc = cv2.VideoWriter_fourcc(*'XVID')
generandoDebug = False
try:
nombreInfraccion = infraccion['name']
generandoDebug = False
except:
nombreInfraccion = datetime.datetime.now().strftime(
'%Y-%m-%d_%H:%M:%S') + '_{}i'.format(numero)
if (numero == 0) & (len(informacionTotal) < 20):
return 0
generandoDebug = True
directorioActual = self.carpetaDeReporteActual + '/' + nombreInfraccion
if not os.path.exists(directorioActual):
self.miReporte.info('Creado: ' + directorioActual)
os.makedirs(directorioActual)
if generandoDebug == False:
frameInferior = infraccion['frameInicial'] - self.ventana
frameSuperior = infraccion['frameFinal'] + self.ventana
prueba = cv2.VideoWriter(
directorioActual + '/' + nombreInfraccion + '.avi', fourcc,
self.framesPorSegundoEnVideo, (self.width, self.height))
# Check valid frame
if frameInferior < 1:
inicio = 1
else:
inicio = frameInferior
if frameSuperior > len(informacionTotal):
final = len(informacionTotal)
else:
final = frameSuperior
self.miReporte.info('Generada infr de: ' + nombreInfraccion +
' de ' + str(inicio) + ' a ' + str(final) +
' fecha: ' + nombreInfraccion)
if self.guardoRecortados:
directorioRecorte = directorioActual + '/recorte'
if not os.path.exists(directorioRecorte):
os.makedirs(directorioRecorte)
for indiceVideo in range(inicio, final):
prueba.write(informacionTotal[indiceVideo])
prueba.release()
# Vuelvo a iterar por la imagen mas grande:
return 1
else:
prueba = cv2.VideoWriter(
directorioActual + '/' + nombreInfraccion + '.avi', fourcc,
self.framesPorSegundoEnVideo, (self.width, self.height))
inicio = 0
final = len(informacionTotal)
self.miReporte.info('Generado DEBUG de: ' + nombreInfraccion +
' de ' + str(inicio) + ' ' + str(final) +
' total lista: ' + str(len(informacionTotal)))
for indiceVideo in range(inicio, final):
try:
prueba.write(informacionTotal[indiceVideo])
except:
self.miReporte.error('No pude guardar frame: ' +
str(indiceVideo))
prueba.release()
return 0
def __main_function__():
# Import some global varialbes
global archivoDeVideo
global cambiosImportantes
cambiosImportantes = False
global numeroDeObjetos
numeroDeObjetos = 0
# Creamos el reporte inicial
miReporte = MiReporte(
levelLogging=logging.DEBUG, nombre=__name__
) # Se crea por defecto con nombre de la fecha y hora actual
miReporte.info(
'Programa iniciado exitosamente con ingreso de senal video ' +
archivoDeVideo + entradaReal + ' con semaforo ' +
semaforoSimuladoTexto + str(periodoDeSemaforo) + ', corriendo a ' +
str(mifps) + ' Frames por Segundo')
# Si no existe el directorio de reporte lo creo
if not os.path.exists(directorioDeReporte):
os.makedirs(directorioDeReporte)
# Is statements
if generarArchivosDebug:
miReporte.info('Generando Archivos de Debug')
else:
miReporte.info('Generando infracciones unicamente (No debug video)')
# If mostrar Imagenes
if mostrarImagen:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real encendida')
else:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real apagada')
# El directorio de reporte debe crearse al inicio del programa
# Variables de control:
numeroDeFrame = 0
maximoInfraccionesPorFrame = 20
#colores = np.random.randint(0,100,(maximoInfraccionesPorFrame,3))
# Cargando los parametros de instalacion:
# El archivo de video debe tener como minimo 5 caracteres para estar trnajando en modo simulado, de lo contrario estamos trabajando en modo real
if len(archivoDeVideo) > 4:
archivoParametrosACargar = archivoDeVideo[:-4] + '.npy'
else:
archivoParametrosACargar = 'datos.npy'
parametrosInstalacion = np.load(folderDeInstalacion + '/' +
archivoParametrosACargar)
miReporte.info('Datos de Instalacion de: ' + folderDeInstalacion + '/' +
archivoParametrosACargar)
poligonoSemaforo = parametrosInstalacion[0]
verticesPartida = parametrosInstalacion[1]
verticesLlegada = parametrosInstalacion[2]
angulo = parametrosInstalacion[3]
miReporte.info('Cargado exitosamente parametros de instalacion: ' +
str(parametrosInstalacion))
# Arrancando camara
if len(archivoDeVideo) == 0: # modo real
if os.uname()[1] == 'alvarohurtado-305V4A':
miCamara = VideoStream(src=1,
resolution=(640, 480),
poligono=poligonoSemaforo,
debug=saltarFrames,
fps=mifps,
periodo=periodoDeSemaforo,
gamma=gamma).start()
time.sleep(1)
else:
miCamara = VideoStream(src=0,
resolution=(3296, 2512),
poligono=poligonoSemaforo,
debug=saltarFrames,
fps=mifps,
periodo=periodoDeSemaforo,
gamma=gamma).start()
#miCamara = VideoStream(src = 0, resolution = (1920,1080),poligono = poligonoSemaforo, debug = saltarFrames,fps = mifps, periodo = periodoDeSemaforo, gamma = gamma).start()
#miCamara = VideoStream(src = 0, resolution = (1280,960),poligono = poligonoSemaforo, debug = saltarFrames,fps = mifps, periodo = periodoDeSemaforo, gamma = gamma).start()
time.sleep(1)
miReporte.info('Activada Exitosamente cámara en tiempo real')
else:
try:
miCamara = VideoStream(src=directorioDeVideos + '/' +
archivoDeVideo,
resolution=(640, 480),
poligono=poligonoSemaforo,
debug=saltarFrames,
fps=mifps,
periodo=periodoDeSemaforo,
gamma=gamma).start()
time.sleep(1)
miReporte.info('Archivo de video cargado exitosamente: ' +
directorioDeVideos + '/' + archivoDeVideo)
except Exception as currentException:
miReporte.error('No se pudo cargar el video por ' +
str(currentException))
# Se captura la imagen de flujo inicial y se trabaja con la misma
informacion = miCamara.read()
# Creación de objetos:
miPoliciaReportando = PoliciaInfractor(informacion['frame'],
verticesPartida, verticesLlegada)
miGrabadora = GeneradorEvidencia(directorioDeReporte, mifps,
guardarRecortados)
miFiltro = IRSwitch()
#remocionFondo = matches # List like with arrays
if mostrarImagen:
visualLabel = VisualLayer()
visualLabel.crearMascaraCompleta(size=(240, 320))
visualLabel.crearBarraInformacion(height=240)
visualLabel.crearBarraDeProgreso()
visualLabel.ponerPoligono(np.array(verticesPartida))
frame_number = 0
fps = FPS().start()
informacionTotal = {}
frame_number = 0
tiempoAuxiliar = time.time()
periodoDeMuestreo = 1.0 / mifps
while True:
# LEEMOS LA CAMARA DE FLUJO
# Ways to access to the information
# information['frame'] ; numpy array containing the low res frame
# information['semaforo'] ; list like [self.senalColor, self.colorLiteral, self.flancoSemaforo]
# information['recortados'] ; list like of tuples representing listaderecortados from hd frame [(_numpy arrays_)n+1]
# information['rectangulos'] ; list like of tuples representing listaderectangulos and centroids in frame [((x,y,h,w),(p1,p2))n+1]
# n+1 ; represent the 1 by 1 correspndencia de los rectangulos encontrados y imagenes recortadas
informacion = miCamara.read() # Ways to access
# assing index information to the above infomation
# Asign number rfame to the information from miCamara.read()
informacion['index'] = frame_number
informacionTotal[frame_number] = informacion.copy(
) #<------ ese .copy() faltaba
print('Tamanio buffer: ', total_size(informacionTotal), ' en ',
len(informacionTotal))
# Si forzamos por entrada o si estamos en verde botamos la información de los rectangulos:
if (guardarRecortados == False) | (
informacionTotal[frame_number]['semaforo'][0] == 0):
del informacionTotal[frame_number]['recortados']
informacionTotal[frame_number]['recortados'] = {}
if frame_number > maximoMemoria:
try:
informacionTotal[frame_number -
maximoMemoria]['recortados'] = []
#miReporte.debug('Released memory')
except Exception as e:
miReporte.error('No pude liberar por ' + str(e))
# Si tengo infracciones pendientes las evoluciono
if informacion['semaforo'][
0] >= 1: # Si estamos en rojo, realizamos una accion
if informacion['semaforo'][
2] == 1: # esto se inicia al principio de este estado
print('Here was something---')
#miReporte.info('SEMAFORO EN ROJO')
miPoliciaReportando.inicializarAgente()
del informacionTotal
informacionTotal = {}
frame_number = 0
cambiosImportantes = miPoliciaReportando.seguirObjeto(
frame_number, informacion)
if informacion['semaforo'][
0] == 0: # Si estamos en verde realizamos otra accion
if informacion['semaforo'][
2] == -1: # Si estamos en verde y en flanco, primer verde, realizamos algo
miReporte.info('SEMAFORO EN VERDE')
miReporte.info(
'Infracciones: ' +
str(miPoliciaReportando.numeroInfraccionesConfirmadas()))
if generarArchivosDebug:
miGrabadora.generarReporteInfraccion(
informacionTotal, False,
miPoliciaReportando.numeroInfraccionesConfirmadas())
if miPoliciaReportando.numeroInfraccionesConfirmadas() > 0:
infraccionEnRevision = miPoliciaReportando.popInfraccion()
miGrabadora.generarReporteInfraccion(informacionTotal,
infraccionEnRevision)
else:
#Si no hay infracciones a reportar me fijo el estado del filtro:
tiempoAhora = datetime.datetime.now(
).hour * 60 + datetime.datetime.now().minute
if (tiempoAhora > amaneciendo) & (miFiltro.ultimoEstado !=
'Filtro Activado'):
miFiltro.colocarFiltroIR()
if (tiempoAhora < amaneciendo) & (miFiltro.ultimoEstado !=
'Filtro Desactivado'):
miFiltro.quitarFiltroIR()
pass
if mostrarImagen:
# Draw frame number into image on top
cv2.putText(
informacion['frame'],
datetime.datetime.now().strftime('%A %d %B %Y %I:%M:%S%p'),
(4, 236), font, 0.4, (255, 255, 255), 1, cv2.LINE_AA)
cv2.putText(informacion['frame'], str(frame_number), (20, 20),
font, 0.4, (255, 255, 255), 1, cv2.LINE_AA)
visualizacion = informacion['frame']
for infraction in miPoliciaReportando.listaDeInfracciones:
for puntos in infraction['desplazamiento']:
puntosExtraidos = puntos.ravel().reshape(
puntos.ravel().shape[0] // 2, 2)
for punto in puntosExtraidos:
if infraction['estado'] == 'Confirmado':
cv2.circle(visualizacion, tuple(punto), 1,
(0, 0, 255), -1)
else:
cv2.circle(visualizacion, tuple(punto), 1,
(255, 0, 0), -1)
cv2.polylines(visualizacion,
np.array([poligonoSemaforo]) // 2, True,
(200, 200, 200))
# Configs and displays for the MASK according to the semaforo
visualLabel.agregarTextoEn(informacion['semaforo'][1], 0)
visualLabel.agregarTextoEn("F{}".format(frame_number), 1)
visualLabel.agregarTextoEn(
"I{}".format(miPoliciaReportando.infraccionesConfirmadas), 2)
if informacion['semaforo'][0] == 1:
visualLabel.establecerColorFondoDe(backgroudColour=(0, 0, 255),
numeroDeCaja=0)
elif informacion['semaforo'][0] == 0:
visualLabel.establecerColorFondoDe(backgroudColour=(0, 255, 0),
numeroDeCaja=0)
elif informacion['semaforo'][0] == 2:
visualLabel.establecerColorFondoDe(backgroudColour=(0, 255,
255),
numeroDeCaja=0)
else:
visualLabel.establecerColorFondoDe(backgroudColour=(0, 0, 0),
numeroDeCaja=0)
# Draw the rectangles
for rectangulo in informacion['rectangulos']:
visualLabel.agregarRecangulo((rectangulo[0], rectangulo[1]),
rectangulo[2])
visualLabel.establecerMagnitudBarra(
magnitude=int(miPoliciaReportando.ultimaVelocidad))
visualizacion = visualLabel.aplicarMascaraActualAFrame(
visualizacion)
# Show Everything
cv2.imshow('Visual',
cv2.resize(visualLabel.aplicarTodo(), (620, 480)))
tiempoEjecucion = time.time() - tiempoAuxiliar
if tiempoEjecucion > periodoDeMuestreo:
miReporte.warning('Se sobrepaso el periodo de muestreo a {0:2f}'.
format(tiempoEjecucion) +
'[s] en frame {}'.format(frame_number))
#sys.stdout.write("\033[F")
while time.time() - tiempoAuxiliar < periodoDeMuestreo:
True
if (cambiosImportantes) | (numeroDeObjetos != len(
informacion['rectangulos'])):
miReporte.info(
'F{} Sema: '.format(frame_number) +
informacion['semaforo'][1] + ' I: ' +
str(miPoliciaReportando.numeroInfraccionesConfirmadas()) +
'/' + str(miPoliciaReportando.numeroInfraccionesTotales()) +
' Objetos: {}'.format(len(informacion['rectangulos'])))
numeroDeObjetos = len(informacion['rectangulos'])
tiempoAuxiliar = time.time()
frame_number += 1
if (frame_number >= topeEjecucion) & (topeEjecucion != 0):
break
ch = 0xFF & cv2.waitKey(5)
if ch == ord('q'):
break
if ch == ord('s'):
cv2.imwrite(
datetime.datetime.now().strftime('%Y-%m-%d_%H:%M:%S') + '.jpg',
informacion['frame'])
fps.update()
# stop the timer and display FPS information
fps.stop()
def __main_function__():
# Import some global varialbes
global archivoDeVideo
global cambiosImportantes
cambiosImportantes = False
global numeroDeObjetos
numeroDeObjetos = 0
shapeUR = (3296, 2512)
shapeMR = (640, 480)
shapeLR = (320, 240)
# Creamos el reporte inicial
miReporte = MiReporte(
levelLogging=logging.INFO, nombre=__name__
) # Se crea por defecto con nombre de la fecha y hora actual
miReporte.info(
'Programa iniciado exitosamente con ingreso de senal video ' +
archivoDeVideo + entradaReal + ' con semaforo ' +
semaforoSimuladoTexto + str(periodoDeSemaforo) + ', corriendo a ' +
str(mifps) + ' Frames por Segundo')
# Si no existe el directorio de reporte lo creo
if not os.path.exists(directorioDeReporte):
os.makedirs(directorioDeReporte)
# Is statements
if generarArchivosDebug:
miReporte.info('Generando Archivos de Debug')
else:
miReporte.info('Generando infracciones unicamente (No debug video)')
# If mostrar Imagenes
if mostrarImagen:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real encendida')
else:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real apagada')
# El directorio de reporte debe crearse al inicio del programa
# Variables de control:
numeroDeFrame = 0
maximoInfraccionesPorFrame = 20
#colores = np.random.randint(0,100,(maximoInfraccionesPorFrame,3))
# Cargando los parametros de instalacion:
# El archivo de video debe tener como minimo 5 caracteres para estar trnajando en modo simulado, de lo contrario estamos trabajando en modo real
if len(archivoDeVideo) > 4:
archivoParametrosACargar = archivoDeVideo[:-4] + '.npy'
else:
archivoParametrosACargar = 'datos.npy'
parametrosInstalacion = np.load(folderDeInstalacion + '/' +
archivoParametrosACargar)
miReporte.info('Datos de Instalacion de: ' + folderDeInstalacion + '/' +
archivoParametrosACargar)
poligonoSemaforo = parametrosInstalacion[0]
verticesPartida = parametrosInstalacion[1]
verticesLlegada = parametrosInstalacion[2]
angulo = parametrosInstalacion[3]
miReporte.info('Cargado exitosamente parametros de instalacion: ' +
str(parametrosInstalacion))
# Arrancando camara
if len(archivoDeVideo) == 0: # modo real
if os.uname()[1] == 'alvarohurtado-305V4A':
miCamara = VideoStream(src=0,
resolution=shapeMR,
poligono=poligonoSemaforo,
debug=saltarFrames,
fps=mifps).start()
time.sleep(1)
elif os.uname()[1] == 'stanlee321-MS-7693':
print('Hello stanlee321')
miCamara = VideoStream(src=0,
resolution=shapeMR,
poligono=poligonoSemaforo,
debug=saltarFrames,
fps=mifps).start()
elif os.uname()[1] == 'stanlee321-HP-240-G1-Notebook-PC':
print('Hello stanlee321')
miCamara = VideoStream(src=0,
resolution=shapeMR,
poligono=poligonoSemaforo,
debug=saltarFrames,
fps=mifps).start()
else:
miCamara = VideoStream(src=0,
resolution=shapeUR,
poligono=poligonoSemaforo,
debug=saltarFrames,
fps=mifps).start()
miReporte.info('Activada Exitosamente cámara en tiempo real')
else:
try:
miCamara = miCamara = VideoStream(src=directorioDeVideos + '/' +
archivoDeVideo,
resolution=shapeMR).start()
miReporte.info('Archivo de video cargado exitosamente: ' +
directorioDeVideos + '/' + archivoDeVideo)
except Exception as currentException:
miReporte.error('No se pudo cargar el video por ' +
str(currentException))
# Se captura la imagen de flujo inicial y se trabaja con la misma
data = miCamara.read()
capturaEnBaja = data['LRframe']
# Creación de objetos:
miPoliciaReportando = PoliciaInfractor(capturaEnBaja, verticesPartida,
verticesLlegada)
miGrabadora = GeneradorEvidencia(directorioDeReporte, mifps,
guardarRecortados)
miFiltro = IRSwitch()
miAcetatoInformativo = Acetato()
miAcetatoInformativo.colocarPoligono(np.array(poligonoSemaforo) // 2)
miAcetatoInformativo.colocarPoligono(np.array(verticesPartida))
miAcetatoInformativo.colocarPoligono(np.array(verticesLlegada))
frame_number = 0
tiempoAuxiliar = time.time()
periodoDeMuestreo = 1.0 / mifps
periodoReal = time.time()
# Create BGSUBCNT object
backgroundsub = BGSUBCNT()
# Create Multiprocessing parameters
#pool = ThreadPool(2)
#input_q = Queue(5)
#output_q = Queue(5)
#child_process = Process(target = child_process_detect_objects_with_bg, args=(input_q, output_q))
#child_process.daemon = True
#child_process.start()
# Create CUT Object
if os.uname()[1] == 'stanlee321-MS-7693':
cutImage = cutHDImage(shapeHR=shapeMR, shapeLR=shapeLR)
else:
cutImage = cutHDImage(shapeHR=shapeUR, shapeLR=shapeLR)
# Create Semaphro
periodo = 0
semaforo = CreateSemaforo(periodoSemaforo=periodo)
listaderecortados = list
informacion = dict
while True:
tiempoAuxiliar = time.time()
data = miCamara.read()
data['index'] = frame_number
capturaEnAlta = data['HRframe']
capturaEnBaja = data['LRframe']
capturaSemaforo = data['frame_semaforo']
senalColor, colorLiteral, flancoSemaforo, periodoSemaforo = semaforo.obtenerColorEnSemaforo(
capturaSemaforo)
#print('Lectura: ',time.time()-tiempoAuxiliar)
poligonos_warp = backgroundsub.feedbgsub(capturaEnBaja)
#poligonos_warp = pool.starmap(backgroundsub.feedbgsub, capturaEnBaja)
# close the pool and wait for the work to finish
#pool.close()
#pool.join()
#print(poligonos_warp)
listaderecortados = cutImage(HDframe=capturaEnBaja,
matches=poligonos_warp)
informacion = {'semaforo': [senalColor, colorLiteral, flancoSemaforo, periodoSemaforo],\
'frame':capturaEnBaja, 'rectangulos': listaderecortados, 'index': data['index']}
"""
#print('SEMAPHORO STATES: ', senalColor, colorLiteral, flancoSemaforo, periodoSemaforo)
print('Lectura: ',time.time()-tiempoAuxiliar)
tiempoAuxiliar = time.time()
#informacionTotal[frame_number] = informacion.copy() #<------ ese .copy() faltaba
print('Out: ', informacion['semaforo'][2])
# Si forzamos por entrada o si estamos en verde botamos la información de los rectangulos:
if (guardarRecortados == False) | (informacion['semaforo'][0]==0):
#del informacion['recortados']
#informacionTotal[frame_number]['recortados'] = {}
pass
# Se reporta el periodo del semaforo si es necesario:
if informacion['semaforo'][3] != 0:
miReporte.info('SEMAFORO EN VERDE, EL PERIODO ES '+str(informacion['semaforo'][3]))
else:
pass
# Si tengo infracciones pendientes las evoluciono
if informacion['semaforo'][0] >= 1 : # Si estamos en rojo, realizamos una accion
if informacion['semaforo'][2] == 1: # esto se inicia al principio de este estado
miReporte.info('SEMAFORO EN ROJO')
miPoliciaReportando.inicializarAgente()
#del informacionTotal
#informacionTotal = {}
frame_number = 0
else:
pass
cambiosImportantes = miPoliciaReportando.seguirObjeto(informacion['index'], informacion)
else:
pass
if informacion['semaforo'][0] == 0: # Si estamos en verde realizamos otra accion
if informacion['semaforo'][2] == -1: # Si estamos en verde y en flanco, primer verde, realizamos algo
miReporte.info('Infracciones: ' + str(miPoliciaReportando.numeroInfraccionesConfirmadas()))
if generarArchivosDebug:
miGrabadora.generarReporteInfraccion(informacionTotal, False,miPoliciaReportando.numeroInfraccionesConfirmadas())
if miPoliciaReportando.numeroInfraccionesConfirmadas() > 0:
infraccionEnRevision = miPoliciaReportando.popInfraccion()
miGrabadora.generarReporteInfraccion(informacionTotal, infraccionEnRevision)
else:
#Si no hay infracciones a reportar me fijo el estado del filtro:
tiempoAhora = datetime.datetime.now().hour*60 + datetime.datetime.now().minute
if (tiempoAhora > amaneciendo) & (miFiltro.ultimoEstado != 'Filtro Activado'):
miFiltro.colocarFiltroIR()
if (tiempoAhora < amaneciendo) & (miFiltro.ultimoEstado != 'Filtro Desactivado'):
miFiltro.quitarFiltroIR()
pass
# Draw frame number into image on top
for infraction in miPoliciaReportando.listaDeInfracciones:
for puntos in infraction['desplazamiento']:
puntosExtraidos = puntos.ravel().reshape(puntos.ravel().shape[0]//2,2)
for punto in puntosExtraidos:
if infraction['estado'] == 'Confirmado':
miAcetatoInformativo.colocarPunto(tuple(punto),0)
else:
miAcetatoInformativo.colocarPunto(tuple(punto),1)
# Configs and displays for the MASK according to the semaforo
#miAcetatoInformativo.agregarTextoEn("I{}".format(miPoliciaReportando.infraccionesConfirmadas), 2)
miAcetatoInformativo.colorDeSemaforo(informacion['semaforo'][0])
# Draw the rectangles
for rectangulo in informacion['rectangulos']:
miAcetatoInformativo.colocarObjetivo(rectangulo[0],rectangulo[2])
if mostrarImagen:
#cv2.imshow('Visual', miAcetatoInformativo.aplicarAFrame(informacion['frame'])[120:239,60:360])
cv2.imshow('Visual', miAcetatoInformativo.aplicarAFrame(informacion['frame']))
miAcetatoInformativo.inicializar()
tiempoEjecucion = time.time() - tiempoAuxiliar
#if tiempoEjecucion>periodoDeMuestreo:
miReporte.warning('Tiempo Afuera {0:2f}'.format(tiempoEjecucion)+ '[s] en frame {}'.format(frame_number))
#sys.stdout.write("\033[F")
while time.time() - tiempoAuxiliar < periodoDeMuestreo:
True
tiempoAuxiliar = time.time()
if (cambiosImportantes)|(numeroDeObjetos != len(informacion['rectangulos'])):
miReporte.info('F{} Sema: '.format(frame_number)+informacion['semaforo'][1]+' I: '+str(miPoliciaReportando.numeroInfraccionesConfirmadas())+'/'+str(miPoliciaReportando.numeroInfraccionesTotales())+' Objetos: {}'.format(len(informacion['rectangulos'])))
numeroDeObjetos = len(informacion['rectangulos'])
porcentajeDeMemoria = psutil.virtual_memory()[2]
if porcentajeDeMemoria > 80:
miReporte.info('Estado de Memoria: '+str(porcentajeDeMemoria)+'/100')
if porcentajeDeMemoria > 92:
frameAOptimizar = min(informacionTotal)
miReporte.warning('Alcanzado 92/100 de memoria, borrando frame: '+str(frameAOptimizar))
del informacionTotal[frameAOptimizar]['recortados']
informacionTotal[frameAOptimizar]['recortados'] = {}
if porcentajeDeMemoria > 96:
miReporte.warning('Alcanzado 96/100 de memoria, borrando todo e inicializando')
del informacionTotal
informacionTotal = {}
frame_number = 0
frame_number += 1
if (frame_number >= topeEjecucion) &(topeEjecucion!=0):
miReporte.info('ABANDONANDO LA EJECUCION DE PROGRAMA por indice de auto acabado predeterminado')
break
if informacion['semaforo'][0] == -2:
miReporte.critical('ABANDONANDO LA EJECUCION DE PROGRAMA El semaforo ya no obtuvo señal, necesito recalibrar, abandonando la ejecución del programa')
break
ch = 0xFF & cv2.waitKey(5)
if ch == ord('q'):
miReporte.info('ABANDONANDO LA EJECUCION DE PROGRAMA por salida manual')
break
if ch == ord('s'):
cv2.imwrite(datetime.datetime.now().strftime('%Y-%m-%d_%H:%M:%S')+'.jpg',informacion['frame'])
fps.update()
#if colorLiteral == 'Rojo':
#poligonos_warp = backgroundsub.feedbgsub(capturaEnBaja)
#poligonos_warp = pool.starmap(backgroundsub.feedbgsub, capturaEnBaja)
# close the pool and wait for the work to finish
#pool.close()
#pool.join()
#print(poligonos_warp)
#listaderecortados = cutImage(HDframe = capturaEnBaja, matches = poligonos_warp)
#if len(listaderecortados) > 0:
# for i, image in enumerate(listaderecortados):
# cv2.imwrite('imagen_{}_.jpg'.format(i), image)
#else:
# pass
#print('Put: ',time.time()-tiempoAuxiliar)
if mostrarImagen:
tiempoAuxiliar = time.time()
cv2.imshow('Camara', cv2.resize(capturaEnBaja,(640,480)))
print('Show: ',time.time()-tiempoAuxiliar)
print('Periodo total: ',time.time()-periodoReal)
periodoReal = time.time()
#tiempoAuxiliar = time.time()
#if filaImagenes.qsize() > 10:
#miImagen = filaImagenes.get()
# print('Borrado elemento en la fila')
#print('Get: ',time.time()-tiempoAuxiliar)
if frame_number>200:
break
frame_number +=1
"""
ch = 0xFF & cv2.waitKey(5)
if ch == ord('q'):
miReporte.info(
'ABANDONANDO LA EJECUCION DE PROGRAMA por salida manual')
break
def __main_function__():
# Import some global varialbes
global archivoDeVideo
global cambiosImportantes
global grabadoParalelo
cambiosImportantes = False
# Creamos el reporte inicial
miReporte = MiReporte(
levelLogging=logging.INFO, nombre=__name__
) # Se crea por defecto con nombre de la fecha y hora actual
miReporte.info(
'Programa iniciado exitosamente con ingreso de senal video ' +
archivoDeVideo + entradaReal + ' con semaforo ' +
semaforoSimuladoTexto + str(periodoDeSemaforo) + ', corriendo a ' +
str(mifps) + ' Frames por Segundo')
# Si no existe el directorio de reporte lo creo
if not os.path.exists(directorioDeReporte):
os.makedirs(directorioDeReporte)
# Is statements
if generarArchivosDebug:
miReporte.info('Generando Archivos de Debug')
else:
miReporte.info('Generando infracciones unicamente (No debug video)')
# If mostrar Imagenes
if mostrarImagen:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real encendida')
else:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real apagada')
# El directorio de reporte debe crearse al inicio del programa
# Variables de control:
numeroDeFrame = 0
maximoInfraccionesPorFrame = 20
#colores = np.random.randint(0,100,(maximoInfraccionesPorFrame,3))
# Cargando los parametros de instalacion:
# El archivo de video debe tener como minimo 5 caracteres para estar trnajando en modo simulado, de lo contrario estamos trabajando en modo real
if len(archivoDeVideo) > 4:
archivoParametrosACargar = archivoDeVideo[:-4] + '.npy'
else:
archivoParametrosACargar = 'puntos.npy'
parametrosInstalacion = np.load(folderDeInstalacion + '/' +
archivoParametrosACargar)
miReporte.info('Datos de Instalacion de: ' + folderDeInstalacion + '/' +
archivoParametrosACargar)
poligonoSemaforo = parametrosInstalacion[0]
verticesPartida = parametrosInstalacion[1]
verticesLlegada = parametrosInstalacion[2]
indicesSemaforo = obtenerIndicesSemaforo(np.array(poligonoSemaforo))
angulo = parametrosInstalacion[3]
poligonoEnAlta = parametrosInstalacion[4]
miReporte.info('Cargado exitosamente parametros de instalacion: ' +
str(parametrosInstalacion))
# Arrancando camara
if len(archivoDeVideo) == 0:
conVideoGrabado = False # modo real
miCamara = cv2.VideoCapture(1)
miCamara.set(3, 640)
miCamara.set(4, 480)
time.sleep(1)
miReporte.info('Activada Exitosamente cámara en tiempo real')
else:
conVideoGrabado = True
try:
miCamara = cv2.VideoCapture(directorioDeVideos + '/' +
archivoDeVideo)
time.sleep(1)
miReporte.info('Archivo de video cargado exitosamente: ' +
directorioDeVideos + '/' + archivoDeVideo)
except Exception as currentException:
miReporte.error('No se pudo cargar el video por ' +
str(currentException))
# Se captura la imagen de flujo inicial y se trabaja con la misma
ret, frameVideo = miCamara.read()
frameFlujo = cv2.resize(frameVideo, (320, 240))
# Creación de objetos:
miPoliciaReportando = PoliciaInfractor(frameFlujo, verticesPartida,
verticesLlegada, False)
miPoliciaReportando.establecerRegionInteresAlta(poligonoEnAlta)
miGrabadora = GeneradorEvidencia(directorioDeReporte, mifps, False)
miFiltro = IRSwitch()
miAcetatoInformativo = Acetato()
miSemaforo = CreateSemaforo(periodoDeSemaforo)
miAcetatoInformativo.colocarPoligono(np.array(poligonoSemaforo) // 2)
miAcetatoInformativo.colocarPoligono(np.array(verticesPartida))
miAcetatoInformativo.colocarPoligono(np.array(verticesLlegada))
informacionTotal = {}
frame_number = 0
tiempoAuxiliar = time.time()
periodoDeMuestreo = 1.0 / mifps
grupo = [0]
frameAlta = np.empty((320, 240, 3))
capturaEnAlta = False
imagenesEnAlta = []
while True:
# LEEMOS LA CAMARA DE FLUJO
if conVideoGrabado:
for i in range(videofps // mifps):
ret, frameVideo = miCamara.read()
else:
if capturaEnAlta:
ret, frameAlta = miCamara.read()
imagenesEnAlta.append([
miPoliciaReportando.ultimaCarpetaGuardado + '/imagen.jpg',
frameAlta
])
frameVideo = cv2.resize(frameAlta, (320, 240))
capturaEnAlta = False
miCamara.set(3, 640)
miCamara.set(4, 480)
else:
ret, frameVideo = miCamara.read()
pixeles = np.array(
[frameVideo[indicesSemaforo[0][1], indicesSemaforo[0][0]]])
#print('IndicesPixel: ',indicesSemaforo[0][0],indicesSemaforo[0][1])
#print('La longitud semaforo: ',len(indicesSemaforo),' inicial ',pixeles.shape)
#print('La longitud interna: ',len(indicesSemaforo[0]),' inicial ',pixeles.shape)
for indiceSemaforo in indicesSemaforo[1:]:
pixeles = np.append(
pixeles, [frameVideo[indiceSemaforo[1], indiceSemaforo[0]]],
axis=0)
#print('>>> ',pixeles.shape,' in ',indiceSemaforo)
#cv2.circle(frameVideo, (indiceSemaforo[0],indiceSemaforo[1]), 1, (100,100,100), -1)
#print('Pixeles: ',pixeles)
#wtf = pixeles.reshape((24,8,3))
#cv2.imshow('Semaforo', cv2.resize(wtf, (240,320)))
#print('La longitud pixels: ',pixeles.shape)
senalSemaforo, semaforoLiteral, flanco, periodo = miSemaforo.obtenerColorEnSemaforo(
pixeles)
frameFlujo = cv2.resize(frameVideo, (320, 240))
if periodo != 0:
miReporte.info('SEMAFORO EN VERDE, EL PERIODO ES ' + str(periodo))
else:
pass
# Si tengo infracciones pendientes las evoluciono
cambiosImportantes, ondaFiltrada, frenteAutomovil, flujoTotal = miPoliciaReportando.seguirImagen(
frame_number, frameFlujo, colorSemaforo=senalSemaforo)
if senalSemaforo >= 1: # Si estamos en rojo, realizamos una accion
if frenteAutomovil == 1:
miCamara.set(3, 3280)
miCamara.set(4, 2464)
capturaEnAlta = True
if flanco == 1: # esto se inicia al principio de este estado
miReporte.info('SEMAFORO EN ROJO')
miPoliciaReportando.inicializarAgente()
del informacionTotal
informacionTotal = {}
frame_number = 0
else:
pass
else:
pass
if senalSemaforo == 0: # Si estamos en verde realizamos otra accion
if flanco == -1: # Si estamos en verde y en flanco, primer verde, realizamos algo
miReporte.info(
'Infracciones: ' +
str(miPoliciaReportando.numeroInfraccionesConfirmadas()))
if generarArchivosDebug:
miGrabadora.generarReporteInfraccion(
informacionTotal, False,
miPoliciaReportando.numeroInfraccionesConfirmadas())
miPoliciaReportando.purgeInfractions()
if miPoliciaReportando.numeroInfraccionesConfirmadas() > 0:
infraccionEnRevision = miPoliciaReportando.popInfraccion()
miGrabadora.generarReporteInfraccion(informacionTotal,
infraccionEnRevision)
if miPoliciaReportando.numeroInfraccionesConfirmadas == 0:
for imagen in imagenesEnAlta:
print('>>>>> GUARDANDO COMO: ', imagen[0], ' shape ',
imagen[1].shape)
cv2.imwrite(imagen[0], imagen[1])
else:
#Si no hay infracciones a reportar me fijo el estado del filtro:
tiempoAhora = datetime.datetime.now(
).hour * 60 + datetime.datetime.now().minute
if (tiempoAhora > amaneciendo) & (miFiltro.ultimoEstado !=
'Filtro Activado'):
miFiltro.colocarFiltroIR()
if (tiempoAhora < amaneciendo) & (miFiltro.ultimoEstado !=
'Filtro Desactivado'):
miFiltro.quitarFiltroIR()
pass
# Draw frame number into image on top
for infraction in miPoliciaReportando.listaDeInfracciones:
for puntos in infraction['desplazamiento']:
puntosExtraidos = puntos.ravel().reshape(
puntos.ravel().shape[0] // 2, 2)
for punto in puntosExtraidos:
if infraction['estado'] == 'Confirmado':
miAcetatoInformativo.colocarPunto(tuple(punto), 0)
else:
miAcetatoInformativo.colocarPunto(tuple(punto), 1)
# Configs and displays for the MASK according to the semaforo
#miAcetatoInformativo.agregarTextoEn("I{}".format(miPoliciaReportando.infraccionesConfirmadas), 2)
miAcetatoInformativo.colorDeSemaforo(senalSemaforo)
frameFlujo = miAcetatoInformativo.aplicarAFrame(frameFlujo)
if mostrarImagen:
#cv2.imshow('Visual', miAcetatoInformativo.aplicarAFrame(frameFlujo)[120:239,60:360])
cv2.imshow('Visual', frameFlujo)
informacionTotal[frame_number] = frameFlujo.copy()
miAcetatoInformativo.inicializar()
tiempoEjecucion = time.time() - tiempoAuxiliar
if tiempoEjecucion > periodoDeMuestreo:
miReporte.warning('Tiempo Afuera {0:2f}'.format(tiempoEjecucion) +
'[s] en frame {}'.format(frame_number))
#sys.stdout.write("\033[F")
while time.time() - tiempoAuxiliar < periodoDeMuestreo:
True
tiempoAuxiliar = time.time()
if cambiosImportantes:
miReporte.info(
'F{} Sema: '.format(frame_number) + semaforoLiteral + ' I: ' +
str(miPoliciaReportando.numeroInfraccionesConfirmadas()) +
'/' + str(miPoliciaReportando.numeroInfraccionesTotales()))
porcentajeDeMemoria = psutil.virtual_memory()[2]
if (porcentajeDeMemoria > 80) & (os.uname()[1] == 'raspberrypi'):
miReporte.info('Estado de Memoria: ' + str(porcentajeDeMemoria) +
'/100')
if porcentajeDeMemoria > 96:
miReporte.warning(
'Alcanzado 96/100 de memoria, borrando todo e inicializando')
del informacionTotal
informacionTotal = {}
frame_number = 0
frame_number += 1
if (frame_number >= topeEjecucion) & (topeEjecucion != 0):
miReporte.info(
'ABANDONANDO LA EJECUCION DE PROGRAMA por indice de auto acabado predeterminado'
)
break
if senalSemaforo == -2:
miReporte.critical(
'ABANDONANDO LA EJECUCION DE PROGRAMA El semaforo ya no obtuvo señal, necesito recalibrar, abandonando la ejecución del programa'
)
break
ch = 0xFF & cv2.waitKey(5)
if ch == ord('q'):
miReporte.info(
'ABANDONANDO LA EJECUCION DE PROGRAMA por salida manual')
break
if ch == ord('s'):
cv2.imwrite(
datetime.datetime.now().strftime('%Y-%m-%d_%H:%M:%S') + '.jpg',
frameFlujo)
def __main_function__():
# Import some global varialbes
global archivoDeVideo
global cambiosImportantes
cambiosImportantes = False
# Creamos el reporte inicial
miReporte = MiReporte(
levelLogging=logging.INFO, nombre=__name__
) # Se crea por defecto con nombre de la fecha y hora actual
miReporte.info(
'Programa iniciado exitosamente con ingreso de senal video ' +
archivoDeVideo + entradaReal + ' con semaforo ' +
semaforoSimuladoTexto + str(periodoDeSemaforo) + ', corriendo a ' +
str(mifps) + ' Frames por Segundo')
# Si no existe el directorio de reporte lo creo
if not os.path.exists(directorioDeReporte):
os.makedirs(directorioDeReporte)
# Is statements
if generarArchivosDebug:
miReporte.info('Generando Archivos de Debug')
else:
miReporte.info('Generando infracciones unicamente (No debug video)')
# If mostrar Imagenes
if mostrarImagen:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real encendida')
else:
miReporte.info(
'Pantalla de muestra de funcionamiento en tiempo real apagada')
# El directorio de reporte debe crearse al inicio del programa
# Variables de control:
numeroDeFrame = 0
maximoInfraccionesPorFrame = 20
#colores = np.random.randint(0,100,(maximoInfraccionesPorFrame,3))
# Cargando los parametros de instalacion:
# El archivo de video debe tener como minimo 5 caracteres para estar trnajando en modo simulado, de lo contrario estamos trabajando en modo real
if len(archivoDeVideo) > 4:
archivoParametrosACargar = archivoDeVideo[:-4] + '.npy'
else:
archivoParametrosACargar = 'datos.npy'
parametrosInstalacion = np.load(folderDeInstalacion + '/' +
archivoParametrosACargar)
miReporte.info('Datos de Instalacion de: ' + folderDeInstalacion + '/' +
archivoParametrosACargar)
poligonoSemaforo = parametrosInstalacion[0]
verticesPartida = parametrosInstalacion[1]
verticesLlegada = parametrosInstalacion[2]
angulo = parametrosInstalacion[3]
indicesSemaforo = SemaphoroParameters(poligonoSemaforo)
miReporte.info('Cargado exitosamente parametros de instalacion: ' +
str(parametrosInstalacion))
# Arrancando camara
if len(archivoDeVideo) == 0:
conVideoGrabado = False # modo real
if os.uname()[1] == 'alvarohurtado-305V4A':
miCamara = cv2.VideoCapture(1)
time.sleep(1)
elif os.uname()[1] == 'stanlee321-HP-240-G1-Notebook-PC':
miCamara = cv2.VideoCapture(0)
miCamara.set(cv2.CAP_PROP_FRAME_WIDTH, mediumRes[0])
miCamara.set(cv2.CAP_PROP_FRAME_HEIGHT, mediumRes[1])
time.sleep(1)
else:
miCamara = cv2.VideoCapture(1)
miCamara.set(cv2.CAP_PROP_FRAME_WIDTH, mediumRes[0])
miCamara.set(cv2.CAP_PROP_FRAME_HEIGHT, mediumRes[1])
#miCamara = VideoStream(src = 0, resolution = (1920,1080),poligono = poligonoSemaforo, debug = saltarFrames,fps = mifps, periodo = periodoDeSemaforo, gamma = gamma).start()
#miCamara = VideoStream(src = 0, resolution = (1280,960),poligono = poligonoSemaforo, debug = saltarFrames,fps = mifps, periodo = periodoDeSemaforo, gamma = gamma).start()
time.sleep(1)
miReporte.info('Activada Exitosamente cámara en tiempo real')
else:
conVideoGrabado = True
try:
miCamara = cv2.VideoCapture(directorioDeVideos + '/' +
archivoDeVideo)
miCamara.set(cv2.CAP_PROP_FRAME_WIDTH, mediumRes[0])
miCamara.set(cv2.CAP_PROP_FRAME_HEIGHT, mediumRes[1])
time.sleep(1)
miReporte.info('Archivo de video cargado exitosamente: ' +
directorioDeVideos + '/' + archivoDeVideo)
except Exception as currentException:
miReporte.error('No se pudo cargar el video por ' +
str(currentException))
# Load points for the semaphoro
# Se captura la imagen de flujo inicial y se trabaja con la misma
ret, frameVideo = miCamara.read()
frameFlujo = cv2.resize(frameVideo, (320, 240))
# Creación de objetos:
miPoliciaReportando = PoliciaInfractor(frameFlujo, verticesPartida,
verticesLlegada)
miGrabadora = GeneradorEvidencia(directorioDeReporte, mifps,
guardarRecortados)
miFiltro = IRSwitch()
miAcetatoInformativo = Acetato()
miSemaforo = CreateSemaforo(periodoDeSemaforo)
miAcetatoInformativo.colocarPoligono(np.array(poligonoSemaforo) // 2)
miAcetatoInformativo.colocarPoligono(np.array(verticesPartida))
miAcetatoInformativo.colocarPoligono(np.array(verticesLlegada))
fps = FPS().start()
informacionTotal = {}
frame_number = 0
tiempoAuxiliar = time.time()
periodoDeMuestreo = 1.0 / mifps
grupo = [0]
while True:
# LEEMOS LA CAMARA DE FLUJO
if conVideoGrabado:
for i in range(videofps // mifps):
ret, frameVideo = miCamara.read()
else:
ret, frameVideo = miCamara.read()
frameFlujo = cv2.resize(frameVideo, (320, 240),
interpolation=cv2.INTER_NEAREST)
tic = time.time()
informacionTotal[frame_number] = frameFlujo.copy()
pixeles = indicesSemaforo(frameVideo)
print('La longitud pixels: ', pixeles.shape)
senalSemaforo, semaforoLiteral, flanco, periodo = miSemaforo.obtenerColorEnSemaforo(
pixeles)
tac = time.time()
print('tic-tac', tac - tic)
if periodo != 0:
miReporte.info('SEMAFORO EN VERDE, EL PERIODO ES ' + str(periodo))
else:
pass
# Si tengo infracciones pendientes las evoluciono
if senalSemaforo >= 1: # Si estamos en rojo, realizamos una accion
if flanco == 1: # esto se inicia al principio de este estado
miReporte.info('SEMAFORO EN ROJO')
miPoliciaReportando.inicializarAgente()
del informacionTotal
informacionTotal = {}
frame_number = 0
else:
pass
cambiosImportantes, ondaFiltrada, flanco, flujoTotal = miPoliciaReportando.seguirImagen(
frame_number, frameFlujo)
else:
pass
if senalSemaforo == 0: # Si estamos en verde realizamos otra accion
if flanco == -1: # Si estamos en verde y en flanco, primer verde, realizamos algo
miReporte.info(
'Infracciones: ' +
str(miPoliciaReportando.numeroInfraccionesConfirmadas()))
if generarArchivosDebug:
miGrabadora.generarReporteInfraccion(
informacionTotal, False,
miPoliciaReportando.numeroInfraccionesConfirmadas())
if miPoliciaReportando.numeroInfraccionesConfirmadas() > 0:
infraccionEnRevision = miPoliciaReportando.popInfraccion()
miGrabadora.generarReporteInfraccion(informacionTotal,
infraccionEnRevision)
else:
#Si no hay infracciones a reportar me fijo el estado del filtro:
tiempoAhora = datetime.datetime.now(
).hour * 60 + datetime.datetime.now().minute
if (tiempoAhora > amaneciendo) & (miFiltro.ultimoEstado !=
'Filtro Activado'):
miFiltro.colocarFiltroIR()
if (tiempoAhora < amaneciendo) & (miFiltro.ultimoEstado !=
'Filtro Desactivado'):
miFiltro.quitarFiltroIR()
pass
# Draw frame number into image on top
for infraction in miPoliciaReportando.listaDeInfracciones:
for puntos in infraction['desplazamiento']:
puntosExtraidos = puntos.ravel().reshape(
puntos.ravel().shape[0] // 2, 2)
for punto in puntosExtraidos:
if infraction['estado'] == 'Confirmado':
miAcetatoInformativo.colocarPunto(tuple(punto), 0)
else:
miAcetatoInformativo.colocarPunto(tuple(punto), 1)
# Configs and displays for the MASK according to the semaforo
#miAcetatoInformativo.agregarTextoEn("I{}".format(miPoliciaReportando.infraccionesConfirmadas), 2)
miAcetatoInformativo.colorDeSemaforo(senalSemaforo)
if mostrarImagen:
#cv2.imshow('Visual', miAcetatoInformativo.aplicarAFrame(frameFlujo)[120:239,60:360])
cv2.imshow('Visual',
miAcetatoInformativo.aplicarAFrame(frameFlujo))
miAcetatoInformativo.inicializar()
tiempoEjecucion = time.time() - tiempoAuxiliar
if tiempoEjecucion > periodoDeMuestreo:
miReporte.warning('Tiempo Afuera {0:2f}'.format(tiempoEjecucion) +
'[s] en frame {}'.format(frame_number))
#sys.stdout.write("\033[F")
while time.time() - tiempoAuxiliar < periodoDeMuestreo:
True
tiempoAuxiliar = time.time()
if cambiosImportantes:
miReporte.info(
'F{} Sema: '.format(frame_number) + semaforoLiteral + ' I: ' +
str(miPoliciaReportando.numeroInfraccionesConfirmadas()) +
'/' + str(miPoliciaReportando.numeroInfraccionesTotales()))
porcentajeDeMemoria = psutil.virtual_memory()[2]
if (porcentajeDeMemoria > 80) & (os.uname()[1] == 'raspberrypi'):
miReporte.info('Estado de Memoria: ' + str(porcentajeDeMemoria) +
'/100')
if porcentajeDeMemoria > 92:
frameAOptimizar = min(informacionTotal)
miReporte.warning('Alcanzado 92/100 de memoria, borrando frame: ' +
str(frameAOptimizar))
del informacionTotal[frameAOptimizar]['recortados']
informacionTotal[frameAOptimizar]['recortados'] = {}
if porcentajeDeMemoria > 96:
miReporte.warning(
'Alcanzado 96/100 de memoria, borrando todo e inicializando')
del informacionTotal
informacionTotal = {}
frame_number = 0
frame_number += 1
if (frame_number >= topeEjecucion) & (topeEjecucion != 0):
miReporte.info(
'ABANDONANDO LA EJECUCION DE PROGRAMA por indice de auto acabado predeterminado'
)
break
if senalSemaforo == -2:
miReporte.critical(
'ABANDONANDO LA EJECUCION DE PROGRAMA El semaforo ya no obtuvo señal, necesito recalibrar, abandonando la ejecución del programa'
)
break
ch = 0xFF & cv2.waitKey(5)
if ch == ord('q'):
miReporte.info(
'ABANDONANDO LA EJECUCION DE PROGRAMA por salida manual')
break
if ch == ord('s'):
cv2.imwrite(
datetime.datetime.now().strftime('%Y-%m-%d_%H:%M:%S') + '.jpg',
frameFlujo)
fps.update()
# stop the timer and display FPS information
fps.stop()