Cambio de tamaño de imagen usando OpenCV. Para cambiar el tamaño de una imagen, puede escalarla según cada eje (alto y ancho), tener en cuenta factores de escala específicos o simplemente establecer la altura y el ancho deseados.
Al cambiar el tamaño de una imagen:
- Es importante tener en cuenta la relación de aspecto original (es decir, ancho y alto) de la imagen si desea mantener la misma relación de aspecto en la imagen redimensionada.
- Reducir el tamaño de una imagen requiere volver a muestrear los píxeles.
- Para aumentar el tamaño de una imagen es necesario reconstruirla. Esto significa que es necesario interpolar nuevos píxeles.
Para realizar estas operaciones entran en juego varias técnicas de interpolación. Hay varios métodos disponibles en OpenCV, la elección generalmente depende de la aplicación específica.
Cambiar tamaño con OpenCV
Haga las imágenes cada vez más pequeñas cambiando el tamaño con altura y ancho personalizados. A medida que avance, analizaremos el cambio de tamaño utilizando diferentes factores de escala y métodos de interpolación.
1. Información sobre el tamaño de la imagen
Pitón
# let's start with the Imports
import cv2
import numpy as np
# Read the image using imread function
image = cv2.imread('image.jpg')
cv2.imshow('Original Image', image)
# let's downscale the image using new width and height
down_width = 300
down_height = 200
down_points = (down_width, down_height)
resized_down = cv2.resize(image, down_points, interpolation= cv2.INTER_LINEAR)
# let's upscale the image using new width and height
up_width = 600
up_height = 400
up_points = (up_width, up_height)
resized_up = cv2.resize(image, up_points, interpolation= cv2.INTER_LINEAR)
# Display images
cv2.imshow('Resized Down by defining height and width', resized_down)
cv2.waitKey()
cv2.imshow('Resized Up image by defining height and width', resized_up)
cv2.waitKey()
#press any key to close the windows
cv2.destroyAllWindows()
C++
// let's start with including libraries
#include<opencv2/opencv.hpp>
#include<iostream>
// Namespace to nullify use of cv::function(); syntax
using namespace std;
using namespace cv;
int main()
{
// Read the image using imread function
Mat image = imread("image.jpg");
imshow("Original Image", image);
// let's downscale the image using new width and height
int down_width = 300;
int down_height = 200;
Mat resized_down;
//resize down
resize(image, resized_down, Size(down_width, down_height), INTER_LINEAR);
// let's upscale the image using new width and height
int up_width = 600;
int up_height = 400;
Mat resized_up;
//resize up
resize(image, resized_up, Size(up_width, up_height), INTER_LINEAR);
// Display Images and press any key to continue
imshow("Resized Down by defining height and width", resized_down);
waitKey();
imshow("Resized Up image by defining height and width", resized_up);
waitKey();
destroyAllWindows();
return 0;
}
Antes de comenzar a cambiar el tamaño de una imagen, conozca sus dimensiones originales. Para obtener el tamaño de una imagen:
- Usando el método de forma en Python
- Parámetros de filas y columnas en C++.
image.shape en Python devuelve tres valores: alto, ancho y número de canales.
En C++:
- image.rows: la altura de la imagen
- image.columns: el ancho de la imagen
Los resultados anteriores también se pueden obtener usando la función size().
- image.size().width devuelve el ancho
- image.size().height devuelve la altura
Pitón
# Get original height and width
h,w,c = image.shape
print("Original Height and Width:", h,"x", w)
C++
// Get height and width
cout << "Original Height and Width :" << image.rows << "x" << image.cols << endl;
Una cosa importante a tener en cuenta aquí es que OpenCV usa altura ∗ ancho ∗ canales alto*ancho*canalesaltura _ _ _ _ _∗ancho _ _ _ _∗El formato c h a n e l s genera la forma de la imagen, mientras que algunas otras bibliotecas de procesamiento de imágenes la generan en forma de ancho, alto . Hay opiniones lógicas al respecto.
Cuando las imágenes se leen con OpenCV, se representan como matrices NumPy. En general, utilice siempre filas ∗ columnas filas*columnasfilas _ _ _∗c o l u m n s (filas para su altura y columnas para su ancho) para referirse a la forma de la matriz. Entonces, las mismas reglas de matriz NumPy entran en juego incluso si la imagen se lee usando OpenCV para obtener su forma. La forma que obtienes esalto ∗ ancho ∗ canales alto*ancho*canalesaltura _ _ _ _ _∗ancho _ _ _ _∗c h a n n e l s。
Sintaxis de la función OpenCV resize()
La sintaxis de la función OpenCV resize() requiere dos parámetros de entrada:
- imagen fuente.
- El tamaño deseado de la imagen redimensionada, tamaño d.
Analizamos las diversas opciones de parámetros de entrada en las siguientes secciones.
resize(src, dsize[, dst[, fx[, fy[, interpolation]]]])
- src: esta es la imagen de entrada requerida, puede ser una cadena con la ruta de la imagen de entrada (por ejemplo: "test_image.png").
- dsize: Es el tamaño deseado de la imagen de salida, puede tener un nuevo alto y ancho.
- fx: factor de escala a lo largo del eje horizontal.
- fy: factor de escala a lo largo del eje vertical.
- Interpolación: Nos da la opción de elegir entre diferentes métodos para cambiar el tamaño de la imagen.
2. Cambiar el tamaño de la imagen con ancho y alto personalizados
En el primer ejemplo, cambiemos el tamaño de la imagen especificando un nuevo ancho y alto, lo que reducirá la escala de la imagen. En el siguiente código:
- Establecemos el ancho deseado en 300 y el alto deseado en 200.
- Estos dos valores se combinan en un vector bidimensional, que es lo que requiere la función resize().
- También especificamos el método de interpolación, que resulta ser el predeterminado.
Pitón
# Set rows and columns
# lets downsize the image using new width and height
down_width = 300
down_height = 200
down_points = (down_width, down_height)
resized_down = cv2.resize(image, down_points, interpolation= cv2.INTER_LINEAR)
C++
// Set rows and columns
// lets downsize the image using new width and height
int down_width = 300;
int down_height = 200;
Mat resize_down;
// resize down
resize(image, resize_down, Size(down_width, down_height), INTER_LINEAR);
A continuación, creamos otra variable para aumentar el tamaño de la imagen.
Pitón
# Set rows and columns
up_width = 600
up_height = 400
up_points = (up_width, up_height)
# resize the image
resized_up = cv2.resize(image, up_points, interpolation = cv2.INTER_LINEAR)
C++
// Set rows and columns
int up_width = 600;
int up_height = 400;
Mat resized_up;
//resize up
resize(image, resized_up, Size(up_width, up_height), INTER_LINEAR);
En el código Python anterior, estamos actualizando la imagen usando la función resize() para definir un nuevo ancho y alto. El proceso y los pasos son similares al fragmento anterior.
En código C++:
- Definimos nuevos números enteros para el ancho y alto de la actualización.
- da la matriz de la imagen de salida.
- Luego use la función resize(), igual que el código anterior.
Ahora, mostremos todas las imágenes usando la función imshow() de OpenCV.
Pitón
# Display images
cv2.imshow('Resized Down by defining height and width', resized_down)
cv2.waitKey()
cv2.imshow('Resized Up image by defining height and width', resized_up)
cv2.waitKey()
cv2.destroyAllWindows()
C++
// Display Images and press any key to continue
imshow("Resized Down by defining height and width", resized_down);
waitKey();
imshow("Resized Up image by defining height and width", resized_up);
waitKey();
destroyAllWindows();
3. Cambie el tamaño de la imagen usando el factor de escala.
Ahora cambiamos el tamaño de la imagen con el factor de escala. Pero antes de continuar, es necesario comprender qué es un factor de escala.
Un factor de escala suele ser un número que escala o se multiplica por alguna cantidad; en las imágenes las dimensiones son el ancho y el alto de la imagen. El factor de escala ayuda a mantener intacta la relación de aspecto y preserva la calidad de la visualización. Por lo tanto, cuando aumenta o reduce la escala de una imagen, la imagen no aparecerá distorsionada.
Pitón
# Scaling Up the image 1.2 times by specifying both scaling factors
scale_up_x = 1.2
scale_up_y = 1.2
# Scaling Down the image 0.6 times specifying a single scale factor.
scale_down = 0.6
scaled_f_down = cv2.resize(image, None, fx= scale_down, fy= scale_down, interpolation= cv2.INTER_LINEAR)
scaled_f_up = cv2.resize(image, None, fx= scale_up_x, fy= scale_up_y, interpolation= cv2.INTER_LINEAR)
C++
// Scaling Up the image 1.2 times by specifying both scaling factors
double scale_up_x = 1.2;
double scale_up_y = 1.2;
// Scaling Down the image 0.6 times specifying a single scale factor.
double scale_down = 0.6;
Mat scaled_f_up, scaled_f_down;
//resize
resize(image,scaled_f_down, Size(), scale_down, scale_down, INTER_LINEAR);
resize(image, scaled_f_up, Size(), scale_up_x, scale_up_y, INTER_LINEAR);
En el código Python anterior:
- Definimos nuevos factores de escala a lo largo de los ejes horizontal y vertical.
- Defina el factor de escala, no es necesario agregar nuevos anchos y altos de imagen. Por tanto, el valor es Ninguno.
En el código C++ anterior:
- Definimos el nuevo factor de escala así como la matriz para la nueva imagen.
- Como no necesitamos nuevos puntos de ancho y alto, mantenemos Size() vacío y usamos la función resize()
Ahora, mostremos la imagen para su visualización y mejor comprensión.
Pitón
# Display images and press any key to check next image
cv2.imshow('Resized Down by defining scaling factor', scaled_f_down)
cv2.waitKey()
cv2.imshow('Resized Up image by defining scaling factor', scaled_f_up)
cv2.waitKey()
C++
// Display images and Press any key to continue check next image
imshow("Resized Down by defining scaling factor", scaled_f_down);
waitKey();
imshow("Resized Up by defining scaling factor", scaled_f_up);
waitKey();
La imagen de la izquierda es una versión reducida y la imagen de la derecha es una versión ampliada.
4. Cambiar el tamaño con diferentes métodos de interpolación
Se utilizan diferentes métodos de interpolación para escalar diferentes dimensiones.
- INTER_AREA : INTER_AREA utiliza relaciones de área de píxeles para el remuestreo. Esto funciona mejor para reducir el tamaño de la imagen (alejar). Cuando se usa para acercar una imagen, usa el método INTER_NEAREST.
- INTER_CUBIC : utiliza interpolación bicúbica para cambiar el tamaño de la imagen. Este método actúa sobre los píxeles adyacentes de 4×4 de la imagen al cambiar el tamaño e interpolar nuevos píxeles. Luego, se necesita un peso promedio de 16 píxeles para crear nuevos píxeles interpolados.
- INTER_LINEAR : este método es algo similar a la interpolación INTER_CUBIC. Pero a diferencia de INTER_CUBIC, este utiliza píxeles vecinos de 2×2 para obtener un promedio ponderado de píxeles interpolados.
- INTER_NEAREST : El método INTER_NEAREST utiliza el concepto de vecino más cercano para la interpolación. Este es uno de los métodos más sencillos, ya que utiliza solo un píxel vecino en la imagen para la interpolación.
No se preocupe si no comprende completamente el método de interpolación. Los explicaremos en un ejemplo aparte.
Pitón
# Scaling Down the image 0.6 times using different Interpolation Method
res_inter_nearest = cv2.resize(image, None, fx= scale_down, fy= scale_down, interpolation= cv2.INTER_NEAREST)
res_inter_linear = cv2.resize(image, None, fx= scale_down, fy= scale_down, interpolation= cv2.INTER_LINEAR)
res_inter_area = cv2.resize(image, None, fx= scale_down, fy= scale_down, interpolation= cv2.INTER_AREA)
C++
# Scaling Down the image 0.6 using different Interpolation Method
Mat res_inter_linear, res_inter_nearest, res_inter_area;
resize(image, res_inter_linear, Size(), scale_down, scale_down, INTER_LINEAR);
resize(image, res_inter_nearest, Size(), scale_down, scale_down, INTER_NEAREST);
resize(image, res_inter_area, Size(), scale_down, scale_down, INTER_AREA);
En el fragmento de Python anterior, cambiamos el tamaño de la imagen utilizando diferentes métodos de interpolación. Además, en el fragmento de C++, primero definimos nuevas matrices para las imágenes de salida y luego cambiamos su tamaño usando diferentes métodos de interpolación. Ahora mostremos la imagen.
Pitón
# Concatenate images in horizontal axis for comparison
vertical= np.concatenate((res_inter_nearest, res_inter_linear, res_inter_area), axis = 0)
# Display the image Press any key to continue
cv2.imshow('Inter Nearest :: Inter Linear :: Inter Area', vertical)
C++
Mat a,b,c;
vconcat(res_inter_linear, res_inter_nearest, a);
vconcat(res_inter_area, res_inter_area, b);
vconcat(a, b, c);
// Display the image Press any key to continue
imshow("Inter Linear :: Inter Nearest :: Inter Area :: Inter Area", c);
INTER_LINEAR a la izquierda, INTER_NEAREST en el medio, INTER_AREA a la derecha