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:

  1. Proyectos de procesamiento de imágenes: como filtros de imagen, restauración de imágenes, mejora de imágenes, etc.

  2. Proyectos de detección y seguimiento de objetos: como detección de rostros, reconocimiento de matrículas, seguimiento de objetos en movimiento, etc.

  3. Proyectos de aprendizaje profundo: como clasificación de imágenes, detección de objetos, segmentación semántica, etc.

  4. 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

#include <opencv2/opencv.hpp>

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

#include <opencv2/opencv.hpp>

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 <opencv2/opencv.hpp>
#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:

  1. Cargar el modelo de clasificador en cascada Haar.

  2. Abrir la cámara o un archivo de video.

  3. Realizar detección de rostros en cada fotograma.

  4. Dibujar los resultados de detección y mostrarlos.

Ejemplo

#include <opencv2/opencv.hpp>
#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

#include <opencv2/opencv.hpp>

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

#include <opencv2/opencv.hpp>

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

#include <opencv2/opencv.hpp>

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/opencv.hpp>
#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:

  1. Cargar el modelo YOLO y los archivos de configuración.

  2. Cargar las etiquetas de clases.

  3. Preprocesar la imagen de entrada.

  4. Ejecutar el modelo y analizar los resultados de detección.

  5. Dibujar los cuadros de detección y mostrar los resultados.

Ejemplo

#include <opencv2/opencv.hpp>
#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:

  1. Abrir la cámara o un archivo de video.

  2. Aplicar efectos a cada fotograma.

  3. Mostrar el video procesado.

Ejemplo

#include <opencv2/opencv.hpp>
#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;
}
Otras extensiones