1、需求介绍
调用 opencv 库，绘制轮廓的矩形边框，坐标顺序为右下→左下→左上→右上，我们实现一下转化为熟悉的 左上→右上→右下→左下 形式
按照这样的顺序组织边界框坐标是执行透视转换或匹配对象角点(例如计算对象之间的距离)等操作的先决条件
2、算法实现
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/10/17 0:20
# @File : order_coordinates.py.py
# @Software: PyCharm
# 导入包
from __future__ import print_function
from imutils import perspective
from imutils import contours
import numpy as np
import argparse
import imutils
import cv2
from scipy.spatial import distance as dist
def order_points_old(pts):
# 初始化将被排序的坐标列表，这样，列表中的第一个条目是左上，第二个条目是右上，第三个条目是右下，第四个条目是左下
rect = np.zeros((4, 2), dtype="float32")
"""
array([[ 90, 236],
[ 42, 236],
[ 42, 190],
[ 90, 190]])
"""
# 左上点的总和最小，而右下点的总和最大
s = pts.sum(axis=1) # x+y array([326, 278, 232, 280])
rect[0] = pts[np.argmin(s)] # 2, array([ 42., 190.], dtype=float32)
rect[2] = pts[np.argmax(s)] # 0, array([ 90., 236.], dtype=float32)
# 现在，计算点之间的差值，右上角的差值最小，而左下角的差值最大
diff = np.diff(pts, axis=1) # array([[146], [194], [148], [100]])
rect[1] = pts[np.argmin(diff)]
rect[3] = pts[np.argmax(diff)]
# 返回有序坐标
return rect
def order_points_old 前，边界框四个顶点的坐标顺序
右下→左下→左上→右上
def order_points_old 后，边界框四个顶点的坐标顺序
左上→右上→右下→左下
假设矩形框比较正，无倾斜，左上角坐标为 （x，y）
- 右上角（x+w，y）
- 左下角（x，y+h）
- 右下角（x+w，y+h）
横纵坐标之差的大小
- 左上角（y-x）
- 右上角（y-x-w）
- 左下角（y-x+h）
- 右下角（y-x+h-w）
这么对比分析的话，确实差值右上角最小，最下角最大
缺陷
当两点的和或差相同时会发生什么？如果数组 和 或数组 diff 有相同的值，我们有选择不正确索引的风险，这会对我们的排序产生严重影响。
改进：
def order_points(pts):
# 根据点的 x 坐标对点进行排序
xSorted = pts[np.argsort(pts[:, 0]), :]
# 从根据点的 x 坐标排序的坐标点中获取最左和最右的点
leftMost = xSorted[:2, :]
rightMost = xSorted[2:, :]
# 现在，根据y坐标对最左边的坐标排序，这样我们就可以分别获取左上角和左下角的点
leftMost = leftMost[np.argsort(leftMost[:, 1]), :]
(tl, bl) = leftMost
# 现在我们有了左上角的坐标，用它作为锚点来计算左上角和右下角点之间的欧氏距离;根据勾股定理，距离最大的点就是右下点
D = dist.cdist(tl[np.newaxis], rightMost, "euclidean")[0]
(br, tr) = rightMost[np.argsort(D)[::-1], :]
# 按左上、右上、右下和左下顺序返回坐标
return np.array([tl, tr, br, bl], dtype="float32")
下面找张图片来实战一下
输入图片
# 构造参数解析并解析参数
ap = argparse.ArgumentParser()
ap.add_argument("-n", "--new", type=int, default=1,
help="whether or not the new order points should should be used")
args = vars(ap.parse_args())
# 加载我们的输入图像，将其转换为灰度，并稍微模糊它
image = cv2.imread("1.jpg")
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imwrite("gray.jpg", gray)
gray.jpg
gray = cv2.GaussianBlur(gray, (7, 7), 0)
cv2.imwrite("GaussianBlur.jpg", gray)
GaussianBlur.jpg
# 执行边缘检测，然后执行膨胀+腐蚀以缩小对象边缘之间的间隙
edged = cv2.Canny(gray, 50, 100)
cv2.imwrite("Canny.jpg", edged)
Canny.jpg
edged = cv2.dilate(edged, None, iterations=1)
cv2.imwrite("dilate.jpg", edged)
dilate.jpg
edged = cv2.erode(edged, None, iterations=1)
cv2.imwrite("erode.jpg", edged)
erode.jpg
# 在边缘图中找到轮廓
cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
# 从左到右对轮廓进行排序并初始化边界框点颜色
(cnts, _) = contours.sort_contours(cnts)
colors = ((0, 0, 255), (240, 0, 159), (255, 0, 0), (255, 255, 0))
# 分别在轮廓上循环
for (i, c) in enumerate(cnts):
# 如果轮廓不够大，则忽略它
if cv2.contourArea(c) < 100:
continue
# 计算轮廓的旋转边界框，然后绘制轮廓
box = cv2.minAreaRect(c)
box = cv2.cv.BoxPoints(box) if imutils.is_cv2() else cv2.boxPoints(box)
box = np.array(box, dtype="int")
cv2.drawContours(image, [box], -1, (0, 255, 0), 2)
# 显示原始坐标
print("Object #{}:".format(i + 1))
print("detect order:\n", box)
# 对轮廓中的点进行排序，使它们以左上、右上、右下和左下的顺序出现，然后绘制旋转边界框的轮廓
rect = order_points_old(box)
print("old order:\n", rect)
rect_new = order_points(box)
print("new order1:\n", rect_new)
# 检查是否应使用新方法对坐标进行排序
if args["new"] > 0:
rect = perspective.order_points(box)
# 显示重新排序的坐标
print("new order2:\n", rect.astype("int"))
print("")
# 遍历原始点并绘制它们
for ((x, y), color) in zip(rect, colors):
cv2.circle(image, (int(x), int(y)), 5, color, -1)
# 在左上角绘制对象编号
cv2.putText(image, "Object #{}".format(i + 1),
(int(rect[0][0] - 15), int(rect[0][1] - 15)),
cv2.FONT_HERSHEY_SIMPLEX, 0.55, (255, 255, 255), 2)
# 显示
cv2.imwrite(f"result_{i+1}.jpg", image)
cv2.imshow("Image", image)
cv2.waitKey(0)
输出
result_1.jpg
Object #1:
detect order:
[[ 90 236]
[ 42 236]
[ 42 190]
[ 90 190]]
old order:
[[ 42. 190.]
[ 90. 190.]
[ 90. 236.]
[ 42. 236.]]
new order1:
[[ 42. 190.]
[ 90. 190.]
[ 90. 236.]
[ 42. 236.]]
new order2:
[[ 42 190]
[ 90 190]
[ 90 236]
[ 42 236]]
result_2.jpg
Object #2:
detect order:
[[192 192]
[171 94]
[342 59]
[362 157]]
old order:
[[171. 94.]
[342. 59.]
[362. 157.]
[192. 192.]]
new order1:
[[171. 94.]
[342. 59.]
[362. 157.]
[192. 192.]]
new order2:
[[171 94]
[342 59]
[362 157]
[192 192]]
result_3.jpg
Object #3:
detect order:
[[395 229]
[348 229]
[348 183]
[395 183]]
old order:
[[348. 183.]
[395. 183.]
[395. 229.]
[348. 229.]]
new order1:
[[348. 183.]
[395. 183.]
[395. 229.]
[348. 229.]]
new order2:
[[348 183]
[395 183]
[395 229]
[348 229]]
result_4.jpg
Object #4:
detect order:
[[400 383]
[377 258]
[489 237]
[512 363]]
old order:
[[377. 258.]
[489. 237.]
[512. 363.]
[400. 383.]]
new order1:
[[377. 258.]
[489. 237.]
[512. 363.]
[400. 383.]]
new order2:
[[377 258]
[489 237]
[512 363]
[400 383]]
result_5.jpg
Object #5:
detect order:
[[495 211]
[392 161]
[450 42]
[553 92]]
old order:
[[450. 42.]
[553. 92.]
[495. 211.]
[392. 161.]]
new order1:
[[450. 42.]
[553. 92.]
[495. 211.]
[392. 161.]]
new order2:
[[450 42]
[553 92]
[495 211]
[392 161]]
result_6.jpg
Object #6:
detect order:
[[520 255]
[491 226]
[520 197]
[549 226]]
old order:
[[491. 226.]
[520. 197.]
[520. 255.]
[520. 255.]]
new order1:
[[491. 226.]
[520. 197.]
[549. 226.]
[520. 255.]]
new order2:
[[491 226]
[520 197]
[549 226]
[520 255]]
注意到目标 6：
横纵坐标和：
520 + 255 = 775
491 + 226 = 717
520 + 197 = 717
549 + 226 = 775
横纵坐标差:
520 – 255 = 265
491 – 226 = 265
520 – 197 = 323
549 – 226 = 323
和、差里面出现了相等的元素，old order 方法可能会出现错误顺序的赋值导致错误，新的方法则不会
3、完整代码
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2021/10/17 0:20
# @File : order_coordinates.py.py
# @Software: PyCharm
# 导入包
from __future__ import print_function
from imutils import perspective
from imutils import contours
import numpy as np
import argparse
import imutils
import cv2
from scipy.spatial import distance as dist
def order_points_old(pts):
# 初始化将被排序的坐标列表，这样，列表中的第一个条目是左上，第二个条目是右上，第三个条目是右下，第四个条目是左下
rect = np.zeros((4, 2), dtype="float32")
"""
array([[ 90, 236],
[ 42, 236],
[ 42, 190],
[ 90, 190]])
"""
# 左上点的总和最小，而右下点的总和最大
s = pts.sum(axis=1) # x+y array([326, 278, 232, 280])
rect[0] = pts[np.argmin(s)] # 2, array([ 42., 190.], dtype=float32)
rect[2] = pts[np.argmax(s)] # 0, array([ 90., 236.], dtype=float32)
# 现在，计算点之间的差值，右上角的差值最小，而左下角的差值最大
diff = np.diff(pts, axis=1) # array([[146], [194], [148], [100]])
rect[1] = pts[np.argmin(diff)]
rect[3] = pts[np.argmax(diff)]
# 返回有序坐标
return rect
def order_points(pts):
# 根据点的 x 坐标对点进行排序
xSorted = pts[np.argsort(pts[:, 0]), :]
# 从根据点的 x 坐标排序的坐标点中获取最左和最右的点
leftMost = xSorted[:2, :]
rightMost = xSorted[2:, :]
# 现在，根据y坐标对最左边的坐标排序，这样我们就可以分别获取左上角和左下角的点
leftMost = leftMost[np.argsort(leftMost[:, 1]), :]
(tl, bl) = leftMost
# 现在我们有了左上角的坐标，用它作为锚点来计算左上角和右下角点之间的欧氏距离;根据勾股定理，距离最大的点就是右下点
D = dist.cdist(tl[np.newaxis], rightMost, "euclidean")[0]
(br, tr) = rightMost[np.argsort(D)[::-1], :]
# 按左上、右上、右下和左下顺序返回坐标
return np.array([tl, tr, br, bl], dtype="float32")
# 构造参数解析并解析参数
ap = argparse.ArgumentParser()
ap.add_argument("-n", "--new", type=int, default=1,
help="whether or not the new order points should should be used")
args = vars(ap.parse_args())
# 加载我们的输入图像，将其转换为灰度，并稍微模糊它
image = cv2.imread("1.jpg")
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imwrite("gray.jpg", gray)
gray = cv2.GaussianBlur(gray, (7, 7), 0)
cv2.imwrite("GaussianBlur.jpg", gray)
# 执行边缘检测，然后执行膨胀+腐蚀以缩小对象边缘之间的间隙
edged = cv2.Canny(gray, 50, 100)
cv2.imwrite("Canny.jpg", edged)
edged = cv2.dilate(edged, None, iterations=1)
cv2.imwrite("dilate.jpg", edged)
edged = cv2.erode(edged, None, iterations=1)
cv2.imwrite("erode.jpg", edged)
# 在边缘图中找到轮廓
cnts = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = imutils.grab_contours(cnts)
# 从左到右对轮廓进行排序并初始化边界框点颜色
(cnts, _) = contours.sort_contours(cnts)
colors = ((0, 0, 255), (240, 0, 159), (255, 0, 0), (255, 255, 0))
# 分别在轮廓上循环
for (i, c) in enumerate(cnts):
# 如果轮廓不够大，则忽略它
if cv2.contourArea(c) < 100:
continue
# 计算轮廓的旋转边界框，然后绘制轮廓
box = cv2.minAreaRect(c)
box = cv2.cv.BoxPoints(box) if imutils.is_cv2() else cv2.boxPoints(box)
box = np.array(box, dtype="int")
cv2.drawContours(image, [box], -1, (0, 255, 0), 2)
# 显示原始坐标
print("Object #{}:".format(i + 1))
print("detect order:\n", box)
# 对轮廓中的点进行排序，使它们以左上、右上、右下和左下的顺序出现，然后绘制旋转边界框的轮廓
rect = order_points_old(box)
print("old order:\n", rect)
rect_new = order_points(box)
print("new order1:\n", rect_new)
# 检查是否应使用新方法对坐标进行排序
if args["new"] > 0:
rect = perspective.order_points(box)
# 显示重新排序的坐标
print("new order2:\n", rect.astype("int"))
print("")
# 遍历原始点并绘制它们
for ((x, y), color) in zip(rect, colors):
cv2.circle(image, (int(x), int(y)), 5, color, -1)
# 在左上角绘制对象编号
cv2.putText(image, "Object #{}".format(i + 1),
(int(rect[0][0] - 15), int(rect[0][1] - 15)),
cv2.FONT_HERSHEY_SIMPLEX, 0.55, (255, 255, 255), 2)
# 显示
cv2.imwrite(f"result_{i+1}.jpg", image)
cv2.imshow("Image", image)
cv2.waitKey(0)
