OpenCV: segmentación mediante umbralización

En este artículo, una técnica básica para la segmentación de objetos llamada Thresholding .
Pero antes de pasar a más detalles, a continuación se muestra una breve descripción general de OpenCV.

OpenCV (Open Source Computer Vision) es una biblioteca de funciones de programación de código abierto y multiplataforma, destinada a realizar tareas de visión artificial en tiempo real en una amplia variedad de campos, tales como:

• Reconocimiento facial
• Sistemas de reconocimiento de iris
• Reconocimiento de gestos
• Interacción humano-computadora (HCI)
• Robótica móvil
• Identificación de objetos
• Segmentación y reconocimiento
• Stereopsis stereo vision: percepción de profundidad a partir de 2 cámaras
• Realidad aumentada

También incluye una sólida biblioteca de aprendizaje automático estadístico, que contiene una serie de clasificadores diferentes que se utilizan para respaldar las áreas anteriores.

Para usar OpenCV, simplemente importe o incluya las bibliotecas requeridas y comience a utilizar la gran cantidad de funciones disponibles.

La umbralización es una técnica de segmentación muy popular, utilizada para separar un objeto de su fondo. En el artículo a continuación, describí varias técnicas utilizadas para umbralizar imágenes en escala de grises (8 bits) .

El proceso de umbralización implica comparar cada valor de píxel de la imagen (intensidad de píxel) con un umbral específico. Esto divide todos los píxeles de la imagen de entrada en 2 grupos:

1. Píxeles que tienen un valor de intensidad inferior al umbral.
2. Píxeles que tienen un valor de intensidad superior al umbral.

A estos 2 grupos ahora se les asignan valores diferentes, según los distintos tipos de segmentación.
OpenCV admite 5 esquemas de umbral diferentes en imágenes en escala de grises (8 bits) utilizando la función:

Umbral doble (InputArray src, OutputArray dst, doble umbral, doble maxval, tipo int)

Parámetros:

* A continuación se proporciona una lista de tipos de umbrales.

Imagen de entrada

La imagen RGB de entrada se convierte primero en una imagen en escala de grises antes de realizar el umbral.

Tipos de umbral

• Umbral binario (tipo int = 0)

  
  De los dos grupos obtenidos anteriormente, al grupo que tiene miembros con una intensidad de píxel superior al umbral establecido, se le asigna «Max_Value», o en el caso de una escala de grises, un valor de 255 (blanco).
  Los miembros del grupo restante tienen sus intensidades de píxeles establecidas en 0 (negro).

  

  Si el valor de intensidad de píxel en (x, y) en la imagen de origen es mayor que el umbral, el valor en la imagen final se establece en «maxVal».

• Umbral binario invertido (tipo int = 1)

  

  inversión El umbral binario es lo mismo que el umbral binario. La única diferencia esencial es que, en el umbral Inv.Binary, al grupo que tiene intensidades de píxeles superiores al umbral establecido se le asigna ‘0’, mientras que los píxeles restantes que tienen intensidades inferiores al umbral se establecen en «maxVal».

  

  Si el valor de intensidad de píxel en (x, y) en la imagen de origen es mayor que el umbral, el valor en la imagen final se establece en «0», de lo contrario, se establece en «maxVal».

• Truncar Umbral (tipo int=2)

  

  El grupo que tiene intensidades de píxel mayores que el umbral establecido, se trunca al umbral establecido o, en otras palabras, los valores de píxel se establecen para que sean iguales al umbral establecido.
  Todos los demás valores siguen siendo los mismos.

  

  Si el valor de intensidad de píxel en (x, y) en la imagen de origen es mayor que el umbral, el valor en la imagen final se establece en «umbral», de lo contrario, no cambia.

• Umbral a cero (tipo int = 3)

  

  Una técnica de umbralización muy simple, en la que establecemos la intensidad de píxel en ‘0’, para todos los píxeles del grupo que tienen un valor de intensidad de píxel inferior al umbral.

  

  Si el valor de intensidad de píxeles en (x, y) en la imagen de origen es mayor que el umbral, el valor en (x, y) en la imagen final no cambia. Todos los píxeles restantes se establecen en ‘0’.

• Umbral a cero, invertido (tipo int=4)

  

  Similar a la técnica anterior, aquí establecemos la intensidad de píxel en ‘0’, para todos los píxeles del grupo que tienen un valor de intensidad de píxel mayor que el umbral.

  

  Si el valor de intensidad de píxel en (x, y) en la imagen de origen es mayor que el umbral, el valor en (x, y) en la imagen final se establece en ‘0’. Todo el valor de píxel restante no cambia.

Para compilar programas OpenCV, debe tener instalada la biblioteca OpenCV en su sistema. Estaré publicando un tutorial simple para el mismo, en los próximos días.
Si ya ha instalado OpenCV, ejecute el siguiente código con la imagen de entrada de su elección.

// CPP program to demonstrate segmentation
// thresholding.
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <stdio.h>
#include <stdlib.h>
  
using namespace cv;
  
int main(int argc, char** argv)
{
    if (argc != 2) 
    {
        cout << " Usage: <Sourceprogram>"
                " <ImageToLoad>" << endl;
        return -1;
    }
  
    int threshold_value = 0;
  
    // Valid Values: 0, 1, 2, 3, 4
    int threshold_type = 2; 
  
    // maxVal, useful for threshold_type 1 and 2
    int maxVal = 255; 
  
    // Source image
    Mat src = imread(argv[1], 1);
  
    cvNamedWindow("Original", CV_WINDOW_NORMAL);
    imshow("Original", src);
  
    Mat src_gray, dst;
  
    // Convert the image to GrayScale
    cvtColor(src, src_gray, CV_BGR2GRAY);
  
    // Create a window to display results
    cvNamedWindow("Result", CV_WINDOW_NORMAL);
  
    createTrackbar("Threshold", "Result", 
                  &threshold_value, 255);
    while (1) 
    {
        threshold(src_gray, dst, threshold_value, 
                         maxVal, threshold_type);
        imshow("Result", dst);
        waitKey(1);
    }
}