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 <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 <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 <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 <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 <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 <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 <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;
}