# pip install opencv-python opencv-contrib-python scipy
# Comando para instalar las librerías necesarias de visión por computadora

import cv2
# Importamos la librería OpenCV, que nos permite trabajar con imágenes y video
import matplotlib.pyplot as plt
# Importamos matplotlib para graficar
import numpy as np
# Importamos NumPy para trabajar con arreglos numéricos
from scipy.ndimage import center_of_mass
# Importamos la función center_of_mass para calcular el centro de masa de un arreglo

# Cambia esta dirección IP por la de tu cámara
cap = cv2.VideoCapture('http://192.168.137.163:8080/video')
# Creamos un objeto que captura video desde una cámara IP
# VideoCapture abre la conexión a la dirección web de la cámara

# Configuramos matplotlib para modo interactivo
plt.ion()
# Creamos una figura y un eje para graficar
fig, ax = plt.subplots()
# Ajustamos el tamaño de la figura
ax.figure.set_size_inches(5, 5)
ax.set_title('Intensidad de la línea horizontal central')
ax.set_xlim(0, 480)  # Asumiendo un ancho de imagen de 480 píxeles
ax.set_ylim(0, 255)  # Valores de intensidad en escala de grises
intensity_plot = ax.plot([], 'r-')[0]
center_x_plot = ax.plot([], 'ko')[0]
fig.canvas.draw()

# Iniciamos un bucle que se ejecuta mientras la cámara esté abierta
while (cap.isOpened()):
    # Saltamos algunos frames para reducir el retardo
    for _ in range(5):
        cap.grab()
    # Leemos un frame (fotograma) de la cámara
    # ret indica si la lectura fue exitosa, frame contiene la imagen
    ret, frame = cap.read()
    # Rotamos el frame 90 grados en sentido horario
    frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
    # Convertimos el frame de BGR (Azul, Verde, Rojo) a escala de grises
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    # Obtenemos las dimensiones de la imagen en escala de grises
    height, width = gray.shape

    # Estraemos el vector de valores de intensidad de la línea horizontal central
    horizontal_line = gray[height // 2, :]
    horizontal_line_mean = horizontal_line.mean()
    umbral = horizontal_line_mean * 0.7
    pesos = np.maximum(0, umbral - horizontal_line)
    centro_x = center_of_mass(pesos)[0]
    centro_x = centro_x if not np.isnan(centro_x) else width // 2

    # Ploteamos la intensidad de la línea horizontal central en la imagen
    intensity_plot.set_xdata(range(len(horizontal_line)))
    intensity_plot.set_ydata(horizontal_line)
    center_x_plot.set_xdata([centro_x])
    center_x_plot.set_ydata([horizontal_line[int(centro_x)]])
    fig.canvas.flush_events()

    # Dibujamos una línea horizontal en el centro de la imagen
    cv2.line(frame, (0, height // 2), (width, height // 2), (0, 0, 255), 2)
    # Dibujamos un círculo en el centro de masa calculado
    cv2.circle(frame, (int(centro_x), height // 2), 8, (0, 0, 255), -1)
    cv2.circle(frame, (int(centro_x), height // 2), 5, (0, 0, 0), -1)

    try:
        # Mostramos el frame en una ventana llamada 'Camara'
        # cv2.resize() redimensiona la imagen a 480x640 píxeles
        cv2.imshow('Camara', cv2.resize(frame, (480, 640)))

        # Capturamos la entrada del teclado (espera 1ms por cada iteración)
        key = cv2.waitKey(1)
        # Si presionamos 'q', salimos del bucle
        if key == ord('q'):
            break
    # Capturamos excepciones de OpenCV por si la transmisión se corta
    except cv2.error:
        print("Stream ended...")
        break

# Liberamos los recursos de la cámara
cap.release()
# Cerramos todas las ventanas creadas por OpenCV
cv2.destroyAllWindows()