C++ OpenCV Procesamiento avanzado de imágenes

El procesamiento avanzado de imágenes se refiere a la realización de tareas más complejas sobre la base del procesamiento básico de imágenes (como filtrado, detección de bordes, etc.), como la segmentación de imágenes, la detección de contornos, las operaciones morfológicas, el procesamiento de histogramas, etc. Estas técnicas se aplican ampliamente en campos como la detección de objetos, el análisis de imágenes y el procesamiento de imágenes médicas.

Escenarios de aplicación del procesamiento avanzado de imágenes

Análisis de imágenes médicas:

  • Utilizar técnicas de segmentación de imágenes para extraer regiones patológicas.

  • Utilizar operaciones morfológicas para eliminar el ruido.

Detección y seguimiento de objetos:

  • Utilizar la detección de contornos y la coincidencia de plantillas para localizar objetos.

  • Utilizar el procesamiento de histogramas para mejorar las características de los objetos.

Mejora de imágenes:

  • Utilizar la ecualización del histograma para aumentar el contraste de la imagen.

  • Utilizar el algoritmo de watershed para separar objetos superpuestos.


Segmentación de imágenes

La segmentación de imágenes es un paso importante en el procesamiento de imágenes; divide la imagen en múltiples regiones u objetos para facilitar su posterior análisis y procesamiento. Los métodos comunes de segmentación de imágenes incluyen la segmentación basada en umbral, la segmentación basada en bordes y la segmentación basada en regiones.

Segmentación basada en umbral

La segmentación basada en umbral es uno de los métodos más simples de segmentación de imágenes. Al establecer uno o más umbrales, divide los valores de píxeles de la imagen en diferentes categorías. Los métodos comunes de segmentación por umbral incluyen el umbral global y el umbral adaptativo.

Segmentación por umbral global

La segmentación por umbral global utiliza un umbral fijo para dividir la imagen en primer plano y fondo. OpenCV proporcionacv::thresholdla función para implementar esta funcionalidad.

cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
cv::Mat dst;
cv::threshold(src, dst, 128, 255, cv::THRESH_BINARY);

En el código anterior,128es el umbral,255es el valor máximo de píxel,cv::THRESH_BINARYindica el uso del método de binarización.

Segmentación por umbral adaptativo

La segmentación por umbral adaptativo ajusta dinámicamente el umbral según las regiones locales de la imagen. OpenCV proporcionacv::adaptiveThresholdla función para implementar esta funcionalidad.

cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
cv::Mat dst;
cv::adaptiveThreshold(src, dst, 255, cv::ADAPTIVE_THRESH_MEAN_C, cv::THRESH_BINARY, 11, 2);

En el código anterior,255es el valor máximo de píxel,cv::ADAPTIVE_THRESH_MEAN_Cindica el uso de la media local como umbral,11es el tamaño de la vecindad,2es la constante.

Segmentación basada en bordes

La segmentación basada en bordes divide la imagen mediante la detección de bordes en la imagen. Los algoritmos comunes de detección de bordes incluyen la detección de bordes Canny y el operador Sobel.

Detección de bordes Canny

La detección de bordes Canny es un algoritmo de detección de bordes de múltiples etapas. OpenCV proporcionacv::Cannyla función para implementar esta funcionalidad.

cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
cv::Mat edges;
cv::Canny(src, edges, 100, 200);

En el código anterior,100y200son los dos umbrales del algoritmo de Canny.

Segmentación basada en regiones (algoritmo de watershed)

La segmentación basada en regiones realiza la segmentación dividiendo la imagen en múltiples regiones. El algoritmo de watershed es un método común de segmentación basado en regiones.

Algoritmo de watershed

El algoritmo de watershed trata la imagen como un mapa topográfico y segmenta la imagen simulando la expansión del flujo de agua. OpenCV proporcionacv::watershedla función para implementar esta funcionalidad.

cv::Mat src = cv::imread("image.jpg");
cv::Mat markers = cv::Mat::zeros(src.size(), CV_32S);
cv::watershed(src, markers);

En el código anterior,markerses la matriz de marcadores, utilizada para almacenar el resultado de la segmentación.


Detección de contornos

La detección de contornos es un paso importante en el procesamiento de imágenes; se utiliza para detectar los bordes de los objetos en la imagen. OpenCV proporciona múltiples funciones para la detección y el procesamiento de contornos.

Encontrar contornos

Encontrar contornos es el primer paso de la detección de contornos. OpenCV proporcionacv::findContoursla función para implementar esta funcionalidad.

cv::Mat src = cv::imread("image.jpg", cv::IMREAD_GRAYSCALE);
std::vector<std::vector<cv::Point>> contours;
std::vector<cv::Vec4i> hierarchy;
cv::findContours(src, contours, hierarchy, cv::RETR_TREE, cv::CHAIN_APPROX_SIMPLE);

En el código anterior,contourses el vector que almacena los contornos,hierarchyes el vector que almacena la jerarquía de los contornos.

Características de los contornos

Las características de los contornos incluyen el área, el perímetro, la caja delimitadora, etc. OpenCV proporciona múltiples funciones para calcular estas características.

Área

El área es una característica importante de un contorno. OpenCV proporcionacv::contourAreala función para calcular el área del contorno.

double area = cv::contourArea(contours[0]);

Perímetro

El perímetro es otra característica importante de un contorno. OpenCV proporcionacv::arcLengthla función para calcular el perímetro del contorno.

double perimeter = cv::arcLength(contours[0], true);

Caja delimitadora

La caja delimitadora es el rectángulo envolvente mínimo del contorno. OpenCV proporcionacv::boundingRectla función para calcular la caja delimitadora.

cv::Rect rect = cv::boundingRect(contours[0]);

Dibujo de contornos

El dibujo de contornos consiste en dibujar los contornos detectados sobre la imagen. OpenCV proporcionacv::drawContoursla función para implementar esta funcionalidad.

cv::Mat dst = cv::Mat::zeros(src.size(), CV_8UC3);
cv::drawContours(dst, contours, -1, cv::Scalar(0, 255, 0), 2);

En el código anterior,dstes la imagen después de dibujar los contornos,cv::Scalar(0, 255, 0)es el color de los contornos,2es el grosor de línea de los contornos.


Coincidencia de plantillas

La coincidencia de plantillas es un método para buscar una plantilla específica en una imagen. OpenCV proporcionacv::matchTemplatela función para implementar esta funcionalidad.

Coincidencia de plantilla única

La coincidencia de plantilla única consiste en buscar una plantilla en una imagen. OpenCV proporcionacv::matchTemplatela función para implementar esta funcionalidad.

cv::Mat src = cv::imread("image.jpg");
cv::Mat templ = cv::imread("template.jpg");
cv::Mat result;
cv::matchTemplate(src, templ, result, cv::TM_CCOEFF_NORMED);

En el código anterior,resultes la matriz de resultados de coincidencia,cv::TM_CCOEFF_NORMEDes el método de coincidencia.

Coincidencia de múltiples plantillas

La coincidencia de múltiples plantillas consiste en buscar múltiples plantillas en una imagen. Se puede implementar recorriendo la matriz de resultados de coincidencia.

double minVal, maxVal;
cv::Point minLoc, maxLoc;
cv::minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc);

En el código anterior,maxLoces la posición del valor máximo del resultado de coincidencia.


Ejemplo

Algoritmo de watershed

Ejemplo

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

using namespace cv;
using namespace std;

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

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

    // Binarización
    Mat binary;
    threshold(gray, binary, 0, 255, THRESH_BINARY_INV + THRESH_OTSU);

    // Eliminar el ruido
    Mat kernel = getStructuringElement(MORPH_RECT, Size(3, 3));
    morphologyEx(binary, binary, MORPH_OPEN, kernel, Point(-1, -1), 2);

    // Calcular la transformada de distancia
    Mat dist;
    distanceTransform(binary, dist, DIST_L2, 5);

    // Normalizar la imagen de transformada de distancia
    normalize(dist, dist, 0, 1.0, NORM_MINMAX);

    // Binarizar la imagen de transformada de distancia
    threshold(dist, dist, 0.5, 1.0, THRESH_BINARY);

    // Encontrar contornos
    Mat dist_8u;
    dist.convertTo(dist_8u, CV_8U);
    vector<vector<Point>> contours;
    findContours(dist_8u, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);

    // Crear la imagen de marcadores
    Mat markers = Mat::zeros(dist.size(), CV_32S);
    for (size_t i = 0; i < contours.size(); i++) {
        drawContours(markers, contours, static_cast<int>(i), Scalar(static_cast<int>(i) + 1), -1);
    }

    // Aplicar el algoritmo de watershed
    watershed(image, markers);

    // Mostrar el resultado
    Mat result = image.clone();
    for (int i = 0; i < markers.rows; i++) {
        for (int j = 0; j < markers.cols; j++) {
            if (markers.at<int>(i, j) == -1) {
                result.at<Vec3b>(i, j) = Vec3b(0, 255, 0); // Marcar los bordes en verde
            }
        }
    }

    imshow("Watershed Result", result);
    waitKey(0);

    return 0;
}

Detección de contornos

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

OpenCV proporciona la función findContours para detectar contornos.

Ejemplo

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

using namespace cv;
using namespace std;

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

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

    // Binarización
    Mat binary;
    threshold(gray, binary, 0, 255, THRESH_BINARY_INV + THRESH_OTSU);

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

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

    // Mostrar el resultado
    imshow("Contours", result);
    waitKey(0);

    return 0;
}

Operaciones morfológicas

Las operaciones morfológicas son técnicas de procesamiento de imágenes basadas en la forma; se usan comúnmente para eliminar ruido, separar objetos, etc.

Ejemplo

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

using namespace cv;
using namespace std;

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

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

    // Binarización
    Mat binary;
    threshold(gray, binary, 0, 255, THRESH_BINARY_INV + THRESH_OTSU);

    // Definir el kernel
    Mat kernel = getStructuringElement(MORPH_RECT, Size(5, 5));

    // Operación de apertura (eliminar ruido)
    Mat opened;
    morphologyEx(binary, opened, MORPH_OPEN, kernel);

    // Operación de cierre (rellenar agujeros)
    Mat closed;
    morphologyEx(opened, closed, MORPH_CLOSE, kernel);

    // Mostrar el resultado
    imshow("Original Binary", binary);
    imshow("Opened Image", opened);
    imshow("Closed Image", closed);
    waitKey(0);

    return 0;
}

Procesamiento de histogramas

El procesamiento de histogramas se utiliza para analizar la distribución de píxeles de una imagen. Las operaciones comunes incluyen la ecualización del histograma, la coincidencia de histogramas, etc.

Ejemplo

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

using namespace cv;
using namespace std;

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

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

    // Ecualización del histograma
    Mat equalized;
    equalizeHist(gray, equalized);

    // Mostrar el resultado
    imshow("Original Image", gray);
    imshow("Equalized Image", equalized);
    waitKey(0);

    return 0;
}

Coincidencia de plantillas

La coincidencia de plantillas se utiliza para encontrar regiones similares a una plantilla en una imagen.

Ejemplo


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

using namespace cv;
using namespace std;

int main() {
    // Leer la imagen y la plantilla
    Mat image = imread("scene.jpg");
    Mat templ = imread("template.jpg");
    if (image.empty() || templ.empty()) {
        cout << "Error: no se pudo cargar la imagen, verifique que la ruta sea correcta." << endl;
        return -1;
    }

    // Coincidencia de plantillas
    Mat result;
    matchTemplate(image, templ, result, TM_CCOEFF_NORMED);

    // Encontrar la mejor posición de coincidencia
    double minVal, maxVal;
    Point minLoc, maxLoc;
    minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc);

    // Dibujar el rectángulo
    rectangle(image, maxLoc, Point(maxLoc.x + templ.cols, maxLoc.y + templ.rows), Scalar(0, 255, 0), 2);

    // Mostrar el resultado
    imshow("Template Matching", image);
    waitKey(0);

    return 0;
}
Otras extensiones