Estimación de distancia en tiempo real usando OpenCV – Python

Prerrequisito: Introducción a OpenCV

En este artículo vamos a ver cómo calcular la distancia con una cámara web usando OpenCV en Python. Al usarlo, uno puede procesar imágenes y videos para identificar objetos, rostros o incluso la escritura a mano de un ser humano. Este artículo se centra en la detección de objetos.

Haremos la detección de objetos en este artículo usando algo conocido como cascadas de haar.

Cascadas de Haar

Los clasificadores Haar Cascade son una forma eficaz de detección de objetos. Haar Cascade es un enfoque basado en el aprendizaje automático en el que se utilizan muchas imágenes positivas y negativas para entrenar al clasificador. 

El archivo se puede descargar desde aquí:  Forrontalface .

Pasos para la estimación de distancia:

• Capturar imagen de referencia: Mida la distancia desde el objeto (rostro) hasta la cámara, capture una imagen de referencia y anote la distancia medida
• Mida el ancho del objeto (cara), asegúrese de que las unidades de medida se mantengan para la imagen de referencia y el ancho del objeto (cara). Imagen de referencia de la mina

Detección de rostro:

Esta función detectará la cara y devolverá el ancho de la cara en los valores de píxeles. Esta función de datos faciales simplemente toma un argumento, qué imagen, devuelve el ancho de la cara en píxeles, que es un requisito para la función del buscador de distancia focal y del buscador de distancia. 

def face_data(image):
 
    face_width = 0  # making face width to zero
 
    # converting color image to gray scale image
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
    # detecting face in the image
    faces = face_detector.detectMultiScale(gray_image, 1.3, 5)
 
    # looping through the faces detect in the
    # image getting coordinates x, y ,
    # width and height
    for (x, y, h, w) in faces:
 
        # draw the rectangle on the face
        cv2.rectangle(image, (x, y), (x+w, y+h), GREEN, 2)
 
        # getting face width in the pixels
        face_width = w
 
    # return the face width in pixel
    return face_width

Buscador de longitud focal:

La función del buscador de distancia focal aborda tres argumentos: 

1. Distancia_medida : Es la distancia de la cámara al objeto mientras se captura la imagen de referencia, Distancia_conocida = 72.2 #centímetro
2. Real_width: mide el ancho de un objeto en el mundo real, aquí medimos el ancho de la cara que es alrededor de Known_width = 14.3 #centímetro
3. Width_in_rf_image: Es el ancho del objeto en la imagen/marco, estará en píxeles

Esta función devolverá la distancia focal, que se utiliza para encontrar la distancia. 

# focal length finder function
def FocalLength(measured_distance, real_width, width_in_rf_image):
    focal_length = (width_in_rf_image* measured_distance)/ real_width
    return focal_length

Buscador de distancia:

Esta función tiene tres argumentos.

1. Longitud focal en píxeles, que es un retorno de la función de búsqueda de longitud focal
2. Real_width mide el ancho de un objeto en el mundo real, aquí medimos el ancho de la cara que es alrededor de Known_width =14.3 # centímetro
3. Width_in_rf_image es el ancho del objeto en la imagen/marco, estará en píxeles

La función de buscador de distancia devolverá la distancia en centímetros .

# distance estimation function
def Distance_finder(Focal_Length, real_face_width, face_width_in_frame):
    distance = (real_face_width * Focal_Length)/face_width_in_frame
    return distance

A continuación se muestra la implementación completa:

# install opencv "pip install opencv-python"
import cv2
 
# distance from camera to object(face) measured
# centimeter
Known_distance = 76.2
 
# width of face in the real world or Object Plane
# centimeter
Known_width = 14.3
 
# Colors
GREEN = (0, 255, 0)
RED = (0, 0, 255)
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
 
# defining the fonts
fonts = cv2.FONT_HERSHEY_COMPLEX
 
# face detector object
face_detector = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")
 
# focal length finder function
def Focal_Length_Finder(measured_distance, real_width, width_in_rf_image):
 
    # finding the focal length
    focal_length = (width_in_rf_image * measured_distance) / real_width
    return focal_length
 
# distance estimation function
def Distance_finder(Focal_Length, real_face_width, face_width_in_frame):
 
    distance = (real_face_width * Focal_Length)/face_width_in_frame
 
    # return the distance
    return distance
 
 
def face_data(image):
 
    face_width = 0  # making face width to zero
 
    # converting color image to gray scale image
    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
    # detecting face in the image
    faces = face_detector.detectMultiScale(gray_image, 1.3, 5)
 
    # looping through the faces detect in the image
    # getting coordinates x, y , width and height
    for (x, y, h, w) in faces:
 
        # draw the rectangle on the face
        cv2.rectangle(image, (x, y), (x+w, y+h), GREEN, 2)
 
        # getting face width in the pixels
        face_width = w
 
    # return the face width in pixel
    return face_width
 
 
# reading reference_image from directory
ref_image = cv2.imread("Ref_image.png")
 
# find the face width(pixels) in the reference_image
ref_image_face_width = face_data(ref_image)
 
# get the focal by calling "Focal_Length_Finder"
# face width in reference(pixels),
# Known_distance(centimeters),
# known_width(centimeters)
Focal_length_found = Focal_Length_Finder(
    Known_distance, Known_width, ref_image_face_width)
 
print(Focal_length_found)
 
# show the reference image
cv2.imshow("ref_image", ref_image)
 
# initialize the camera object so that we
# can get frame from it
cap = cv2.VideoCapture(0)
 
# looping through frame, incoming from
# camera/video
while True:
 
    # reading the frame from camera
    _, frame = cap.read()
 
    # calling face_data function to find
    # the width of face(pixels) in the frame
    face_width_in_frame = face_data(frame)
 
    # check if the face is zero then not
    # find the distance
    if face_width_in_frame != 0:
       
        # finding the distance by calling function
        # Distance finder function need
        # these arguments the Focal_Length,
        # Known_width(centimeters),
        # and Known_distance(centimeters)
        Distance = Distance_finder(
            Focal_length_found, Known_width, face_width_in_frame)
 
        # draw line as background of text
        cv2.line(frame, (30, 30), (230, 30), RED, 32)
        cv2.line(frame, (30, 30), (230, 30), BLACK, 28)
 
        # Drawing Text on the screen
        cv2.putText(
            frame, f"Distance: {round(Distance,2)} CM", (30, 35),
          fonts, 0.6, GREEN, 2)
 
    # show the frame on the screen
    cv2.imshow("frame", frame)
 
    # quit the program if you press 'q' on keyboard
    if cv2.waitKey(1) == ord("q"):
        break
 
# closing the camera
cap.release()
 
# closing the windows that are opened
cv2.destroyAllWindows()

Producción: