C++ OpenCV Procesamiento de Imágenes

Filtrado de imágenes

El filtrado de imágenes es una operación básica en el procesamiento de imágenes, utilizada principalmente para eliminar el ruido de la imagen o realzar ciertas características de la misma. Los métodos de filtrado más comunes incluyen el filtro de promedio, el filtro gaussiano, el filtro de mediana y los filtros personalizados.

Filtro de promedio

El filtro de promedio es un método de filtrado lineal simple que reemplaza el valor de cada píxel de la imagen por el valor promedio de todos los píxeles en su vecindad. Este método puede eliminar el ruido de manera efectiva, pero también hace que la imagen se vuelva borrosa.

cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
cv::Mat dst;
cv::blur(src, dst, cv::Size(3, 3));  // 3x3的均值滤波

Filtro gaussiano

El filtro gaussiano es un método de filtrado no lineal que utiliza la función gaussiana para calcular los pesos de los píxeles en la vecindad, logrando así un suavizado de la imagen. El filtro gaussiano, mientras elimina el ruido, puede preservar mejor la información de los bordes de la imagen.

cv::GaussianBlur(src, dst, cv::Size(5, 5), 0);  // 5x5的高斯滤波

Filtro de mediana

El filtro de mediana es un método de filtrado no lineal que reemplaza el valor de cada píxel de la imagen por la mediana de todos los valores de píxeles en su vecindad. Este método es muy eficaz para eliminar el ruido de sal y pimienta.

cv::medianBlur(src, dst, 5);  // 5x5的中值滤波

Filtro personalizado

OpenCV permite a los usuarios personalizar el núcleo del filtro. Mediantecv::filter2Dla función se puede implementar la operación de filtrado personalizado.

cv::Mat kernel = (cv::Mat_<float>(3, 3) << 1, 0, -1, 0, 0, 0, -1, 0, 1);
cv::filter2D(src, dst, -1, kernel);

Detección de bordes de imágenes

La detección de bordes es una tarea importante en el procesamiento de imágenes, utilizada para identificar los límites de los objetos en una imagen. Los métodos de detección de bordes más comunes incluyen el operador Sobel y la detección de bordes Canny.

Operador Sobel

El operador Sobel es un método de detección de bordes basado en gradientes, que puede detectar bordes horizontales y verticales en la imagen.

cv::Mat grad_x, grad_y;
cv::Sobel(src, grad_x, CV_16S, 1, 0);  // 水平方向
cv::Sobel(src, grad_y, CV_16S, 0, 1);  // 垂直方向
cv::convertScaleAbs(grad_x, grad_x);
cv::convertScaleAbs(grad_y, grad_y);
cv::addWeighted(grad_x, 0.5, grad_y, 0.5, 0, dst);  // 合并结果

Detección de bordes Canny

La detección de bordes Canny es un algoritmo de detección de bordes de múltiples etapas que puede detectar eficazmente los bordes de la imagen y es altamente robusto frente al ruido.

cv::Canny(src, dst, 100, 200);  // 阈值1=100,阈值2=200

Operaciones morfológicas de imágenes

Las operaciones morfológicas son una serie de operaciones basadas en la forma de la imagen, comúnmente utilizadas para tareas como la separación de primer plano y fondo, y la eliminación de ruido. Las operaciones morfológicas más comunes incluyen erosión, dilatación, apertura, cierre y gradiente morfológico.

Erosión

La operación de erosión puede eliminar pequeños objetos o detalles en la imagen, haciendo que los objetos del primer plano se vuelvan más pequeños.

cv::Mat kernel = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(3, 3));
cv::erode(src, dst, kernel);

Dilatación

La operación de dilatación puede expandir los objetos del primer plano en la imagen y se utiliza a menudo para rellenar huecos en los objetos del primer plano.

cv::dilate(src, dst, kernel);

Apertura

La apertura es una operación que primero erosiona y luego dilata, comúnmente utilizada para eliminar objetos pequeños o ruido.

cv::morphologyEx(src, dst, cv::MORPH_OPEN, kernel);

Cierre

El cierre es una operación que primero dilata y luego erosiona, comúnmente utilizada para rellenar pequeños agujeros en los objetos del primer plano.

cv::morphologyEx(src, dst, cv::MORPH_CLOSE, kernel);

Gradiente morfológico

El gradiente morfológico es la diferencia entre la dilatación y la erosión, y se puede utilizar para extraer los bordes de los objetos.

cv::morphologyEx(src, dst, cv::MORPH_GRADIENT, kernel);

Umbralización de imágenes

La umbralización de imágenes es el proceso de convertir una imagen en una imagen binaria, comúnmente utilizada en la segmentación de imágenes. Los métodos de umbralización más comunes incluyen la binarización, el umbral adaptativo y el método de umbral de Otsu.

Binarización

La binarización divide los valores de píxeles de la imagen en dos categorías según un umbral establecido, y generalmente se utiliza para la segmentación simple de imágenes.

cv::threshold(src, dst, 127, 255, cv::THRESH_BINARY);

Umbral adaptativo

El umbral adaptativo calcula dinámicamente el umbral según las regiones locales de la imagen, siendo adecuado para imágenes con iluminación no uniforme.

cv::adaptiveThreshold(src, dst, 255, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, 11, 2);

Método de umbral de Otsu

El método de umbral de Otsu es un método para determinar automáticamente el umbral, adecuado para imágenes con histogramas bimodales.

cv::threshold(src, dst, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);

Histograma de imágenes

El histograma es una herramienta utilizada en el procesamiento de imágenes para analizar la distribución de brillo de la imagen. Las operaciones comunes con histogramas incluyen el cálculo del histograma, la ecualización del histograma y la comparación de histogramas.

Cálculo del histograma

El histograma puede reflejar la distribución de los valores de píxeles en la imagen.

cv::Mat hist;
int histSize = 256;
float range[] = {0, 256};
const float* histRange = {range};
cv::calcHist(&src, 1, 0, cv::Mat(), hist, 1, &histSize, &histRange);

Ecualización del histograma

La ecualización del histograma puede mejorar el contraste de la imagen, haciendo que la distribución de brillo sea más uniforme.

cv::equalizeHist(src, dst);

Comparación de histogramas

La comparación de histogramas se puede utilizar para comparar la similitud entre dos imágenes.

double compare = cv::compareHist(hist1, hist2, cv::HISTCMP_CORREL);

Ejemplo

Las operaciones comunes de procesamiento de imágenes en OpenCV incluyen filtrado, detección de bordes, umbralización, operaciones morfológicas y detección de contornos. Con estas técnicas, puedes realizar tareas de procesamiento de imágenes más complejas.

A continuación se muestran las operaciones comunes de procesamiento de imágenes en C++ OpenCV y sus ejemplos de código:

1. Filtrado de imágenes

El filtrado de imágenes se utiliza para eliminar ruido o realzar características de la imagen.

1.1 Filtro de promedio

Ejemplo

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    Mat image = imread("test.jpg");
    if (image.empty()) {
        cout << "Error: no se puede cargar la imagen, verifique que la ruta sea correcta." << endl;
        return -1;
    }

    // Filtro de promedio
    Mat blurredImage;
    blur(image, blurredImage, Size(5, 5)); // Núcleo de 5x5

    imshow("Original Image", image);
    imshow("Blurred Image", blurredImage);
    waitKey(0);
    destroyAllWindows();

    return 0;
}

1.2 Filtro gaussiano

Ejemplo

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    Mat image = imread("test.jpg");
    if (image.empty()) {
        cout << "Error: no se puede cargar la imagen, verifique que la ruta sea correcta." << endl;
        return -1;
    }

    // Filtro gaussiano
    Mat gaussianBlurredImage;
    GaussianBlur(image, gaussianBlurredImage, Size(5, 5), 0); // Núcleo de 5x5

    imshow("Original Image", image);
    imshow("Gaussian Blurred Image", gaussianBlurredImage);
    waitKey(0);
    destroyAllWindows();

    return 0;
}

1.3 Filtro de mediana

Ejemplo

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    Mat image = imread("test.jpg");
    if (image.empty()) {
        cout << "Error: no se puede cargar la imagen, verifique que la ruta sea correcta." << endl;
        return -1;
    }

    // Filtro de mediana
    Mat medianBlurredImage;
    medianBlur(image, medianBlurredImage, 5); // Tamaño del núcleo: 5

    imshow("Original Image", image);
    imshow("Median Blurred Image", medianBlurredImage);
    waitKey(0);
    destroyAllWindows();

    return 0;
}

2. Detección de bordes

La detección de bordes se utiliza para extraer la información de bordes de la imagen.

2.1 Detección de bordes Canny

Ejemplo

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    Mat image = imread("test.jpg");
    if (image.empty()) {
        cout << "Error: no se puede cargar la imagen, verifique que la ruta sea correcta." << endl;
        return -1;
    }

    // Convertir a imagen en escala de grises
    Mat grayImage;
    cvtColor(image, grayImage, COLOR_BGR2GRAY);

    // Detección de bordes Canny
    Mat edges;
    Canny(grayImage, edges, 100, 200); // Umbral 1 y umbral 2

    imshow("Original Image", image);
    imshow("Canny Edges", edges);
    waitKey(0);
    destroyAllWindows();

    return 0;
}

3. Umbralización de imágenes

La umbralización se utiliza para convertir la imagen en una imagen binaria.

3.1 Umbralización simple

Ejemplo

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    Mat image = imread("test.jpg");
    if (image.empty()) {
        cout << "Error: no se puede cargar la imagen, verifique que la ruta sea correcta." << endl;
        return -1;
    }

    // Convertir a imagen en escala de grises
    Mat grayImage;
    cvtColor(image, grayImage, COLOR_BGR2GRAY);

    // Umbralización simple
    Mat binaryImage;
    threshold(grayImage, binaryImage, 127, 255, THRESH_BINARY);

    imshow("Original Image", image);
    imshow("Binary Image", binaryImage);
    waitKey(0);
    destroyAllWindows();

    return 0;
}

3.2 Umbralización adaptativa

Ejemplo

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    Mat image = imread("test.jpg");
    if (image.empty()) {
        cout << "Error: no se puede cargar la imagen, verifique que la ruta sea correcta." << endl;
        return -1;
    }

    // Convertir a imagen en escala de grises
    Mat grayImage;
    cvtColor(image, grayImage, COLOR_BGR2GRAY);

    // Umbralización adaptativa
    Mat adaptiveBinaryImage;
    adaptiveThreshold(grayImage, adaptiveBinaryImage, 255, ADAPTIVE_THRESH_MEAN_C, THRESH_BINARY, 11, 2);

    imshow("Original Image", image);
    imshow("Adaptive Binary Image", adaptiveBinaryImage);
    waitKey(0);
    destroyAllWindows();

    return 0;
}

4. Operaciones morfológicas

Las operaciones morfológicas se utilizan para procesar la forma y la estructura de las imágenes.

4.1 Erosión y dilatación

Ejemplo

#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    Mat image = imread("test.jpg");
    if (image.empty()) {
        cout << "Error: no se puede cargar la imagen, verifique que la ruta sea correcta." << endl;
        return -1;
    }

    // Convertir a imagen en escala de grises
    Mat grayImage;
    cvtColor(image, grayImage, COLOR_BGR2GRAY);

    // Binarización
    Mat binaryImage;
    threshold(grayImage, binaryImage, 127, 255, THRESH_BINARY);

    // Operación de erosión
    Mat erodedImage;
    Mat kernel = getStructuringElement(MORPH_RECT, Size(5, 5));
    erode(binaryImage, erodedImage, kernel);

    // Operación de dilatación
    Mat dilatedImage;
    dilate(binaryImage, dilatedImage, kernel);

    imshow("Original Image", image);
    imshow("Eroded Image", erodedImage);
    imshow("Dilated Image", dilatedImage);
    waitKey(0);
    destroyAllWindows();

    return 0;
}

5. Detección de contornos

La detección de contornos se utiliza para extraer los contornos de los objetos en la imagen.

Ejemplo


#include <opencv2/opencv.hpp>
#include <iostream>

using namespace cv;
using namespace std;

int main() {
    Mat image = imread("test.jpg");
    if (image.empty()) {
        cout << "Error: no se puede cargar la imagen, verifique que la ruta sea correcta." << endl;
        return -1;
    }

    // Convertir a imagen en escala de grises
    Mat grayImage;
    cvtColor(image, grayImage, COLOR_BGR2GRAY);

    // Binarización
    Mat binaryImage;
    threshold(grayImage, binaryImage, 127, 255, THRESH_BINARY);

    // Encontrar contornos
    vector<vector<Point>> contours;
    vector<Vec4i> hierarchy;
    findContours(binaryImage, contours, hierarchy, RETR_TREE, CHAIN_APPROX_SIMPLE);

    // Dibujar contornos
    Mat contourImage = Mat::zeros(image.size(), CV_8UC3);
    for (size_t i = 0; i < contours.size(); i++) {
        drawContours(contourImage, contours, i, Scalar(0, 255, 0), 2);
    }

    imshow("Original Image", image);
    imshow("Contours", contourImage);
    waitKey(0);
    destroyAllWindows();

    return 0;
}
Otras extensiones