获取轮廓的最小外接矩形

本文主要实现了轮廓的最小面积外接矩形：

(1)对获取的凸包点，计算凸包线的角度；

(2)将凸包点按照计算的凸包线角度进行旋转；

(3)获取旋转后的点在x、y两方向上各自的最大最小值；

(4)利用获取的最大最小值计算此时最小外接矩形的面积。

typedef struct min_area_rect
{
point_t* pt;
int width;
int height;
float angle;
}min_area_rect_t;

min_area_rect_t* get_rotate_rect(IplImage* img, point_t *p, const int num);

#include "min_area_rect.h"

//计算凸包线角度
float* get_angle(point_t *p,const int num)
{
float* angle = (float*)malloc(num * sizeof(float));
float temp = 0;
for (int i = 0; i < num - 1; i++)
{
temp = atan2(p[i + 1].y - p[i].y,p[i + 1].x - p[i].x);
if (temp < 0)
temp += PI / 2;
angle[i] = -temp;
}

return angle;
}

//剔除冗余角度
unsigned int* angle_unique(float* angle,const int num)
{
unsigned int* state = (int*)malloc(num * sizeof(unsigned int));
for (int i = 0; i < num; i++)
state[i] = 1;

for (int i = 0; i < num; i++)
{
for (int j = i + 1; j < num; j++)
{
if (angle[i] == angle[j])
state[j] = 0;
}
}

return state;
}

//计算旋转凸包点坐标
point_t* get_rotate_point(point_t* p,float theta, const int num)
{
point_t* r_p = (point_t*)malloc(num * sizeof(point_t));

for (int i = 0; i < num; i++)
{
r_p[i].x = p[i].x * cos(theta) - p[i].y * sin(theta);
r_p[i].y = p[i].x * sin(theta) + p[i].y * cos(theta);
}

return r_p;
}

//计算旋转后凸包点的坐标对应的原始坐标
point_t* get_remap_point(point_t* p, float theta)
{
point_t* r = (point_t*)malloc(4 * sizeof(point_t));
for (int i = 0; i < 4; i++)
{
r[i].x = p[i].x * cos(theta) + p[i].y * sin(theta);
r[i].y = -p[i].x * sin(theta) + p[i].y * cos(theta);
}

return r;
}

float get_distance(const point_t p1, const point_t p2)
{
return sqrt((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
}

min_area_rect_t* get_rotate_rect(IplImage* img, point_t *p, const int num)
{
float* angle;
unsigned int* state;
point_t* r_p = NULL;
point_t* rect_p = (point_t*)malloc(4 * sizeof(point_t));

angle = get_angle(p, num);
state = angle_unique(angle, num);

float min_area = 100000.;
float min_angle = 0.;
for (int i = 0; i < num; i++)
{
float area = 0.0;
float max_x = -1000;
float min_x = 1000;
float max_y = -1000;
float min_y = 1000;

if (state[i] == 1)
{
r_p = get_rotate_point(p, angle[i], num);
for (int j = 0; j < num; j++)
{
if (r_p[j].x > max_x)
max_x = r_p[j].x;
if (r_p[j].x < min_x)
min_x = r_p[j].x;
if (r_p[j].y > max_y)
max_y = r_p[j].y;
if (r_p[j].y < min_y)
min_y = r_p[j].y;
}

area = ((max_x - min_x) * (max_y - min_y));
if (area < min_area)
{
min_area = area;
min_angle = angle[i];
rect_p[0].x = min_x;
rect_p[0].y = min_y;
rect_p[1].x = min_x;
rect_p[1].y = max_y;
rect_p[2].x = max_x;
rect_p[2].y = min_y;
rect_p[3].x = max_x;
rect_p[3].y = max_y;
}
}
}

min_area_rect_t* _minAreaRect = (min_area_rect_t*)malloc(sizeof(min_area_rect_t));
_minAreaRect -> pt = get_remap_point(rect_p, min_angle);
_minAreaRect->width = get_distance(rect_p[0],rect_p[1]);
_minAreaRect->height = get_distance(rect_p[0],rect_p[2]);
_minAreaRect->angle = min_area;

free(angle);
free(state);
free(r_p);
free(rect_p);

return _minAreaRect;

}

实现效果：