CheatSheet de OpenCV

Para instalar OpenCV en Python, utiliza pip:

pip install opencv-python
pip install opencv-python-headless  # Sin GUI

Leer una imagen

Puedes cargar imágenes utilizando la función cv2.imread():

import cv2

imagen = cv2.imread('ruta/a/la/imagen.jpg')

Mostrar una imagen

Para mostrar una imagen en una ventana:

cv2.imshow('Título de la Ventana', imagen)
cv2.waitKey(0)  # Espera hasta que se presione una tecla
cv2.destroyAllWindows()

Guardar una imagen

Para guardar una imagen modificada:

cv2.imwrite('ruta/a/la/nueva_imagen.jpg', imagen)

Convertir a escala de grises

Para convertir una imagen a escala de grises:

imagen_gris = cv2.cvtColor(imagen, cv2.COLOR_BGR2GRAY)

Convertir a otros espacios de color

Puedes convertir imágenes a diferentes espacios de color, como HSV:

imagen_hsv = cv2.cvtColor(imagen, cv2.COLOR_BGR2HSV)

Redimensionar una imagen

Para cambiar el tamaño de una imagen:

imagen_redimensionada = cv2.resize(imagen, (ancho, alto))

Rotar una imagen

Para rotar una imagen:

altura, ancho = imagen.shape[:2]
centro = (ancho // 2, altura // 2)
matriz_rotacion = cv2.getRotationMatrix2D(centro, angulo, 1.0)
imagen_rotada = cv2.warpAffine(imagen, matriz_rotacion, (ancho, altura))

Recortar una imagen

Para recortar una imagen a una región específica:

recorte = imagen[y:y+h, x:x+w]

Cambiar el brillo y el contraste

imagen_brillante = cv2.convertScaleAbs(imagen, alpha=1.2, beta=30)  # alpha: contraste, beta: brillo

Aplicar un filtro gaussiano

Para suavizar una imagen y reducir ruido:

imagen_suave = cv2.GaussianBlur(imagen, (5, 5), 0)

Filtro de mediana

Para eliminar el ruido mientras se preservan los bordes:

imagen_mediana = cv2.medianBlur(imagen, 5)

Captura de video desde una cámara

Para capturar video en tiempo real:

captura = cv2.VideoCapture(0)

while True:
    ret, frame = captura.read()
    cv2.imshow('Video en vivo', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

captura.release()
cv2.destroyAllWindows()

Leer video desde un archivo

captura = cv2.VideoCapture('ruta/al/video.mp4')

while True:
    ret, frame = captura.read()
    if not ret:
        break
    cv2.imshow('Video', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

captura.release()
cv2.destroyAllWindows()

Detección de bordes con Canny

Para detectar bordes en una imagen:

bordes = cv2.Canny(imagen_gris, umbral1, umbral2)

Encontrar contornos

Para detectar contornos en una imagen binaria:

contornos, _ = cv2.findContours(bordes, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

Dibujar contornos

Para dibujar contornos detectados en una imagen:

cv2.drawContours(imagen, contornos, -1, (0, 255, 0), 3)

Detección de esquinas

Para detectar esquinas (Harris Corner Detection) en una imagen:

esquinas = cv2.cornerHarris(imagen_gris, 2, 3, 0.04)

Detección de características con ORB

Usar ORB para detección de características

orb = cv2.ORB_create()
keypoints, descriptores = orb.detectAndCompute(imagen, None)
imagen_con_keypoints = cv2.drawKeypoints(imagen, keypoints, None, (0, 255, 0), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)

Uso de Haar Cascades

Para detectar objetos, como rostros, puedes usar clasificadores en cascada.

clasificador_rostro = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
rostros = clasificador_rostro.detectMultiScale(imagen_gris, scaleFactor=1.1, minNeighbors=5)

Dibujar rectángulos alrededor de los rostros detectados

for (x, y, w, h) in rostros:
    cv2.rectangle(imagen, (x, y), (x+w, y+h), (255, 0, 0), 2)

Segmentación con k-means

Z = imagen.reshape((-1, 3))
Z = np.float32(Z)
k = 8  # Número de colores
_, etiquetas, centros = cv2.kmeans(Z, k, None, (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 1.0), 10, cv2.KMEANS_RANDOM_CENTERS)
centros = np.uint8(centros)
imagen_segmentada = centros[etiquetas.flatten()].reshape(imagen.shape)

Detección de características avanzadas

sift = cv2.SIFT_create()
keypoints, descriptores = sift.detectAndCompute(imagen, None)

Uso de SVM para clasificación de imágenes

from sklearn import svm

# Suponiendo que tienes datos de entrenamiento X y etiquetas y
clf = svm.SVC()
clf.fit(X, y)

# Predicción
predicciones = clf.predict(nuevos_datos)