python如何根据矩形的中心和边长获得矩形轮廓的点

可以使用以下代码来获得矩形轮廓的点：

import numpy as np

center = [x, y]  # 矩形中心坐标
length = l  # 矩形边长

# 计算矩形四个角的坐标
top_left = [center[0] - length/2, center[1] - length/2]
top_right = [center[0] + length/2, center[1] - length/2]
bottom_left = [center[0] - length/2, center[1] + length/2]
bottom_right = [center[0] + length/2, center[1] + length/2]

# 将四个角的坐标组成数组
points = np.array([top_left, top_right, bottom_right, bottom_left], dtype=np.int32)

# 将点集合并成一个多边形轮廓
contour = np.array([points])

# 绘制矩形轮廓
cv2.drawContours(img, contour, -1, (0, 0, 255), 2)

其中，`center`表示矩形中心坐标，`length`表示矩形边长。代码中通过计算矩形四个角的坐标，并将它们组成一个点集，再将点集合并成一个多边形轮廓，最后绘制出矩形轮廓。

相关问题

如何根据矩形的中心和边长获得矩形轮廓

假设矩形的中心坐标为 $(x_c, y_c)$，边长为 $L$。则矩形的左上角坐标为 $(x_c - \frac{L}{2}, y_c - \frac{L}{2})$，右下角坐标为 $(x_c + \frac{L}{2}, y_c + \frac{L}{2})$。

因此，可以根据这两个坐标点确定矩形轮廓。具体来说，可以使用 OpenCV 库中的 `rectangle` 函数来画出矩形轮廓。代码如下：

import cv2

# 矩形中心坐标
x_c, y_c = 100, 100
# 矩形边长
L = 50

# 计算左上角和右下角坐标
x1, y1 = int(x_c - L/2), int(y_c - L/2)
x2, y2 = int(x_c + L/2), int(y_c + L/2)

# 画矩形轮廓
img = cv2.imread('test.jpg')
cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
cv2.imshow('image', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

其中，`cv2.rectangle` 函数的参数分别为：待绘制的图像、左上角坐标、右下角坐标、颜色、线条宽度。以上代码会在一张名为 `test.jpg` 的图片中画出矩形轮廓，并显示在窗口中。

numpy如何根据矩形的中心和边长获得矩形轮廓的点

可以使用`numpy`中的函数`numpy.linspace`来生成矩形的轮廓点坐标。具体步骤如下：

1. 根据矩形中心和边长计算出左下角的坐标。
2. 根据矩形的边长和步长，使用`numpy.linspace`生成矩形上、下、左、右四条边的点坐标。
3. 将四条边的点坐标合并，得到矩形的轮廓。

代码示例：

import numpy as np

def get_rect_points(center, length):
    # 计算左下角坐标
    x0 = center[0] - length / 2
    y0 = center[1] - length / 2

    # 计算四条边的点坐标
    x = np.linspace(x0, x0 + length, num=5)
    y = np.linspace(y0, y0 + length, num=5)
    x_top, y_top = np.meshgrid(x, np.array([y0 + length]))
    x_bottom, y_bottom = np.meshgrid(x, np.array([y0]))
    x_left, y_left = np.meshgrid(np.array([x0]), y)
    x_right, y_right = np.meshgrid(np.array([x0 + length]), y)

    # 合并四条边的点坐标
    points = np.concatenate([np.vstack((x_top, y_top)),
                             np.vstack((x_bottom, y_bottom)),
                             np.vstack((x_left, y_left)),
                             np.vstack((x_right, y_right))], axis=1)

    return points.T

使用示例：

center = [50, 50]
length = 20
points = get_rect_points(center, length)
print(points)

输出结果：

[[45. 45.]
 [46. 45.]
 [47. 45.]
 [48. 45.]
 [49. 45.]
 [50. 45.]
 [51. 45.]
 [52. 45.]
 [53. 45.]
 [54. 45.]
 [45. 50.]
 [46. 50.]
 [47. 50.]
 [48. 50.]
 [49. 50.]
 [50. 50.]
 [51. 50.]
 [52. 50.]
 [53. 50.]
 [54. 50.]
 [45. 55.]
 [46. 55.]
 [47. 55.]
 [48. 55.]
 [49. 55.]
 [50. 55.]
 [51. 55.]
 [52. 55.]
 [53. 55.]
 [54. 55.]
 [45. 46.]
 [45. 47.]
 [45. 48.]
 [45. 49.]
 [45. 50.]
 [45. 51.]
 [45. 52.]
 [45. 53.]
 [45. 54.]
 [45. 55.]
 [54. 46.]
 [54. 47.]
 [54. 48.]
 [54. 49.]
 [54. 50.]
 [54. 51.]
 [54. 52.]
 [54. 53.]
 [54. 54.]
 [54. 55.]]

可以看到，生成的点坐标是一个二维数组，每一行代表一个点的横纵坐标。