C++ OpenCV Proyectos Prácticos
Los proyectos prácticos de OpenCV son el proceso de aplicar el conocimiento teórico a problemas reales.
A través de proyectos prácticos, se pueden consolidar las habilidades de uso de OpenCV y resolver problemas reales de visión por computadora.
A continuación se presentan los tipos comunes de proyectos de OpenCV:
Proyectos de procesamiento de imágenes: como filtros de imagen, restauración de imágenes, mejora de imágenes, etc.
Proyectos de detección y seguimiento de objetos: como detección de rostros, reconocimiento de matrículas, seguimiento de objetos en movimiento, etc.
Proyectos de aprendizaje profundo: como clasificación de imágenes, detección de objetos, segmentación semántica, etc.
Proyectos de procesamiento de video: como análisis de video, procesamiento de video en tiempo real, efectos de video, etc.
Proyectos simples
Aplicación de filtros de imagen
Los filtros de imagen son una de las operaciones básicas en el procesamiento de imágenes. Aplicando diferentes filtros, se puede cambiar la apariencia y el estilo de una imagen.
OpenCV proporciona una amplia variedad de funciones para implementar diversos efectos de filtro de imagen.
Filtro de escala de grises
El filtro de escala de grises es el proceso de convertir una imagen en color a una imagen en escala de grises. Una imagen en escala de grises tiene un solo canal, y el valor de cada píxel representa la luminosidad.
Ejemplo
int main() {
cv::Mat image = cv::imread("input.jpg");
cv::Mat grayImage;
cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
cv::imwrite("gray_output.jpg", grayImage);
return 0;
}
Desenfoque gaussiano
El desenfoque gaussiano es un filtro de desenfoque comúnmente utilizado que puede eliminar eficazmente el ruido en las imágenes.
Ejemplo
int main() {
cv::Mat image = cv::imread("input.jpg");
cv::Mat blurredImage;
cv::GaussianBlur(image, blurredImage, cv::Size(15, 15), 0);
cv::imwrite("blurred_output.jpg", blurredImage);
return 0;
}
El siguiente ejemplo implementa una aplicación de filtros de imagen que admite múltiples efectos de filtro (como escala de grises, desenfoque, detección de bordes, etc.).
Ejemplo
#include <iostream>
using namespace cv;
using namespace std;
int main() {
// Leer la imagen
Mat image = imread("image.jpg");
if (image.empty()) {
cout << "Error: no se pudo cargar la imagen, verifique que la ruta sea correcta." << endl;
return -1;
}
// Convertir a escala de grises
Mat gray;
cvtColor(image, gray, COLOR_BGR2GRAY);
// Desenfoque gaussiano
Mat blurred;
GaussianBlur(image, blurred, Size(15, 15), 0);
// Detección de bordes
Mat edges;
Canny(image, edges, 100, 200);
// Mostrar el resultado
imshow("Original Image", image);
imshow("Gray Image", gray);
imshow("Blurred Image", blurred);
imshow("Edges", edges);
// Guardar el resultado
imwrite("gray_image.jpg", gray);
imwrite("blurred_image.jpg", blurred);
imwrite("edges.jpg", edges);
waitKey(0);
return 0;
}
Detección de rostros en tiempo real
La detección de rostros en tiempo real es una aplicación importante en la visión por computadora.
OpenCV proporciona clasificadores en cascada Haar preentrenados, que se pueden utilizar para detectar rostros en imágenes o videos.
Pasos de implementación:
Cargar el modelo de clasificador en cascada Haar.
Abrir la cámara o un archivo de video.
Realizar detección de rostros en cada fotograma.
Dibujar los resultados de detección y mostrarlos.
Ejemplo
#include <iostream>
using namespace cv;
using namespace std;
int main() {
// Cargar el clasificador en cascada Haar
CascadeClassifier faceCascade;
if (!faceCascade.load("haarcascade_frontalface_default.xml")) {
cout << "Error: ¡no se pudo cargar el clasificador en cascada Haar!" << endl;
return -1;
}
// Abrir la cámara
VideoCapture cap(0);
if (!cap.isOpened()) {
cout << "Error: ¡no se pudo abrir la cámara!" << endl;
return -1;
}
// Detectar rostros en tiempo real
Mat frame;
while (true) {
cap >> frame;
if (frame.empty()) break;
// Convertir a imagen en escala de grises
Mat gray;
cvtColor(frame, gray, COLOR_BGR2GRAY);
// Detectar rostros
vector<Rect> faces;
faceCascade.detectMultiScale(gray, faces, 1.1, 3, 0, Size(30, 30));
// Dibujar los resultados de detección
for (const auto& face : faces) {
rectangle(frame, face, Scalar(0, 255, 0), 2);
}
// Mostrar el resultado
imshow("Face Detection", frame);
// Presionar la tecla ESC para salir
if (waitKey(30) == 27) break;
}
// Liberar recursos
cap.release();
destroyAllWindows();
return 0;
}
Reconocimiento de matrículas
El reconocimiento de matrículas es una de las tecnologías clave en los sistemas de transporte inteligentes.
OpenCV se puede utilizar para la detección de matrículas y el reconocimiento de caracteres.
Ejemplo
int main() {
cv::Mat image = cv::imread("car.jpg");
cv::Mat grayImage;
cv::cvtColor(image, grayImage, cv::COLOR_BGR2GRAY);
cv::CascadeClassifier plateCascade;
plateCascade.load("haarcascade_russian_plate_number.xml");
std::vector<cv::Rect> plates;
plateCascade.detectMultiScale(grayImage, plates, 1.1, 2, 0 | cv::CASCADE_SCALE_IMAGE, cv::Size(30, 30));
for (const auto& plate : plates) {
cv::rectangle(image, plate, cv::Scalar(0, 255, 0), 2);
}
cv::imwrite("plate_output.jpg", image);
return 0;
}
Proyectos complejos
Aplicación de RA basada en OpenCV
La realidad aumentada (RA) es una tecnología que superpone información virtual al mundo real.
OpenCV se puede utilizar para implementar aplicaciones simples de RA, como superponer objetos virtuales en una imagen.
Ejemplo
int main() {
cv::Mat image = cv::imread("background.jpg");
cv::Mat overlay = cv::imread("overlay.png", cv::IMREAD_UNCHANGED);
cv::resize(overlay, overlay, cv::Size(100, 100));
cv::Mat roi = image(cv::Rect(50, 50, overlay.cols, overlay.rows));
overlay.copyTo(roi, overlay);
cv::imwrite("ar_output.jpg", image);
return 0;
}
Videovigilancia y detección de movimiento
La videovigilancia y la detección de movimiento son funciones importantes en los sistemas de monitoreo de seguridad. OpenCV se puede utilizar para detectar objetos en movimiento en videos.
Ejemplo
int main() {
cv::VideoCapture cap(0);
if (!cap.isOpened()) {
std::cerr << "Error opening video stream" << std::endl;
return -1;
}
cv::Mat frame, prevFrame, diffFrame;
cap >> prevFrame;
cv::cvtColor(prevFrame, prevFrame, cv::COLOR_BGR2GRAY);
while (true) {
cap >> frame;
if (frame.empty()) break;
cv::Mat grayFrame;
cv::cvtColor(frame, grayFrame, cv::COLOR_BGR2GRAY);
cv::absdiff(grayFrame, prevFrame, diffFrame);
cv::threshold(diffFrame, diffFrame, 30, 255, cv::THRESH_BINARY);
cv::imshow("Motion Detection", diffFrame);
if (cv::waitKey(1) == 27) break; // ESC key to exit
prevFrame = grayFrame.clone();
}
cap.release();
cv::destroyAllWindows();
return 0;
}
Seguimiento de múltiples objetos
El seguimiento de múltiples objetos es un problema complejo en la visión por computadora que implica rastrear múltiples objetivos simultáneamente en un video. OpenCV proporciona varios algoritmos de seguimiento, como KCF, MIL y CSRT.
Ejemplo
#include <opencv2/tracking.hpp>
int main() {
cv::VideoCapture cap("video.mp4");
if (!cap.isOpened()) {
std::cerr << "Error opening video stream" << std::endl;
return -1;
}
cv::Ptr<cv::MultiTracker> multiTracker = cv::MultiTracker::create();
cv::Mat frame;
cap >> frame;
std::vector<cv::Rect> bboxes;
cv::selectROIs("Tracking", frame, bboxes);
for (const auto& bbox : bboxes) {
multiTracker->add(cv::TrackerKCF::create(), frame, bbox);
}
while (true) {
cap >> frame;
if (frame.empty()) break;
multiTracker->update(frame);
for (const auto& bbox : multiTracker->getObjects()) {
cv::rectangle(frame, bbox, cv::Scalar(255, 0, 0), 2);
}
cv::imshow("Multi-Object Tracking", frame);
if (cv::waitKey(1) == 27) break; // ESC key to exit
}
cap.release();
cv::destroyAllWindows();
return 0;
}
Proyecto de aprendizaje profundo: detección de objetos (YOLO)
Implementar la detección de objetos utilizando el modelo YOLO.
Pasos de implementación:
Cargar el modelo YOLO y los archivos de configuración.
Cargar las etiquetas de clases.
Preprocesar la imagen de entrada.
Ejecutar el modelo y analizar los resultados de detección.
Dibujar los cuadros de detección y mostrar los resultados.
Ejemplo
#include <opencv2/dnn.hpp>
#include <iostream>
using namespace cv;
using namespace dnn;
using namespace std;
int main() {
// Cargar el modelo YOLO
Net net = readNet("yolov3.weights", "yolov3.cfg");
if (net.empty()) {
cout << "Error: ¡no se pudo cargar el modelo YOLO!" << endl;
return -1;
}
// Cargar las etiquetas de clases
ifstream classNamesFile("coco.names");
vector<string> classNames;
string className;
while (getline(classNamesFile, className)) {
classNames.push_back(className);
}
// Cargar la imagen
Mat image = imread("image.jpg");
if (image.empty()) {
cout << "Error: no se pudo cargar la imagen, verifique que la ruta sea correcta." << endl;
return -1;
}
// Preprocesar la imagen
Mat blob = blobFromImage(image, 1 / 255.0, Size(416, 416), Scalar(0, 0, 0), true, false);
net.setInput(blob);
// Propagación hacia adelante
vector<Mat> outs;
net.forward(outs, net.getUnconnectedOutLayersNames());
// Analizar los resultados de detección
float confThreshold = 0.5; // Umbral de confianza
vector<int> classIds;
vector<float> confidences;
vector<Rect> boxes;
for (const auto& output : outs) {
for (int i = 0; i < output.rows; i++) {
Mat scores = output.row(i).colRange(5, output.cols);
Point classIdPoint;
double confidence;
minMaxLoc(scores, nullptr, &confidence, nullptr, &classIdPoint);
if (confidence > confThreshold) {
int centerX = static_cast<int>(output.at<float>(i, 0) * image.cols);
int centerY = static_cast<int>(output.at<float>(i, 1) * image.rows);
int width = static_cast<int>(output.at<float>(i, 2) * image.cols);
int height = static_cast<int>(output.at<float>(i, 3) * image.rows);
int left = centerX - width / 2;
int top = centerY - height / 2;
classIds.push_back(classIdPoint.x);
confidences.push_back(static_cast<float>(confidence));
boxes.push_back(Rect(left, top, width, height));
}
}
}
// Supresión de no máximos
float nmsThreshold = 0.4; // Umbral NMS
vector<int> indices;
NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices);
// Dibujar los resultados de detección
for (int idx : indices) {
Rect box = boxes[idx];
rectangle(image, box, Scalar(0, 255, 0), 2);
string label = format("%s: %.2f", classNames[classIds[idx]].c_str(), confidences[idx]);
putText(image, label, Point(box.x, box.y - 10), FONT_HERSHEY_SIMPLEX, 0.5, Scalar(0, 255, 0), 2);
}
// Mostrar el resultado
imshow("Object Detection", image);
waitKey(0);
return 0;
}
Proyecto de procesamiento de video: efectos de video en tiempo real
Implementar una aplicación de efectos de video en tiempo real que admita múltiples efectos (como detección de bordes, desenfoque, inversión de color, etc.).
Pasos de implementación:
Abrir la cámara o un archivo de video.
Aplicar efectos a cada fotograma.
Mostrar el video procesado.
Ejemplo
#include <iostream>
using namespace cv;
using namespace std;
int main() {
// Abrir la cámara
VideoCapture cap(0);
if (!cap.isOpened()) {
cout << "Error: ¡no se pudo abrir la cámara!" << endl;
return -1;
}
// Procesar fotogramas de video en tiempo real
Mat frame, edges;
while (true) {
cap >> frame;
if (frame.empty()) break;
// Detección de bordes
Canny(frame, edges, 100, 200);
// Mostrar el resultado
imshow("Original Frame", frame);
imshow("Edges", edges);
// Presionar la tecla ESC para salir
if (waitKey(30) == 27) break;
}
// Liberar recursos
cap.release();
destroyAllWindows();
return 0;
}