Comment redimensionner une image avec OpenCV2.0 et Python2.6

Question

Je souhaite utiliser OpenCV2.0 et Python2.6 pour afficher des images redimensionnées. J'ai utilisé et adopté este mais malheureusement, ce code est pour OpenCV2.1 et ne semble pas fonctionner sur 2.0. Voici mon code :

import os, glob
import cv

ulpath = "exampleshq/"

for infile in glob.glob( os.path.join(ulpath, "*.jpg") ):
    im = cv.LoadImage(infile)
    thumbnail = cv.CreateMat(im.rows/10, im.cols/10, cv.CV_8UC3)
    cv.Resize(im, thumbnail)
    cv.NamedWindow(infile)
    cv.ShowImage(infile, thumbnail)
    cv.WaitKey(0)
    cv.DestroyWindow(name)

Puisque je ne peux pas utiliser

cv.LoadImageM

J'ai utilisé

cv.LoadImage

ce qui n'a pas posé de problème dans d'autres applications. Néanmoins, cv.iplimage n'a pas d'attribut rows, cols ou size. Quelqu'un peut-il me donner un indice sur la façon de résoudre ce problème ?

Answer 1

Si vous souhaitez utiliser CV2, vous devez utiliser l'option resize fonction.

Par exemple, cela permet de redimensionner les deux axes de moitié :

small = cv2.resize(image, (0,0), fx=0.5, fy=0.5) 

ce qui redimensionnera l'image pour qu'elle ait 100 colonnes (largeur) et 50 lignes (hauteur) :

resized_image = cv2.resize(image, (100, 50)) 

Une autre option consiste à utiliser scipy en utilisant le module :

small = scipy.misc.imresize(image, 0.5)

Il existe évidemment d'autres options que vous pouvez consulter dans la documentation de ces fonctions ( cv2.resize , scipy.misc.imresize ).

---

Mise à jour :
Selon la Documentation SciPy :

imresize est obsolète dans SciPy 1.0.0, et sera supprimé dans la version 1.2.0.
Utilice skimage.transform.resize au lieu de cela.

Notez que si vous cherchez à redimensionner par un facteur Il se peut que vous souhaitiez en fait skimage.transform.rescale .

Answer 2

Exemple de doublement de la taille de l'image

Il existe deux façons de redimensionner une image. La nouvelle taille peut être spécifiée :

1. Manuellement ;

   height, width = src.shape[:2]

   dst = cv2.resize(src, (2*width, 2*height), interpolation = cv2.INTER_CUBIC)

2. Par un facteur d'échelle.

   dst = cv2.resize(src, None, fx = 2, fy = 2, interpolation = cv2.INTER_CUBIC) , où fx est le facteur d'échelle le long de l'axe horizontal et fy le long de l'axe vertical.

Pour rétrécir une image, l'interpolation INTER_AREA est généralement la meilleure, tandis que pour l'agrandir, l'interpolation INTER_CUBIC (lente) ou INTER_LINEAR (plus rapide, mais qui reste correcte) est généralement la meilleure.

Exemple de rétrécissement d'une image pour l'adapter à une hauteur/largeur maximale (en conservant le rapport d'aspect)

import cv2

img = cv2.imread('YOUR_PATH_TO_IMG')

height, width = img.shape[:2]
max_height = 300
max_width = 300

# only shrink if img is bigger than required
if max_height < height or max_width < width:
    # get scaling factor
    scaling_factor = max_height / float(height)
    if max_width/float(width) < scaling_factor:
        scaling_factor = max_width / float(width)
    # resize image
    img = cv2.resize(img, None, fx=scaling_factor, fy=scaling_factor, interpolation=cv2.INTER_AREA)

cv2.imshow("Shrinked image", img)
key = cv2.waitKey()

Utiliser votre code avec cv2

import cv2 as cv

im = cv.imread(path)

height, width = im.shape[:2]

thumbnail = cv.resize(im, (round(width / 10), round(height / 10)), interpolation=cv.INTER_AREA)

cv.imshow('exampleshq', thumbnail)
cv.waitKey(0)
cv.destroyAllWindows()

Answer 3

Vous pouvez utiliser la fonction GetSize pour obtenir ces informations. cv.GetSize(im) renvoie un tuple contenant la largeur et la hauteur de l'image. Vous pouvez également utiliser im.depth et img.nChan pour obtenir d'autres informations.

Et pour redimensionner une image, j'utiliserais un processus légèrement différent, avec une autre image au lieu d'une matrice. Il vaut mieux essayer de travailler avec le même type de données :

size = cv.GetSize(im)
thumbnail = cv.CreateImage( ( size[0] / 10, size[1] / 10), im.depth, im.nChannels)
cv.Resize(im, thumbnail)

J'espère que cela vous aidera ;)

Julien

Answer 4

Voici une fonction qui permet d'augmenter ou de réduire l'échelle d'une image en fonction de la largeur ou de la hauteur souhaitée, tout en conservant le rapport hauteur/largeur.

# Resizes a image and maintains aspect ratio
def maintain_aspect_ratio_resize(image, width=None, height=None, inter=cv2.INTER_AREA):
    # Grab the image size and initialize dimensions
    dim = None
    (h, w) = image.shape[:2]

    # Return original image if no need to resize
    if width is None and height is None:
        return image

    # We are resizing height if width is none
    if width is None:
        # Calculate the ratio of the height and construct the dimensions
        r = height / float(h)
        dim = (int(w * r), height)
    # We are resizing width if height is none
    else:
        # Calculate the ratio of the width and construct the dimensions
        r = width / float(w)
        dim = (width, int(h * r))

    # Return the resized image
    return cv2.resize(image, dim, interpolation=inter)

Utilisation

import cv2

image = cv2.imread('1.png')
cv2.imshow('width_100', maintain_aspect_ratio_resize(image, width=100))
cv2.imshow('width_300', maintain_aspect_ratio_resize(image, width=300))
cv2.waitKey()

---

En utilisant cet exemple d'image

Il suffit de réduire l'échelle à width=100 (à gauche) ou de passer à width=300 (à droite)

Answer 5

def rescale_by_height(image, target_height, method=cv2.INTER_LANCZOS4):
    """Rescale `image` to `target_height` (preserving aspect ratio)."""
    w = int(round(target_height * image.shape[1] / image.shape[0]))
    return cv2.resize(image, (w, target_height), interpolation=method)

def rescale_by_width(image, target_width, method=cv2.INTER_LANCZOS4):
    """Rescale `image` to `target_width` (preserving aspect ratio)."""
    h = int(round(target_width * image.shape[0] / image.shape[1]))
    return cv2.resize(image, (target_width, h), interpolation=method)