Apuntes Graficación

Método recomendado: usando Homebrew

brew install git

Método alternativo: paquete descargado

1. Verificar si ya tienes una llave SSH

2. Generar una nueva llave SSH

3. Añadir la llave SSH al agente SSH

4. Copiar la llave SSH pública

5. Añadir la llave SSH a GitHub

6. Probar la conexión SSH con GitHub

7. Usar la conexión SSH en repositorios de GitHub

1. Abrir Git Bash

2. Verificar si ya tienes una llave SSH

3. Generar una nueva llave SSH

4. Añadir la llave SSH al agente SSH

5. Copiar la llave SSH pública

6. Añadir la llave SSH a GitHub

7. Probar la conexión SSH con GitHub

8. Usar la conexión SSH en repositorios de GitHub

1. Instalar Git en Windows

2. Configurar Git

   git config --global user.name "Tu Nombre"
   git config --global user.email "tuemail@ejemplo.com"

   git config --list

3. Clonar un repositorio

   git clone https://github.com/usuario/repo.git

4. Comandos básicos de Git

   git status

   git add nombre_de_archivo

   git add .

   git commit -m "Mensaje de commit"

   git push

5. Actualizar el repositorio local

   git pull

6. Crear y cambiar de ramas (branches)

   git branch nombre_de_la_rama

   git checkout nombre_de_la_rama

   git checkout -b nombre_de_la_rama

7. Ver historial de commits

   git log

   git log --oneline

8. Configurar una llave SSH

   ssh-keygen -t ed25519 -C "tuemail@ejemplo.com"

   eval "$(ssh-agent -s)"
   ssh-add ~/.ssh/id_ed25519

   cat ~/.ssh/id_ed25519.pub

Objetivos de la Graficación por Computadora

Áreas de estudio en Graficación por Computadora

Aplicaciones de la Graficación por Computadora

Temas principales en Graficación por Computadora

HSV opencv

Tutorial: Umbrales en el Modelo de Color HSV

Definición de los Parámetros del Modelo HSV

Detectar un color en el espacio HSV

• Código en Python para detectar un color (Verde)
  

  import cv2
  import numpy as np
  
  # Leer la imagen
  img = cv2.imread('imagen.jpg')
  
  # Convertir la imagen al espacio de color HSV
  hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
  
  # Definir el rango inferior y superior para detectar verde
  lower_green = np.array([35, 100, 100])  # Hue, Saturación, Brillo mínimos
  upper_green = np.array([85, 255, 255])  # Hue, Saturación, Brillo máximos
  
  # Crear una máscara que solo incluya los píxeles dentro del rango
  mask = cv2.inRange(hsv, lower_green, upper_green)
  
  # Aplicar la máscara a la imagen original
  result = cv2.bitwise_and(img, img, mask=mask)
  
  # Mostrar la imagen original y la imagen con el color detectado
  cv2.imshow("Imagen Original", img)
  cv2.imshow("Color Detectado", result)
  cv2.waitKey(0)
  cv2.destroyAllWindows()
  

Explicación de los Parámetros:

Ajustes de los Umbrales

Ejemplo visual: Rango de tonos para detectar verde

Uso de cv2.inRange

Tutorial: Operaciones Bitwise en OpenCV

• 1. Operación cv2.bitwise_and
  

  Esta operación realiza una operación AND bit a bit sobre los píxeles correspondientes de dos imágenes. Devuelve una imagen donde un píxel será 1 si ambos píxeles en las imágenes de entrada son 1.

  import cv2
  import numpy as np
  
  # Crear dos imágenes en negro
  img1 = np.zeros((300, 300), dtype=np.uint8)
  img2 = np.zeros((300, 300), dtype=np.uint8)
  
  # Dibujar un rectángulo blanco en img1
  cv2.rectangle(img1, (50, 50), (250, 250), 255, -1)
  
  # Dibujar un círculo blanco en img2
  cv2.circle(img2, (150, 150), 100, 255, -1)
  
  # Aplicar la operación bitwise AND
  result = cv2.bitwise_and(img1, img2)
  
  # Mostrar las imágenes
  cv2.imshow("img1", img1)
  cv2.imshow("img2", img2)
  cv2.imshow("AND Result", result)
  cv2.waitKey(0)
  cv2.destroyAllWindows()
  

• 2. Operación cv2.bitwise_or
  

  Realiza una operación OR bit a bit entre los píxeles de dos imágenes. El resultado será 1 si al menos uno de los píxeles correspondientes es 1.

  import cv2
  import numpy as np
  
  # Crear dos imágenes en negro
  img1 = np.zeros((300, 300), dtype=np.uint8)
  img2 = np.zeros((300, 300), dtype=np.uint8)
  
  # Dibujar un rectángulo blanco en img1
  cv2.rectangle(img1, (50, 50), (250, 250), 255, -1)
  
  # Dibujar un círculo blanco en img2
  cv2.circle(img2, (150, 150), 100, 255, -1)
  
  # Aplicar la operación bitwise OR
  result = cv2.bitwise_or(img1, img2)
  
  # Mostrar las imágenes
  cv2.imshow("img1", img1)
  cv2.imshow("img2", img2)
  cv2.imshow("OR Result", result)
  cv2.waitKey(0)
  cv2.destroyAllWindows()
  

• 3. Operación cv2.bitwise_xor
  

  La operación XOR devuelve una imagen donde un píxel será 1 si exactamente uno de los píxeles correspondientes en las imágenes de entrada es 1.

  import cv2
  import numpy as np
  
  # Crear dos imágenes en negro
  img1 = np.zeros((300, 300), dtype=np.uint8)
  img2 = np.zeros((300, 300), dtype=np.uint8)
  
  # Dibujar un rectángulo blanco en img1
  cv2.rectangle(img1, (50, 50), (250, 250), 255, -1)
  
  # Dibujar un círculo blanco en img2
  cv2.circle(img2, (150, 150), 100, 255, -1)
  
  # Aplicar la operación bitwise XOR
  result = cv2.bitwise_xor(img1, img2)
  
  # Mostrar las imágenes
  cv2.imshow("img1", img1)
  cv2.imshow("img2", img2)
  cv2.imshow("XOR Result", result)
  cv2.waitKey(0)
  cv2.destroyAllWindows()
  

• 4. Operación cv2.bitwise_not
  

  La operación NOT invierte los colores de la imagen. Los píxeles blancos se convierten en negros y viceversa.

  import cv2
  import numpy as np
  
  # Crear una imagen en negro
  img = np.zeros((300, 300), dtype=np.uint8)
  
  # Dibujar un rectángulo blanco
  cv2.rectangle(img, (50, 50), (250, 250), 255, -1)
  
  # Aplicar la operación bitwise NOT
  result = cv2.bitwise_not(img)
  
  # Mostrar las imágenes
  cv2.imshow("Original", img)
  cv2.imshow("NOT Result", result)
  cv2.waitKey(0)
  cv2.destroyAllWindows()
  

• Ejemplo práctico: Enmascarar una región de interés (ROI)
  

  Aquí aplicamos operaciones bitwise para enmascarar y combinar una imagen.

  import cv2
  import numpy as np
  
  # Cargar la imagen principal
  img1 = cv2.imread('imagen_principal.jpg')
  
  # Cargar la imagen que queremos enmascarar
  img2 = cv2.imread('logo.png')
  
  # Obtener las dimensiones de la segunda imagen (logo)
  rows, cols, channels = img2.shape
  
  # Definir la región de interés (ROI) en la imagen principal
  roi = img1[0:rows, 0:cols]
  
  # Convertir la imagen del logo a escala de grises
  img2gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
  
  # Crear una máscara binaria a partir de la imagen en escala de grises
  ret, mask = cv2.threshold(img2gray, 10, 255, cv2.THRESH_BINARY)
  
  # Invertir la máscara
  mask_inv = cv2.bitwise_not(mask)
  
  # Hacer visible el fondo de la imagen principal en la región del logo
  img1_bg = cv2.bitwise_and(roi, roi, mask=mask_inv)
  
  # Extraer el logo
  img2_fg = cv2.bitwise_and(img2, img2, mask=mask)
  
  # Combinar el fondo y el logo
  dst = cv2.add(img1_bg, img2_fg)
  
  # Colocar la imagen combinada en la imagen principal
  img1[0:rows, 0:cols] = dst
  
  # Mostrar la imagen final
  cv2.imshow("Resultado", img1)
  cv2.waitKey(0)
  cv2.destroyAllWindows()
  

Principales operaciones bit a bit

• 1. AND bit a bit (&)
  

  Devuelve `1` si ambos bits en la misma posición son `1`, de lo contrario devuelve `0`.

  A = 1010 (10 en decimal)
  B = 1100 (12 en decimal)
  Resultado: 1000 (8 en decimal)
  

• 2. OR bit a bit (|)
  

  Devuelve `1` si al menos uno de los bits en la misma posición es `1`, de lo contrario devuelve `0`.

  A = 1010 (10 en decimal)
  B = 1100 (12 en decimal)
  Resultado: 1110 (14 en decimal)
  

• 3. XOR bit a bit (^)
  

  Devuelve `1` si los bits en la misma posición son diferentes, y `0` si son iguales.

  A = 1010 (10 en decimal)
  B = 1100 (12 en decimal)
  Resultado: 0110 (6 en decimal)
  

• 4. NOT bit a bit (~~)
  

  Invierte los bits de un número: convierte los `0` en `1` y los `1` en `0`. En sistemas de complemento a dos, esto también implica cambiar el signo de un número entero.

  A = 1010 (10 en decimal)
  Resultado: 0101 (-11 en decimal, si estamos usando complemento a dos)
  

• 5. Desplazamiento a la izquierda (<<)
  

  Desplaza todos los bits del número hacia la izquierda por un número específico de posiciones. Los bits desplazados fuera del límite se descartan y se rellenan con ceros en el extremo derecho.

  A = 0001 (1 en decimal)
  A << 2 = 0100 (4 en decimal)
  

• 6. Desplazamiento a la derecha (>>)
  

  Desplaza todos los bits del número hacia la derecha por un número específico de posiciones. Los bits desplazados fuera del límite se descartan y el bit más significativo depende del signo del número.

  A = 1000 (8 en decimal)
  A >> 2 = 0010 (2 en decimal)
  

• Aplicaciones de las operaciones bit a bit
  
  • Máscaras de bits: Las operaciones bit a bit se usan para aplicar máscaras que seleccionan o modifican partes específicas de un número o secuencia binaria.
  • Manipulación de imágenes: En procesamiento de imágenes, las operaciones bit a bit son útiles para combinar y modificar píxeles en OpenCV.
  • Optimización de algoritmos: Las operaciones bit a bit permiten optimizar cálculos en sistemas de bajo nivel o con restricciones de recursos.

Definición

Características

Tipos de Operadores Puntuales

• Operador de Identidad
  
  • No altera la imagen. Cada píxel de la imagen de salida tiene el mismo valor que el píxel correspondiente en la imagen de entrada.
  • Fórmula: \( g(x, y) = f(x, y) \), donde \( f(x, y) \) es el valor del píxel original y \( g(x, y) \) es el valor del píxel modificado.
• Negativo de la Imagen
  
  • Este operador invierte los valores de los píxeles de una imagen, produciendo su negativo.
  • Fórmula: \( g(x, y) = L - 1 - f(x, y) \), donde \( L \) es el valor máximo posible en la imagen (por ejemplo, 255 en imágenes de 8 bits).
  • Uso: Se utiliza en técnicas como la extracción de detalles o cuando es necesario invertir una imagen para un análisis.
• Umbralización (Thresholding)
  
  • Convierte la imagen a una versión binaria, donde los píxeles con valores por encima de un umbral se establecen en un valor (generalmente blanco), y los que están por debajo se establecen en otro (generalmente negro).
  • Fórmula: \[ g(x, y) = 0, & \text{si } f(x, y) \leq T \\ L, & \text{si } f(x, y) > T \]
  • Uso: Se utiliza para segmentación de imágenes y procesamiento de imágenes en blanco y negro.
• Corrección Gamma
  
  • Ajusta los valores de intensidad de los píxeles para modificar el brillo o contraste de la imagen.
  • Fórmula: \( g(x, y) = c \cdot f(x, y)^\gamma \), donde \( c \) es una constante de escala, y \( \gamma \) es el factor de corrección.
  • Uso: Corrige la distorsión de brillo en pantallas o para obtener una mejor representación visual.
• Transformaciones Logarítmicas
  
  • Aumentan los detalles en regiones oscuras de la imagen al expandir los valores de intensidad bajos.
  • Fórmula: \( g(x, y) = c \cdot \log(1 + f(x, y)) \), donde \( c \) es una constante.
  • Uso: Mejora la visualización de imágenes con una alta gama dinámica (HDR), como imágenes astronómicas.
• Corrección Lineal o Estiramiento de Contraste
  
  • Expande los valores de intensidad en una imagen para cubrir un rango más amplio, aumentando el contraste.
  • Fórmula: \[ g(x, y) = \frac{f(x, y) - f_{\min}}{f_{\max} - f_{\min}} \cdot (L - 1) \]
  • Uso: Aumenta el contraste en imágenes con poca variación de intensidad.
• Transformaciones de Potencia (Raise to Power Transform)
  
  • Eleva cada valor de píxel a una potencia \( n \), lo que permite ajustar el brillo y contraste de una imagen.
  • Fórmula: \( g(x, y) = c \cdot f(x, y)^n \).

Aplicaciones de Operadores Puntuales

1. Representación de las coordenadas en forma homogénea

2. Definición de la matriz de transformación

3. Multiplicación de la matriz por las coordenadas

• 3.1 Cálculo del nuevo valor de \(x'\)
  

  \[ x' = a_{11} \cdot x + a_{12} \cdot y + t_x \]

• 3.2 Cálculo del nuevo valor de \(y'\)
  

  \[ y' = a_{21} \cdot x + a_{22} \cdot y + t_y \]

• 3.3 El valor constante de la tercera coordenada
  

  La tercera coordenada se mantiene como \(1\), ya que no cambia en las transformaciones afines.

  \[1 = (0 \cdot x) + (0 \cdot y) + 1 \]

4. Resultado final

Ejemplo concreto: Rotación

Resumen del proceso

1. Traslación (Translation)

2. Rotación (Rotation)

3. Escalado (Scalin

4. Cizallamiento (Shearing)

5. Reflexión (Reflection)

6. Transformación Afín (Affine Transformation)

7. Transformación Proyectiva (Homografía)

Aplicaciones

Fundamentos de los Landmarks

Aplicaciones de los Landmarks

• Reconocimiento Facial
  

  En el reconocimiento facial, se utilizan landmarks para identificar estructuras anatómicas del rostro, como los ojos, la nariz y la boca. Un ejemplo común es el modelo de 68 puntos faciales utilizado en bibliotecas como dlib, donde cada punto representa una característica clave del rostro.

• Registro y Segmentación de Imágenes Médicas
  

  Los landmarks juegan un papel clave en el registro de imágenes médicas, facilitando la comparación de imágenes de distintos pacientes o en diferentes momentos temporales. Se utilizan en la detección de estructuras anatómicas en radiografías, tomografías y microscopía.

• Seguimiento de Movimiento y Estimación de Postura
  

  Los sistemas de visión artificial pueden detectar landmarks en el cuerpo humano para el análisis de la postura y el seguimiento de movimientos en tiempo real, como en aplicaciones deportivas y rehabilitación médica.

• Detección de Características en Citología Cervical
  

  En el análisis de imágenes de citología cervical, los landmarks pueden utilizarse para localizar estructuras celulares relevantes, facilitando la segmentación y clasificación de células en exámenes de Papanicolaou.

Métodos de Detección de Landmarks

• Métodos Clásicos
  

  SIFT (Scale-Invariant Feature Transform): Detecta puntos clave invariables a cambios de escala y rotación.

  SURF (Speeded-Up Robust Features): Similar a SIFT pero más rápido.

  ORB (Oriented FAST and Rotated BRIEF): Optimizado para detección rápida en tiempo real.

• Métodos Basados en Aprendizaje Profundo
  

  Redes neuronales convolucionales (CNNs): Utilizadas en el reconocimiento facial y análisis biomédico.

  MediaPipe: Biblioteca de Google para la detección de landmarks en tiempo real.

  Modelos de Regresión de Forma Activa (ASM) y Modelos de Forma Constrained Local Models (CLM): Métodos específicos para la detección de formas anatómicas.

Introducción

Instalación de Dependencias

pip install mediapipe opencv-python

Código para Detección de Manos en Tiempo Real

import cv2
import mediapipe as mp

# Inicializar MediaPipe Hands
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils
hands = mp_hands.Hands(min_detection_confidence=0.5, min_tracking_confidence=0.5)

# Captura de video
cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Convertir imagen a RGB
    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    
    # Detectar manos
    results = hands.process(frame_rgb)

    # Dibujar los puntos clave y conexiones
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            mp_drawing.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)

    # Mostrar la imagen
    cv2.imshow("Salida", frame)

    # Salir con 'q'
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2
import mediapipe as mp

# Inicializar MediaPipe Hands
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils
hands = mp_hands.Hands(min_detection_confidence=0.5, min_tracking_confidence=0.5)

# Captura de video
cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Convertir imagen a RGB
    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    
    # Detectar manos
    results = hands.process(frame_rgb)

    # Dibujar los puntos clave y conexiones
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            for idx, landmark in enumerate(hand_landmarks.landmark):

                h,w,_ =frame.shape
                x,y=int(landmark.x*w), int(landmark.y*h)

                cv2.circle(frame, (x,y), 2, (12, 233,4), -1)
            #mp_drawing.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)

    # Mostrar la imagen
    cv2.imshow("Salida", frame)

    # Salir con 'q'
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

Explicación del Código

Mejoras Posibles

Indice de dedos en mediapipe

Medipipe Reconocimiento de letras

import cv2
import mediapipe as mp
import numpy as np

# Inicializar MediaPipe Hands
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils
hands = mp_hands.Hands(min_detection_confidence=0.7, min_tracking_confidence=0.7)

# Función para determinar la letra según la posición de los dedos
def reconocer_letra(hand_landmarks, frame):
    # Obtener coordenadas de los puntos clave de la mano
    dedos = [hand_landmarks.landmark[i] for i in range(21)]
    
    # Obtener posiciones clave (puntas y base de los dedos)
    pulgar = dedos[4]   # Punta del pulgar
    indice = dedos[8]   # Punta del índice
    medio = dedos[12]   # Punta del medio
    anular = dedos[16]  # Punta del anular
    meñique = dedos[20] # Punta del meñique

    # Distancias entre puntos (para definir gestos)
    distancia_pulgar_indice = np.linalg.norm([pulgar.x - indice.x, pulgar.y - indice.y])
    distancia_indice_medio = np.linalg.norm([indice.x - medio.x, indice.y - medio.y])
    
    # Lógica para reconocer algunas letras
    if distancia_pulgar_indice < 0.05 and distancia_indice_medio > 0.1:
        return "A"  # Seña de la letra A (puño cerrado con pulgar al lado)
    elif indice.y < medio.y and medio.y < anular.y and anular.y < meñique.y:
        return "B"  # Seña de la letra B (todos los dedos estirados, pulgar en la palma)
    elif distancia_pulgar_indice > 0.1 and distancia_indice_medio > 0.1:
        return "C"  # Seña de la letra C (mano en forma de "C")
    
    return "Desconocido"

# Captura de video en tiempo real
cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Convertir a RGB
    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    # Procesar la imagen con MediaPipe
    results = hands.process(frame_rgb)

    # Dibujar puntos de la mano y reconocer letras
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            mp_drawing.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)
            
            # Identificar la letra
            letra_detectada = reconocer_letra(hand_landmarks, frame)

            # Mostrar la letra en pantalla
            cv2.putText(frame, f"Letra: {letra_detectada}", (50, 50), 
                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)

    # Mostrar el video
    cv2.imshow("Reconocimiento de Letras", frame)

    # Salir con la tecla 'q'
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Liberar recursos
cap.release()
cv2.destroyAllWindows()

import cv2
import mediapipe as mp
import numpy as np

# Inicializar MediaPipe Hands
mp_hands = mp.solutions.hands
mp_drawing = mp.solutions.drawing_utils
hands = mp_hands.Hands(min_detection_confidence=0.7, min_tracking_confidence=0.7)

# Función para determinar la letra según la posición de los dedos
def reconocer_letra(hand_landmarks, frame):
    h, w, _ = frame.shape  # Tamaño de la imagen
    
    # Obtener coordenadas de los puntos clave en píxeles
    dedos = [(int(hand_landmarks.landmark[i].x * w), int(hand_landmarks.landmark[i].y * h)) for i in range(21)]
    
    # Obtener posiciones clave (puntas de los dedos)
    pulgar, indice, medio, anular, meñique = dedos[4], dedos[8], dedos[12], dedos[16], dedos[20]

    # Mostrar los números de los landmarks en la imagen
    for i, (x, y) in enumerate(dedos):
        cv2.circle(frame, (x, y), 5, (0, 234, 0), -1)  # Puntos verdes
        cv2.putText(frame, str(i), (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1)

    # Dibujar coordenadas del pulgar
    cv2.putText(frame, f'({int(pulgar[0])}, {int(pulgar[1])})', (pulgar[0], pulgar[1] - 15), 
                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (245, 0, 0), 2, cv2.LINE_AA)

    cv2.line(frame, (int(pulgar[0]), int(pulgar[1])), (int(indice[0]), int(indice[1])), (244,34,12), 2)
    
    # Calcular distancias en píxeles
    distancia_pulgar_indice = np.linalg.norm(np.array(pulgar) - np.array(indice))
    distancia_indice_medio = np.linalg.norm(np.array(indice) - np.array(medio))

    cv2.putText(frame, f'({distancia_pulgar_indice})', (pulgar[0]-40, pulgar[1] - 45), 
                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2, cv2.LINE_AA)


    cv2.circle(frame, (pulgar[0]+20,pulgar[1]+20), int(distancia_indice_medio), (34,234,65), -1 )
    
    # Lógica para reconocer algunas letras
    if distancia_pulgar_indice < 30 and distancia_indice_medio > 50:
        return "A"  # Seña de la letra A (puño cerrado con pulgar al lado)
    elif indice[1] < medio[1] and medio[1] < anular[1] and anular[1] < meñique[1]:
        return "B"  # Seña de la letra B (todos los dedos estirados, pulgar en la palma)
    elif distancia_pulgar_indice > 50 and distancia_indice_medio > 50:
        return "C"  # Seña de la letra C (mano en forma de "C")

    return "Desconocido"

# Captura de video en tiempo real
cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Convertir a RGB
    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    # Procesar la imagen con MediaPipe
    results = hands.process(frame_rgb)

    # Dibujar puntos de la mano y reconocer letras
    if results.multi_hand_landmarks:
        for hand_landmarks in results.multi_hand_landmarks:
            mp_drawing.draw_landmarks(frame, hand_landmarks, mp_hands.HAND_CONNECTIONS)
            
            # Identificar la letra
            letra_detectada = reconocer_letra(hand_landmarks, frame)

            # Mostrar la letra en pantalla
            cv2.putText(frame, f"Letra: {letra_detectada}", (50, 50), 
                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2, cv2.LINE_AA)

    # Mostrar el video
    cv2.imshow("Reconocimiento de Letras", frame)

    # Salir con la tecla 'q'
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Liberar recursos
cap.release()
cv2.destroyAllWindows()

import cv2
import mediapipe as mp

# Inicializar MediaPipe Face Mesh
mp_face_mesh = mp.solutions.face_mesh
face_mesh = mp_face_mesh.FaceMesh(static_image_mode=False, max_num_faces=2, min_detection_confidence=0.5, min_tracking_confidence=0.5)

# Inicializar dibujador de MediaPipe
mp_drawing = mp.solutions.drawing_utils
drawing_spec = mp_drawing.DrawingSpec(thickness=1, circle_radius=1, color=(234, 255, 233))  # Puntos verdes

# Captura de video
cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    frqame = cv2.flip(frame, 1)  # Espejo para mayor naturalidad
    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = face_mesh.process(rgb_frame)

    if results.multi_face_landmarks:
        for face_landmarks in results.multi_face_landmarks:
            mp_drawing.draw_landmarks(frame, face_landmarks, mp_face_mesh.FACEMESH_TESSELATION, drawing_spec, drawing_spec)

    cv2.imshow('PuntosFacialesMediaPipe', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import cv2
import mediapipe as mp
import numpy as np

# Inicializar MediaPipe Face Detection
mp_face_detection = mp.solutions.face_detection
face_detection = mp_face_detection.FaceDetection(min_detection_confidence=0.7)

# Cargar la máscara con transparencia (debe ser un PNG con canal alpha)
mask = cv2.imread("300.png", cv2.IMREAD_UNCHANGED)

# Función para superponer la máscara en la cara
def overlay_mask(frame, mask, x, y, w, h):
    # Redimensionar la máscara al tamaño de la cara detectada
    mask_resized = cv2.resize(mask, (w, h))

    # Extraer los canales de la máscara (RGBA)
    mask_rgb = mask_resized[:, :, :3]  # Canales de color
    mask_alpha = mask_resized[:, :, 3] / 255.0  # Canal de transparencia

    # Obtener la región donde se colocará la máscara
    roi = frame[y:y+h, x:x+w]

    # Mezclar la máscara con el frame
    for c in range(3):  # Aplicar a cada canal de color (BGR)
        roi[:, :, c] = (1 - mask_alpha) * roi[:, :, c] + mask_alpha * mask_rgb[:, :, c]

    frame[y:y+h, x:x+w] = roi  # Colocar la máscara en el frame

# Captura de video
cap = cv2.VideoCapture(0)

while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    frame = cv2.flip(frame, 1)  # Espejo para mejor experiencia
    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
    results = face_detection.process(rgb_frame)

    if results.detections:
        for detection in results.detections:
            # Obtener la caja delimitadora del rostro
            bboxC = detection.location_data.relative_bounding_box
            ih, iw, _ = frame.shape  # Alto y ancho del frame

            # Convertir a coordenadas de píxeles
            x = int(bboxC.xmin * iw) - 20
            y = int(bboxC.ymin * ih) - 40
            w = int(bboxC.width * iw) + 40
            h = int(bboxC.height * ih) + 40

            # Superponer la máscara en la imagen
            overlay_mask(frame, mask, x, y, w, h)

    cv2.imshow("Mascara Animada", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

Creación de una Imagen

import numpy as np   # Importa la librería NumPy, útil para trabajar con arreglos y operaciones numéricas.
import cv2 as cv     # Importa la librería OpenCV, que se utiliza para procesamiento de imágenes.

# Crea una imagen de 500x500 píxeles, todos con valor 240 (gris claro). 
# La imagen tiene solo un canal (escala de grises) y está inicializada con valores de tipo uint8 (enteros sin signo de 8 bits).
img = np.ones((500, 500), dtype=np.uint8) * 240

# Modifica algunos píxeles específicos en las coordenadas (30, 30) a (30, 35) para que tengan un valor de 1 (casi negro).
# Esto creará una pequeña línea vertical de 6 píxeles en la imagen de color casi negro.
img[30, 30] = 1
img[30, 31] = 1
img[30, 32] = 1
img[30, 33] = 1
img[30, 34] = 1
img[30, 35] = 1

# Muestra la imagen en una ventana con el título 'img'. 
cv.imshow('img', img)

# Espera a que el usuario presione cualquier tecla para continuar.
cv.waitKey()

# Cierra todas las ventanas creadas por OpenCV.
cv.destroyAllWindows()

Cargar Imagen

import cv2 as cv  # Importa la librería OpenCV, que se usa para el procesamiento de imágenes y videos.

# Lee una imagen desde el archivo 'tr.png'. 
# El segundo argumento '1' indica que se leerá la imagen en color (1 para color, 0 para escala de grises, -1 para incluir el canal alfa si existe).
img = cv.imread('tr.png', 1)

# Muestra la imagen leída en una ventana llamada 'ejemplo'.
cv.imshow('ejemplo', img)

# Espera indefinidamente hasta que el usuario presione una tecla.
cv.waitKey(0)

# Cierra todas las ventanas abiertas por OpenCV.
cv.destroyAllWindows()

Split y Merge Imagen

import cv2 as cv  # Importa OpenCV, que es útil para procesamiento de imágenes.
import numpy as np  # Importa NumPy, que es útil para trabajar con matrices y operaciones numéricas.

# Carga la imagen '1a.png' en color (1 para color, 0 para escala de grises).
img = cv.imread('1a.png', 1)

# Crea una imagen vacía (llena de ceros, que representa color negro) con el mismo tamaño que la imagen original.
# La imagen vacía tiene un solo canal (escala de grises), por lo que se usa `img.shape[:2]` para obtener las dimensiones de la imagen (alto, ancho).
img2 = np.zeros((img.shape[:2]), dtype=np.uint8)

# Imprime las dimensiones de la imagen en la terminal (alto, ancho).
print(img.shape[:2])

# Separa los canales rojo (r), verde (g) y azul (b) de la imagen utilizando la función `cv.split()`.
r, g, b = cv.split(img)

# Recombina los canales, pero los reorganiza como rojo, azul y verde (RBG en lugar de RGB).
#r2 = cv.merge([img2, img2, r])
#g2 = cv.merge([img2, g, img2])
#b2 = cv.merge([b, img2, img2])
img3 = cv.merge([b, r, g])
# Crea una imagen que contiene solo el canal rojo, llenando los otros dos canales (verde y azul) con ceros (negro).
#r = cv.merge([r, img2, img2])

# Crea una imagen que contiene solo el canal verde, llenando los otros dos canales (rojo y azul) con ceros.
#g = cv.merge([img2, g, img2])

# Crea una imagen que contiene solo el canal azul, llenando los otros dos canales (rojo y verde) con ceros.#
#b = cv.merge([img2, img2, b])

# Muestra la imagen original en una ventana llamada 'ejemplo'.
cv.imshow('ejemplo', img)

# Muestra la imagen que contiene solo el canal rojo.
#cv.imshow('r', r)
#cv.imshow('r2', r2)



# Muestra la imagen que contiene solo el canal verde.
#cv.imshow('g', g)
#cv.imshow('g2', g2)

# Muestra la imagen que contiene solo el canal azul.
#cv.imshow('b', b)
#cv.imshow('b2', b2)

# Muestra la imagen con los canales reorganizados (RBG en lugar de RGB).
cv.imshow('img3', img3)

# Espera indefinidamente a que el usuario presione una tecla.
cv.waitKey(0)

# Cierra todas las ventanas abiertas por OpenCV.
cv.destroyAllWindows()

Ejemplo de Operador Puntual en Imágenes

import cv2 as cv

img = cv.imread('tr.png', 0)
cv.imshow('salida', img)
x,y=img.shape
for i in range(x):
        for j in range(y):
                if(img[i,j]>150):
                        img[i,j]=255
                else:
                        img[i,j]=0


cv.imshow('negativo', img)
print( img.shape, x , y)
cv.waitKey(0)
cv.destroyAllWindows()

Cargar vídeo Opencv

import cv2 as cv
import numpy as np
cap = cv.VideoCapture(0)

while(True):
    ret, img = cap.read()
    if ret:
        cv.imshow('video', img)
        k =cv.waitKey(1) & 0xFF
        if k == 27 :
            break
    else:
        break
   
cap.release()
cv.destroyAllWindows()

import cv2 as cv
import numpy as np
cap = cv.VideoCapture(0)

while(True):
    ret, img = cap.read()
    if ret:
        cv.imshow('video', img)
        img2 = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
        hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)
        w,h = img2.shape
        img3=255-img2
        cv.imshow('img2', img2)
        cv.imshow('hsv', hsv)
        cv.imshow('img3', img3)
        
        k =cv.waitKey(1) & 0xFF
        if k == 27 :
            break
    else:
        break
    
cap.release()
cv.destroyAllWindows()

1. Traslación

import cv2 as cv
import numpy as np

# Cargar la imagen en escala de grises
img = cv.imread('tr.png', 0)

# Obtener el tamaño de la imagen
x, y = img.shape

# Crear una imagen vacía para la traslación
translated_img = np.zeros((x, y), dtype=np.uint8)

# Definir el desplazamiento en x e y
dx, dy = 100, 50

# Trasladar la imagen
for i in range(x):
    for j in range(y):
        new_x = i + dy
        new_y = j + dx
        if 0 <= new_x < x and 0 <= new_y < y:
            translated_img[new_x, new_y] = img[i, j]

# Mostrar la imagen original y la trasladada
cv.imshow('Imagen Original', img)
cv.imshow('Imagen Trasladada', translated_img)
cv.waitKey(0)
cv.destroyAllWindows()

2. Rotación (alrededor del centro de la imagen)

import cv2 as cv
import numpy as np
import math

# Cargar la imagen en escala de grises
img = cv.imread('tr.png', 0)

# Obtener el tamaño de la imagen
x, y = img.shape

# Crear una imagen vacía para almacenar el resultado
rotated_img = np.zeros((x*2, y*2), dtype=np.uint8)
xx, yy = rotated_img.shape
# Calcular el centro de la imagen
cx, cy = int(x  // 2), int(y  // 2)

# Definir el ángulo de rotación (en grados) y convertirlo a radianes
angle = 45
theta = math.radians(angle)

# Rotar la imagen
for i in range(x):
    for j in range(y):
        new_x = int((j - cx) * math.cos(theta) - (i - cy) * math.sin(theta) + cx)
        new_y = int((j - cx) * math.sin(theta) + (i - cy) * math.cos(theta) + cy)
        if 0 <= new_x < y and 0 <= new_y < x:
            rotated_img[new_y, new_x] = img[i, j]

# Mostrar la imagen original y la rotada
cv.imshow('Imagen Original', img)
cv.imshow('Imagen Rotada (modo raw)', rotated_img)
cv.waitKey(0)
cv.destroyAllWindows()

3. Escalado

import cv2 as cv
import numpy as np

# Cargar la imagen en escala de grises
img = cv.imread('tr.png', 0)
# Obtener el tamaño de la imagen
x, y = img.shape
# Definir el factor de escala
scale_x, scale_y = 2, 2
# Crear una nueva imagen para almacenar el escalado
scaled_img = np.zeros((int(x * scale_y), int(y * scale_x)), dtype=np.uint8)
# Aplicar el escalado
for i in range(x):
    for j in range(y):
                   #orig_x = int(i * scale_y)
                   #orig_y = int(j * scale_x)
                   scaled_img[i*2, j*2] = img[i, j]

# Mostrar la imagen original y la escalada
cv.imshow('Imagen Original', img)
cv.imshow('Imagen Escalada (modo raw)', scaled_img)
cv.waitKey(0)
cv.destroyAllWindows()

4. Cizallamiento (Shearing)

import cv2 as cv
import numpy as np

# Cargar la imagen en escala de grises
img = cv.imread('tr.png', 0)

# Obtener el tamaño de la imagen
x, y = img.shape

# Crear una imagen vacía para el cizallamiento
sheared_img = np.zeros((x, y), dtype=np.uint8)

# Definir el factor de cizallamiento
shear_factor_x = 0.5

# Aplicar el cizallamiento en el eje x
for i in range(x):
    for j in range(y):
        new_x = i
        new_y = int(j + shear_factor_x * i)
        if 0 <= new_x < x and 0 <= new_y < y:
            sheared_img[new_x, new_y] = img[i, j]

# Mostrar la imagen original y la cizallada
cv.imshow('Imagen Original', img)
cv.imshow('Imagen Cizallada (modo raw)', sheared_img)
cv.waitKey(0)
cv.destroyAllWindows()

5. Reflexión (Reflection)

• Reflexión horizontal
  

  import cv2 as cv
  import numpy as np
  
  # Cargar la imagen en escala de grises
  img = cv.imread('tr.png', 0)
  
  # Obtener el tamaño de la imagen
  x, y = img.shape
  
  # Crear una imagen vacía para la reflexión
  reflected_img = np.zeros((x, y), dtype=np.uint8)
  
  # Aplicar la reflexión horizontal
  for i in range(x):
      for j in range(y):
          reflected_img[i, y - j - 1] = img[i, j]
  
  # Mostrar la imagen original y la reflejada
  cv.imshow('Imagen Original', img)
  cv.imshow('Imagen Reflejada Horizontalmente (modo raw)', reflected_img)
  cv.waitKey(0)
  cv.destroyAllWindows()
  

• Reflexión vertical
  

  import cv2 as cv
  import numpy as np
  
  # Cargar la imagen en escala de grises
  img = cv.imread('tr.png', 0)
  
  # Obtener el tamaño de la imagen
  x, y = img.shape
  
  # Crear una imagen vacía para la reflexión
  reflected_img = np.zeros((x, y), dtype=np.uint8)
  
  # Aplicar la reflexión vertical
  for i in range(x):
      for j in range(y):
          reflected_img[x - i - 1, j] = img[i, j]
  
  # Mostrar la imagen original y la reflejada
  cv.imshow('Imagen Original', img)
  cv.imshow('Imagen Reflejada Verticalmente (modo raw)', reflected_img)
  cv.waitKey(0)
  cv.destroyAllWindows()
  

1. Traslación

import cv2 as cv
import numpy as np

# Cargar la imagen en escala de grises
img = cv.imread('tr.png', 0)

# Obtener el tamaño de la imagen
x, y = img.shape

# Definir el desplazamiento en x e y
dx, dy = 100, 50

# Crear la matriz de traslación
M = np.float32([[1, 0, dx], [0, 1, dy]])

# Aplicar la traslación usando warpAffine
translated_img = cv.warpAffine(img, M, (y, x))

# Mostrar la imagen original y la trasladada
cv.imshow('Imagen Original', img)
cv.imshow('Imagen Trasladada', translated_img)
cv.waitKey(0)
cv.destroyAllWindows()

2. Rotación (alrededor del centro de la imagen)

import cv2 as cv
import numpy as np

# Cargar la imagen en escala de grises
img = cv.imread('tr.png', 0)

# Obtener el tamaño de la imagen
x, y = img.shape

# Calcular el centro de la imagen
center = (y // 2, x // 2)

# Definir el ángulo de rotación (en grados)
angle = 45

# Crear la matriz de rotación
M = cv.getRotationMatrix2D(center, angle, 1.0)

# Aplicar la rotación usando warpAffine
rotated_img = cv.warpAffine(img, M, (y, x))

# Mostrar la imagen original y la rotada
cv.imshow('Imagen Original', img)
cv.imshow('Imagen Rotada', rotated_img)
cv.waitKey(0)
cv.destroyAllWindows()

3. Escalado

import cv2 as cv
import numpy as np

# Cargar la imagen en escala de grises
img = cv.imread('tr.png', 1)

# Definir el factor de escala
scale_x, scale_y = 0.5, 0.5

# Aplicar el escalado usando cv.resize()
scaled_img = cv.resize(img, None, fx=scale_x, fy=scale_y)

# Mostrar la imagen original y la escalada
cv.imshow('Imagen Original', img)
cv.imshow('Imagen Escalada', scaled_img)
cv.waitKey(0)
cv.destroyAllWindows()

4. Cizallamiento (Shearing)

import cv2 as cv
import numpy as np

# Cargar la imagen en escala de grises
img = cv.imread('tr.png', 0)

# Obtener el tamaño de la imagen
x, y = img.shape

# Definir el factor de cizallamiento
shear_factor = 0.5

# Crear la matriz de cizallamiento
M = np.float32([[1, shear_factor, 0], [0, 1, 0]])

# Aplicar el cizallamiento usando warpAffine
sheared_img = cv.warpAffine(img, M, (y, x))

# Mostrar la imagen original y la cizallada
cv.imshow('Imagen Original', img)
cv.imshow('Imagen Cizallada', sheared_img)
cv.waitKey(0)
cv.destroyAllWindows()

5. Reflexión (Reflection)

• Reflexión horizontal
  

  import cv2 as cv
  
  # Cargar la imagen en escala de grises
  img = cv.imread('tr.png', 0)
  
  # Aplicar la reflexión horizontal usando cv.flip()
  reflected_img = cv.flip(img, 1)
  
  # Mostrar la imagen original y la reflejada
  cv.imshow('Imagen Original', img)
  cv.imshow('Imagen Reflejada Horizontalmente', reflected_img)
  cv.waitKey(0)
  cv.destroyAllWindows()
  

• Reflexión vertical
  

  import cv2 as cv
  
  # Cargar la imagen en escala de grises
  img = cv.imread('tr.png', 0)
  
  # Aplicar la reflexión vertical usando cv.flip()
  reflected_img = cv.flip(img, 0)
  
  # Mostrar la imagen original y la reflejada
  cv.imshow('Imagen Original', img)
  cv.imshow('Imagen Reflejada Verticalmente', reflected_img)
  cv.waitKey(0)
  cv.destroyAllWindows()
  

Sintaxis básica de np.where:

np.where(condición, valor_si_verdadero, valor_si_falso)

• Ejemplo sencillo:
  

  import numpy as np
  
  # Creamos un array de ejemplo
  array = np.array([1, 2, 3, 4, 5])
  
  # Aplicamos np.where para cambiar los valores mayores a 3 por 100 y el resto por 0
  resultado = np.where(array > 3, 100, 0)
  
  print(resultado)  # Resultado: [  0   0   0 100 100]
  

  En este ejemplo, la condición `array > 3` se cumple para los elementos 4 y 5, por lo que se cambian por 100, mientras que los otros elementos se cambian por 0.

Aplicación en procesamiento de imágenes:

• Parte del código relevante:
  

  imagen_colores_resaltados = np.where(mascara_rojo[:, :, None] == 255, imagen, imagen_gris_bgr)
  

• Desglose:
  
  1. `mascara<sub>rojo</sub>[:, :, None] == 255`:
     • La máscara es un arreglo 2D con los mismos altos y anchos que la imagen original, donde los valores son 255 para los pixeles que coinciden con el color rojo, y 0 para los que no.
     • `[:, :, None]`: Añade una tercera dimensión para que la máscara coincida con la estructura 3D de la imagen original, donde tenemos tres canales (R, G, B).
     • La condición `== 255` selecciona los píxeles donde el color rojo fue detectado.
  2. `imagen`:
     • Es la imagen original en color. Se utiliza en las posiciones donde la máscara detecta el color rojo (condición `True`).
  3. `imagen<sub>grisbgr</sub>`:
     • Es la versión de la imagen en escala de grises, convertida a formato BGR. Se usa en las posiciones donde la condición es `False`, es decir, donde no se detectó el color rojo.
• Ejemplo visual:
  

  Imagina que tienes un pixel con los siguientes valores RGB: `(255, 0, 0)` (un rojo intenso). Si este pixel cae dentro del rango de color rojo, entonces `mascara<sub>rojo</sub>` tendrá el valor 255 para ese pixel. Esto hará que `np.where` conserve el pixel original en color:

  • Condición True (rojo detectado): Se conserva el pixel original.
  • Condición False (no es rojo): El pixel se convierte a su equivalente en escala de grises.

  ****y el Ejemplo simplificado:

  # Si la máscara es:
  mascara_rojo = [[255, 0], 
                  [0, 255]]
  
  # La imagen original en color (simplificada):
  imagen = [[[255, 0, 0], [0, 255, 0]],
            [[0, 0, 255], [255, 0, 0]]]
  
  # La imagen en gris (también simplificada):
  imagen_gris_bgr = [[[128, 128, 128], [128, 128, 128]],
                     [[128, 128, 128], [128, 128, 128]]]
  
  # Aplicando np.where:
  resultado = np.where(mascara_rojo[:, :, None] == 255, imagen, imagen_gris_bgr)
  
  # Resultado esperado:
  resultado = [[[255, 0, 0], [128, 128, 128]],
               [[128, 128, 128], [255, 0, 0]]]
  

  En el resultado, los pixeles que coinciden con el color rojo permanecen iguales, mientras que los otros se convierten a escala de grises.

• ¿Cómo funciona esto para toda la imagen?
  

  `np.where` revisa cada pixel de la imagen:

  • Si un pixel es rojo (según la máscara), lo toma de la imagen original.
  • Si un pixel no es rojo, lo toma de la versión en escala de grises.

  • np.where actúa como un filtro condicional que selecciona valores en base a una máscara booleana.
  • En este caso, se utiliza para dejar intactos los pixeles que coinciden con el color deseado (rojo) y convertir el resto de la imagen a escala de grises.

  import cv2
  import numpy as np
  
  # Leer la imagen en formato RGB
  imagen = cv2.imread('man1.jpg', 1)
  # Convertir la imagen de RGB a HSV
  imagen_hsv = cv2.cvtColor(imagen, cv2.COLOR_BGR2HSV)
  # Definir el rango de color rojo en HSV
  bajo_rojo1 = np.array([0, 40, 40])
  alto_rojo1 = np.array([10, 255, 255])
  bajo_rojo2 = np.array([160, 40, 40])
  alto_rojo2 = np.array([180, 255, 255])
  # Crear una máscara para el color rojo
  mascara_rojo1 = cv2.inRange(imagen_hsv, bajo_rojo1, alto_rojo1)
  mascara_rojo2 = cv2.inRange(imagen_hsv, bajo_rojo2, alto_rojo2)
  #mascara_rojo = mascara_rojo1 + mascara_rojo2
  mascara_rojo = cv2.add(mascara_rojo1, mascara_rojo2)
  # Convertir la imagen original a escala de grises
  imagen_gris = cv2.cvtColor(imagen, cv2.COLOR_BGR2GRAY)
  # Convertir la imagen gris a un formato BGR para que coincida con la original
  imagen_gris_bgr = cv2.cvtColor(imagen_gris, cv2.COLOR_GRAY2BGR)
  # Combinar la imagen en gris con las áreas en rojo
  resultado = np.where(mascara_rojo[:, :, None] == 255, imagen, imagen_gris_bgr)
  # Mostrar la imagen final
  cv2.imshow('Color resaltado', resultado)
  cv2.imshow('mascara_rojo', mascara_rojo)
  cv2.imshow('imagen', imagen)
  cv2.imshow('imagen_gris__bgr', imagen_gris_bgr)
  cv2.waitKey(0)
  cv2.destroyAllWindows()
  
  

  import cv2 as cv
  import numpy as np
  cap = cv.VideoCapture(0)
  
  while(True):
      ret, imagen = cap.read()
      if ret:
          cv.imshow('video', imagen)
          imagen_hsv = cv.cvtColor(imagen, cv.COLOR_BGR2HSV)
          bajo_azul1 = np.array([100, 40, 40])
          alto_azul1 = np.array([140, 255, 255])
        
          # Crear una máscara para el color rojo
          mascara_azul1 = cv.inRange(imagen_hsv, bajo_azul1, alto_azul1)
        
          # Convertir la imagen original a escala de grises
          imagen_gris = cv.cvtColor(imagen, cv.COLOR_BGR2GRAY)
  
          # Convertir la imagen gris a un formato BGR para que coincida con la original
          imagen_gris_bgr = cv.cvtColor(imagen_gris, cv.COLOR_GRAY2BGR)
  
          # Combinar la imagen en gris con las áreas en rojo
          resultado = np.where(mascara_azul1[:, :, None] == 255, imagen, imagen_gris_bgr)
  
          # Mostrar la imagen final
          cv.imshow('Color resaltado', resultado)
          
          k =cv.waitKey(1) & 0xFF
          if k == 27 :
              break
      else:
          break
      
  cap.release()
  cv.destroyAllWindows()
  

Ejemplo de Proyección Isométrica en OpenCV

• Código en Python
  

  import cv2
  import numpy as np
  import math
  
  # Dimensiones de la ventana
  WIDTH, HEIGHT = 800, 600
  
  # Vértices del cubo en coordenadas 3D
  vertices = np.array([
      [-1, -1, -1],
      [1, -1, -1],
      [1, 1, -1],
      [-1, 1, -1],
      [-1, -1, 1],
      [1, -1, 1],
      [1, 1, 1],
      [-1, 1, 1]
  ])
  
  # Conexiones de los vértices para formar las aristas del cubo
  edges = [
      (0, 1), (1, 2), (2, 3), (3, 0),  # Base inferior
      (4, 5), (5, 6), (6, 7), (7, 4),  # Base superior
      (0, 4), (1, 5), (2, 6), (3, 7)   # Conexiones entre bases
  ]
  
  def project_isometric(vertex):
      """Función para proyectar un punto 3D a 2D con proyección isométrica"""
      x, y, z = vertex
      x2D = x - z
      y2D = (x + 2 * y + z) / 2
      return int(x2D * 100 + WIDTH / 2), int(-y2D * 100 + HEIGHT / 2)
  
  # Crear ventana
  cv2.namedWindow("Cubo Isométrico")
  
  while True:
      # Crear imagen negra para el fondo
      frame = np.zeros((HEIGHT, WIDTH, 3), dtype=np.uint8)
  
      # Dibujar aristas del cubo
      for edge in edges:
          pt1 = project_isometric(vertices[edge[0]])
          pt2 = project_isometric(vertices[edge[1]])
          cv2.line(frame, pt1, pt2, (255, 255, 255), 2)
  
      # Mostrar imagen
      cv2.imshow("Cubo Isométrico", frame)
  
      # Salir si se presiona 'q'
      if cv2.waitKey(1) & 0xFF == ord('q'):
          break
  
  cv2.destroyAllWindows()
  

• Explicación del Código
  
  1. Definición de Vértices y Aristas:
     • `vertices` define los puntos 3D del cubo en coordenadas `(x, y, z)`.
     • `edges` define las conexiones entre los vértices para formar las aristas del cubo.
  2. Función `project<sub>isometric</sub>`:
     • Convierte cada vértice 3D en coordenadas 2D usando una proyección isométrica. La fórmula aplicada crea un efecto 3D sin perspectiva.
  3. Bucle de Renderizado:
     • Cada fotograma crea una imagen de fondo negro (`frame`) y dibuja las aristas del cubo conectando los puntos proyectados en 2D.
     • El bucle continúa hasta que se presiona la tecla `'q'`.
• Salida Esperada
  

  La ventana mostrará un cubo en perspectiva isométrica. Las aristas se dibujan en blanco y el cubo parece tener profundidad, aunque es solo una representación en 2D.

  Este ejemplo simula un efecto 3D mediante una proyección isométrica, útil para aplicaciones de diseño y gráficos 2D en OpenCV.

Configuración del Entorno

  pip install PyOpenGL PyOpenGL_accelerate glfw 
  pip install PyOpenGL glfw PyFreeGLUT

Estructura básica de un programa OpenGL

Coordenadas del Objeto

Coordenadas del Mundo

Coordenadas de Vista

Coordenadas de Recorte

Coordenadas Normalizadas del Dispositivo (NDC)

Coordenadas de Pantalla

Código en Python con OpenGL y GLUT

• Importación de módulos
  

  Se importan los módulos necesarios para trabajar con OpenGL y GLUT en Python.

  import sys
  from OpenGL.GL import *
  from OpenGL.GLUT import *
  from OpenGL.GLU import *
  

  • import sys: Se importa el módulo `sys`, que proporciona acceso a algunas variables y funciones específicos del sistema. En este caso, se usa para acceder a los argumentos de la línea de comandos al iniciar el programa.
  • from OpenGL.GL import: Se importa todo el módulo `GL` de OpenGL. Este módulo contiene las funciones necesarias para manejar las operaciones gráficas, como la manipulación de la ventana, la configuración de colores, la creación de objetos y más.
  • from OpenGL.GLUT import: Se importa el módulo `GLUT` de OpenGL, que es la biblioteca utilizada para crear y gestionar ventanas, manejar la interacción del usuario y ejecutar un bucle de eventos en el sistema. Aquí se utiliza para crear la ventana y controlar la visualización.
  • from OpenGL.GLU import: Se importa el módulo `GLU` de OpenGL. GLU (OpenGL Utility Library) ofrece funciones adicionales que simplifican algunas operaciones gráficas complejas, como las proyecciones en perspectiva, que se utilizan en este código.
• Función `init()`
  

  La función `init()` realiza las configuraciones iniciales para la visualización, como establecer el color de fondo, definir la proyección y configurar las matrices.

  def init():
      glClearColor(0.0, 0.0, 0.0, 1.0)  # Establecer color de fondo
      glMatrixMode(GL_PROJECTION)  # Establecer la matriz de proyección
      glLoadIdentity()  # Restablecer la matriz a la identidad
      gluPerspective(45, 1.0, 0.1, 50.0)  # Configuración de perspectiva
      glMatrixMode(GL_MODELVIEW)  # Establecer la matriz de modelo de vista
  

  • `glClearColor(0.0, 0.0, 0.0, 1.0)`: Define el color de fondo de la ventana. Los valores (0.0, 0.0, 0.0) representan el color negro, y el valor 1.0 en el último parámetro significa opacidad total (sin transparencia).
  • `glMatrixMode(GL<sub>PROJECTION</sub>)`: Establece que la matriz activa sea la matriz de proyección, que es la encargada de definir cómo se proyectan los objetos 3D en la pantalla.
  • `glLoadIdentity()`: Restablece la matriz activa a la matriz identidad. Este comando es necesario para borrar cualquier transformación previa antes de aplicar nuevas transformaciones.
  • `gluPerspective(45, 1.0, 0.1, 50.0)`: Configura una proyección en perspectiva. El primer parámetro (45) es el ángulo de visión en grados. El segundo parámetro (1.0) es la relación de aspecto, que debe ser igual a la relación entre el ancho y la altura de la ventana (en este caso, una ventana cuadrada). El tercer parámetro (0.1) define la distancia mínima (cerca) del plano de corte, y el cuarto parámetro (50.0) define la distancia máxima (lejos) del plano de corte.
  • `glMatrixMode(GL<sub>MODELVIEW</sub>)`: Cambia la matriz activa de nuevo a la de modelo de vista. Esto significa que las siguientes transformaciones (como traslación o rotación de objetos) afectarán a los objetos en el espacio 3D.
• Función `display()`
  

  La función `display()` se encarga de limpiar los buffers y dibujar los objetos en pantalla, en este caso, un triángulo. La función se llama constantemente para actualizar la ventana.

  def display():
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)  # Limpiar buffers
      glLoadIdentity()  # Restablecer transformaciones previas
      glTranslatef(0.0, 0.0, -5)  # Mover la cámara hacia atrás
  
      # Dibujar un triángulo
      glBegin(GL_TRIANGLES)  # Inicia la especificación de los vértices para un triángulo
      glColor3f(1.0, 0.0, 0.0)  # Rojo
      glVertex3f(-1.0, -1.0, 0.0)  # Primer vértice
      glColor3f(0.0, 1.0, 0.0)  # Verde
      glVertex3f(1.0, -1.0, 0.0)  # Segundo vértice
      glColor3f(0.0, 0.0, 1.0)  # Azul
      glVertex3f(0.0, 1.0, 0.0)  # Tercer vértice
      glEnd()  # Finaliza el bloque de dibujo
  
      glutSwapBuffers()  # Intercambiar buffers
  

  • glClear(GL_{COLORBUFFERBIT} | GL_{DEPTHBUFFERBIT}): Limpia los buffers de color y profundidad. Esto borra lo que se haya dibujado anteriormente en la ventana, asegurando que cada nueva imagen se dibuje sobre un fondo limpio.
  • glLoadIdentity(): Restablece las transformaciones actuales, como traslación, rotación, o escala, para asegurarse de que el triángulo se dibuje en su posición inicial.
  • glTranslatef(0.0, 0.0, -5): Aplica una traslación a la cámara. Este comando mueve la vista de la cámara a lo largo del eje Z, alejándola 5 unidades para que el triángulo sea visible en la pantalla.
  • glBegin(GL_TRIANGLES): Inicia la especificación de los vértices para un objeto en forma de triángulo. Todos los vértices dentro de este bloque serán interpretados como parte de un triángulo.
  • glColor3f(1.0, 0.0, 0.0): Establece el color del primer vértice del triángulo a rojo (con valores de 1.0 para rojo y 0.0 para verde y azul).
  • glVertex3f(-1.0, -1.0, 0.0): Define las coordenadas (x, y, z) del primer vértice del triángulo.
  • glColor3f(0.0, 1.0, 0.0): Establece el color del segundo vértice del triángulo a verde.
  • glVertex3f(1.0, -1.0, 0.0): Define las coordenadas del segundo vértice del triángulo.
  • glColor3f(0.0, 0.0, 1.0): Establece el color del tercer vértice del triángulo a azul.
  • glVertex3f(0.0, 1.0, 0.0): Define las coordenadas del tercer vértice del triángulo.
  • glEnd(): Finaliza la especificación del triángulo. Todos los vértices y colores definidos entre `glBegin` y `glEnd` forman un triángulo.
  • glutSwapBuffers(): Intercambia los buffers de pantalla en una ventana de doble buffer. Esto garantiza que lo que se dibujó se renderice en la ventana de manera eficiente, evitando parpadeos.
• Función `main()`
  

  La función `main()` inicializa GLUT, configura la ventana y asigna la función de visualización. También lanza el bucle principal de GLUT.

  def main():
      glutInit(sys.argv)  # Inicializar GLUT
      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)  # Establecer modo de visualización
      glutInitWindowSize(800, 600)  # Establecer tamaño de la ventana
      glutCreateWindow("Triángulo con GLUT y Python")  # Crear ventana con título
  
      init()  # Llamar a la función de configuración inicial
      glutDisplayFunc(display)  # Asignar función de visualización
      glutMainLoop()  # Comenzar el bucle principal de GLUT
  

  • glutInit(sys.argv): Inicializa GLUT y permite pasar parámetros desde la línea de comandos.
  • glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH): Establece el modo de visualización. Usamos un modo de doble buffer, el modelo RGB para el color y un buffer de profundidad para gestionar la visibilidad de objetos en 3D.
  • glutInitWindowSize(800, 600): Define el tamaño de la ventana (800 píxeles de ancho por 600 píxeles de altura).
  • glutCreateWindow("Triángulo con GLUT y Python"): Crea una ventana con el título especificado.
  • init(): Llama a la función `init()`, que establece las configuraciones iniciales de OpenGL.
  • glutDisplayFunc(display): Asocia la función `display()` con el proceso de renderizado de la ventana. Esta función se llamará cada vez que sea necesario actualizar la ventana.
  • glutMainLoop(): Inicia el bucle principal de GLUT, que gestiona la ventana, la entrada del usuario y la actualización de la pantalla.
• Ejecución del código
  

  Este bloque final se asegura de que el código se ejecute correctamente cuando se llama al archivo directamente.

  if __name__ == "__main__":
      main()  # Llamar a la función principal para ejecutar el programa
  

  Este código completa la configuración para mostrar un triángulo 3D en una ventana utilizando OpenGL y GLUT, con el fondo negro y los colores rojo, verde y azul para los vértices del triángulo.

  import sys
  from OpenGL.GL import *
  from OpenGL.GLUT import *
  from OpenGL.GLU import *
  
  def init():
      glClearColor(0.0, 0.0, 0.0, 1.0)  # Establecer color de fondo
      glMatrixMode(GL_PROJECTION)
      glLoadIdentity()
      gluPerspective(45, 1.0, 0.1, 50.0)  # Configuración de perspectiva
      glMatrixMode(GL_MODELVIEW)
  
  def display():
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)  # Limpiar buffers
      glLoadIdentity()
      glTranslatef(0.0, 0.0, -5)  # Mover la cámara hacia atrás
  
      # Dibujar un triángulo
      glBegin(GL_TRIANGLES)
      glColor3f(1.0, 0.0, 0.0)  # Rojo
      glVertex3f(-1.0, -1.0, 0.0)
      glColor3f(0.0, 1.0, 0.0)  # Verde
      glVertex3f(1.0, -1.0, 0.0)
      glColor3f(0.0, 0.0, 1.0)  # Azul
      glVertex3f(0.0, 1.0, 0.0)
      glEnd()
  
      glutSwapBuffers()  # Intercambiar buffers
  
  def main():
      # Inicializar GLUT
      glutInit(sys.argv)
      glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH)
      glutInitWindowSize(800, 600)
      glutCreateWindow("Triángulo con GLUT y Python")
  
      init()
      glutDisplayFunc(display)
      glutMainLoop()
  
  if __name__ == "__main__":
      main()
  

  import glfw
  from OpenGL.GL import *
  
  # Inicializar GLFW
  if not glfw.init():
      raise Exception("No se pudo inicializar GLFW")
  
  # Crear ventana
  window = glfw.create_window(800, 600, "OpenGL Test", None, None)
  if not window:
      glfw.terminate()
      raise Exception("No se pudo crear la ventana GLFW")
  
  # Activar el contexto
  glfw.make_context_current(window)
  
  # Obtener versión de OpenGL
  version = glGetString(GL_VERSION)
  print("Versión de OpenGL:", version.decode("utf-8"))
  
  # Terminar GLFW
  glfw.terminate()
  
  

  import glfw
  from OpenGL.GL import *
  from OpenGL.GLU import *
  
  def draw_triangle():
      # Dibuja un triángulo con OpenGL
      glBegin(GL_TRIANGLES)
      glColor3f(1.0, 0.0, 0.0)  # Rojo
      glVertex2f(-0.5, -0.5)    # Vértice inferior izquierdo
      glColor3f(0.0, 1.0, 0.0)  # Verde
      glVertex2f(0.5, -0.5)     # Vértice inferior derecho
      glColor3f(0.0, 0.0, 1.0)  # Azul
      glVertex2f(0.0, 0.5)      # Vértice superior
      glEnd()
  
  def main():
      # Inicializa GLFW
      if not glfw.init():
          return
  
      # Crear la ventana
      window = glfw.create_window(800, 600, "OpenGL Triángulo", None, None)
      if not window:
          glfw.terminate()
          return
  
      # Hacer el contexto de OpenGL actual para la ventana
      glfw.make_context_current(window)
  
      # Configurar la proyección (2D simple)
      glMatrixMode(GL_PROJECTION)
      glLoadIdentity()
      glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0)  # Proyección ortográfica 2D
      glMatrixMode(GL_MODELVIEW)
  
      # Bucle principal
      while not glfw.window_should_close(window):
          glClear(GL_COLOR_BUFFER_BIT)  # Limpiar la pantalla con color de fondo
  
          draw_triangle()  # Dibujar el triángulo
  
          glfw.swap_buffers(window)  # Intercambiar los buffers
          glfw.poll_events()  # Comprobar eventos
  
      # Finalizar GLFW
      glfw.terminate()
  
  if __name__ == "__main__":
      main()
  

  import glfw
  from OpenGL.GL import glClearColor, glEnable, glClear, glLoadIdentity, glTranslatef, glRotatef, glMatrixMode
  from OpenGL.GL import glBegin, glColor3f, glVertex3f, glEnd, glFlush, glViewport
  from OpenGL.GL import GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_DEPTH_TEST, GL_QUADS, GL_PROJECTION, GL_MODELVIEW
  from OpenGL.GLU import gluPerspective
  import sys
  
  # Variables globales
  window = None
  angle = 0  # Declaramos angle en el nivel superior
  
  def init():
      # Configuración inicial de OpenGL
      glClearColor(0.0, 0.0, 0.0, 1.0)  # Color de fondo
      glEnable(GL_DEPTH_TEST)  # Activar prueba de profundidad para 3D
  
      # Configuración de proyección
      glMatrixMode(GL_PROJECTION)
      glLoadIdentity()
      gluPerspective(45, 1.0, 0.1, 50.0)
  
      # Cambiar a la matriz de modelo para los objetos
      glMatrixMode(GL_MODELVIEW)
  
  def draw_cube():
      global angle
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)  # Limpiar pantalla y buffer de profundidad
  
      # Configuración de la vista del cubo
      glLoadIdentity()
      glTranslatef(0.0, 0.0, -5)  # Alejar el cubo para que sea visible
      glRotatef(angle, 0, 0,1)   # Rotar el cubo en todos los ejes
  
      glBegin(GL_QUADS)  # Iniciar el cubo como un conjunto de caras (quads)
  
      # Cada conjunto de cuatro vértices representa una cara del cubo
      glColor3f(1.0, 0.0, 0.0)  # Rojo
      glVertex3f( 1, 1,-1)
      glVertex3f(-1, 1,-1)
      glVertex3f(-1, 1, 1)
      glVertex3f( 1, 1, 1)
  
      glColor3f(0.0, 1.0, 0.0)  # Verde
      glVertex3f( 1,-1, 1)
      glVertex3f(-1,-1, 1)
      glVertex3f(-1,-1,-1)
      glVertex3f( 1,-1,-1)
  
      glColor3f(0.0, 0.0, 1.0)  # Azul
      glVertex3f( 1, 1, 1)
      glVertex3f(-1, 1, 1)
      glVertex3f(-1,-1, 1)
      glVertex3f( 1,-1, 1)
  
      glColor3f(1.0, 1.0, 0.0)  # Amarillo
      glVertex3f( 1,-1,-1)
      glVertex3f(-1,-1,-1)
      glVertex3f(-1, 1,-1)
      glVertex3f( 1, 1,-1)
  
      glColor3f(1.0, 0.0, 1.0)  # Magenta
      glVertex3f(-1, 1, 1)
      glVertex3f(-1, 1,-1)
      glVertex3f(-1,-1,-1)
      glVertex3f(-1,-1, 1)
  
      glColor3f(0.0, 1.0, 1.0)  # Cyan
      glVertex3f( 1, 1,-1)
      glVertex3f( 1, 1, 1)
      glVertex3f( 1,-1, 1)
      glVertex3f( 1,-1,-1)
  
      glEnd()
      glFlush()
  
      glfw.swap_buffers(window)  # Intercambiar buffers para animación suave
      angle += 1  # Incrementar el ángulo para rotación
  
  def main():
      global window
  
      # Inicializar GLFW
      if not glfw.init():
          sys.exit()
  
      # Crear ventana de GLFW
      width, height = 500, 500
      window = glfw.create_window(width, height, "Cubo 3D Rotando con GLFW", None, None)
      if not window:
          glfw.terminate()
          sys.exit()
  
      # Configurar el contexto de OpenGL en la ventana
      glfw.make_context_current(window)
  
      # Configuración de viewport y OpenGL
      glViewport(0, 0, width, height)
      init()
  
      # Bucle principal
      while not glfw.window_should_close(window):
          draw_cube()
          glfw.poll_events()
  
      glfw.terminate()  # Cerrar GLFW al salir
  
  if __name__ == "__main__":
      main()
  
  

  import glfw
  from OpenGL.GL import glClearColor, glEnable, glClear, glLoadIdentity, glTranslatef, glRotatef, glMatrixMode
  from OpenGL.GL import glBegin, glColor3f, glVertex3f, glEnd, glFlush, glViewport
  from OpenGL.GL import GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_DEPTH_TEST, GL_QUADS, GL_PROJECTION, GL_MODELVIEW
  from OpenGL.GLU import gluPerspective
  import sys
  
  # Variables globales
  window = None
  angle_x, angle_y = 0, 0  # Ángulos de rotación en los ejes X e Y
  last_x, last_y = None, None  # Última posición del ratón para calcular la diferencia
  
  def init():
      # Configuración inicial de OpenGL
      glClearColor(0.0, 0.0, 0.0, 1.0)  # Color de fondo
      glEnable(GL_DEPTH_TEST)  # Activar prueba de profundidad para 3D
  
      # Configuración de proyección
      glMatrixMode(GL_PROJECTION)
      glLoadIdentity()
      gluPerspective(45, 1.0, 0.1, 50.0)
  
      # Cambiar a la matriz de modelo para los objetos
      glMatrixMode(GL_MODELVIEW)
  
  def draw_cube():
      global angle_x, angle_y
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)  # Limpiar pantalla y buffer de profundidad
  
      # Configuración de la vista del cubo
      glLoadIdentity()
      glTranslatef(0.0, 0.0, -5)  # Alejar el cubo para que sea visible
      glRotatef(angle_x, 1, 0, 0)   # Rotar el cubo en el eje X
      glRotatef(angle_y, 0, 1, 0)   # Rotar el cubo en el eje Y
  
      glBegin(GL_QUADS)  # Iniciar el cubo como un conjunto de caras (quads)
  
      # Cada conjunto de cuatro vértices representa una cara del cubo
      glColor3f(1.0, 0.0, 0.0)  # Rojo
      glVertex3f( 1, 1,-1)
      glVertex3f(-1, 1,-1)
      glVertex3f(-1, 1, 1)
      glVertex3f( 1, 1, 1)
  
      glColor3f(0.0, 1.0, 0.0)  # Verde
      glVertex3f( 1,-1, 1)
      glVertex3f(-1,-1, 1)
      glVertex3f(-1,-1,-1)
      glVertex3f( 1,-1,-1)
  
      glColor3f(0.0, 0.0, 1.0)  # Azul
      glVertex3f( 1, 1, 1)
      glVertex3f(-1, 1, 1)
      glVertex3f(-1,-1, 1)
      glVertex3f( 1,-1, 1)
  
      glColor3f(1.0, 1.0, 0.0)  # Amarillo
      glVertex3f( 1,-1,-1)
      glVertex3f(-1,-1,-1)
      glVertex3f(-1, 1,-1)
      glVertex3f( 1, 1,-1)
  
      glColor3f(1.0, 0.0, 1.0)  # Magenta
      glVertex3f(-1, 1, 1)
      glVertex3f(-1, 1,-1)
      glVertex3f(-1,-1,-1)
      glVertex3f(-1,-1, 1)
  
      glColor3f(0.0, 1.0, 1.0)  # Cyan
      glVertex3f( 1, 1,-1)
      glVertex3f( 1, 1, 1)
      glVertex3f( 1,-1, 1)
      glVertex3f( 1,-1,-1)
  
      glEnd()
      glFlush()
  
      glfw.swap_buffers(window)  # Intercambiar buffers para animación suave
  
  def mouse_callback(window, xpos, ypos):
      global angle_x, angle_y, last_x, last_y
  
      # Si es la primera vez que movemos el ratón, inicializamos last_x y last_y
      if last_x is None or last_y is None:
          last_x, last_y = xpos, ypos
  
      # Calcular las diferencias en el movimiento del ratón
      dx = xpos - last_x
      dy = ypos - last_y
  
      # Ajustar los ángulos de rotación en función del movimiento del ratón
      angle_x += dy * 0.1  # El factor 0.1 ajusta la sensibilidad
      angle_y += dx * 0.1
  
      # Actualizar las posiciones anteriores del ratón
      last_x, last_y = xpos, ypos
  
  def main():
      global window
  
      # Inicializar GLFW
      if not glfw.init():
          sys.exit()
  
      # Crear ventana de GLFW
      width, height = 500, 500
      window = glfw.create_window(width, height, "Cubo 3D Controlado por Ratón", None, None)
      if not window:
          glfw.terminate()
          sys.exit()
  
      # Configurar el contexto de OpenGL en la ventana
      glfw.make_context_current(window)
      glViewport(0, 0, width, height)
      init()
  
      # Configurar el callback de ratón
      glfw.set_cursor_pos_callback(window, mouse_callback)
  
      # Bucle principal
      while not glfw.window_should_close(window):
          draw_cube()
          glfw.poll_events()
  
      glfw.terminate()  # Cerrar GLFW al salir
  
  if __name__ == "__main__":
      main()
  
  
  

  import glfw
  from OpenGL.GL import *
  from OpenGL.GLU import gluPerspective
  import numpy as np
  import sys
  
  # Variables globales para el ángulo de rotación
  window = None
  angle_x, angle_y = 0.0, 0.0  # Ángulos de rotación en los ejes X e Y
  last_x, last_y = None, None  # Última posición del ratón para calcular la diferencia
  
  # Parámetros del toroide
  R = 1.0  # Radio mayor (distancia del centro del tubo al centro del toroide)
  r = 0.4  # Radio menor (radio del tubo)
  num_major = 30  # Segmentos en el círculo mayor
  num_minor = 15  # Segmentos en el círculo menor
  
  def init():
      # Configuración inicial de OpenGL
      glClearColor(0.0, 0.0, 0.0, 1.0)  # Color de fondo
      glEnable(GL_DEPTH_TEST)  # Activar prueba de profundidad para 3D
  
      # Configuración de proyección
      glMatrixMode(GL_PROJECTION)
      glLoadIdentity()
      gluPerspective(45, 1.0, 0.1, 50.0)
  
      # Cambiar a la matriz de modelo para los objetos
      glMatrixMode(GL_MODELVIEW)
  
  def draw_torus():
      global angle_x, angle_y
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)  # Limpiar pantalla y buffer de profundidad
  
      # Configuración de la vista del toroide
      glLoadIdentity()
      glTranslatef(0.0, 0.0, -5)  # Alejar el toroide para que sea visible
      glRotatef(angle_x, 1, 0, 0)   # Rotar el toroide en el eje X
      glRotatef(angle_y, 0, 1, 0)   # Rotar el toroide en el eje Y
  
      # Dibujar el toroide utilizando segmentos
      for i in range(num_major):
          theta = 2 * np.pi * i / num_major
          next_theta = 2 * np.pi * (i + 1) / num_major
  
          glBegin(GL_QUAD_STRIP)
          for j in range(num_minor + 1):
              phi = 2 * np.pi * j / num_minor
              cos_theta, sin_theta = np.cos(theta), np.sin(theta)
              cos_next_theta, sin_next_theta = np.cos(next_theta), np.sin(next_theta)
              cos_phi, sin_phi = np.cos(phi), np.sin(phi)
  
              # Color dinámico para variación visual
              glColor3f((i % 2) * 0.5 + 0.5, (j % 2) * 0.5 + 0.5, 0.5)
  
              # Primera esquina
              x = (R + r * cos_phi) * cos_theta
              y = r * sin_phi
              z = (R + r * cos_phi) * sin_theta
              glVertex3f(x, y, z)
  
              # Segunda esquina
              x = (R + r * cos_phi) * cos_next_theta
              z = (R + r * cos_phi) * sin_next_theta
              glVertex3f(x, y, z)
  
          glEnd()
  
      glfw.swap_buffers(window)  # Intercambiar buffers para animación suave
  
  def mouse_callback(window, xpos, ypos):
      global angle_x, angle_y, last_x, last_y
  
      # Si es la primera vez que movemos el ratón, inicializamos last_x y last_y
      if last_x is None or last_y is None:
          last_x, last_y = xpos, ypos
  
      # Calcular las diferencias en el movimiento del ratón
      dx = xpos - last_x
      dy = ypos - last_y
  
      # Ajustar los ángulos de rotación en función del movimiento del ratón
      angle_x += dy * 0.2  # Factor de sensibilidad en Y
      angle_y += dx * 0.2  # Factor de sensibilidad en X
  
      # Actualizar las posiciones anteriores del ratón
      last_x, last_y = xpos, ypos
  
  def main():
      global window
  
      # Inicializar GLFW
      if not glfw.init():
          sys.exit()
  
      # Crear ventana de GLFW
      width, height = 500, 500
      window = glfw.create_window(width, height, "Toroide 3D Controlado por Ratón", None, None)
      if not window:
          glfw.terminate()
          sys.exit()
  
      # Configurar el contexto de OpenGL en la ventana
      glfw.make_context_current(window)
      glViewport(0, 0, width, height)
      init()
  
      # Configurar el callback de ratón
      glfw.set_cursor_pos_callback(window, mouse_callback)
  
      # Bucle principal
      while not glfw.window_should_close(window):
          draw_torus()
          glfw.poll_events()
  
      glfw.terminate()  # Cerrar GLFW al salir
  
  if __name__ == "__main__":
      main()
  
  

  import glfw
  from OpenGL.GL import *
  from OpenGL.GLU import gluNewQuadric, gluSphere, gluPerspective
  import sys
  import math
  
  # Variables globales para el ángulo de rotación y posición de la esfera
  window = None
  rotation_angle = 0.0  # Ángulo de rotación de la esfera
  movement_offset = 0.0  # Offset para el movimiento de vaivén
  movement_speed = 0.05  # Velocidad del movimiento de vaivén
  movement_direction = 1  # Dirección del movimiento (1 a la derecha, -1 a la izquierda)
  
  def init():
      glClearColor(0.5, 0.8, 1.0, 1.0)  # Fondo negro
      glEnable(GL_DEPTH_TEST)            # Activar prueba de profundidad
      glEnable(GL_LIGHTING)              # Activar iluminación
      glEnable(GL_LIGHT0)                # Activar la luz 0
  
      # Configuración de la perspectiva
      glMatrixMode(GL_PROJECTION)
      gluPerspective(45, 1.0, 0.1, 50.0)
      glMatrixMode(GL_MODELVIEW)
  
      # Configuración de la luz
      light_pos = [1.0, 1.0, 1.0, 0.0]  # Posición de la luz
      light_color = [1.0, 1.0, 1.0, 1.0]  # Color de la luz blanca
      ambient_light = [0.2, 0.2, 0.2, 1.0]  # Luz ambiental
  
      glLightfv(GL_LIGHT0, GL_POSITION, light_pos)
      glLightfv(GL_LIGHT0, GL_DIFFUSE, light_color)
      glLightfv(GL_LIGHT0, GL_AMBIENT, ambient_light)
  
      # Configuración de las propiedades de material
      material_diffuse = [1, 0.2, 1.0, 0.0]  # Color difuso (azul claro)
      glMaterialfv(GL_FRONT, GL_DIFFUSE, material_diffuse)
  
  def draw_sphere(radius=1, slices=32, stacks=32):
      global rotation_angle, movement_offset
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
      glLoadIdentity()
      glTranslatef(movement_offset, 0.0, -50)      # Mover la esfera en vaivén
      glRotatef(rotation_angle, 0, 1, 0)  # Rotar la esfera sobre su eje Y
  
      quadric = gluNewQuadric()
      gluSphere(quadric, radius, slices, stacks)  # Dibujar la esfera
  
      glfw.swap_buffers(window)
  
  def update_motion():
      global rotation_angle, movement_offset, movement_direction
  
      # Actualizar el ángulo de rotación
      rotation_angle += 1
      if rotation_angle >= 360:
          rotation_angle = 0  # Reiniciar el ángulo después de una vuelta completa
  
      # Actualizar el movimiento de vaivén
      movement_offset += movement_speed * movement_direction
      if movement_offset > 3.0:       # Limite derecho
          movement_direction = -1     # Cambiar dirección hacia la izquierda
      elif movement_offset < -3.0:    # Limite izquierdo
          movement_direction = 1      # Cambiar dirección hacia la derecha
  
  def main():
      global window
  
      # Inicializar GLFW
      if not glfw.init():
          sys.exit()
      
      # Crear ventana de GLFW
      width, height = 500, 500
      window = glfw.create_window(width, height, "Esfera en Movimiento y Rotación", None, None)
      if not window:
          glfw.terminate()
          sys.exit()
  
      glfw.make_context_current(window)
      glViewport(0, 0, width, height)
      init()
  
      # Bucle principal
      while not glfw.window_should_close(window):
          draw_sphere()
          update_motion()  # Actualizar el movimiento y rotación
          glfw.poll_events()
  
      glfw.terminate()
  
  if __name__ == "__main__":
      main()
  
  

  import glfw
  from OpenGL.GL import *
  from OpenGL.GLU import gluNewQuadric, gluSphere, gluPerspective, gluCylinder
  import sys
  
  def init():
      glClearColor(0.5, 0.7, 1.0, 1.0)  # Fondo de cielo
      glEnable(GL_DEPTH_TEST)
  
      # Configuración de la perspectiva
      glMatrixMode(GL_PROJECTION)
      gluPerspective(45, 1.0, 0.1, 50.0)
      glMatrixMode(GL_MODELVIEW)
  
  def draw_sphere(radius=1, x=0, y=0, z=0):
      glPushMatrix()
      glTranslatef(x, y, z)
      quadric = gluNewQuadric()
      gluSphere(quadric, radius, 32, 32)
      glPopMatrix()
  
  def draw_cone(base=0.1, height=0.5, x=0, y=0, z=0):
      glPushMatrix()
      glTranslatef(x, y, z)
      glRotatef(-90, 1, 0, 0)  # Orientar el cono hacia adelante
      quadric = gluNewQuadric()
      gluCylinder(quadric, base, 0, height, 32, 32)
      glPopMatrix()
  
  def draw_snowman():
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
      glLoadIdentity()
      glTranslatef(0.0, -1.5, -8)  # Alejar al muñeco de nieve
  
      # Cuerpo
      glColor3f(1, 1, 1)
      draw_sphere(1.0, 0, 0, 0)     # Base
      draw_sphere(0.75, 0, 1.2, 0)  # Cuerpo medio
      draw_sphere(0.5, 0, 2.2, 0)   # Cabeza
  
      # Ojos
      glColor3f(0, 0, 0)
      draw_sphere(0.05, -0.15, 2.3, 0.4)  # Ojo izquierdo
      draw_sphere(0.05, 0.15, 2.3, 0.4)   # Ojo derecho
  
      # Nariz (cono)
      glColor3f(1, 0.5, 0)  # Color naranja
      draw_cone(0.05, 0.2, 0, 2.2, 0.5)  # Nariz
  
      glfw.swap_buffers(window)
  
  def main():
      if not glfw.init():
          sys.exit()
      
      global window
      window = glfw.create_window(500, 500, "Muñeco de Nieve en OpenGL", None, None)
      if not window:
          glfw.terminate()
          sys.exit()
  
      glfw.make_context_current(window)
      init()
  
      while not glfw.window_should_close(window):
          draw_snowman()
          glfw.poll_events()
  
      glfw.terminate()
  
  if __name__ == "__main__":
      main()
  

  import glfw
  from OpenGL.GL import *
  from OpenGL.GLU import gluNewQuadric, gluSphere, gluPerspective, gluCylinder
  import sys
  import math
  
  # Variables globales
  window = None
  jump_offset = 0.0       # Para el movimiento de salto vertical
  jump_speed = 0.05       # Velocidad del salto
  jump_direction = 1      # Dirección del salto (1 hacia arriba, -1 hacia abajo)
  rotation_angle = 0.0    # Ángulo de rotación del muñeco de nieve
  
  def init():
      glClearColor(0.5, 0.7, 1.0, 1.0)  # Fondo de cielo
      glEnable(GL_DEPTH_TEST)
  
      # Configuración de la perspectiva
      glMatrixMode(GL_PROJECTION)
      gluPerspective(45, 1.0, 0.1, 50.0)
      glMatrixMode(GL_MODELVIEW)
  
  def draw_sphere(radius=1, x=0, y=0, z=0):
      glPushMatrix()
      glTranslatef(x, y, z)
      quadric = gluNewQuadric()
      gluSphere(quadric, radius, 32, 32)
      glPopMatrix()
  
  def draw_cone(base=0.1, height=0.5, x=0, y=0, z=0):
      glPushMatrix()
      glTranslatef(x, y, z)
      glRotatef(-90, 1, 0, 0)  # Orientar el cono hacia adelante
      quadric = gluNewQuadric()
      gluCylinder(quadric, base, 0, height, 32, 32)
      glPopMatrix()
  
  def draw_snowman():
      global jump_offset, rotation_angle
  
      # Limpiar la pantalla y la profundidad
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
      glLoadIdentity()
  
      # Configurar posición de la cámara
      glTranslatef(0.0 + jump_offset, -1.5 , -8)  # Posición del muñeco de nieve y altura
      glRotatef(rotation_angle, 0, 0, 1)  # Rotación en el eje Y
  
      # Cuerpo
      glColor3f(1, 1, 1)
      draw_sphere(1.0, 0, 0, 0)     # Base
      draw_sphere(0.75, 0, 1.2, 0)  # Cuerpo medio
      draw_sphere(0.5, 0, 2.2, 0)   # Cabeza
  
      # Ojos
      glColor3f(0, 0, 0)
      draw_sphere(0.05, -0.15, 2.3, 0.4)  # Ojo izquierdo
      draw_sphere(0.05, 0.15, 2.3, 0.4)   # Ojo derecho
  
      # Nariz (cono)
      glColor3f(1, 0.5, 0)  # Color naranja
      draw_cone(0.05, 0.2, 0, 2.2, 0.5)  # Nariz
  
      glfw.swap_buffers(window)
  
  def update_motion():
      global jump_offset, jump_direction, rotation_angle
  
      # Actualizar el ángulo de rotación
      rotation_angle += 1  # Incrementa para que el muñeco gire
      if rotation_angle >= 360:
          rotation_angle = 0  # Reiniciar el ángulo después de una vuelta completa
  
      # Actualizar el movimiento de salto
      jump_offset += jump_speed * jump_direction
      if jump_offset > 1.0:        # Limite superior del salto
          jump_direction = -1      # Cambiar dirección hacia abajo
      elif jump_offset < 0.0:      # Limite inferior del salto
          jump_direction = 1       # Cambiar dirección hacia arriba
  
  def main():
      global window
  
      # Inicializar GLFW
      if not glfw.init():
          sys.exit()
      
      # Crear ventana de GLFW
      width, height = 500, 500
      window = glfw.create_window(width, height, "Muñeco de Nieve en Movimiento", None, None)
      if not window:
          glfw.terminate()
          sys.exit()
  
      glfw.make_context_current(window)
      glViewport(0, 0, width, height)
      init()
  
      # Bucle principal
      while not glfw.window_should_close(window):
          draw_snowman()
          update_motion()  # Actualizar el movimiento en cada cuadro
          glfw.poll_events()
  
      glfw.terminate()
  
  if __name__ == "__main__":
      main()