裁剪 minAreaRect OpenCV 返回的矩形 [Python]

Question

OpenCV 中的

minAreaRect

返回一个旋转的矩形。如何裁剪矩形内图像的这部分？

boxPoints

返回旋转矩形角点的坐标，以便可以通过循环框内的点来访问像素，但是在 Python 中是否有更快的裁剪方法？

编辑

请参阅下面我的回答中的

code

。

Answer 1

这里有一个执行此任务的函数：

import cv2
import numpy as np

def crop_minAreaRect(img, rect):

    # rotate img
    angle = rect[2]
    rows,cols = img.shape[0], img.shape[1]
    M = cv2.getRotationMatrix2D((cols/2,rows/2),angle,1)
    img_rot = cv2.warpAffine(img,M,(cols,rows))

    # rotate bounding box
    rect0 = (rect[0], rect[1], 0.0) 
    box = cv2.boxPoints(rect0)
    pts = np.int0(cv2.transform(np.array([box]), M))[0]    
    pts[pts < 0] = 0

    # crop
    img_crop = img_rot[pts[1][1]:pts[0][1], 
                       pts[1][0]:pts[2][0]]

    return img_crop

这里有一个示例用法

# generate image
img = np.zeros((1000, 1000), dtype=np.uint8)
img = cv2.line(img,(400,400),(511,511),1,120)
img = cv2.line(img,(300,300),(700,500),1,120)

# find contours / rectangle
_,contours,_ = cv2.findContours(img, 1, 1)
rect = cv2.minAreaRect(contours[0])

# crop
img_croped = crop_minAreaRect(img, rect)

# show
import matplotlib.pylab as plt
plt.figure()
plt.subplot(1,2,1)
plt.imshow(img)
plt.subplot(1,2,2)
plt.imshow(img_croped)
plt.show()

这是输出

Answer 2

@AbdulFatir 提出了一个很好的解决方案，但正如评论所述（@Randika @epinal），它对我来说也不太有效，所以我稍微修改了它，它似乎对我的情况有效。这是我正在使用的图像。

im, contours, hierarchy = cv2.findContours(open_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
print("num of contours: {}".format(len(contours)))


mult = 1.2   # I wanted to show an area slightly larger than my min rectangle set this to one if you don't
img_box = cv2.cvtColor(img.copy(), cv2.COLOR_GRAY2BGR)
for cnt in contours:
    rect = cv2.minAreaRect(cnt)
    box = cv2.boxPoints(rect)
    box = np.int0(box)
    cv2.drawContours(img_box, [box], 0, (0,255,0), 2) # this was mostly for debugging you may omit

    W = rect[1][0]
    H = rect[1][1]

    Xs = [i[0] for i in box]
    Ys = [i[1] for i in box]
    x1 = min(Xs)
    x2 = max(Xs)
    y1 = min(Ys)
    y2 = max(Ys)

    rotated = False
    angle = rect[2]

    if angle < -45:
        angle+=90
        rotated = True

    center = (int((x1+x2)/2), int((y1+y2)/2))
    size = (int(mult*(x2-x1)),int(mult*(y2-y1)))
    cv2.circle(img_box, center, 10, (0,255,0), -1) #again this was mostly for debugging purposes

    M = cv2.getRotationMatrix2D((size[0]/2, size[1]/2), angle, 1.0)

    cropped = cv2.getRectSubPix(img_box, size, center)    
    cropped = cv2.warpAffine(cropped, M, size)

    croppedW = W if not rotated else H 
    croppedH = H if not rotated else W

    croppedRotated = cv2.getRectSubPix(cropped, (int(croppedW*mult), int(croppedH*mult)), (size[0]/2, size[1]/2))

    plt.imshow(croppedRotated)
    plt.show()

plt.imshow(img_box)
plt.show()

这应该会产生一系列如下图像：

它还会给出如下结果图像：

Answer 3

这是执行上述任务的代码。为了加快该过程，不是首先旋转整个图像并裁剪，而是先裁剪图像中具有旋转矩形的部分，然后旋转并再次裁剪以获得最终结果。

# Let cnt be the contour and img be the input

rect = cv2.minAreaRect(cnt)  
box = cv2.boxPoints(rect) 
box = np.int0(box)

W = rect[1][0]
H = rect[1][1]

Xs = [i[0] for i in box]
Ys = [i[1] for i in box]
x1 = min(Xs)
x2 = max(Xs)
y1 = min(Ys)
y2 = max(Ys)

angle = rect[2]
if angle < -45:
    angle += 90

# Center of rectangle in source image
center = ((x1+x2)/2,(y1+y2)/2)
# Size of the upright rectangle bounding the rotated rectangle
size = (x2-x1, y2-y1)
M = cv2.getRotationMatrix2D((size[0]/2, size[1]/2), angle, 1.0)
# Cropped upright rectangle
cropped = cv2.getRectSubPix(img, size, center)
cropped = cv2.warpAffine(cropped, M, size)
croppedW = H if H > W else W
croppedH = H if H < W else W
# Final cropped & rotated rectangle
croppedRotated = cv2.getRectSubPix(cropped, (int(croppedW),int(croppedH)), (size[0]/2, size[1]/2))

Answer 4

您没有给出示例代码，所以我也没有代码地回答。 您可以按照以下步骤操作：

1. 从矩形的角点，确定相对于水平轴的旋转角度 alpha。
2. 按 Alpha 旋转图像，使裁剪后的矩形与图像边框平行。确保临时图像尺寸较大，以免丢失信息（参见：旋转图像而不裁剪 OpenCV）
3. 使用 numpy 切片裁剪图像（参见：如何使用 Python 在 OpenCV 中裁剪图像）
4. 将图像旋转回 -alpha。

Answer 5

不幸的是，Oliver Wilken的回答并没有产生所显示的图像。也许是因为 openCV 版本不同？这是我采用的版本，添加了几个功能：

• 矩形的缩放和填充，即获取原始矩形之外的部分
• 结果图像的角度可以相对于矩形进行配置，即 0 或 90 [deg] 的角度将水平或垂直返回矩形
• 返回平移矩阵以旋转其他事物，例如点、线、...
• 用于 numpy 和 openCV 数组索引和矩形操作的辅助函数

代码

import cv2
import numpy as np


def img_rectangle_cut(img, rect=None, angle=None):
    """Translate an image, defined by a rectangle. The image is cropped to the size of the rectangle
    and the cropped image can be rotated.
    The rect must be of the from (tuple(center_xy), tuple(width_xy), angle).
    The angle are in degrees.
    PARAMETER
    ---------
    img: ndarray
    rect: tuple, optional
        define the region of interest. If None, it takes the whole picture
    angle: float, optional
        angle of the output image in respect to the rectangle.
        I.e. angle=0 will return an image where the rectangle is parallel to the image array axes
        If None, no rotation is applied.
    RETURNS
    -------
    img_return: ndarray
    rect_return: tuple
        the rectangle in the returned image
    t_matrix: ndarray
        the translation matrix
    """
    if rect is None:
        if angle is None:
            angle = 0
        rect = (tuple(np.array(img.shape) * .5), img.shape, 0)
    box = cv2.boxPoints(rect)

    rect_target = rect_rotate(rect, angle=angle)
    pts_target = cv2.boxPoints(rect_target)

    # get max dimensions
    size_target = np.int0(np.ceil(np.max(pts_target, axis=0) - np.min(pts_target, axis=0)))

    # translation matrix
    t_matrix = cv2.getAffineTransform(box[:3].astype(np.float32),
                                      pts_target[:3].astype(np.float32))

    # cv2 needs the image transposed
    img_target = cv2.warpAffine(cv2.transpose(img), t_matrix, tuple(size_target))

    # undo transpose
    img_target = cv2.transpose(img_target)
    return img_target, rect_target, t_matrix


def reshape_cv(x, axis=-1):
    """openCV and numpy have a different array indexing (row, cols) vs (cols, rows), compensate it here."""
    if axis < 0:
        axis = len(x.shape) + axis
    return np.array(x).astype(np.float32)[(*[slice(None)] * axis, slice(None, None, -1))]

def connect(x):
    """Connect data for a polar or closed loop plot, i.e. np.append(x, [x[0]], axis=0)."""
    if isinstance(x, np.ma.MaskedArray):
        return np.ma.append(x, [x[0]], axis=0)
    else:
        return np.append(x, [x[0]], axis=0)


def transform_np(x, t_matrix):
    """Apply a transform on a openCV indexed array and return a numpy indexed array."""
    return transform_cv2np(reshape_cv(x), t_matrix)


def transform_cv2np(x, t_matrix):
    """Apply a transform on a numpy indexed array and return a numpy indexed array."""
    return reshape_cv(cv2.transform(np.array([x]).astype(np.float32), t_matrix)[0])


def rect_scale_pad(rect, scale=1., pad=40.):
    """Scale and/or pad a rectangle."""
    return (rect[0],
            tuple((np.array(rect[1]) + pad) * scale),
            rect[2])


def rect_rotate(rect, angle=None):
    """Rotate a rectangle by an angle in respect to it's center.
    The rect must be of the from (tuple(center_xy), tuple(width_xy), angle).
    The angle is in degrees.
    """
    if angle is None:
        angle = rect[2]
    rad = np.deg2rad(np.abs(angle))
    rot_matrix_2d = np.array([[np.cos(rad), np.sin(rad)],
                              [np.sin(rad), np.cos(rad)]])

    # cal. center of rectangle
    center = np.sum(np.array(rect[1]).reshape(1, -1) * rot_matrix_2d, axis=-1) * .5
    center = np.abs(center)

    return tuple(center), rect[1], angle

示例：

# Generate Image
img = np.zeros((1200, 660), dtype=np.uint8)

# Draw some lines and gen. points
x_0 = np.array([150,600])
x_1 = np.int0(x_0 + np.array((100, 100)))
x_2 = np.int0(x_0 + np.array((100, -100))*2.5)
img = cv2.line(img,tuple(x_0),tuple(x_1),1,120)
img = cv2.line(img,tuple(x_0),tuple(x_2),1,120)
points = np.array([x_0, x_1, x_2])

# Get Box
rect = cv2.minAreaRect(np.argwhere(img))

# Apply transformation
rect_scale = rect_scale_pad(rect, scale = 1., pad = 40.)
img_return, rect_target, t_matrix = img_rectangle_cut(
    img, 
    rect_scale, 
    angle=0,
    angle_normalize=True  # True <-> angel=0 vertical; angel=90 horizontal
   )

# PLOT
fig, ax = plt.subplots(ncols=2, figsize=(10,5))
ax = ax.flatten()
ax[0].imshow(img)

box_i = reshape_cv(cv2.boxPoints(rect))
ax[0].plot(*connect(box_i).T, 'o-', color='gray', alpha=.75, label='Original Box')
box_i = reshape_cv(cv2.boxPoints(rect_scale))
ax[0].plot(*connect(box_i).T, 'o-', color='green', alpha=.75, label='Scaled Box')
ax[0].plot(*points.T, 'o', label='Points')


ax[1].imshow(img_return)
box_i = transform_cv2np(cv2.boxPoints(rect), t_matrix)
ax[1].plot(*connect(box_i).T, 'o-', color='gray', alpha=.75, label='Original Box')

point_t = transform_np(points, t_matrix)
ax[1].plot(*point_t.T, 'o', label='Points')

ax[0].set_title('Original')
ax[1].set_title('Translated')

for axi in ax:
    axi.legend(loc=1)
    
plt.tight_layout()

Answer 6

所以，我在这个问题提供的答案中发现了一个错误（尤其是@OliverWilken 的最佳答案）。我认为它可能会严重影响基于该线程的许多算法。这是我发现错误的案例，尽管我认为它是系统发生的：

当使用@OliverWilken的建议函数时，我们得到以下结果：

漂移可能是由于舍入误差和变换的不正确使用造成的。修复如下：

def crop_minAreaRect(img, rect):

   box = cv2.boxPoints(rect)
   box = np.int0(box)
   width, height = int(rect[1][0]), int(rect[1][1])

   src_pts = box.astype('float32')
   dst_pts = np.array([[0, height-1], [0, 0], [width-1, 0], [width-1, height-1]], dtype='float32')
   M = cv2.getPerspectiveTransform(src_pts, dst_pts)
   img_crop = cv2.warpPerspective(img, M, (width, height))

   return img_crop

结果如下：