Numpy Redimensionner/Réduire l'image

Question

Je voudrais prendre une image et changer l'échelle de l'image, alors qu'elle est un tableau numpy.

Par exemple, j'ai cette image d'une bouteille de coca-cola : bouteille-1

Ce qui se traduit par un tableau numpy de forme (528, 203, 3) et je veux le redimensionner à la taille de cette deuxième image : bouteille-2

Qui a une forme de (140, 54, 3) .

Comment puis-je modifier la taille de l'image pour lui donner une certaine forme tout en conservant l'image originale ? D'autres réponses suggèrent de supprimer une ligne sur deux ou sur trois, mais ce que je veux faire, c'est réduire l'image comme on le ferait avec un éditeur d'images, mais en code Python. Existe-t-il des bibliothèques pour faire cela en numpy/SciPy ?

Answer 1

Oui, vous pouvez installer opencv (il s'agit d'une bibliothèque utilisée pour le traitement de l'image et la vision par ordinateur), et utilisez la balise cv2.resize fonction. Et à utiliser par exemple :

import cv2
import numpy as np

img = cv2.imread('your_image.jpg')
res = cv2.resize(img, dsize=(54, 140), interpolation=cv2.INTER_CUBIC)

Ici img est donc un tableau numpy contenant l'image originale, alors que res est un tableau numpy contenant les redimensionné l'image. Un aspect important est le interpolation paramètre : il existe plusieurs façons de redimensionner une image. D'autant plus que vous réduisez l'échelle de l'image, et que la taille de l'image originale est no un multiple de la taille de l'image redimensionnée. Les schémas d'interpolation possibles sont :

• INTER_NEAREST - une interpolation des plus proches voisins
• INTER_LINEAR - une interpolation bilinéaire (utilisée par défaut)
• INTER_AREA - rééchantillonnage utilisant la relation entre la surface des pixels. Il s'agit d'une méthode privilégiée pour la décimation des images, car elle donne des résultats sans moirage. sans moirage. Mais lorsque l'image est zoomée, elle est similaire à l'image INTER_NEAREST méthode.
• INTER_CUBIC - une interpolation bicubique sur un voisinage de 4x4 pixels
• INTER_LANCZOS4 - une interpolation de Lanczos sur un voisinage de 8x8 pixels

Comme pour la plupart des options, il n'y a pas de "meilleure" option dans le sens où, pour chaque schéma de redimensionnement, il existe des scénarios où une stratégie peut être préférée à une autre.

Answer 2

Bien qu'il soit possible d'utiliser numpy seul pour le faire, cette opération n'est pas intégrée. Cela dit, vous pouvez utiliser scikit-image (qui est construit sur numpy) pour faire ce genre de manipulation d'images.

La documentation sur le redimensionnement de Scikit-Image est la suivante aquí .

Par exemple, vous pouvez faire ce qui suit avec votre image :

from skimage.transform import resize
bottle_resized = resize(bottle, (140, 54))

Cela prendra en charge des choses comme l'interpolation, l'anticrénelage, etc. pour vous.

Answer 3

Pour les personnes qui viennent de Google et qui cherchent un moyen rapide de sous-échantillonner des images en numpy pour l'utilisation dans des applications d'apprentissage automatique, voici une méthode super rapide (adaptée de aquí ). Cette méthode ne fonctionne que lorsque les dimensions d'entrée sont un multiple des dimensions de sortie.

Les exemples suivants réduisent l'échantillonnage de 128x128 à 64x64 (ceci peut être facilement modifié).

Dernières commandes de chaînes

# large image is shape (128, 128, 3)
# small image is shape (64, 64, 3)
input_size = 128
output_size = 64
bin_size = input_size // output_size
small_image = large_image.reshape((output_size, bin_size, 
                                   output_size, bin_size, 3)).max(3).max(1)

Commande de canaux en premier lieu

# large image is shape (3, 128, 128)
# small image is shape (3, 64, 64)
input_size = 128
output_size = 64
bin_size = input_size // output_size
small_image = large_image.reshape((3, output_size, bin_size, 
                                      output_size, bin_size)).max(4).max(2)

Pour les images en niveaux de gris, il suffit de modifier le paramètre 3 à un 1 comme ça :

Commande de canaux en premier lieu

# large image is shape (1, 128, 128)
# small image is shape (1, 64, 64)
input_size = 128
output_size = 64
bin_size = input_size // output_size
small_image = large_image.reshape((1, output_size, bin_size,
                                      output_size, bin_size)).max(4).max(2)

Cette méthode utilise l'équivalent du max pooling. C'est la méthode la plus rapide que j'ai trouvée.

Answer 4

SciPy imresize() était une autre méthode de redimensionnement, mais elle sera supprimée à partir de SciPy v 1.3.0 . SciPy fait référence à LIP méthode de redimensionnement de l'image : Image.resize(size, resample=0)

taille - La taille demandée en pixels, sous forme de 2-tuple : (largeur, hauteur).
rééchantillonner - Un filtre de rééchantillonnage facultatif. Il peut s'agir d'un des filtres suivants : PIL.Image.NEAREST (utilisation du plus proche voisin), PIL.Image.BILINEAR (interpolation linéaire), PIL.Image.BICUBIC (interpolation par spline cubique) ou PIL.Image.LANCZOS (filtre de sous-échantillonnage de haute qualité). S'il est omis, ou si l'image a le mode "1" ou "P", il est défini PIL.Image.NEAREST.

Lien ici : https://pillow.readthedocs.io/en/3.1.x/reference/Image.html#PIL.Image.Image.resize

Answer 5

import cv2
import numpy as np

image_read = cv2.imread('filename.jpg',0) 
original_image = np.asarray(image_read)
width , height = 452,452
resize_image = np.zeros(shape=(width,height))

for W in range(width):
    for H in range(height):
        new_width = int( W * original_image.shape[0] / width )
        new_height = int( H * original_image.shape[1] / height )
        resize_image[W][H] = original_image[new_width][new_height]

print("Resized image size : " , resize_image.shape)

cv2.imshow(resize_image)
cv2.waitKey(0)