def image_callback(msg):
    print("Received an image!")
    try:
        # Convert your ROS Image message to OpenCV2
        cv2_img = bridge.imgmsg_to_cv2(msg, "bgr8")
        rg = recog(msg)
    except CvBridgeError, e:
        print(e)
Esempio n. 2
0
def upload_file():
    if request.method == 'POST':
        file = request.files['file']
        if file and allowed_file(file.filename):
            path = os.path.join(app.config['UPLOAD_FOLDER'], file.filename)
            file.save(path)
            result = recog(path)
            return '这是猫' if result else '这不是猫'
        else:
            return '文件不是图片'
Esempio n. 3
0
    def rgb_exists(self):
        try:
            cv2.imwrite('rgb.jpeg', self.cv2_img)
        except CvBridgeError as e:
            print(e)
        else:
            target = "target2.jpg"

            test = cv2.imread("rgb.jpeg")
            rg = recog(test, target)
            rospy.loginfo(rospy.get_caller_id() + ": " + rg.if_exist())
Esempio n. 4
0
def init():
    x = int(
        input(
            "**Programa de reconocimiento facial**\n *Para tener acceso al programa necesita realizar un reconocimiento facial*\n *Para realizar reconocimiento presione (1)*\n *Si ya realizo anterior mente el reconocimiento presiones cualquier tecla* "
        ))

    if (x == 1):
        rec.facial_recog()
        tr.trainner()
        x = (input("**Ya se a creado su reconocimiento facial**"))
    else:
        reco = rec.recog()
        if (reco):
            x = (input("**ha sido reconocido"))
            ta.numeros()
Esempio n. 5
0
def translate(box, frame, language="es"):
    """
    performs the translation operation including 
        - saving and recognizing a give portion of the image (current_box or frame)
        - deciding which recognition is the best
        - returns the recognition and the translation
    """
    x, y, w, h = [int(p) for p in box]  # convert the coordinates to integers
    cv2.imwrite(frame_name, frame[y:y + h, x:x + w])  # save image of just the
    recognition_output = recog(frame_name)  # run the image recognition
    to_translate = parse_label(
        recognition_output)  # get the name of the object in english
    translated = change_lang(
        to_translate, language)  # translate the object into specified language
    return to_translate, translated
Esempio n. 6
0
import cv2
import numpy as np
from recog import recog

target = cv2.imread("target.jpg")
test = cv2.imread("test_img.jpg")
#test = cv2.imread("blue.jpg")

rg = recog(test)
print(rg.if_exist())
def funcionPrincipal():
    video_capture = 1.0
    movimientoPir = True
    primeraVez = True
    abriendo = "nada"
    nombre = "Sin reconocer"
    extraccion = False
    indexCamara = 0
    db.child("Facial").update({"Error": "IniciaProg"})
    print("Inicia el proceso")
    while True:

        numeroMuestrasRostros = 60
        configurado = db.child("Facial/Configurado").get()
        configurado = configurado.val()
        print("valor configurado" + str(configurado))
        if configurado == True:

            numeroUsuarios = db.child("Facial/NumeroUsuarios").get()
            numeroUsuarios = numeroUsuarios.val()
            detener = db.child("Facial/Detener").get()
            if detener.val() == True:
                break
            if extraccion == False:
                #                try:
                print("Esta configurado")

                tomaDatos = open(
                    "/home/pi/Desktop/P2/CaptureSVMReco/archivo_modelo_LBP.pickle",
                    "rb")
                datos = pickle.load(tomaDatos)
                clf = datos["modelo"]
                pca = datos["pca"]
                target_names = datos["target_names"]
                NombreCarpetaPrueba = datos["NombreCarpetaPrueba"]
                tomaDatos.close()
                im_en, errorExtraccionImagenes = rg.encode(
                    NombreCarpetaPrueba, numeroUsuarios)

                if errorExtraccionImagenes:
                    print("Fallo Entrenamiento de modelo")
                    db.child("Facial").update({"Error": "Extract"})
                    #                        db.child("Facial").update({"Error":"Train"})
                    break

                extraccion = True
                print("Extracciòn de modelo realizado correctamente")

                db.child("Facial").update({"Error": "NoErrorExtract"})


#                except:
#                    print("Fallo en la extracción del modelo")
            """----------------!!!!!!!!!!!!!!!!!!!!!!!!!!!-----------------"""
            ### checar la reconexion a firebase
            #            try:
            #                db.child("Facial/UsuariosActivados").update(nombreUsuario)
            #            except:
            #                conexionExitosa, firebase, db, valores,entrenamiento = conectarFirebase()

            #Validacion para entrenar mas usuarios
            if len(target_names) < numeroUsuarios - 1:
                print("se va a añadir un nuevo usuario")
                NombresEtiquetas = {}
                for i in range(len(target_names)):
                    NombresEtiquetas[i + 1] = target_names[i]
                #Obtencion de rostros fatantes
                try:
                    errorObtencion, NombreCarpetaPrueba, nombreUsuarios, NombresEtiquetas, video_capture, indexCamara, numeroMuestrasRostros, nombresAñadir = obtenerRostros(
                        indexCamara, list(target_names),
                        len(target_names) + 1, NombresEtiquetas,
                        NombreCarpetaPrueba)
                    # Envio de mensaje de error <-------------------
                    if errorObtencion == True:
                        print("Se  reinicia el proceso")
                        break

                    for i in nombresAñadir:
                        nombreUsuario = {i: True}
                        db.child("Facial/UsuariosActivados").update(
                            nombreUsuario)

                    db.child("Facial").update({"Error": "NoErrorCaptura"})

                except:

                    print("Fallo en metodo de obtencion de rostros")
                    # Envio de mensaje de error <-------------------
                    db.child("Facial").update({"Error": "Captura"})

                detener = db.child("Facial/Detener").get()
                if detener.val() == True:
                    break

                # Entrenamiento de rostros
                vR.filtrar(NombreCarpetaPrueba, numeroUsuarios)
                #            NombreCarpetaPrueba = "/home/pi/Desktop/P2/CaptureSVMReco/"

                detener = db.child("Facial/Detener").get()
                if detener.val() == True:
                    break

                try:
                    svm.SVM(NombreCarpetaPrueba, nombreUsuarios,
                            numeroMuestrasRostros)
                    # Envio de mensaje de error <-------------------
                    print("Entrenamiento realizado correctamente")

                    db.child("Facial").update({"Error": "NoErrorTrain"})
                except:
                    # Actualiza
                    db.child("Facial").update({"ProcesoFinalizado": True})
                    # Envio de mensaje de error <-------------------
                    print("Fallo entrenamiento")
                    db.child("Facial").update({"Error": "Train"})
                print("Termino modelo")
                print("Coninua con identifcacion de rostros")
                db.child("Facial").update({"Configurado": True})
                db.child("Facial").update({"ProcesoFinalizado": True})

                detener = db.child("Facial/Detener").get()
                if detener.val() == True:
                    break
                print("Extraccion de modelo con nuevos usuarios")
                tomaDatos = open(
                    "/home/pi/Desktop/P2/CaptureSVMReco/archivo_modelo_LBP.pickle",
                    "rb")
                datos = pickle.load(tomaDatos)
                clf = datos["modelo"]
                pca = datos["pca"]
                target_names = datos["target_names"]
                NombreCarpetaPrueba = datos["NombreCarpetaPrueba"]
                tomaDatos.close()

                im_en, errorExtraccionImagenes = rg.encode(
                    NombreCarpetaPrueba, numeroUsuarios)
                if errorExtraccionImagenes:
                    print("Fallo Entrenamiento de modelo")
                    db.child("Facial").update({"Error": "Extract"})
                    break

            print("Clasificación de rostros")

            # Obtener Discriminantes
            usuariosActivados = db.child("Facial/UsuariosActivados").get()
            usuariosActivados = usuariosActivados.val()
            usuariosActivados = list(usuariosActivados)
            discriminantes = []
            target_names = list(target_names)
            # Comparacion de metodos
            print(usuariosActivados)
            for i in target_names:
                if i not in usuariosActivados:
                    discriminantes.append(i)
            if pir.motion_detected == True and (nombre == "Desconocido"
                                                or nombre == "Sin reconocer"):
                detener = db.child("Facial/Detener").get()
                if detener.val() == True:
                    break
        #        ledes.on()
        #        conexionCamara, p, inputQueue, outputQueue, video_capture,nombre = rL.reconocimiento(db,llamada,indexCamara,p, inputQueue, outputQueue,video_capture, ledes, clf, pca, target_names)

                video_capture, nombre = rg.recog(im_en, target_names, db,
                                                 ledes, pca, clf,
                                                 video_capture, discriminantes)
                #        vd.release()
                #        ledes.off()
                if nombre == "Desconocido":
                    os.system("mpg321 /home/pi/Desktop/mal.mp3")

                    time.sleep(4)
                elif nombre == "Sin reconocer":
                    time.sleep(4)
                elif nombre != "Desconocido":
                    tts = gTTS(text='Bienvenido' + nombre, lang='es')
                    tts.save("/home/pi/Desktop/bien2.mp3")
                    os.system("mpg321 /home/pi/Desktop/bien2.mp3")
                    db.child("Habitaciones/Entrada").update(
                        {"Puerta": "Abrir"})
                    while True:
                        print("Esta en el true")
                        abriendo = db.child(
                            "Habitaciones/Entrada/Puerta").get()
                        abriendo = abriendo.val()
                        if abriendo == "Abierto":
                            break
                    print("Esta esperando los 10 segundos")
                    time.sleep(10)
        #            t0 = 0.0
        #            if t0 == 0.0:
        #                t0 = time.time()

                llamada = True
                print("valor llamada: " + str(llamada))
                print("Sale del reconocimiento")
            elif nombre != "Sin reconocer" and nombre != "Desconocido":

                if primeraVez == True:
                    t0 = time.time()
                print("estado actual PIR")
                print(movimientoPir)
                if time.time() - t0 >= 5:
                    primeraVez = True
                    if pir.motion_detected == True:
                        movimientoPir = True

                    else:
                        movimientoPir = False
                else:
                    primeraVez = False
                if movimientoPir == False:
                    print("Puerta cerrada")
                    db.child("Habitaciones/Entrada").update(
                        {"Puerta": "Cerrar"})

                    while True:
                        print("Esta en el true")
                        abriendo = db.child(
                            "Habitaciones/Entrada/Puerta").get()
                        abriendo = abriendo.val()
                        if abriendo == "Cerrado":
                            break
                    nombre = "Sin reconocer"

            time.sleep(1)

        else:
            try:
                os.remove("archivo_modelo_LBP.pickle")
            except:
                print("ya fue borrado el archivo")
            NombreCarpetaPrueba = "/home/pi/Desktop/P2/Imagenes/Proyecto del " + time.strftime(
                "%Y_%B_%d") + "_" + time.strftime('%H_%M_%S')
            #NombreCarpetaPrueba = "/home/pi/Desktop/P2/Prue/2018_October_11_16_49_11/"
            pathlib.Path(NombreCarpetaPrueba).mkdir(parents=True,
                                                    exist_ok=True)

            try:
                errorObtencion = True
                targetnames = []
                NombresEtiquetas = {}
                numeroUsuario = 1
                errorObtencion, NombreCarpetaPrueba, nombreUsuarios, NombresEtiquetas, video_capture, indexCamara, numeroMuestrasRostros, nombresAñadir = obtenerRostros(
                    indexCamara, targetnames, numeroUsuario, NombresEtiquetas,
                    NombreCarpetaPrueba)

                if errorObtencion == True:
                    print("Se  reinicia el proceso")
                    break
                for i in nombresAñadir:
                    nombreUsuario = {i: True}
                    db.child("Facial/UsuariosActivados").update(nombreUsuario)
                # Envio de mensaje de error <-------------------
                db.child("Facial").update({"Error": "NoErrorCaptura"})

            except:

                print("Fallo en metodo de obtencion de rostros")
                # Envio de mensaje de error <-------------------
                db.child("Facial").update({"Error": "Captura"})

            if errorObtencion == False:
                #            try:
                db.child("Facial").update({"ProcesoFinalizado": False})
                print("ruta carpeta imagenes: " + NombreCarpetaPrueba)
                vR.filtrar(NombreCarpetaPrueba, len(nombreUsuarios))
                #            NombreCarpetaPrueba = "/home/pi/Desktop/P2/CaptureSVMReco/"
                try:
                    svm.SVM(NombreCarpetaPrueba, nombreUsuarios,
                            numeroMuestrasRostros)
                    # Envio de mensaje de error <-------------------
                    print("Entrenamiento realizado correctamente")

                    db.child("Facial").update({"Error": "NoErrorTrain"})
                except:
                    # Actualiza
                    db.child("Facial").update({"ProcesoFinalizado": True})
                    # Envio de mensaje de error <-------------------
                    print("Fallo entrenamiento")
                    db.child("Facial").update({"Error": "Train"})
                print("Termino modelo")
                print("Coninua con identifcacion de rostros")
                db.child("Facial").update({"Configurado": True})
                db.child("Facial").update({"ProcesoFinalizado": True})