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

Je souhaite utiliser OpenCV2.0 et Python2.6 pour afficher des images redimensionnées. J'ai utilisé et adopté l'exemple à http://opencv.willowgarage.com/documentation/python/cookbook.html 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

au lieu de cela, ce qui ne posait aucun problème dans d'autres applications. Néanmoins cv.iplimage n'a pas de lignes d'attributs, de colonnes ou de taille. Quelqu'un peut-il me donner un indice, comment résoudre ce problème? Merci.

Si vous souhaitez utiliser CV2, vous devez utiliser la resizefonction.

Par exemple, cela redimensionnera les deux axes de moitié:

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

et cela redimensionnera l'image pour avoir 100 cols (largeur) et 50 lignes (hauteur):

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

Une autre option consiste à utiliser le scipymodule, en utilisant:

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

Il y a évidemment plus d'options que vous pouvez lire dans la documentation de ces fonctions ( cv2.resize , scipy.misc.imresize ).

Mise à jour:
selon la documentation SciPy :

imresizeest obsolète dans SciPy 1.0.0 et sera supprimé dans 1.2.0.
Utilisez skimage.transform.resizeplutôt.

Notez que si vous cherchez à redimensionner par un facteur , vous voudrez peut-être skimage.transform.rescale.

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 de mise à l'échelle le long de l'axe horizontal et fy le long de l'axe vertical.

Pour réduire une image, elle sera généralement meilleure avec l'interpolation INTER_AREA, tandis que pour agrandir une image, elle sera généralement meilleure avec INTER_CUBIC (lent) ou INTER_LINEAR (plus rapide mais semble toujours OK).

Exemple d'image réduite pour s'adapter à une hauteur / largeur maximale (en conservant le rapport hauteur / largeur)

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()

Vous pouvez utiliser la fonction GetSize pour obtenir ces informations, cv.GetSize (im) renverrait un tuple avec la largeur et la hauteur de l'image. Vous pouvez également utiliser im.depth et img.nChan pour obtenir plus d'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 t'aides ;)

Julien

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)

Voici une fonction pour augmenter ou réduire une image 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)

Usage

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()

Utilisation de cette image d'exemple

Réduisez simplement l'échelle vers width=100(gauche) ou augmentez l'échelle vers width=300(droite)