Procesamiento global en OpenCV

Operaciones de procesamiento global:
Tipos: unarias, binarias, histogramas.
Las funciones reciben una (unarias) o dos (binarias) imágenes de entrada, y producen una de salida. Las de entrada deben estar creadas y normalmente deben tener el mismo tipo y tamaño.
La mayoría de las funciones admite modo inplace: una imagen de entrada se puede usar también para guardar el resultado.
Muchas operaciones trabajan con ROI y mask ? No operan sobre toda la imagen sino solo sobre una parte concreta.
Un ROI es una imagen que se crea como un fragmento (rectangular) de otra imagen.

Es importante observar las restricciones impuestas sobre las imágenes admitidas en cada función.
En otro caso ocurrirá un error (se produce una excepción).
Normalmente:
Todas las imágenes deben ser del mismo tipo: profundidad y número de canales.
Todas las imágenes deben tener el mismo tamaño. Si se utilizan imágenes ROI, el tamaño debe ser el mismo en todas.
Algunas funciones requieren imágenes con 1 solo canal.
Opcionalmente, algunas admiten el uso de una máscara (mask), que será otra imagen, de 8 bits y con un 1 canal. Un valor 0 significa que el píxel no se procesa, y ? 0 sí se procesa.
Ver la documentación para cada función.

Operaciones globales:
Asignación, copia y constantes: =, clone, copyTo, zeros, ones
Aritméticas: +, -, *, /, scaleAdd, add, subtract, addWeighted, multiply, divide
Valor absoluto: abs, absdiff
Conversión: convertTo, split, merge
Booleanas: bitwise_and, bitwise_or, bitwise_xor, bitwise_not
Comparación: ==, >, >=, <, <=
Otras: threshold, adaptiveThreshold, pow, log, exp
Comparación: min, max, compare, inRange
Operaciones con histogramas:
calcHist, at, minMaxLoc, compareHist, normalize, equalizeHist, LUT

Inicializar una imagen con un valor constante: Se realiza directamente asignando (=) a la imagen un valor de tipo Scalar.
Ejemplo. Inicializar a verde:
Mat imagen(480, 640, CV_8UC3);
imagen= CV_RGB(0, 255, 0);
Asignación entre imágenes: La asignación (=) de una imagen a otra, no implica una copia, sino que ambas comparten la misma memoria.
Copia de imágenes: Para copiar una imagen, debe usarse clone().
Ejemplo. Copia de una imagen:
Mat imagen(480, 640, CV_8UC3);
Mat copia= imagen.clone();
Imagen como ROI de otra: una imagen puede ser una región de interés (ROI) de otra imagen. Esto es útil, por ejemplo, si queremos operar solo sobre un fragmento rectangular de otra imagen. Dos formas de crearla:
Mat imagen(480, 640, CV_8UC3);
Mat roi1(imagen, Rect(x, y, ancho, alto));
Mat roi2= imagen(Rect(x, y, ancho, alto));

Crear una imagen con un valor inicial: En la definición de la variable:
Mat imagen1(ancho, alto, tipo, CV_RGB(rojo, verde, azul));
Imágenes con valor inicial 0 o 1: Mat::zeros y Mat::ones:
Mat img1= Mat::zeros(ancho, alto, tipo);
img1= Mat::ones(ancho, alto, tipo);
Copiar una imagen en otra: copia el contenido (el valor de los píxeles):
void imagen.copyTo (Mat destino);
? Si la imagen de destino no está creada o su tamaño o tipo no es correcto, se crea automáticamente. En otro caso, se usa la imagen existente.
Ejemplo. Copiar un trozo de la imagen img en otra posición:
Mat imagen= imread("imagen.jpg");
Mat roi1= imagen(Rect(0, 0, 100, 100));
Mat roi2= imagen(Rect(200, 200, 100, 100));
roi1.copyTo(roi2);
void imagen.copyTo (Mat destino, Mat máscara);
? Copia en la imagen de destino solo aquellos píxeles que sean distintos de cero en máscara (debe ser de un canal).

Sumar a una imagen un valor constante: Suponiendo que tenemos: Mat img, img1, img2; Scalar escalar;
img1 = img2 + escalar;
img += escalar;
? Suma con saturación píxel a píxel: img(x,y):= img(x,y) + escalar
Ejemplo. Sumar un poco de azul: img + Scalar(40,0,0);
Aumentar el brillo (inplace): img+= Scalar::all(50);
Restar a una imagen un valor constante: Igual que antes pero con -:
img1 = img2 – escalar; img1= escalar – img2;
img -= escalar;
Ejemplo. Disminuir el brillo: img-= Scalar::all (50);
Ejemplo. Invertir el color de una imagen: img= Scalar::all(255)-img;
Sumar y restar dos imágenes: Se puede hacer también con + y -:
img = img1 + img2; img1+= img2;
img = img1 – img2; img1-= img2;

Multiplicar una imagen por una constante: Siendo valor un número:
img= img1*valor; img*= valor; img= img1/valor; img/= valor;
Ejemplo. Aumentar el contraste: img*= 1.5;
Media ponderada de dos imágenes:
img= img1*0.5 + img2*0.5;
Las operaciones de suma y resta también se pueden hacer con notación funcional, con las operaciones add y substract. Estas funciones: (1) permiten usar máscaras; (2) permiten definir el tipo de datos de salida; y (3) img1 o img2 pueden ser un Scalar (de manera que el resultado sería sumar o restar un escalar a todos los píxeles de una imagen).
Suma de dos imágenes:
void add (Mat img1, Mat img2, Mat dest, [ Mat máscara=NULO, int tipo=-1] );
si máscara(x,y)?0 entonces dest(x,y):= img1(x,y) + img2(x,y)
Resta de dos imágenes:
void subtract (Mat img1, Mat img2, Mat dest, Mat máscara, int tipo);
si máscara(x,y)?0 entonces dest(x,y):= img1(x,y) – img2(x,y)

Tipo de la imagen dest

Suma escalada de una imagen con otra:
void scaleAdd (Mat img1, double valor, Mat img2, Mat dest);
dest(x, y) := valor*img1(x,y) + img2(x,y)
Suma ponderada de dos imágenes:
void addWeighted(Mat A, double a, Mat B, double b, double c, Mat dest, [int tipo]);
dest:= a*A + b*B + c
Se puede hacer con la suma y el producto, pero de esta manera se evita la posible saturación en pasos intermedios. A o B pueden ser escalares.
Ejemplo: crear una transición entre dos imágenes A y B, que deben tener el mismo tamaño y número de canales.
Mat A= imread("a.jpg", 1);
Mat B= imread("b.jpg", 1);
Mat res;
for (int i= 0; i<100; i++) {
addWeighted(A, i/100.0, B, 1-i/100.0, 0, res);
imshow("Transicion", res);
waitKey(10);
}

Valor absoluto de diferencia entre dos imágenes:
void absdiff (Mat src1, Mat src2, Mat dest);
? dest(x,y):= | src1(x,y) – src2(x,y) |
Ejemplo. “Buscar las 7 diferencias”: absdiff(img1, img2, resultado);
Valor absoluto de una imagen:
Mat abs (Mat imagen);
? resultado(x,y):= | imagen(x,y) |
Tiene sentido cuando la profundidad son números con signo.
Convertir la profundidad de una imagen:
void Mat::convertTo(Mat dest, int tipo, [ double prod=1, double suma=0 ] );
? dest(x,y):= M(x,y) * prod + suma (igual para todos los canales)
Se puede hacer cualquier transformación lineal (suma/producto).
Permite convertir a cualquier profundidad, con igual número de canales.
Producto, suma y conversión del tipo de una imagen:
void convertScaleAbs(Mat src, Mat dest, [ double prod=1, double suma=0 ] );
? dest(x,y):= | src(x,y) * prod + suma | (igual para todos los canales)
Se puede hacer cualquier transformación lineal.
La función permite cualquier profundidad de entrada y convierte a 8U.