Redimensionner une image sans distorsion OpenCV

Je suis à l'aide de python 3 et la dernière version d'openCV. Je suis en train de redimensionner une image à l'aide de la fonction de redimensionnement donnés, mais après redimensionnement de l'image est très déformée. Code :

import cv2
file = "/home/tanmay/Desktop/test_image.png"
img = cv2.imread(file , 0)
print(img.shape)
cv2.imshow('img' , img)
k = cv2.waitKey(0)
if k == 27:
    cv2.destroyWindow('img')
resize_img = cv2.resize(img  , (28 , 28))
cv2.imshow('img' , resize_img)
x = cv2.waitKey(0)
if x == 27:
    cv2.destroyWindow('img')

L'image d'origine est de 480 x 640 (RVB donc j'ai passé le 0 à niveaux de gris)

Est-il possible de le redimensionner et éviter la distorsion à l'aide d'OpenCV ou toute autre bibliothèque peut-être? J'ai l'intention de faire un manuscrites chiffres logiciel de reconnaissance et j'ai formé mon réseau de neurones utilisant les données MNIST donc j'ai besoin de l'image pour être 28x28.

Sans aucune distorsion, vous avez 2 options: a) des cultures de la partie de l'image pour qu'elle le même aspect. b) ajouter une partie de l'image (par exemple, les pixels noirs) sur les côtés des images pour en faire le même aspect. Si vous n'avez pas le même rapport d'aspect, il ne sera pas possible de l'obtenir sans distorsion.
Vous devez vous assurer que le ratio d'aspect de la nouvelle dimension de passe est le même que l'image d'origine et assurez-vous que vous utilisez un adapté de la méthode d'interpolation
J'ai ajouté les pixels noirs de l'image d'origine pour en faire 640x640 mais encore quand j'redimensionner, je reçois une image déformée. Que puis-je faire ?
La spécification de l'interpolation, il fixe. Merci.

InformationsquelleAutor Tanmay Bhatnagar | 2017-06-20

Vous pouvez essayer ci-dessous. La fonction de garder l'aspect taux de l'image d'origine.

def image_resize(image, width = None, height = None, inter = cv2.INTER_AREA):
    # initialize the dimensions of the image to be resized and
    # grab the image size
    dim = None
    (h, w) = image.shape[:2]

    # if both the width and height are None, then return the
    # original image
    if width is None and height is None:
        return image

    # check to see if the 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)

    # otherwise, the height is None
    else:
        # calculate the ratio of the width and construct the
        # dimensions
        r = width / float(w)
        dim = (width, int(h * r))

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

    # return the resized image
    return resized

Voici un exemple d'utilisation.

image = image_resize(image, height = 800)

Espère que cette aide.

Que faire si je veux changer le ratio d'aspect de l'image d'origine ? Je veux profiter de chaque image à 28x28 peu importe ses dimensions d'origine.
Ensuite, allez tout droit pour utiliser cv2.resize(image, (28,28), interpolation = inter).
pourriez-vous également me donner un vote si ma réponse vous aide à résoudre votre problème?
Pourriez-vous nous expliquer ce que l'interpolation est ? Je sais que cela permet de réduire l'erreur qui se produit en raison de redimensionnement de l'image, mais comment pouvons-nous décider quelle technique utiliser ? Est-il juste de frapper et d'essai?
vous pourriez vous référer à ce tutoriel sur cv2.redimensionner docs.opencv.org/3.0-beta/modules/imgproc/doc/....
N'oubliez pas de saisir un tableau numpy de pixels plutôt que de donner l'emplacement de l'image dans cette fonction

InformationsquelleAutor thewaywewere

5

Si vous avez besoin de modifier la résolution de l'image et de garder votre ratio d'aspect de l'utilisation de la fonction imutils (voir la documentation). quelque chose comme ceci:
```
img = cv2.imread(file , 0)
img = imutils.resize(img, width=1280)
cv2.imshow('image' , img)
```
espère que ça aide, bonne chance !

InformationsquelleAutor Andres Mitre

La réponse, fournie par @vijay jai est trop spécifique. Comprend un ajout inutile de rembourrage. Je propose fixe code ci-dessous:

def resize2SquareKeepingAspectRation(img, size, interpolation):
  h, w = img.shape[:2]
  c = None if len(img.shape) < 3 else img.shape[2]
  if h == w: return cv2.resize(img, (size, size), interpolation)
  if h > w: dif = h
  else:     dif = w
  x_pos = int((dif - w)/2.)
  y_pos = int((dif - h)/2.)
  if c is None:
    mask = np.zeros((dif, dif), dtype=img.dtype)
    mask[y_pos:y_pos+h, x_pos:x_pos+w] = img[:h, :w]
  else:
    mask = np.zeros((dif, dif, c), dtype=img.dtype)
    mask[y_pos:y_pos+h, x_pos:x_pos+w, :] = img[:h, :w, :]
  return cv2.resize(mask, (size, size), interpolation)

Le code redimensionne une image carrée et en gardant l'aspect ratio en même temps. Le code est adapté pour 3 canaux (en couleur) des images.
Exemple d'utilisation:

resized = resize2SquareKeepingAspectRation(img, size, cv2.INTER_AREA)

InformationsquelleAutor Alexey Antonenko

4

Essayez ce simple fonction en python qui utilise opencv. il suffit de passer l'image et à la mention de la taille des carrés que vous voulez.
```
def get_square(image,square_size):

    height,width=image.shape
    if(height>width):
      differ=height
    else:
      differ=width
    differ+=4

    mask = np.zeros((differ,differ), dtype="uint8")   
    x_pos=int((differ-width)/2)
    y_pos=int((differ-height)/2)
    mask[y_pos:y_pos+height,x_pos:x_pos+width]=image[0:height,0:width]
    mask=cv2.resize(mask,(square_size,square_size),interpolation=cv2.INTER_AREA)

    return mask 
```
utilisation:
squared_image=get_square(image 28)

explication:
fonction prend en entrée de n'importe quelle taille et il crée une forme rectangulaire vide de l'image d'une taille supérieure à l'entrée de l'image en hauteur et en largeur.
il place ensuite l'image d'origine au centre de l'image vide. et puis il redimensionne cette place de l'image dans la taille désirée de sorte que la forme de l'image d'origine contenu est préservé.

espoir ,cela vous aidera à
- jk n'est pas défini
- merci @Mitali Cyrus pour le rapport de bug. j'ai corrigé ça.
InformationsquelleAutor vijay jha

J'ai un jeu de données de dessins à main levée et j'avais besoin de créer de petites images carrées de dessins asymétriques.

Redimensionner une image sans distorsion OpenCV

Grâce à @vijay jai j'ai créé images carrées tout en maintenant le ratio d'aspect de l'image d'origine. Une question toutefois que plus vous revus à la baisse plus l'information a été perdu.

512x256 à 64x64 devrait ressembler à ceci:

Redimensionner une image sans distorsion OpenCV

J'ai modifié un peu la code d'origine douceur, de réduire la taille de l'image.

from skimage.transform import resize, pyramid_reduce


def get_square(image, square_size):

    height, width = image.shape    
    if(height > width):
      differ = height
    else:
      differ = width
    differ += 4

    # square filler
    mask = np.zeros((differ, differ), dtype = "uint8")

    x_pos = int((differ - width) / 2)
    y_pos = int((differ - height) / 2)

    # center image inside the square
    mask[y_pos: y_pos + height, x_pos: x_pos + width] = image[0: height, 0: width]

    # downscale if needed
    if differ / square_size > 1:
      mask = pyramid_reduce(mask, differ / square_size)
    else:
      mask = cv2.resize(mask, (square_size, square_size), interpolation = cv2.INTER_AREA)
    return mask

512x256 -> 64x64

Redimensionner une image sans distorsion OpenCV

512x256 -> 28x28

Redimensionner une image sans distorsion OpenCV

InformationsquelleAutor Arthur

2
```
img = cv2.resize(img, (int(img.shape[1]/2), int(img.shape[0]/2)))
```
redimensionner l'image à la moitié de la taille d'origine. Vous pouvez le modifier pour tout autre rapport.
Notez que le premier argument passé à redimensionner() est img.la forme[1], et non pas d'img.de la forme[0]. Cela peut être contre-intuitif. Il est facile d'oublier ce revers et une image déformée.

InformationsquelleAutor Raja

Le code est donné un window_height par lequel il calcule la window_width variable, tout en maintenant le ratio d'aspect de l'image. Afin de prévenir de toute distorsion.

import cv2

def resize(self,image,window_height = 500):
    aspect_ratio = float(image.shape[1])/float(image.shape[0])
    window_width = window_height/aspect_ratio
    image = cv2.resize(image, (int(window_height),int(window_width)))
    return image

img = cv2.imread(img_source)         #image location
img_resized = resize(img,window_height = 800)
cv2.imshow("Resized",img_resized)
cv2.waitKey(0)
cv2.destroyAllWindows()

InformationsquelleAutor Shikhar Johri

Peut pas citer les aligner avec ce que l'original qui est demandé, mais j'ai atterri ici à la recherche d'une réponse à une question similaire.

import cv2
def resize_and_letter_box(image, rows, cols):
    """
    Letter box (black bars) a color image (think pan & scan movie shown 
    on widescreen) if not same aspect ratio as specified rows and cols. 
    :param image: numpy.ndarray((image_rows, image_cols, channels), dtype=numpy.uint8)
    :param rows: int rows of letter boxed image returned  
    :param cols: int cols of letter boxed image returned
    :return: numpy.ndarray((rows, cols, channels), dtype=numpy.uint8)
    """
    image_rows, image_cols = image.shape[:2]
    row_ratio = rows / float(image_rows)
    col_ratio = cols / float(image_cols)
    ratio = min(row_ratio, col_ratio)
    image_resized = cv2.resize(image, dsize=(0, 0), fx=ratio, fy=ratio)
    letter_box = np.zeros((int(rows), int(cols), 3))
    row_start = int((letter_box.shape[0] - image_resized.shape[0]) / 2)
    col_start = int((letter_box.shape[1] - image_resized.shape[1]) / 2)
    letter_box[row_start:row_start + image_resized.shape[0], col_start:col_start + image_resized.shape[1]] = image_resized
    return letter_box

InformationsquelleAutor orangepips

Vous devez vous connecter pour publier un commentaire.