【python】OpenCV—Coordinates Sorted Clockwise

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 distdef 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 distdef 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 rectdef 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)

---

参考学习来自：OpenCV基础（26）使用 Python 和 OpenCV 顺时针排序坐标