コード例 #1
0
def __main_function__():
    # Import some global varialbes
    global archivoDeVideo
    global tuveInfracciones
    tuveInfracciones = False

    print(
        'Programa de visualizacion exitosamente con ingreso de senal video ' +
        archivoDeVideo)
    # Si no existe el directorio de reporte lo creo
    if not os.path.exists(directorioDeReporte):
        os.makedirs(directorioDeReporte)

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

    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]
    poligonoEnAlta = parametrosInstalacion[6]

    # 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)
        print('Activada Exitosamente cámara en tiempo real')
    else:
        conVideoGrabado = True
        try:
            miCamara = cv2.VideoCapture(directorioDeVideos + '/' +
                                        archivoDeVideo)
            time.sleep(1)
            print('Archivo de video cargado exitosamente: ' +
                  directorioDeVideos + '/' + archivoDeVideo)
        except Exception as currentException:
            print('No se pudo cargar el video por ' + str(currentException))

    # Se captura la imagen de flujo inicial y se trabaja con la misma
    for descarte in range(50):
        ret, frameVideo = miCamara.read()
    cv2.imwrite(folderDeInstalacion + '/flujo.jpg', frameVideo)
    print('Generada Imagen de Instalacion')
    # Se captura para la cámara de Alta:
    try:
        miCamaraAlta = cv2.VideoCapture(1)
        miCamaraAlta.set(3, 3280)
        miCamaraAlta.set(4, 2464)
        ret, framePlaca = miCamaraAlta.read()
        cv2.imwrite(folderDeInstalacion + '/placa.jpg', framePlaca)
        print('Imagen de 8 Mp para instalacion capturada con exito')
    except:
        cv2.imwrite(folderDeInstalacion + '/placa.jpg',
                    np.zeros((3280, 2464, 3), np.uint8))
        print('No se pudo capturar la imagen de 8 Mp')

    frameFlujo = cv2.resize(frameVideo, (320, 240))
    miPoliciaReportando = PoliciaInfractor(frameFlujo,
                                           verticesPartida,
                                           verticesLlegada,
                                           verticesDerecha,
                                           verticesIzquierda,
                                           8,
                                           directorioDeReporte,
                                           False,
                                           flujoAntiguo=False)

    miSemaforo = CreateSemaforo(0)

    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)

    senalSemaforo, semaforoLiteral, flanco, periodo = miSemaforo.obtenerColorEnSemaforo(
        pixeles)
    tiempoAhora = datetime.datetime.now().hour * 60 + datetime.datetime.now(
    ).minute

    miFiltro = IRSwitch()
    if (tiempoAhora > amaneciendo) & (tiempoAhora < anocheciendo) & (
        (miFiltro.ultimoEstado == 'Filtro Desactivado') |
        (miFiltro.ultimoEstado == 'Inicializado')):
        miFiltro.colocarFiltroIR()
        print('Active Filtro' + datetime.datetime.now().strftime('%H:%M:%S'))
    if ((tiempoAhora < amaneciendo) | (tiempoAhora > anocheciendo)) & (
        (miFiltro.ultimoEstado == 'Filtro Activado') |
        (miFiltro.ultimoEstado == 'Inicializado')):
        miFiltro.quitarFiltroIR()
        print('Desactive Filtro')

    # Se introduce el acetato con el fin de determinar la calidad de la instalación actual
    miAcetatoInformativo = Acetato()
    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.areaFlujo)
    miAcetatoInformativo.colocarPoligono(miPoliciaReportando.carrilValido)
    miAcetatoInformativo.colocarObjeto(
        miPoliciaReportando.obtenerLineasDeResguardo(True), 'Referencia')
    miAcetatoInformativo.colorDeSemaforo(senalSemaforo)

    frameFlujo = miAcetatoInformativo.aplicarAFrame(frameFlujo)
    cv2.imwrite(
        directorioDeReporte +
        '/view_{}.jpg'.format(datetime.datetime.now().strftime('%Y%m%d_%H%M')),
        frameFlujo)
コード例 #2
0
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()
コード例 #3
0
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)
コード例 #4
0
ファイル: prototipo26.py プロジェクト: stanlee321/prototipo
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()
コード例 #5
0
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()