1. 项目概述：从“知其然”到“知其所以然”

在计算机视觉和图像处理的实际项目中，我们经常会遇到一个看似简单、实则暗藏玄机的问题：如何精确地处理一个旋转的矩形？无论是文档矫正、车牌识别，还是工业视觉中的零件定位，RotatedRect（旋转矩形）都是一个绕不开的核心数据结构。很多朋友在初次接触OpenCV的RotatedRect时，可能会被它的几个属性搞得一头雾水——中心点(center)、尺寸(size)、旋转角度(angle)，以及通过points()方法获取的四个顶点。这些属性之间到底有什么对应关系？那个角度是相对于谁旋转的？四个顶点的顺序又遵循什么规律？

更实际的问题是，当我们需要对这个旋转矩形进行进一步操作时，比如：“我想获取这个矩形‘顶部’的那条边进行长度测量”，或者“我需要找到距离图像左上角最近的那个顶点”，如果对上述关系理解不透彻，代码写起来就会非常别扭，甚至得到错误的结果。我自己在早期项目中就踩过不少坑，比如误将角度理解为与水平轴的夹角，导致后续的仿射变换完全错位；又或者想当然地认为顶点顺序是固定的，结果在计算矩形宽度时得到了负值。

因此，这篇内容将彻底厘清OpenCV C++中RotatedRect的所有核心关系。我们不止于解释API文档，更要深入到几何层面和源码逻辑，弄明白每一个参数的定义、计算方式以及它们之间的约束。然后，我们会基于这些理解，解决两个非常实用的工程问题：1. 如何从任意一个RotatedRect中，稳定地获取其指定的边（例如“长边”或“与水平方向夹角小于45度的那条边”）；2. 如何根据某种规则（例如“最上方的点”、“最左侧的点”）获取其指定的顶点。最后，我们还会通过一个“将矩形向右倾斜10度”的案例，来综合运用这些知识，演示如何对旋转矩形进行精确的操控。无论你是正在处理图像矫正的新手，还是需要精确定位的老手，相信这些“干货”和“踩坑经验”都能让你对RotatedRect有一个全新的、透彻的认识。

2. RotatedRect 核心五要素的深度解析

要驾驭RotatedRect，首先必须像了解老朋友一样，熟知它的五个核心属性：中心坐标、宽度、高度、旋转角度以及四个顶点的顺序。它们并非独立存在，而是一个相互约束、共同定义唯一矩形的整体。

2.1 旋转角度(angle)的定义与“陷阱”

这是最容易产生误解的地方。OpenCV官方文档指出，RotatedRect::angle表示矩形围绕其中心点旋转的角度。但关键在于它的取值范围和基准。

角度范围与方向：angle的取值范围是[0, 90)度。是的，它只有90度的范围，而不是360度。这是因为OpenCV用这个角度来描述矩形**“偏转”**的状态，而不是完整的旋转周期。其方向定义为：角度是矩形size.width（即我们通常认为的矩形的“宽度”所在的边）与水平轴（X轴正方向）的夹角，并且这个夹角被限制在0到90度之间。

重要提示：这里的“宽度”(size.width)并不总是视觉上较短的边。RotatedRect的size属性是cv::Size2f类型，包含width和height。OpenCV约定，width是第一条边的长度，height是与第一条边垂直的第二条边的长度。而angle描述的正是这“第一条边”（即width边）的倾斜情况。

角度计算规则：为了将角度限制在[0,90)，OpenCV在内部有一套处理逻辑。假设我们有一个未经限制的、可能超过90度的旋转角度raw_angle（例如来自minAreaRect函数计算的最小外接矩形）。OpenCV会通过交换width和height，并对角度取余或加减90度的方式，将其“规范化”到0-90度范围内。这意味着，你从RotatedRect对象直接读到的angle，可能已经过内部调整，与你直观想象的旋转角度不同。

一个必须理解的例子：想象一个竖直摆放的矩形（高大于宽）。它的最小外接矩形计算后，RotatedRect的size可能是(height, width)，而angle可能是0度（表示“宽度”边是水平的）。此时，视觉上竖直的矩形，其angle属性却是0。这就是很多初学者困惑的根源。

2.2 中心点(center)与尺寸(size)的几何意义

中心点center是一个cv::Point2f，它就是这个旋转矩形的几何中心，也是所有旋转操作的轴心。尺寸size是一个cv::Size2f，如前所述，size.width和size.height分别代表两条相邻边的长度。

这里的关键在于理解size与angle的耦合关系：size.width对应的边，其方向由angle定义。size.height对应的边，则与width边垂直。因此，仅仅知道size和center，只能确定一个轴对齐的矩形。必须加上angle，才能唯一确定一个旋转矩形在平面中的位置和姿态。

2.3 四个顶点(points)的顺序之谜

通过RotatedRect::points(cv::Point2f pts[4])函数可以获取矩形的四个顶点。这个顺序是固定的，并且与angle和size的定义强相关。

顶点顺序规则：

1. 索引0 (pts[0]): 这个点与angle定义的width边直接相关。可以将其理解为“起始点”。
2. 后续顺序：四个顶点按逆时针方向排列。
3. 与width/height的关系：从pts[0]到pts[1]的向量，方向对应于angle所定义的width边的方向。从pts[1]到pts[2]的向量，方向对应于height边的方向（与width垂直）。

如何推导顶点坐标？理解其计算方式能加深记忆。假设中心为(cx, cy)，width = w,height = h, 角度为theta（弧度制）。

• 首先计算angle方向（即width边方向）的单位向量：u = (cos(theta), sin(theta))
• 计算height边方向（与width垂直，逆时针旋转90度）的单位向量：v = (-sin(theta), cos(theta))
• 那么四个顶点可以计算为：
  • pts[0] = center + ( -w/2 * u ) + ( -h/2 * v )
  • pts[1] = center + ( +w/2 * u ) + ( -h/2 * v )
  • pts[2] = center + ( +w/2 * u ) + ( +h/2 * v )
  • pts[3] = center + ( -w/2 * u ) + ( +h/2 * v )从pts[0]到pts[1]的向量是w * u，即width边。从pts[1]到pts[2]的向量是h * v，即height边。

实操心得：永远不要依赖顶点的“上下左右”视觉位置来编程，因为顺序是固定的，而矩形旋转后，pts[0]可能出现在任何角落。必须依据上述几何关系来理解顶点。

2.4 属性间的约束与联动关系

这五个要素是一个闭环系统：

• center和size定义了矩形的“本体”。
• angle定义了size.width边的空间朝向。
• points是center,size,angle通过几何公式计算出的结果，是它们的直观体现。

一个关键推论：如果你修改了RotatedRect的angle，它的points会变，但center和size不变。如果你修改了size，points也会变，但center和angle不变。center只影响位置。points是派生属性，通常不建议直接修改顶点来反向定义矩形，因为四个点可能不构成精确的矩形，最好通过RotatedRect(center, size, angle)构造函数来创建或修改。

3. 获取最小外接矩形(minAreaRect)的深入理解

cv::minAreaRect(InputArray points)是我们获取RotatedRect最常用的函数。它接收一个点集（轮廓），返回能包围该点集的面积最小的旋转矩形。理解它的输出对于后续操作至关重要。

3.1 minAreaRect 的输出行为

这个函数内部实现了旋转卡壳算法。其返回的RotatedRect严格遵守我们之前讨论的规则：angle在[0,90)度之间。但这里有一个极其重要的细节，也是无数人踩坑的地方：

minAreaRect为了满足angle in [0,90)的约定，可能会交换其计算出的原始矩形的width和height。

这意味着什么？假设一个点集的最小外接矩形实际是一个“竖长横短”的矩形，其长边与水平轴夹角为10度。理论上，width应该是较短的边，angle应该是10度。但minAreaRect内部可能这样处理：它发现如果设定width为长边，angle会是10+90=100度，超出了[0,90)范围。于是，它将长边赋值给height，短边赋值给width，并将角度调整为10-90=-80，再规范化为10度（因为-80度与10度在矩形朝向上市等价的，只是宽高交换了）。最终你得到的RotatedRect可能是：size = (短边, 长边),angle = 10度。

带来的影响：此时，angle表示的是短边（即width）与水平轴的夹角。如果你期望angle始终代表长边的倾斜角度，就需要在代码中做判断和转换。

3.2 判断与统一“长边”与“角度”的实践

为了在工程中统一处理，我们常常希望RotatedRect的width始终代表长边，height代表短边，angle代表长边的倾斜角度（范围可以扩展到[0,180)）。这需要我们对minAreaRect的结果进行后处理。

cv::RotatedRect unifiedMinAreaRect(const std::vector<cv::Point>& contour) { cv::RotatedRect rect = cv::minAreaRect(contour); cv::Size2f size = rect.size; float angle = rect.angle; // 如果宽度小于高度，说明minAreaRect可能交换了宽高以符合angle范围 // 此时，实际的长边是height，我们需要将其交换到width，并调整角度 if (size.width < size.height) { std::swap(size.width, size.height); angle += 90.0f; // 原角度是短边（现width）的，长边（现height）需加90度 // 可选：将角度规范到[0, 180)度范围 // angle = fmod(angle, 180.0f); // if (angle < 0) angle += 180.0f; } // 注意：经过此操作，angle可能超出[0,90)，这是我们自定义的约定 return cv::RotatedRect(rect.center, size, angle); }

注意事项：是否进行这个转换取决于你的具体需求。如果你的后续算法（比如仿射变换校正）依赖于OpenCV标准的RotatedRect定义（angle in [0,90)），则不应交换。如果你的逻辑需要基于“长边的倾斜”来工作，则必须进行转换。在团队项目中，务必明确并统一使用哪一种约定。

4. 实战技巧一：从RotatedRect中获取指定边

理解了底层原理，我们就可以解决实际工程问题。第一个常见需求是：给定一个RotatedRect，如何稳定地获取它的某一条特定的边？例如，“上边”、“左边”，或者“长度较长的边”、“长度较短的边”。

4.1 基于顶点顺序的边获取方法

最直接的方法是利用四个顶点的固定顺序。我们知道：

• 边E0:pts[0]->pts[1]对应width边。
• 边E1:pts[1]->pts[2]对应height边。
• 边E2:pts[2]->pts[3]对应width边（反向）。
• 边E3:pts[3]->pts[0]对应height边（反向）。

因此，获取width边和height边非常简单：

void getWidthAndHeightEdges(const cv::RotatedRect& rect, cv::Point2f& widthEdgeStart, cv::Point2f& widthEdgeEnd, cv::Point2f& heightEdgeStart, cv::Point2f& heightEdgeEnd) { cv::Point2f pts[4]; rect.points(pts); // width边: pts[0] -> pts[1] widthEdgeStart = pts[0]; widthEdgeEnd = pts[1]; // height边: pts[1] -> pts[2] heightEdgeStart = pts[1]; heightEdgeEnd = pts[2]; }

4.2 获取“长边”与“短边”

如果我们的矩形是经过minAreaRect获取且未做统一化处理，那么width可能不是长边。我们需要先判断：

void getLongAndShortEdges(const cv::RotatedRect& rect, cv::Point2f& longEdgeStart, cv::Point2f& longEdgeEnd, cv::Point2f& shortEdgeStart, cv::Point2f& shortEdgeEnd) { cv::Point2f pts[4]; rect.points(pts); float w = rect.size.width; float h = rect.size.height; if (w >= h) { // width是长边或相等 longEdgeStart = pts[0]; longEdgeEnd = pts[1]; shortEdgeStart = pts[1]; shortEdgeEnd = pts[2]; } else { // height是长边 longEdgeStart = pts[1]; longEdgeEnd = pts[2]; shortEdgeStart = pts[0]; shortEdgeEnd = pts[1]; } }

4.3 根据角度或位置获取特定边（如“最接近水平的边”）

这是一个更复杂但也更实用的需求。例如，在文档矫正中，我们想找到文本行的基线（通常接近水平）。思路是计算每条边与水平轴的夹角，选择夹角最小的那条边。

// 计算两点构成向量与水平轴（X轴正方向）的夹角，范围[-180, 180] float edgeAngle(const cv::Point2f& p1, const cv::Point2f& p2) { cv::Point2f vec = p2 - p1; // 使用atan2计算角度（弧度），并转换为度 float angle_rad = std::atan2(vec.y, vec.x); float angle_deg = angle_rad * 180.0 / CV_PI; return angle_deg; } // 获取RotatedRect中与水平方向夹角绝对值最小的边 void getMostHorizontalEdge(const cv::RotatedRect& rect, cv::Point2f& edgeStart, cv::Point2f& edgeEnd) { cv::Point2f pts[4]; rect.points(pts); // 定义四条边 std::vector<std::pair<cv::Point2f, cv::Point2f>> edges = { {pts[0], pts[1]}, // E0 {pts[1], pts[2]}, // E1 {pts[2], pts[3]}, // E2 {pts[3], pts[0]} // E3 }; float minAbsAngle = 180.0f; int minIdx = 0; for (int i = 0; i < 4; ++i) { float angle = edgeAngle(edges[i].first, edges[i].second); // 将角度规范到[-90, 90)度，因为一条边与其反向边在“水平程度”上是等价的 if (angle >= 90.0f) angle -= 180.0f; if (angle < -90.0f) angle += 180.0f; float absAngle = std::fabs(angle); if (absAngle < minAbsAngle) { minAbsAngle = absAngle; minIdx = i; } } edgeStart = edges[minIdx].first; edgeEnd = edges[minIdx].second; }

这个方法可以灵活地扩展到寻找“最垂直的边”或其他方向的边。

5. 实战技巧二：从RotatedRect中获取指定点

另一个常见需求是根据某种空间规则获取特定的顶点，例如“y坐标最小的点”（最上方的点，因为图像坐标系y轴向下）、“x坐标最小的点”（最左侧的点）等。

5.1 获取四个顶点并排序

基本步骤是先获取四个顶点，然后根据规则排序。

// 获取最上方的顶点（y坐标最小） cv::Point2f getTopmostPoint(const cv::RotatedRect& rect) { cv::Point2f pts[4]; rect.points(pts); cv::Point2f topPt = pts[0]; for (int i = 1; i < 4; ++i) { if (pts[i].y < topPt.y) { topPt = pts[i]; } } return topPt; } // 获取最左侧的顶点（x坐标最小） cv::Point2f getLeftmostPoint(const cv::RotatedRect& rect) { cv::Point2f pts[4]; rect.points(pts); cv::Point2f leftPt = pts[0]; for (int i = 1; i < 4; ++i) { if (pts[i].x < leftPt.x) { leftPt = pts[i]; } } return leftPt; } // 更通用的方法：获取所有顶点并按规则排序 std::vector<cv::Point2f> getPointsSortedByY(const cv::RotatedRect& rect) { cv::Point2f pts[4]; rect.points(pts); std::vector<cv::Point2f> pointVec(pts, pts+4); std::sort(pointVec.begin(), pointVec.end(), [](const cv::Point2f& a, const cv::Point2f& b) { return a.y < b.y; }); return pointVec; // 第一个元素就是最上方的点 }

5.2 获取距离某点最近/最远的顶点

在交互或匹配场景中，我们可能需要找到距离另一个点（如鼠标点击点、另一个矩形的中心）最近或最远的顶点。

cv::Point2f getClosestVertexToPoint(const cv::RotatedRect& rect, const cv::Point2f& targetPt) { cv::Point2f pts[4]; rect.points(pts); int minIdx = 0; double minDist = cv::norm(pts[0] - targetPt); for (int i = 1; i < 4; ++i) { double dist = cv::norm(pts[i] - targetPt); if (dist < minDist) { minDist = dist; minIdx = i; } } return pts[minIdx]; }

5.3 根据角度关系获取顶点（如“角度方向上的前端点”）

有时我们需要获取矩形在某个特定方向上的“前端”顶点。例如，在车辆检测中，矩形代表车辆，我们想获取车头方向上的点。这需要结合矩形的angle和center来计算。

假设我们定义矩形的“前端”是width边（即pts[0]到pts[1]的向量方向）的中点。那么，前端点可以近似为(pts[0] + pts[1]) / 2。但更精确的方法是，从中心点沿angle方向（即width边的方向）移动width/2的距离。

cv::Point2f getFrontPoint(const cv::RotatedRect& rect) { float angle_rad = rect.angle * CV_PI / 180.0f; // 转为弧度 // 计算width边方向的单位向量 cv::Point2f dir(std::cos(angle_rad), std::sin(angle_rad)); // 从中心点，沿dir方向，移动 width/2 的距离 cv::Point2f frontPt = rect.center + dir * (rect.size.width / 2.0f); return frontPt; }

注意，这个方法依赖于rect.angle代表width边方向的前提。如果你使用了自定义的统一化矩形（width为长边），那么这个方法获取的就是长边方向的前端点。

6. 综合案例：将矩形向右倾斜10度

现在，我们综合运用以上知识，完成一个具体任务：给定一个RotatedRect（可能来自minAreaRect），将其围绕自身中心点，向右（顺时针）倾斜10度，并得到新的RotatedRect。

这个任务分解为几个关键步骤：

1. 理解“向右倾斜10度”：在图像坐标系中，X轴向右，Y轴向下。因此，“向右倾斜”通常意味着顺时针旋转。顺时针旋转，角度增加（在常见的数学极坐标系中，逆时针为正）。但OpenCV的RotatedRect::angle定义是width边与X轴的夹角，且范围在[0,90)。我们需要小心处理。
2. 确定旋转基准：是保持矩形的物理形状不变，只改变其angle属性？还是保持width和height对应的边不变，改变angle？通常，我们指的是前者：矩形作为一个整体刚性旋转。
3. 处理角度范围：直接给angle加上10度，可能会使新角度超出[0,90)范围。我们需要决定是让新的RotatedRect仍然遵守OpenCV的规范（可能需要交换宽高），还是保留我们自定义的角度范围。

6.1 方案一：遵守OpenCV规范，进行规范化旋转

目标是生成一个仍然合法的、angle在[0,90)范围内的新RotatedRect。

cv::RotatedRect rotateRectClockwiseStandard(const cv::RotatedRect& rect, float degrees) { // degrees 应为正数，表示顺时针旋转 float new_angle = rect.angle + degrees; cv::Size2f new_size = rect.size; // 处理角度，使其落在[0, 90)区间，必要时交换宽高 // 由于是顺时针旋转，角度增加，我们主要处理角度>=90的情况 while (new_angle >= 90.0f) { new_angle -= 90.0f; // 角度每变化90度，宽高需要交换一次，以保持矩形的视觉朝向不变 std::swap(new_size.width, new_size.height); } // 处理角度为负的情况（如果degrees是负数或初始angle很小） while (new_angle < 0.0f) { new_angle += 90.0f; std::swap(new_size.width, new_size.height); } return cv::RotatedRect(rect.center, new_size, new_angle); } // 使用：向右倾斜10度 cv::RotatedRect rect_rotated = rotateRectClockwiseStandard(original_rect, 10.0f);

这个方案的优点是结果完全符合OpenCV标准，可以直接用于其他OpenCV函数。缺点是旋转后，width和height可能被交换，如果你之前的逻辑依赖于width是某条特定的边，就会出错。

6.2 方案二：基于自定义统一化矩形的旋转（推荐用于逻辑控制）

如果我们事先将矩形统一化（width为长边，angle为长边角度，范围[0,180)），那么旋转操作就直观很多。

// 假设我们有一个统一化后的矩形 unified_rect (width为长边，angle范围[0,180)) cv::RotatedRect rotateRectCustom(const cv::RotatedRect& unified_rect, float degrees) { // 直接修改角度，保持宽高不变 float new_angle = unified_rect.angle + degrees; // 顺时针加，逆时针减 // 可选：将角度规范到[0, 180)度 // new_angle = fmod(new_angle, 180.0f); // if (new_angle < 0) new_angle += 180.0f; return cv::RotatedRect(unified_rect.center, unified_rect.size, new_angle); } // 使用步骤： // 1. 从轮廓获取原始矩形 cv::RotatedRect raw_rect = cv::minAreaRect(contour); // 2. 统一化（确保width为长边） cv::RotatedRect unified_rect = unifiedMinAreaRect(contour); // 使用3.2节定义的函数 // 3. 向右倾斜10度 cv::RotatedRect rotated_rect = rotateRectCustom(unified_rect, 10.0f);

这个方案逻辑清晰，旋转前后矩形的“长边”和“短边”属性保持不变，非常适合需要基于矩形方向进行后续处理的场景。

6.3 方案三：通过顶点旋转再重新计算最小外接矩形

这是一种更“暴力”但更几何直观的方法：直接计算原矩形的四个顶点，将这些顶点绕矩形中心旋转指定角度，然后用minAreaRect重新计算旋转后的矩形。

cv::RotatedRect rotateRectByPoints(const cv::RotatedRect& rect, float degrees) { cv::Point2f pts[4]; rect.points(pts); float angle_rad = -degrees * CV_PI / 180.0f; // 注意：将点绕中心顺时针旋转degrees度，等价于坐标系逆时针旋转，故用负号 float cos_a = std::cos(angle_rad); float sin_a = std::sin(angle_rad); cv::Point2f center = rect.center; std::vector<cv::Point2f> rotated_pts; for (int i = 0; i < 4; ++i) { // 将点平移至原点（相对于中心），旋转，再平移回去 cv::Point2f p = pts[i] - center; float x_new = p.x * cos_a - p.y * sin_a; float y_new = p.x * sin_a + p.y * cos_a; rotated_pts.push_back(cv::Point2f(x_new, y_new) + center); } // 重新计算最小外接矩形 return cv::minAreaRect(rotated_pts); }

这个方法的优点是绝对准确，符合几何旋转的定义。缺点是效率稍低（需要计算点和一次minAreaRect），且结果会再次受到minAreaRect规范化规则的影响，可能不是最直观的。

实操心得：在大多数需要精确控制旋转且后续逻辑依赖矩形属性的项目中，我推荐方案二。它先在逻辑层建立一个清晰、稳定的矩形表示（统一化），然后在这个表示上进行直观的角度加减操作，避免了OpenCV内部规范化带来的歧义。方案一适合与OpenCV其他函数无缝交互。方案三则在需要确保旋转的纯粹几何正确性时使用。

7. 常见问题与排查技巧实录

在实际使用RotatedRect的过程中，肯定会遇到各种奇怪的现象。下面是我总结的一些典型问题及其解决方法。

7.1 角度计算为什么和我预想的不一样？

问题描述：用minAreaRect计算一个明显倾斜的矩形，得到的angle却是0度或一个很小的角度。原因分析：这是最经典的“宽高交换”问题。如3.1节所述，minAreaRect为了满足angle in [0,90)，可能交换了宽高。你看到的angle是交换后width边（可能是短边）的角度。解决方案：

1. 打印出rect.size.width和rect.size.height，看是否width < height。如果是，则发生了交换。
2. 根据你的需求，决定是否使用第3.2节的unifiedMinAreaRect函数进行统一化。
3. 在调试时，同时绘制出矩形和它的四个顶点（用不同颜色或数字标记pts[0]），观察width边（pts[0]->pts[1]）的实际方向，与angle值对照理解。

7.2 绘制出来的矩形方向错误

问题描述：使用cv::rectangle或cv::drawContours绘制RotatedRect时，方向不对。原因分析：cv::rectangle只能画轴对齐的矩形。绘制旋转矩形通常用cv::drawContours或cv::polylines。正确绘制方法：

cv::RotatedRect rect = ...; cv::Point2f vertices[4]; rect.points(vertices); std::vector<std::vector<cv::Point>> contours; std::vector<cv::Point> pts; for (int i = 0; i < 4; ++i) { pts.push_back(vertices[i]); // 可能需要转换为cv::Point } contours.push_back(pts); cv::drawContours(image, contours, 0, cv::Scalar(0, 255, 0), 2);

或者直接用polylines:

cv::Point2f vertices[4]; rect.points(vertices); cv::Point ptsi[4]; for (int i = 0; i < 4; ++i) ptsi[i] = vertices[i]; cv::polylines(image, std::vector<cv::Point>(ptsi, ptsi+4), true, cv::Scalar(0,0,255), 2);

7.3 如何根据RotatedRect进行图像裁剪(ROI)？

问题描述：想从原图中裁剪出旋转矩形区域的内容。解决方案：这需要用到仿射变换。步骤是：

1. 获取旋转矩形的中心、大小和角度。
2. 获取旋转矩形对应的旋转矩阵（cv::getRotationMatrix2D）。
3. 对原图进行旋转，使矩形变为水平。
4. 在旋转后的图像中，使用cv::Rect（中心点 - size/2, size）进行裁剪。

cv::Mat cropRotatedRect(const cv::Mat& src, const cv::RotatedRect& rect) { // 获取矩形的参数 cv::Point2f center = rect.center; cv::Size2f size = rect.size; float angle = rect.angle; // 为了正确裁剪，如果宽度小于高度，需要调整（因为angle可能对应短边） bool swapSize = false; if (size.width < size.height) { std::swap(size.width, size.height); angle += 90.0f; swapSize = true; // 标记我们交换过 } // 获取旋转矩阵 cv::Mat M = cv::getRotationMatrix2D(center, angle, 1.0); // 旋转图像 cv::Mat rotated; cv::warpAffine(src, rotated, M, src.size(), cv::INTER_CUBIC); // 在旋转后的图像中裁剪矩形区域 cv::Rect roi(center.x - size.width/2, center.y - size.height/2, size.width, size.height); // 确保ROI在图像范围内 roi = roi & cv::Rect(0, 0, rotated.cols, rotated.rows); cv::Mat cropped = rotated(roi).clone(); // 如果之前交换了宽高，裁剪出的图像可能是“横”的，可能需要再转置一下？视需求而定。 // 通常我们期望裁剪出的图像是正放的（物体水平）。如果物体原本是竖直的，交换宽高并加90度后，裁剪出的图像就是正的。 return cropped; }

这是一个简化示例，实际应用中需要考虑边界、插值方法以及是否需要对裁剪结果进行二次旋转。

7.4 计算两个RotatedRect的重叠面积(IoU)

问题描述：在目标检测等任务中，需要计算两个旋转矩形的交并比。难点分析：旋转矩形的IoU计算比轴对齐矩形复杂得多，因为交集是多边形。解决方案：OpenCV没有直接提供函数。常用方法是：

1. 使用cv::rotatedRectangleIntersection计算两个旋转矩形的相交多边形。
2. 使用cv::contourArea计算相交多边形的面积。
3. 分别计算两个旋转矩形的面积（rect.size.area()）。
4. IoU = 交集面积 / (面积1 + 面积2 - 交集面积)。

double rotatedRectIoU(const cv::RotatedRect& rect1, const cv::RotatedRect& rect2) { std::vector<cv::Point2f> intersectPts; int intersectType = cv::rotatedRectangleIntersection(rect1, rect2, intersectPts); if (intersectPts.empty() || intersectType == cv::INTERSECT_NONE) { return 0.0; } if (intersectType == cv::INTERSECT_FULL) { // 一个矩形完全包含另一个，交集面积等于被包含者的面积 float area1 = rect1.size.area(); float area2 = rect2.size.area(); return std::min(area1, area2) / (area1 + area2 - std::min(area1, area2)); } // 计算相交多边形面积 float intersectArea = cv::contourArea(intersectPts); float area1 = rect1.size.area(); float area2 = rect2.size.area(); return intersectArea / (area1 + area2 - intersectArea); }

注意：cv::rotatedRectangleIntersection的结果多边形点序可能是乱的，contourArea要求点序为顺时针或逆时针。上述代码在大多数情况下工作，但对于非常扭曲的交集，可能需要先对点进行排序。

7.5 性能优化与小技巧

• 避免频繁计算顶点：rect.points(pts)每次调用都会进行三角函数计算。如果在一个循环中需要多次使用同一矩形的顶点，应先计算并保存。
• 面积比较：rect.size.area()（width * height）比通过顶点计算contourArea快得多。
• 快速判断是否水平/垂直：如果只关心矩形是否接近水平或垂直，可以检查angle是否接近0或90度，或者检查width边向量与水平轴的夹角。对于统一化后的矩形（width为长边），angle接近0度表示水平，接近90度表示垂直。
• 与boundingRect结合使用：cv::boundingRect(contour)可以快速得到轴对齐的外接矩形。如果你只需要一个粗略的ROI进行后续处理，先用boundingRect裁剪可以大幅减少计算量，然后再在裁剪后的小图中进行minAreaRect等精细操作。

处理旋转矩形就像与一个有着固定习惯但偶尔会闹别扭的伙伴合作。充分理解它的规则（angle的范围约定、顶点顺序），在必要时建立我们自己的“沟通协议”（如统一化），就能让它成为图像处理中无比强大的工具。希望这些从原理到实战，再到踩坑经验的分享，能让你下次面对RotatedRect时，心中不再有疑惑，手下尽是准确的代码。