# data[].attributes.attachment_link.description
Get access to files anywhere through secure cloud storage and file backup for your photos, videos, files and more with Google Drive.

# data[].attributes.attachment_link.readable_text
La dirección de mi tesis es actualmente usar una cámara monocular para seguir al robot a los humanos. En primer lugar, la mayor diferencia entre una cámara monocular y una cámara de profundidad como Kinect es que es imposible obtener información de profundidad de manera efectiva. Luego comience con este aspecto. La distancia de las personas.

Leí algunos artículos en la web sobre los principios de calibración de la cámara y la distancia focal de la cámara en Internet, y luego realmente me inspiró a través de este artículo: Use python y opencv para medir la distancia entre el objetivo y la cámara. El principio principal de la medición de distancia es calcular la distancia desde el objeto a la cámara utilizando triángulos similares.

Aquí mi entorno es: Ubuntu14.04 + Opencv2.4.9

1. Use triángulos similares para calcular la distancia entre un objeto u objetivo y la cámara

Usaremos triángulos similares para calcular la distancia desde la cámara a un objeto u objetivo conocido.

Triángulos similares son así: supongamos que tenemos un objetivo u objeto de ancho W. Luego colocamos este objetivo a una distancia de D de nuestra cámara. Usamos la cámara para tomar imágenes del objeto y medir el ancho de píxel P del objeto. Entonces tenemos la fórmula para la distancia focal de la cámara

F = (P x D) / W

Por ejemplo, supongamos que coloco un papel A4 estándar de 8.5 x 11 pulgadas (horizontal; W = 11) a una distancia D = 24 pulgadas de la cámara y tomo una foto. Medí el ancho de píxeles del papel A4 en la foto como P = 249 píxeles.

Entonces mi distancia focal F es:

F = (248px x 24in) / 11in = 543.45

Cuando continúo moviendo mi cámara más cerca o lejos de objetos u objetivos distantes, puedo usar triángulos similares para calcular la distancia del objeto desde la cámara:

D' = (W x F) / P

Para ser más específicos, tomemos otro ejemplo. Supongamos que muevo la cámara a 3 pies (o 36 pulgadas) del objetivo y tomo el papel A4 anterior. A través del procesamiento automático de gráficos, puedo obtener una distancia de píxeles de papel A4 en la imagen de 170 píxeles. Sustituir esto en la fórmula:

D '= (11 pulgadas x 543.45) / 170 = 35 pulgadas

O alrededor de 36 pulgadas o 3 pies.

De la explicación anterior, podemos ver que para obtener la distancia, necesitamos conocer la distancia focal de la cámara y el tamaño del objeto objetivo. Estas dos condiciones conocidas se basan en la fórmula:

Obtenga la distancia D desde el objetivo hasta la cámara, donde P es la distancia en píxeles, W es el ancho del papel A4 y F es la distancia focal de la cámara.

En el texto original, la distancia focal de la cámara se calculó a partir de la primera foto tomando una pre-fotografía, y la distancia del papel blanco a la cámara en la siguiente foto se calculó en función de la longitud focal conocida. Esto no es intuitivo y requiere una pre-fotografía. El programa fuente se cambia a rango en tiempo real. En términos simples, convierte la foto original en una cámara. Este efecto se ve más intuitivo. El programa fuente es el siguiente:

#!usr/bin/python # -*- coding: utf-8 -*- #Definir codificación, comentario chino #import the necessary packages import numpy as np import cv2 # Encuentra la función objetivo def find_marker(image): # convert the image to grayscale, blur it, and detect edges gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) gray = cv2.GaussianBlur(gray, (5, 5), 0) edged = cv2.Canny(gray, 35, 125) # find the contours in the edged image and keep the largest one; # we'll assume that this is our piece of paper in the image (cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE) # Buscando el área más grande c = max(cnts, key = cv2.contourArea) # compute the bounding box of the of the paper region and return it # cv2.minAreaRect () c representa el conjunto de puntos y devuelve rect [0] son ​​las coordenadas del punto central del rectángulo circunscrito más pequeño, # rect [1] [0] es ancho, rect [1] [1] es altura, rect [2] es ángulo return cv2.minAreaRect(c) # Función de cálculo de distancia def distance_to_camera(knownWidth, focalLength, perWidth): # compute and return the distance from the maker to the camera return (knownWidth * focalLength) / perWidth # initialize the known distance from the camera to the object, which # in this case is 24 inches KNOWN_DISTANCE = 24.0 # initialize the known object width, which in this case, the piece of # paper is 11 inches wide # A4 longitud y ancho del papel (unidad: pulgadas) KNOWN_WIDTH = 11.69 KNOWN_HEIGHT = 8.27 # initialize the list of images that we'll be using IMAGE_PATHS = ["Picture1.jpg", "Picture2.jpg", "Picture3.jpg"] # load the furst image that contains an object that is KNOWN TO BE 2 feet # from our camera, then find the paper marker in the image, and initialize # the focal length # Lea la primera imagen y calcule la distancia focal de la cámara a partir de la distancia conocida image = cv2.imread(IMAGE_PATHS[0]) marker = find_marker(image) focalLength = (marker[1][0] * KNOWN_DISTANCE) / KNOWN_WIDTH # Distancia focal del píxel obtenida a través de la calibración de la cámara #focalLength = 811.82 print('focalLength = ',focalLength) #Enciende la camara camera = cv2.VideoCapture(0) while camera.isOpened(): # get a frame (grabbed, frame) = camera.read() marker = find_marker(frame) if marker == 0: print(marker) continue inches = distance_to_camera(KNOWN_WIDTH, focalLength, marker[1][0]) # draw a bounding box around the image and display it box = np.int0(cv2.cv.BoxPoints(marker)) cv2.drawContours(frame, [box], -1, (0, 255, 0), 2) # pulgadas a centímetros cv2.putText(frame, "%.2fcm" % (inches *30.48/ 12), (frame.shape[1] - 200, frame.shape[0] - 20), cv2.FONT_HERSHEY_SIMPLEX, 2.0, (0, 255, 0), 3) # show a frame cv2.imshow("capture", frame) if cv2.waitKey(1) & 0xFF == ord('q'): break camera.release() cv2.destroyAllWindows()

La tabla de efectos del programa es la siguiente:

En esta imagen, mi cámara está a unos 100 cm del escritorio, puede ver que la distancia es de 96 cm en la imagen, puede ver que la precisión está bien.

Cabe señalar que si está utilizando la versión opencv3,

1. Necesidad de encontrar la función de marcador

(cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)

A:

(_, cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)

2. Necesidad de:

box = np.int0(cv2.cv.BoxPoints(marker))

A:

box = cv2.boxPoints(marker) box = np.int0(box)

Los dos lugares anteriores deben modificarse para instalar diferentes versiones de opencv.

1. El programa a veces informa un error cuando no se detecta papel A4 mientras se ejecuta:

Traceback (most recent call last):
File "video_paper_distance.py", line 86, in <module>
marker = find_marker(frame)
File "video_paper_distance.py", line 18, in find_marker
c = max(cnts, key = cv2.contourArea)

ValueError: max() arg is an empty sequence

Por el momento, no he resuelto este error. La suposición se debe principalmente al hecho de que la función max () está vacía porque el objetivo no se detecta, pero no se ha investigado.

2. El procedimiento consiste en calcular la distancia focal de la cámara conociendo la distancia desde el objetivo a la cámara en la primera imagen, y luego calcular la distancia desde el siguiente objetivo a la cámara por la distancia focal, donde la distancia focal es un parámetro clave, así que voy a intentar pasar la cámara La calibración de la cámara obtiene directamente la distancia focal de píxeles de la cámara. Implementé la calibración de la cámara a través de un paquete de ros, pero la distancia calculada por la distancia focal de píxeles obtenida por la calibración de la cámara no se calcula por la distancia focal calculada por la primera imagen. La distancia es precisa y no se comprende el motivo específico, ¿tal vez el resultado de mi calibración no es lo suficientemente preciso?

3. Cuando la cámara mide la distancia, la distancia obtenida también es precisa y cambia linealmente con la distancia de la cámara desde el escritorio, pero la distancia ocasionalmente cambia repentinamente y actualmente no se encuentra la causa.

La referencia principal para la calibración de la cámara ros es este blog. El blogger es chocolate blanco y el único. ROS Dios:

El registro principal aquí es la matriz de parámetros internos 3 * 3 obtenida por la calibración de la cámara, donde M [1] [1] y M [2] [2] son ​​las distancias focales de píxeles de los ejes x e y de la cámara que requerimos .

Segundo, use la cámara para calcular la distancia entre la persona y la cámara.

En la primera parte, hemos calculado la distancia del papel A4 desde la cámara. En aplicaciones específicas, necesito calcular la distancia de la persona desde la cámara para darme cuenta del juicio del robot sobre la distancia de la persona objetivo, la aplicación y seguir a la persona objetivo. La idea principal aquí es detectar primero a la persona a través del método HOG en opencv, y luego calcular la distancia de la persona a la cámara en función de la altura estimada de la persona y la distancia focal de la cámara. La razón para elegir la altura aquí es que la altura de la persona cambia poco en diferentes direcciones, y la altura de nuestra cámara es fija, así que elija la altura.

1) Primero, use opencv para la detección de peatones:

#!usr/bin/python # -*- coding: utf-8 -*- # import the necessary packages from __future__ import print_function from imutils.object_detection import non_max_suppression from imutils import paths import numpy as np import argparse import imutils import cv2 cap = cv2.VideoCapture(0) # initialize the HOG descriptor/person detector hog = cv2.HOGDescriptor() # Use el clasificador SVM predeterminado de opencv hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector()) while(1): # get a frame ret, frame = cap.read() frame = imutils.resize(frame, width=min(400, frame.shape[1])) # detect people in the image (rects, weights) = hog.detectMultiScale(frame, winStride=(4, 4), padding=(8, 8), scale=1.05) rects = np.array([[x, y, x + w, y + h] for (x, y, w, h) in rects]) # Supresión no máxima, eliminar cuadros innecesarios, encontrar el mejor cuerpo humano pick = non_max_suppression(rects, probs=None, overlapThresh=0.65) # Dibuja un borde for (xA, yA, xB, yB) in pick: cv2.rectangle(frame, (xA, yA), (xB, yB), (0, 255, 0), 2) # show a frame cv2.imshow("capture", frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows()

2) Combinación de detección de peatones y códigos de alcance:

while camera.isOpened(): # get a frame (grabbed, frame) = camera.read() # Si no puedes tomar un marco, significa que hemos llegado al final del video if not grabbed: break frame = imutils.resize(frame, width=min(400, frame.shape[1])) #marker = find_marker(frame) marker = find_person(frame) #inches = distance_to_camera(KNOWN_WIDTH, focalLength, marker[1][0]) for (xA, yA, xB, yB) in marker: cv2.rectangle(frame, (xA, yA), (xB, yB), (0, 255, 0), 2) ya_max = yA yb_max = yB pix_person_height = yb_max - ya_max if pix_person_height == 0: #pix_person_height = 1 continue print (pix_person_height) #print (pix_person_height) inches = distance_to_camera(KNOW_PERSON_HEIGHT, focalLength, pix_person_height) print("%.2fcm" % (inches *30.48/ 12)) # draw a bounding box around the image and display it #box = np.int0(cv2.cv.BoxPoints(marker)) #cv2.drawContours(frame, [box], -1, (0, 255, 0), 2) cv2.putText(frame, "%.2fcm" % (inches *30.48/ 12), (frame.shape[1] - 200, frame.shape[0] - 20), cv2.FONT_HERSHEY_SIMPLEX, 2.0, (0, 255, 0), 3) # show a frame cv2.imshow("capture", frame) if cv2.waitKey(1) & 0xFF == ord('q'): break

3) Problemas existentes:

Actualmente, el efecto del uso de HOG para detectar peatones no es muy bueno, ya que enmarcará objetos como cuerpos humanos, como trípodes de laboratorio y otros objetos, que se ven muy perturbados por el fondo. Hay un error en el programa que cuando no se detecta a una persona, pix_person_height será 0, por lo que el denominador no se puede calcular cuando es 0. En el siguiente también mejoraré a través de tres aspectos, en primer lugar, debo encontrar una manera de mejorar aún más la detección humana, usar YOLO El método es actualmente mejor, pero es más lento bajo la CPU. Lo siguiente que hay que mejorar es la precisión. Lo principal aquí es seleccionar la cámara. Para seleccionar una cámara de distancia focal fija, la distancia focal de la cámara con zoom automático cambiará, y la distancia medida también cambiará. El último paso es mejorar el programa tanto como sea posible y reducir los errores.

4. Trabajo por hacer

A través del programa, puede ver que la distancia entre la persona y la cámara se detecta utilizando la cámara monocular. Uno de los factores que tiene un mayor impacto es la detección precisa del cuerpo humano. Si desea que la distancia medida sea precisa (la precisión completa es imposible, pero puede lograrla Para el grado en que el robot sigue la función de la persona), es necesario detectar a la persona con la mayor precisión posible. A través de mi prueba, bajo la premisa de conocer con precisión la altura de la persona objetivo, tomar una foto de la persona a una distancia fija de la cámara, y luego manualmente Encuadra a la persona, calibra la altura de la persona objetivo en la pantalla, y la distancia obtenida mediante el cálculo es relativamente precisa, y la precisión es completamente aceptable, por lo que el siguiente trabajo es principalmente cómo encuadrar con precisión el objetivo a través del programa Las personas para obtener su altura en la imagen.

El código fuente del programa se ha publicado anteriormente, también puede ir a Descargar páginadescargar.

# data[].attributes.attachment_link.keywords[]
rango de cámara monocular (python + opencv)

# data[].attributes.attachment_link.description
La dirección de mi tesis es actualmente usar una cámara monocular para seguir al robot a los humanos. En primer lugar, la mayor diferencia entre una cámara monocular y una cámara de profundidad como Kinect es que es imposible obtener información de profundidad de manera efectiva. Luego comience con este aspecto.

# data[].attributes.body
-Nunura Jaramillo Angel Eduardo
-Valencia Preciado Christhian Paul
-Valverde Chiroque Jean Carlos
-Meca Alama José Grabiel

# data[].attributes.attachment_link.description
Get access to files anywhere through secure cloud storage and file backup for your photos, videos, files and more with Google Drive.

# data[].attributes.body
La distancia focal es la distancia entre el centro óptico del objetivo, y el sensor o plano focal sobre el cual se proyecta la imagen.

# data[].attributes.attachment_link.readable_text
Requisito previo: Introducción a OpenCV

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

Haremos 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 la distancia:

Capturar imagen de referencia: mida la distancia desde el objeto (rostro) a 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 los píxeles, que es un requisito para la función de buscador de distancia focal y buscador de distancia.

def face_data(image): face_width = 0 # making face width to zero # converting color image ot 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 distancia focal:

La función del buscador de distancia focal se basa en tres argumentos:

1. Distancia_medida : es la distancia desde 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 está alrededor de Known_width = 14.3 #centímetro

3. Width_in_rf_image: Es el ancho del objeto en la imagen / marco que 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 buscador de longitud focal

2. Real_width mide el ancho de un objeto en el mundo real, aquí medimos el ancho de la cara que está alrededor de Known_width = 14.3 #centimete r

3. Width_in_rf_image es el ancho del objeto en la imagen / marco será 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 ot 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 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 the windows that are opened cv2.destroyAllWindows()
Producción:
¡Atención geek! Fortalezca sus bases con el Curso básico de programación de Python y aprenda los conceptos básicos.

# data[].attributes.attachment_link.title
Estimación de distancia en tiempo real usando OpenCV - Python

# data[].attributes.attachment_link.description
Requisito previo: Introducción a OpenCV En este artículo, veremos cómo calcular la distancia con una cámara web usando OpenCV en Python. Al usarlo, se pueden procesar imágenes y videos para identificar objetos, rostros o incluso la escritura a mano de un humano. Este artículo se centra en la detección de objetos.

# data[].attributes.attachment_caption
Explicación a alumnos de los 1ros ciclos

# data[].attributes.attachment_caption
Explicación a alumnos de los 1ros ciclos

# data[].attributes.attachment_caption
Explicación a compañeros de la promoción

# data[].attributes.attachment_link.description
Get access to files anywhere through secure cloud storage and file backup for your photos, videos, files and more with Google Drive.

# data[].attributes.attachment_caption
Voluntarios que colaboraron con su participación

# data[].attributes.attachment_caption
Voluntarios que colaboraron con su participación

# data[].attributes.attachment_caption
Voluntarios que colaboraron con su participación

# data[].attributes.attachment_link.description
Get access to files anywhere through secure cloud storage and file backup for your photos, videos, files and more with Google Drive.

# data[].attributes.headline
MEDIAPIPE POSE (puntos 19 y 15 para mano derecha; 16 y 20 para mano izquierda)

# data[].attributes.subject
MEDIAPIPE POSE (puntos 19 y 15 para mano derecha; 16 y 20 para mano izquierda)

# data[].attributes.attachment_link.description
Sign up free or login to securely view this document.

# data[].attributes.headline
DISTANCIA DE PRUEBA (90cm aprox) PARA ENVIAR ALERTA

# data[].attributes.subject
DISTANCIA DE PRUEBA (90cm aprox) PARA ENVIAR ALERTA