Cómo recortar una imagen en OpenCV usando Python

¿Cómo puedo recortar imágenes, como lo hice antes en PIL, usando OpenCV?

Ejemplo de trabajo en PIL

im = Image.open('0.png').convert('L')
im = im.crop((1, 1, 98, 33))
im.save('_0.png')

¿Pero cómo puedo hacerlo en OpenCV?

Esto es lo que probé:

im = cv.imread('0.png', cv.CV_LOAD_IMAGE_GRAYSCALE)
(thresh, im_bw) = cv.threshold(im, 128, 255, cv.THRESH_OTSU)
im = cv.getRectSubPix(im_bw, (98, 33), (1, 1))
cv.imshow('Img', im)
cv.waitKey(0)

Pero no funciona.

Creo que lo usé incorrectamente getRectSubPix. Si este es el caso, explique cómo puedo usar esta función correctamente.

Es muy simple. Usa rebanadas numpy.

import cv2
img = cv2.imread("lenna.png")
crop_img = img[y:y+h, x:x+w]
cv2.imshow("cropped", crop_img)
cv2.waitKey(0)

Tenía esta pregunta y encontré otra respuesta aquí: copiar región de interés

Si consideramos (0,0) como la esquina superior izquierda de la imagen llamada imcon de izquierda a derecha como dirección xy de arriba hacia abajo como dirección y. y tenemos (x1, y1) como el vértice superior izquierdo y (x2, y2) como el vértice inferior derecho de una región rectangular dentro de esa imagen, entonces:

roi = im[y1:y2, x1:x2]

Aquí hay un recurso completo sobre indexación y corte de matriz numpy que puede brindarle más información sobre cosas como recortar una parte de una imagen. las imágenes se almacenarían como una matriz numpy en opencv2.

:)

Tenga en cuenta que, rebanar la imagen no es la creación de una copia de la cropped imagepero la creación de una pointera laroi . Si está cargando tantas imágenes, recorta las partes relevantes de las imágenes con un corte y luego las agrega a una lista, esto podría ser un gran desperdicio de memoria.

Suponga que carga N imágenes cada una >1MPy solo necesita una 100x100región desde la esquina superior izquierda.

Slicing:

X = []
for i in range(N):
    im = imread('image_i')
    X.append(im[0:100,0:100]) # This will keep all N images in the memory. 
                              # Because they are still used.

Alternativamente, puede copiar la parte relevante por .copy(), para que el recolector de basura se elimine im.

X = []
for i in range(N):
    im = imread('image_i')
    X.append(im[0:100,0:100].copy()) # This will keep only the crops in the memory. 
                                     # im's will be deleted by gc.

Después de descubrir esto, me di cuenta de que uno de los comentarios del usuario1270710 mencionaba eso, pero me llevó bastante tiempo descubrirlo (es decir, depuración, etc.). Entonces, creo que vale la pena mencionarlo.

este código recorta una imagen de x = 0, y = 0 posición a h = 100, w = 200

import numpy as np
import cv2

image = cv2.imread('download.jpg')
y=0
x=0
h=100
w=200
crop = image[y:y+h, x:x+w]
cv2.imshow('Image', crop)
cv2.waitKey(0) 

A continuación se muestra la forma de recortar una imagen.

ruta de la imagen: la ruta a la imagen para editar

coords: una tupla de coordenadas x / y (x1, y1, x2, y2) [abra la imagen en mspaint y verifique la "regla" en la pestaña de vista para ver las coordenadas]

ubicación_ guardada : ruta para guardar la imagen recortada

from PIL import Image
    def crop(image_path, coords, saved_location:
        image_obj = Image.open("Path of the image to be cropped")
            cropped_image = image_obj.crop(coords)
            cropped_image.save(saved_location)
            cropped_image.show()


if __name__ == '__main__':
    image = "image.jpg"
    crop(image, (100, 210, 710,380 ), 'cropped.jpg')

Recorte robusto con la función de borde de copia opencv:

def imcrop(img, bbox):
   x1, y1, x2, y2 = bbox
   if x1 < 0 or y1 < 0 or x2 > img.shape[1] or y2 > img.shape[0]:
        img, x1, x2, y1, y2 = pad_img_to_fit_bbox(img, x1, x2, y1, y2)
   return img[y1:y2, x1:x2, :]

def pad_img_to_fit_bbox(img, x1, x2, y1, y2):
    img = cv2.copyMakeBorder(img, - min(0, y1), max(y2 - img.shape[0], 0),
                            -min(0, x1), max(x2 - img.shape[1], 0),cv2.BORDER_REPLICATE)
   y2 += -min(0, y1)
   y1 += -min(0, y1)
   x2 += -min(0, x1)
   x1 += -min(0, x1)
   return img, x1, x2, y1, y2

Aquí hay un código para un imcrop más robusto (un poco como en matlab)

def imcrop(img, bbox): 
    x1,y1,x2,y2 = bbox
    if x1 < 0 or y1 < 0 or x2 > img.shape[1] or y2 > img.shape[0]:
        img, x1, x2, y1, y2 = pad_img_to_fit_bbox(img, x1, x2, y1, y2)
    return img[y1:y2, x1:x2, :]

def pad_img_to_fit_bbox(img, x1, x2, y1, y2):
    img = np.pad(img, ((np.abs(np.minimum(0, y1)), np.maximum(y2 - img.shape[0], 0)),
               (np.abs(np.minimum(0, x1)), np.maximum(x2 - img.shape[1], 0)), (0,0)), mode="constant")
    y1 += np.abs(np.minimum(0, y1))
    y2 += np.abs(np.minimum(0, y1))
    x1 += np.abs(np.minimum(0, x1))
    x2 += np.abs(np.minimum(0, x1))
    return img, x1, x2, y1, y2

Alternativamente, puede usar el flujo de tensor para el recorte y openCV para hacer una matriz a partir de la imagen.

import cv2
img = cv2.imread('YOURIMAGE.png')

Ahora imges una matriz de formas (altura de imagen, ancho de imagen, 3). Recorte la matriz con tensorflow:

import tensorflow as tf
offset_height=0
offset_width=0
target_height=500
target_width=500
x = tf.image.crop_to_bounding_box(
    img, offset_height, offset_width, target_height, target_width
)

Vuelva a montar la imagen con tf.keras, para que podamos verla si funcionó:

tf.keras.preprocessing.image.array_to_img(
    x, data_format=None, scale=True, dtype=None
)

Esto imprime la imagen en un cuaderno (probado en Google Colab).

Todo el código juntos:

import cv2
img = cv2.imread('YOURIMAGE.png')

import tensorflow as tf
offset_height=0
offset_width=0
target_height=500
target_width=500
x = tf.image.crop_to_bounding_box(
    img, offset_height, offset_width, target_height, target_width
)

tf.keras.preprocessing.image.array_to_img(
    x, data_format=None, scale=True, dtype=None
)