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()
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
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()
class PoliciaInfractor():
"""
Entre las principales funciones de esta clase esta traducir la información de los frames entrantes a información mas manipulable y valiosa para un ser humano o para una inteligencia artificial
Tambien se encarga de crear los objetos Vehiculos que pueden estar en estado cruce o infraccion
También se encarga de proveer el estado actual del infractor
"""
def __init__(self,
imagenParaInicializar,
poligonoPartida,
poligonoLlegada,
poligonoDerecha,
poligonoIzquierda,
mifps=8,
directorioDeReporte=os.getenv('HOME') + '/' +
datetime.datetime.now().strftime('%Y-%m-%d') + '_reporte',
debug=False,
flujoAntiguo=False,
anguloCarril=0):
# Tomo la imagen de inicialización y obtengo algunas caracteristicas de la misma
self.directorioDeReporte = directorioDeReporte
self.miReporte = MiReporte(levelLogging=logging.DEBUG, nombre=__name__)
self.miGrabadora = GeneradorEvidencia(self.directorioDeReporte, mifps,
False)
self.reportarDebug = debug
self.minimosFramesVideoNormalDebug = 1 * mifps # minimo 1 segundos de debug
# Se cargan las variables de creación de la clase
self.imagenAuxiliar = cv2.cvtColor(imagenParaInicializar,
cv2.COLOR_BGR2GRAY)
self.areaDeResguardo = np.array(poligonoPartida)
self.areaDeConfirmacion = np.array(poligonoLlegada)
self.areaDeGiroDerecha = np.array(poligonoDerecha)
self.areaDeGiroIzquierda = np.array(poligonoIzquierda)
self.anguloCarril = -anguloCarril
self.desplazamiento = np.array(
[8 * math.cos(self.anguloCarril), 8 * math.sin(self.anguloCarril)])
# CONDICIONES DE DESCARTE
# En si un punto sale del carril valido (ensanchado debidamente) se descarta el punto individual
self.carrilValido = self.generarCarrilValido(poligonoPartida,
poligonoLlegada,
poligonoDerecha,
poligonoIzquierda)
self.maximoNumeroFramesParaDescarte = 80
self.numeroDePuntosASeguirDeInicializacion = 4
# 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.maximaDistanciaEntrePuntos = self.tamanoVector(
np.array(poligonoPartida[0]) - np.array(poligonoPartida[1]))
# Se crea la clase correspondiente
self.miFiltro = AnalisisOnda()
self.angulo = 18
# 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]])
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) / self.tamanoVector(vectorParalelo)
self.vectorPerpendicularUnitario = np.array(
[self.vectorParaleloUnitario[1], -self.vectorParaleloUnitario[0]])
self.numeroDePuntos = 15
self.flujoAntiguo = False
if flujoAntiguo == True:
self.flujoAntiguo = True
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))
self.lineaFijaDelantera = np.zeros((self.numeroDePuntos + 1, 1, 2))
self.lineaDeResguardoDelantera = self.crearLineaDeResguardo()
self.lineaDeResguardoAlteradaDelantera = self.lineaDeResguardoDelantera
# Se inicializa la perspectiva con 1/9 del largo del paso de cebra como ancho
self.areaFlujo = self.obtenerRegionFlujo(self.areaDeResguardo)
self.miPerspectiva = Perspective(self.areaFlujo)
self.anteriorFranja = self.miPerspectiva.transformarAMitad(
self.imagenAuxiliar)
self.optimalStep = 2
self.listaVehiculos = []
"""
Estados de vehiculos
1. Previo
2. Cruce
3. Giro
4. Ruido
"""
self.reestablecerEstado()
if os.uname()[1] == 'raspberrypi':
self.camaraAlta = ControladorCamara()
def obtenerRegionFlujo(self, npArrayDePartida):
punto01 = npArrayDePartida[0]
punto02 = npArrayDePartida[1]
punto03 = npArrayDePartida[2]
punto04 = npArrayDePartida[3]
unitario12 = (punto02 - punto01) / self.tamanoVector(punto02 - punto01)
unitario43 = (punto03 - punto04) / self.tamanoVector(punto03 - punto04)
largoPasoCebra = self.tamanoVector(punto04 - punto01)
punto02 = punto01 + largoPasoCebra / 3 * unitario12
punto03 = punto04 + largoPasoCebra / 3 * unitario43
return np.array([punto01, punto02, punto03, punto04]).astype(int)
def nuevoDia(self, directorioDeReporte):
self.directorioDeReporte = directorioDeReporte
self.miReporte.setDirectory(directorioDeReporte)
self.miGrabadora.nuevoDia()
self.reestablecerEstado()
def generarCarrilValido(self, poligonoPartida, poligonoLlegada,
poligonoDerecha, poligonoIzquierda):
# Input type: self.carrilValido = np.array([poligonoPartida[0],poligonoPartida[1],poligonoPartida[2],poligonoPartida[3],poligonoLlegada[2],poligonoLlegada[3],poligonoLlegada[0],poligonoLlegada[1]])
# Se modifican los puntos
# partida: 0-,3+
# llegada: 1+,2-
# La matriz de rotacion por un angulo de 15 grados
carrilValido = np.array([
poligonoPartida[0], poligonoPartida[1], poligonoPartida[2],
poligonoPartida[3], poligonoLlegada[2], poligonoLlegada[3],
poligonoLlegada[0], poligonoLlegada[1]
])
self.angulo = 14
cos15 = math.cos(self.angulo * math.pi / 180)
sin15 = math.sin(self.angulo * math.pi / 180)
rotacionNegativa = np.array([[cos15, sin15], [-sin15, cos15]])
rotacionPositiva = np.array([[cos15, -sin15], [sin15, cos15]])
llegada1_p7 = carrilValido[6] + rotacionPositiva.dot(carrilValido[7] -
carrilValido[6])
llegada1_p4 = carrilValido[5] + rotacionNegativa.dot(carrilValido[4] -
carrilValido[5])
llegada1_p0 = carrilValido[1] + rotacionNegativa.dot(carrilValido[0] -
carrilValido[1])
llegada1_p3 = carrilValido[2] + rotacionPositiva.dot(carrilValido[3] -
carrilValido[2])
carrilValido[0] = llegada1_p0
carrilValido[3] = llegada1_p3
carrilValido[4] = llegada1_p4
carrilValido[7] = llegada1_p7
# Hasta este punto se obtiene el carril valido simplemente ensanchado
# Ahora concatenamos con los puntos de llegada a Derecha e Izquierda
carrilValido = np.array([
carrilValido[0], carrilValido[1], carrilValido[2], carrilValido[3],
poligonoDerecha[2], poligonoDerecha[3], poligonoDerecha[0],
poligonoDerecha[1], carrilValido[4], carrilValido[5],
carrilValido[6], carrilValido[7], poligonoIzquierda[2],
poligonoIzquierda[3], poligonoIzquierda[0], poligonoIzquierda[1]
])
return carrilValido
def tamanoVector(self, vector):
# Metodo auxiliar por la recurencia de esta aplicacion
return math.sqrt(vector[0]**2 + vector[1]**2)
def puntoEstaEnRectangulo(self, punto, rectangulo):
# Metodo auxiliar por la recurencia de esta aplicacion
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
# No longer needed
def inicializarAgente(self, ):
"""
Resets the starting line to get ready to the next frame
"""
del self.listaVehiculos
self.listaVehiculos = []
def crearLineaDeResguardo(self):
"""
La linea de resguardo es una linea preparada para entrar en el algoritmo de lucas Kanade y controlar el flujo o seguir objetos que crucen la zona de partida
"""
lineaAuxiliar = np.array([[self.lineaDePintadoLK[0]]])
for numeroDePunto in range(1, self.numeroDePuntos + 1):
lineaAuxiliar = np.append(lineaAuxiliar, [[
self.lineaDePintadoLK[0] +
numeroDePunto * np.array([self.stepX, self.stepY])
]],
axis=0)
self.lineaFijaDelantera = lineaAuxiliar
self.lineaFijaDelantera = np.array(self.lineaFijaDelantera,
dtype=np.float32)
return lineaAuxiliar
def seguirImagen(self,
numeroDeFrame,
imagenActual,
informacion=False,
colorSemaforo=1):
"""
Metodo mas importante del infractor: Se encarga de:
1. Crear vehiculos de ser necesario
2. Seguir vehiculos
3. Confirmar o descartar vehículos
"""
#print('>> 01 Inicio Seguir')
if colorSemaforo == 1:
self.estadoActual['colorSemaforo'] = 'Rojo'
elif colorSemaforo == 0:
self.estadoActual['colorSemaforo'] = 'Verde'
elif colorSemaforo == 2:
self.estadoActual['colorSemaforo'] = 'Amarillo'
else:
self.estadoActual['colorSemaforo'] = 'No hay semaforo'
imagenActualEnGris = cv2.cvtColor(imagenActual, cv2.COLOR_BGR2GRAY)
arrayAuxiliarParaVelocidad, activo, err = cv2.calcOpticalFlowPyrLK(
self.imagenAuxiliar, imagenActualEnGris, self.lineaFijaDelantera,
None, **self.lk_params)
self.lineaDeResguardoAlteradaDelantera = arrayAuxiliarParaVelocidad
if self.flujoAntiguo:
velocidadEnBruto = self.obtenerMagnitudMovimientoEnRegion(
self.miPerspectiva.transformarAMitad(imagenActualEnGris))
else:
velocidadEnBruto = self.obtenerMagnitudMovimiento(
self.lineaFijaDelantera,
self.lineaDeResguardoAlteradaDelantera)
velocidadFiltrada, pulsoVehiculos = self.miFiltro.obtenerOndaFiltrada(
velocidadEnBruto)
# Se evoluciona el resto de vehiculos solo si son 'Previo'
for infraccion in self.listaVehiculos:
# Si es candidato evoluciona:
if infraccion['estado'] == 'Previo':
if (infraccion['infraccion'] == 'candidato') & (colorSemaforo
== 0):
#infraccion['observacion'] = 'LlegoEnVerde'
self.miReporte.info(
'Infraccion Descartada Por Llegar En Verde')
infraccion['infraccion'] = ''
# Al principio descarto los puntos negativos o en los bordes (0,0), -(x,y)
nuevaPosicionVehiculo, activo, err = cv2.calcOpticalFlowPyrLK(
self.imagenAuxiliar, imagenActualEnGris,
infraccion['desplazamiento'], None, **self.lk_params)
# Si ya no hay puntos que seguir el anterior retorna NoneType, se determina como Giro,
NoneType = type(None)
if type(nuevaPosicionVehiculo) == NoneType:
infraccion['estado'] = 'Salio'
if infraccion['infraccion'] == 'candidato':
infraccion['infraccion'] = ''
self.eliminoCarpetaDeSerNecesario(infraccion)
# VALIDO SOLO PARA GIRO CONTROLADO POR SEMAFORO A PARTE
self.estadoActual['salio'] += 1
break
# DESCARTE INDIVIDUAL POR PUNTO
# Se descarta puntos individualmente, si un punto esta en el borde del frame o fuera de el entonces se lo mantiene congelado
# PELIGRO, los frames congelados estan ingresando al calcOpticalFlow arriba, revisar
# 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)):
# nuevaPosicionVehiculo[otroIndice] = infraccion['desplazamiento'][otroIndice]
# DESCARTE POR TIEMPO, POR VEHICULO
if (numeroDeFrame - infraccion['frameInicial']
) > self.maximoNumeroFramesParaDescarte:
infraccion['estado'] = 'TimeOut'
infraccion['infraccion'] = ''
self.estadoActual['ruido'] += 1
self.eliminoCarpetaDeSerNecesario(infraccion)
break
# Si es candidato y algun punto llego al final se confirma
indicesValidos = []
puntosQueLlegaron = 0
puntosQueGiraronDerecha = 0
puntosQueGiraronIzquierda = 0
for indiceVector in range(len(nuevaPosicionVehiculo)):
# Para cada indice
vector = nuevaPosicionVehiculo[indiceVector]
xTest, yTest = vector[0][0], vector[0][1]
# hago una lista de los indices que aun son validos
if cv2.pointPolygonTest(
self.carrilValido, (xTest, yTest), True
) >= 0: # Si esta dentro del carril valido se mantiene el punto
indicesValidos.append(indiceVector)
# Confirmo la llegada de uno
if cv2.pointPolygonTest(
self.areaDeConfirmacion, (xTest, yTest), True
) >= 0: # Si esta dentro del espacio de llegada se confirma
puntosQueLlegaron += 1
if cv2.pointPolygonTest(
self.areaDeGiroDerecha, (xTest, yTest), True
) >= 0: # Si esta dentro del espacio de llegada se confirma
puntosQueGiraronDerecha += 1
if cv2.pointPolygonTest(
self.areaDeGiroIzquierda, (xTest, yTest), True
) >= 0: # Si esta dentro del espacio de llegada se confirma
puntosQueGiraronIzquierda += 1
if puntosQueLlegaron >= 2:
# Si llego al otro extremo, entonces cruzo:
infraccion['estado'] = 'Cruzo'
self.estadoActual['cruzo'] += 1
infraccion['frameFinal'] = numeroDeFrame
# Si era candidato y esta llegando en rojo o amarillo
# ESTO DESCARTA LAS LLEGADAS EN VERDE # Anulado por mala intensión
if (infraccion['infraccion'] == 'candidato'
): #&(colorSemaforo>=1):
infraccion['infraccion'] = 'CAPTURADO'
self.estadoActual['infraccion'] += 1
self.miReporte.info(infraccion['infraccion'] + '\t' +
infraccion['estado'] +
' a horas ' + infraccion['name'] +
' (' +
str(infraccion['frameInicial']) +
'-' +
str(infraccion['frameFinal']) +
')')
break
if puntosQueGiraronDerecha >= 2:
# Si llego al otro extremo, entonces cruzo:
infraccion['estado'] = 'Giro derecha'
self.estadoActual['derecha'] += 1
infraccion['frameFinal'] = numeroDeFrame
# Si era candidato y esta llegando en rojo o amarillo
# ESTO DESCARTA LAS LLEGADAS EN VERDE # Anulado por mala intensión
if (infraccion['infraccion'] == 'candidato'
): #&(colorSemaforo>=1):
infraccion['infraccion'] = 'CAPTURADO_DERECHA'
self.estadoActual['infraccion'] += 1
self.miReporte.info(infraccion['infraccion'] + '\t' +
infraccion['estado'] +
' a horas ' + infraccion['name'] +
' (' +
str(infraccion['frameInicial']) +
'-' +
str(infraccion['frameFinal']) +
')')
break
if puntosQueGiraronIzquierda >= 2:
# Si llego al otro extremo, entonces cruzo:
infraccion['estado'] = 'Giro izquierda'
self.estadoActual['izquierda'] += 1
infraccion['frameFinal'] = numeroDeFrame
# Si era candidato y esta llegando en rojo o amarillo
# ESTO DESCARTA LAS LLEGADAS EN VERDE # Anulado por mala intensión
if (infraccion['infraccion'] == 'candidato'
): #&(colorSemaforo>=1):
infraccion['infraccion'] = 'CAPTURADO_IZQUIERDA'
self.estadoActual['infraccion'] += 1
self.miReporte.info(infraccion['infraccion'] + '\t' +
infraccion['estado'] +
' a horas ' + infraccion['name'] +
' (' +
str(infraccion['frameInicial']) +
'-' +
str(infraccion['frameFinal']) +
')')
break
# Se continuara solamente con los puntos validos
infraccion['desplazamiento'] = nuevaPosicionVehiculo[
indicesValidos]
if pulsoVehiculos == 1:
# Se determina los mejores puntos para seguir para ser parte del objeto Vehiculo
puntosMasMoviles = self.obtenerPuntosMoviles(
self.lineaFijaDelantera,
self.lineaDeResguardoAlteradaDelantera, informacion)
# Cada vehiculo tiene un numbre que biene a xer ela fecja y hora de la infracción en cuestion
nombreInfraccionYFolder = datetime.datetime.now().strftime(
'%H-%M-%S'
) # Eliminada redundancia en nombre de archivo %Y-%m-%d_
# CREACION NUEVO VEHICULO
nuevoVehiculo = {
'name': nombreInfraccionYFolder,
'frameInicial': numeroDeFrame,
'frameFinal': 0,
'desplazamiento': puntosMasMoviles,
'estado': 'Previo',
'infraccion': '',
'observacion': ''
}
# CREACION NUEVO CANDIDATO
direccionDeGuardadoFotos = 'None'
if colorSemaforo >= 1:
nuevoVehiculo['infraccion'] = 'candidato'
direccionDeGuardadoFotos = self.directorioDeReporte + '/' + nombreInfraccionYFolder
if not os.path.exists(direccionDeGuardadoFotos):
os.makedirs(direccionDeGuardadoFotos)
if os.uname()[1] == 'raspberrypi':
# AQUI!
self.camaraAlta.encenderCamaraEnSubDirectorio(
direccionDeGuardadoFotos)
#self.camaraAlta.encenderCamaraEnSubDirectorio(nombreInfraccionYFolder)
self.listaVehiculos.append(nuevoVehiculo)
self.miReporte.info('\t\tCreado vehiculo ' +
nuevoVehiculo['name'] + ' en frame ' +
str(nuevoVehiculo['frameInicial']) +
' con nivel ' + nuevoVehiculo['infraccion'] +
' guardado en ' +
direccionDeGuardadoFotos[19:])
infraccionesConfirmadas = self.numeroInfraccionesConfirmadas()
self.imagenAuxiliar = imagenActualEnGris
#print(self.estadoActual)
#sys.stdout.write("\033[F") # Cursor up one line
return velocidadEnBruto, velocidadFiltrada, pulsoVehiculos, 0
def reestablecerEstado(self):
self.estadoActual = {
'previo': 0,
'cruzo': 0,
'salio': 0,
'derecha': 0,
'izquierda': 0,
'ruido': 0,
'infraccion': 0,
'infraccionAmarillo': 0,
'colorSemaforo': 'Verde'
}
def numeroInfraccionesConfirmadas(self):
contadorInfraccionesConfirmadas = 0
for infraccion in self.listaVehiculos:
if infraccion['estado'] == 'Cruzo':
contadorInfraccionesConfirmadas += 1
return contadorInfraccionesConfirmadas
def numeroInfraccionesTotales(self):
contadorInfracciones = 0
for infraccion in self.listaVehiculos:
contadorInfracciones += 1
return contadorInfracciones
def reportarPasoAPaso(self, historial):
"""
Este metodo reporta un caso a la vez de existir el mismo en la base de datos de infracciones
"""
self.listaVehiculos = [
vehiculosPendientes for vehiculosPendientes in self.listaVehiculos
if vehiculosPendientes['estado'] == 'Previo'
or vehiculosPendientes['infraccion'] == 'CAPTURADO'
or vehiculosPendientes['infraccion'] == 'CAPTURADO DERECHA'
or vehiculosPendientes['infraccion'] == 'CAPTURADO IZQUIERDA'
]
listaInfracciones = [
infraccion for infraccion in self.listaVehiculos
if infraccion['infraccion'] == 'CAPTURADO'
]
# Los cruces siguen evolucionando
# Las infracciones en calidad de 'CAPTURADO' son generadas en video
# Los cruces en ruido son eliminados
if len(listaInfracciones) > 0:
# Como python optimiza el copiado de listas de diccionarios la siguiente figura modifica la lista originalself.es
infraccionActual = listaInfracciones[0]
#infraccionActual = self.listaVehiculos[self.listaVehiculos.index(listaInfracciones[0])]
infraccionActual['infraccion'] = 'REPORTADO'
#self.miGrabadora.generarReporteInfraccion(historial, infraccionActual,debug = self.reportarDebug)
self.miGrabadora.generarReporteEnVideoDe(historial,
infraccionActual,
debug=self.reportarDebug)
def generarVideoMuestra(self, historial):
if len(historial) > self.minimosFramesVideoNormalDebug:
#self.miGrabadora.generarReporteInfraccion(historial, True,debug = self.reportarDebug)
self.miGrabadora.generarVideoDebugParaPruebas(historial)
def eliminoCarpetaDeSerNecesario(self, infraccion):
try:
carpetaABorrar = self.directorioDeReporte + '/' + infraccion['name']
self.miReporte.info('\t\t> Borrando: ' + carpetaABorrar +
' con estado ' + infraccion['estado'])
shutil.rmtree(carpetaABorrar)
except Exception as e:
self.miReporte.warning('\t\t\tNo pude borrar carpeta fantasma: ' +
infraccion['name'] + ' por ' + str(e))
def popInfraccion(self):
if self.numeroInfraccionesConfirmadas() != 0:
variableARetornar = self.listaVehiculos.pop()
while variableARetornar['estado'] != 'Cruzo':
variableARetornar = self.listaVehiculos.pop()
return variableARetornar
else:
return {}
return variableARetornar
def reporteActual(self):
self.miReporte.info('Infracciones Sospechosas:')
for infraccion in self.listaVehiculos:
self.miReporte.info(infraccion['frameInicial'] + ' a ' +
str(infraccion['frameFinal']) +
' con estado: ' + infraccion['estado'])
self.miReporte.info('Infracciones Confirmadas:')
for infraccion in self.listaVehiculos:
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.listaVehiculos:
if infraccion['estado'] == 'Previo':
for punto in infraccion['desplazamiento']:
aDevolver.append(tuple(punto[0]))
return aDevolver
def obtenerLineasDeResguardo(self, alterada=False):
aDevolver = []
if alterada:
for punto in self.lineaDeResguardoAlteradaDelantera:
aDevolver.append(tuple(punto[0]))
else:
for punto in self.lineaDeResguardoDelantera:
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
"""
##### OJO AQUI TAMBIEN PUEDO FILTRAR RUIDO???
dif2 = [
] # Para todos los puntos de resguardo veo los que tienen mayor movimiento
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 = []
for numeroDePuntoASeguir in range(
self.numeroDePuntosASeguirDeInicializacion):
indice = dif2.index(max(dif2))
indiceDeMayores.append(indice)
dif2.pop(indice)
listaNuevosPuntos = np.array(nuevoVector[indiceDeMayores])
for indice in range(len(listaNuevosPuntos)):
listaNuevosPuntos[indice][
0] = listaNuevosPuntos[indice][0] + self.desplazamiento
return listaNuevosPuntos #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 obtenerMagnitudMovimientoEnRegion(self, nuevaFranja):
flow = cv2.calcOpticalFlowFarneback(
self.anteriorFranja, nuevaFranja, None, 0.5, 3, 15, 3, 5, 1.2, 0
) #(self.auxiliar_image, current_image, None, 0.7, 3, 9, 3, 5, 1.2, 0)
#y, x = np.mgrid[self.optimalStep//2:nuevaFranja.shape[0]:self.optimalStep, self.optimalStep//2:nuevaFranja.shape[1]:self.optimalStep].reshape(2,-1)
#y = np.int32(y)
#x = np.int32(x)
#fx, fy = flow[y,x].T
#flowX = sum(fx)
#flowY = sum(fy)
flowX = 0
flowY = 0
for row in flow:
for data in row:
flowX += data[0]
flowY += data[1]
self.anteriorFranja = nuevaFranja
# Se retorna el flujo en X invertido
flujoPerpendicular = -10 * flowX / (
(flow.shape[0] * flow.shape[1]) + 1)
return flujoPerpendicular
def apagarCamara(self):
self.camaraAlta.apagarControlador()
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()
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
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()