Обработка изображений с одного на несколько изображений

Question

У меня есть изображение, показывающее ниже:

Мне нужно обрезать заказ с использованием Python кодирования. Мне нужна только карта. Поэтому я хочу обрезать границы. Как это сделать??

Это вывод, который я получил, используя код, указанный в комментарии ниже.

Answer 1

Вы можете попробовать использовать Python Image Library PIL

from PIL import Image
img = Image.open("ImageName.jpg")
area_top = (125,70,444,253)
cropped_img_top = img.crop(area_top)
cropped_img_top.show()

img = Image.open("ImageName.jpg")
area_bottom = (125,306,444,490)
cropped_img_bottom = img.crop(area_bottom)
cropped_img_bottom.show()

если вы хотите редактировать несколько изображений автоматически, вы можете использовать следующую программу, которая обрезает все файлы.jpg в той же папке, что и ваш файл python:

import os
from PIL import Image
files = os.listdir()

for image_name in files:
    if ".jpg" in image_name:
        img = Image.open(image_name)
        area_top = (125, 70, 444, 253)
        cropped_img_top = img.crop(area_top)
        cropped_img_top.save("cropped_top_"+image_name)

        area_bottom = (125, 306, 444, 490)
        cropped_img_bottom = img.crop(area_bottom)
        cropped_img_bottom.save("cropped_bottom_"+image_name)

Изменить: Хорошо, если вы хотите, чтобы он сам находил углы, вы можете попробовать следующий код. Я только что реализовал очень простой алгоритм поиска углов, который отлично работает на предоставленном вами изображении, но я не знаю, как выглядят ваши другие изображения, поэтому там могут быть проблемы. Мне также потребовалось много времени для написания кода, поэтому, пожалуйста, используйте с благодарностью;)

Вот код:

import os
from PIL import Image
import numpy as np


def convolution2d(matrix, kernel):
    m, n = kernel.shape
    y, x = matrix.shape
    y = y - m + 1
    x = x - m + 1
    new_matrix = np.zeros((y, x))
    for i in range(y):
        for j in range(x):
            new_matrix[i][j] = np.sum(matrix[i:i + m, j:j + m] * kernel)
    return new_matrix


def widen(mask, amount):
    return np.array([[mask[0][0]] * amount + [mask[0][1]] * amount] * amount +
                    [[mask[1][0]] * amount + [mask[1][1]] * amount] * amount)


def too_close(existing, new, max_dist):
    for c in existing:
        if (c[0] - new[0]) ** 2 + (c[1] - new[1]) ** 2 < max_dist ** 2:
            return True
    return False


def corner(bw, mask, corner_threshold, offset):
    corner_hotmap = convolution2d(bw, mask)
    corner_threshold = np.max(corner_hotmap) * corner_threshold
    width = len(corner_hotmap)
    height = len(corner_hotmap[0])
    corners = []
    for x in range(width):
        for y in range(height):
            if corner_hotmap[x][y] > corner_threshold:
                if not too_close(corners, [x, y], 10):
                    corners.append([x + offset, y + offset])
    return corners


def get_areas(image, brightness_threshold=100, corner_threshold=0.9, n_pix=4):
    width = len(image)
    height = len(image[0])
    greyscale = np.zeros(shape=(width, height))
    for x in range(width):
        for y in range(height):
            s = sum(image[x][y]) / 3
            if s > brightness_threshold:
                greyscale[x][y] = 1
            else:
                greyscale[x][y] = -1

    top_left = widen([[-1, -1, ], [-1, 1, ]], n_pix)
    bottom_right = widen([[1, -1, ], [-1, -1, ]], n_pix)

    corners_topleft = corner(greyscale, top_left, corner_threshold, n_pix)
    corners_bottomright = corner(greyscale, bottom_right, corner_threshold, n_pix)

    if len(corners_topleft) != len(corners_bottomright):
        return []
    else:
        out = []
        for i in range(len(corners_topleft)):
            out.append((corners_topleft[i][1], corners_topleft[i][0], corners_bottomright[i][1],
                        corners_bottomright[i][0]))
        return out


files = os.listdir()

for image_name in files:
    if ".jpg" in image_name:
        img = Image.open(image_name)
        width = img.size[0]
        height = img.size[1]
        image = np.array(Image.open(image_name).getdata()).reshape(height, width, 3)
        print("Getting Areas for file {}.".format(image_name))
        areas = get_areas(image)
        if len(areas)==0:
            print("Could not find corners for file {}.".format(image_name))
        else:
            print("Found {} cards".format(len(areas)))
        for i in range(len(areas)):
            cropped_img = img.crop(areas[i])
            cropped_img.save("cropped_{}_{}".format(i, image_name))

Найти углы нелегко. Этот алгоритм хорошо работает с предоставленным вами изображением, однако я не знаю, как будут выглядеть другие изображения, и будет ли это работать на них. Удачи вам в обрезке ваших изображений ^^

Answer 2

Все, что вам нужно сделать, это нарезать массивы. Сначала укажите координаты startY и endY, а затем координаты startX и endX для среза. Вот и все. Ваше изображение будет обрезано!

Шаги с использованием Python и OpenCV:

1) загрузить изображение и отобразить его на экране

# import the necessary packages 
import cv2
# load the image and show it
image = cv2.imread("cardWithBorder.jpg")
cv2.imshow("original", image)
cv2.waitKey(0)

2) Получить размеры изображения

print image.shape

3) Обрезка изображения

# crop the image using array slices -- it's a NumPy array
# after all!
cropped = image[70:170, 440:540]
cv2.imshow("cropped", cropped)
cv2.waitKey(0)

4) Сохраните обрезанное изображение на диск, только в формате PNG (оригинал был JPG):

cv2.imwrite("thumbnail.png", cropped)

Answer 3

Может быть, вы можете использовать другой подход, используя opencvгде вы создаете серую маску, чтобы получить только интересные области изображения. Вы можете сделать это так:

#import the necessary packages
import numpy as np
import cv2

#read the image
image = cv2.imread('image.jpg')

#rgb values for grey color in pixels
lower = np.array([80,70,70],dtype='uint8')
upper = np.array([95,85,85],dtype='uint8')

#create a grey mask and then the inverse of that mask
mask = cv2.inRange(image,lower,upper)
mask_inv = cv2.bitwise_not(mask)
output = cv2.bitwise_and(image,image,mask=mask_inv)

# display the result
cv2.imshow('images',np.hstack([output]))
cv2.waitKey(0)

Предполагая, что вы хотите извлекать карты, которые не имеют одинаковую форму / расположение каждый раз, эта техника может пригодиться.