NÂO TESTEI PRA VER SE

FUNCIONA OK?
Medição De Distância Em Tempo Real Entre Objetos Usando Visão
Computacional
O código abaixo é um exemplo de como utilizar o OpenCV em conjunto com o Python para detectar
cachorros e gatos em tempo real e calcular a distância entre eles. As constantes definidas no início
do código são utilizadas posteriormente para desenhar retângulos e linhas na imagem, bem como
para escrever texto.
O código utiliza a função CascadeClassifier do OpenCV para carregar classificadores pré-treinados
para detecção de cachorros e gatos. Em seguida, é realizada a detecção dos objetos na imagem
utilizando a função detectMultiScale.
Além disso, o código apresenta funções para desenhar retângulos e linhas na imagem, bem como
para calcular a distância euclidiana entre os centros dos objetos.
Em resumo, o código mostra como é possível utilizar o OpenCV e o Python para realizar tarefas de
visão computacional em tempo real, tais como a detecção de objetos e o cálculo de distância entre
eles.

import cv2
import numpy as np

# Constantes
FONT = cv2.FONT_HERSHEY_SIMPLEX
FONT_SCALE = 1
FONT_COLOR = (0, 255, 0)
THICKNESS = 2

# Define o classificador para cachorro e gato

DOG_CLASSIFIER = cv2.CascadeClassifier("haarcascade_dog.xml")
CAT_CLASSIFIER = cv2.CascadeClassifier("haarcascade_cat.xml")

# Define a função de medição de distância

def calculate_distance(p1, p2):
x1, y1 = p1
x2, y2 = p2
distance = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
return distance

# Define a função de desenho dos retângulos

def draw_rectangles(frame, objects, color):
for (x, y, w, h) in objects:
cv2.rectangle(frame, (x, y), (x + w, y + h), color, THICKNESS)

# Define a função de desenho das linhas

def draw_lines(frame, center_dog, center_cat):
cv2.line(frame, center_dog, center_cat, (255, 0, 0), THICKNESS)
# Abre a câmera
cap = cv2.VideoCapture(0)

# Verifica se a câmera foi aberta corretamente

if not cap.isOpened():
print("Não foi possível abrir a câmera.")
exit()

# Loop principal
while True:
# Lê o frame da câmera
ret, frame = cap.read()

# Converte o frame para escala de cinza

gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

# Detecta cachorros na imagem em escala de cinza

dogs = DOG_CLASSIFIER.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)

# Detecta gatos na imagem em escala de cinza

cats = CAT_CLASSIFIER.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)

# Se tivermos detectado pelo menos um cachorro e um gato, desenha os retângulos e as linhas

if len(dogs) > 0 and len(cats) > 0:
# Encontra o centro do cachorro e do gato
center_dog = (int(dogs[0][0] + dogs[0][2] / 2), int(dogs[0][1] + dogs[0][3] / 2))
center_cat = (int(cats[0][0] + cats[0][2] / 2), int(cats[0][1] + cats[0][3] / 2))

# Calcula a distância entre o cachorro e o gato

distance = int(calculate_distance(center_dog, center_cat))

# Desenha os retângulos ao redor dos objetos

draw_rectangles(frame, dogs, (0, 255, 0))
draw_rectangles(frame, cats, (255, 0, 0))

# Desenha as linhas entre o centro do cachorro e do gato

draw_lines(frame, center_dog, center_cat)

# Escreve a distância entre os objetos

cv2.putText(
frame,
f"Distância: {distance}

Cálculos
No código apresentado, os cálculos utilizados para medir a distância entre os objetos detectados são
relativamente simples.
Primeiramente, é calculado o ponto central do retângulo que envolve o objeto detectado pela função
CascadeClassifier do OpenCV. Em seguida, é calculada a distância euclidiana entre os pontos centrais
dos objetos, utilizando a função distance do módulo math. Por fim, é exibido na tela o valor da
distância em pixels.

O cálculo do ponto central do retângulo envolvendo o objeto detectado é realizado utilizando a

função "cv2.rectangle" em conjunto com a definição das coordenadas do retângulo detectado.
A função "cv2.rectangle" é responsável por desenhar o retângulo envolvendo o objeto, a partir das
coordenadas informadas. A partir das coordenadas obtidas, o ponto central é calculado utilizando-se
a fórmula para encontrar o centro de um retângulo, que consiste na média aritmética das
coordenadas X e Y do retângulo.
Cálculo do ponto central do retângulo envolvendo o objeto detectado, utilizando a função
"cv2.rectangle":
x, y, w, h = objects[i]
center_x = x + w // 2
center_y = y + h // 2

O cálculo da distância euclidiana entre os pontos centrais dos objetos é realizado utilizando a função
"math.dist".
Essa função é responsável por calcular a distância euclidiana entre dois pontos em um espaço
bidimensional, a partir de suas coordenadas. Nesse caso, as coordenadas dos pontos centrais dos
objetos detectados são utilizadas como entrada para a função. A distância euclidiana é uma medida
direta da distância entre dois pontos no espaço e é calculada a partir do teorema de Pitágoras. A
distância calculada é expressa em pixels, e pode ser convertida para outras unidades, como
centímetros, caso seja necessário, através de uma conversão simples, utilizando-se a resolução da
imagem e a escala de conversão.
Cálculo da distância euclidiana entre os pontos centrais dos objetos, utilizando a função "math.dist":
distance = math.dist((center_x1, center_y1), (center_x2, center_y2))

Bibliotecas
A biblioteca "numpy" é utilizada para trabalhar com arrays multidimensionais em Python, permitindo
a execução de operações matemáticas de forma eficiente. Essa biblioteca é muito utilizada em
processamento de imagens, já que uma imagem pode ser tratada como uma matriz de pixels.

A biblioteca "cv2", por sua vez, é uma das bibliotecas mais utilizadas em processamento de imagens
em Python. Ela oferece uma série de funções para leitura, manipulação e exibição de imagens, além
de ferramentas para detecção de objetos e reconhecimento de padrões em imagens. A combinação
dessas duas bibliotecas é bastante comum em projetos de processamento de imagens em Python.

(Arrays multidimensionais)
também conhecidos como tensores, são estruturas de dados que permitem armazenar e manipular
dados em múltiplas dimensões. Eles são usados em muitos campos da computação, incluindo
processamento de imagens, aprendizado de máquina e ciência de dados.
Em Python, a biblioteca NumPy fornece suporte para trabalhar com arrays multidimensionais de
forma eficiente e conveniente. Os arrays multidimensionais são representados como matrizes, onde
cada elemento é identificado por um conjunto de índices que correspondem às suas coordenadas na
matriz.
Por exemplo, uma matriz bidimensional pode ser representada como um array com duas dimensões
(linhas e colunas), enquanto uma imagem colorida pode ser representada como um array
tridimensional com três dimensões (altura, largura e canal de cor). O uso de arrays multidimensionais
permite a execução de operações matemáticas de forma eficiente em grandes quantidades de
dados.

Melhorias futuras

é possível explorar outras técnicas de visão computacional para melhorar a precisão da medição da
distância, como a estimação de profundidade por meio de duas câmeras.