方法
 
使用python opencv返回点集cnt的最小外接矩形，所用函数为 cv2.minAreaRect(cnt) ，cnt是点集数组或向量（里面存放的是点的坐标），并且这个点集中的元素不定个数。
 
举例说明
 
画一个任意四边形（任意多边形都可以）的最小外接矩形，那么点集 cnt 存放的就是该四边形的4个顶点坐标（点集里面有4个点）
 
cnt = np.array([[x1,y1],[x2,y2],[x3,y3],[x4,y4]]) # 必须是array数组的形式
rect = cv2.minAreaRect(cnt) # 得到最小外接矩形的（中心(x,y), (宽,高), 旋转角度）
box = cv2.cv.BoxPoints(rect) # 获取最小外接矩形的4个顶点坐标(ps: cv2.boxPoints(rect) for OpenCV 3.x)
box = np.int0(box)
# 画出来
cv2.drawContours(img, [box], 0, (255, 0, 0), 1)
cv2.imwrite('contours.png', img)
 
函数 cv2.minAreaRect() 返回一个Box2D结构rect：（最小外接矩形的中心（x，y），（宽度，高度），旋转角度），但是要绘制这个矩形，我们需要矩形的4个顶点坐标box, 通过函数 cv2.cv.BoxPoints() 获得，返回形式[ [x0,y0], [x1,y1], [x2,y2], [x3,y3] ]。得到的最小外接矩形的4个顶点顺序、中心坐标、宽度、高度、旋转角度（是度数形式，不是弧度数）的对应关系如下：
 
 
注意：
 
旋转角度θ是水平轴（x轴）逆时针旋转，直到碰到矩形的第一条边停住，此时该边与水平轴的夹角。并且这个边的边长是width，另一条边边长是height。也就是说，在这里，width与height不是按照长短来定义的。
在opencv中，坐标系原点在左上角，相对于x轴，逆时针旋转角度为负，顺时针旋转角度为正。所以，θ∈（-90度，0]。
 
 
 
 
 

Matlab 中并没有发现最小外接矩形的代码，为了方便
 
下面提供最小外接矩形的代码： 
 
注：这个函数是源于网上找到的代码的改进版，原版不能检测水平线或者垂直线
 

 
 

function [rectx,recty,area,perimeter] = minboundrect(x,y,metric)
% minboundrect: Compute the minimal bounding rectangle of points in the plane
% usage: [rectx,recty,area,perimeter] = minboundrect(x,y,metric)
%
% arguments: (input)
%  x,y - vectors of points, describing points in the plane as
%        (x,y) pairs. x and y must be the same lengths.
%
%  metric - (OPTIONAL) - single letter character flag which
%        denotes the use of minimal area or perimeter as the
%        metric to be minimized. metric may be either 'a' or 'p',
%        capitalization is ignored. Any other contraction of 'area'
%        or 'perimeter' is also accepted.
%
%        DEFAULT: 'a'    ('area')
%
% arguments: (output)
%  rectx,recty - 5x1 vectors of points that define the minimal
%        bounding rectangle.
%
%  area - (scalar) area of the minimal rect itself.
%
%  perimeter - (scalar) perimeter of the minimal rect as found
%
%
% Note: For those individuals who would prefer the rect with minimum
% perimeter or area, careful testing convinces me that the minimum area
% rect was generally also the minimum perimeter rect on most problems
% (with one class of exceptions). This same testing appeared to verify my
% assumption that the minimum area rect must always contain at least
% one edge of the convex hull. The exception I refer to above is for
% problems when the convex hull is composed of only a few points,
% most likely exactly 3. Here one may see differences between the
% two metrics. My thanks to Roger Stafford for pointing out this
% class of counter-examples.
%
% Thanks are also due to Roger for pointing out a proof that the
% bounding rect must always contain an edge of the convex hull, in
% both the minimal perimeter and area cases.
%
%
% See also: minboundcircle, minboundtri, minboundsphere
%
%
% default for metric
if (nargin<3) || isempty(metric)
  metric = 'a';
elseif ~ischar(metric)
  error 'metric must be a character flag if it is supplied.'
else
  % check for 'a' or 'p'
  metric = lower(metric(:)');                    
  ind = strmatch(metric,{'area','perimeter'});             
  if isempty(ind)                
    error 'metric does not match either ''area'' or ''perimeter'''
  end
  
  % just keep the first letter.
  metric = metric(1);
end

% preprocess data
x=x(:);
y=y(:);

% not many error checks to worry about
n = length(x);                                    
if n~=length(y)                               
  error 'x and y must be the same sizes'
end



% if var(x)==0
    
% start out with the convex hull of the points to
% reduce the problem dramatically. Note that any
% points in the interior of the convex hull are
% never needed, so we drop them.
if n>3 
    
    %%%%%%%%%%%%%%%%%%%%%%%%%
    if (var(x)== 0|| var(y)==0)
        if var(x)== 0
            x = [x-1;x(1); x+1 ];
            y = [y ;y(1);y];
            flag = 1;
        else
            y = [y-1;y(1); y+1 ];
            x = [x ;x(1);x];
            flag = 1;
        end
        
    else
        flag = 0;
     %%%%%%%%%%%%%%%%%%%%%%
    edges = convhull(x,y);  % 'Pp' will silence the warnings
  
    end

  % exclude those points inside the hull as not relevant
  % also sorts the points into their convex hull as a
  % closed polygon
  
  %%%%%%%%%%%%%%%%%%%%
  if flag == 0 
  %%%%%%%%%%%%%%%%%%%%    
      
  x = x(edges);
  y = y(edges);
  %%%%%%%%%%%%%%%%%%
  end
  %%%%%%%%%%%%%
  % probably fewer points now, unless the points are fully convex
  nedges = length(x) - 1;                       
elseif n>1
  % n must be 2 or 3
  nedges = n;
  x(end+1) = x(1);
  y(end+1) = y(1);
else
  % n must be 0 or 1
  nedges = n;
end

% now we must find the bounding rectangle of those
% that remain.

% special case small numbers of points. If we trip any
% of these cases, then we are done, so return.
switch nedges
  case 0
    % empty begets empty
    rectx = [];
    recty = [];
    area = [];
    perimeter = [];
    return
  case 1
    % with one point, the rect is simple.
    rectx = repmat(x,1,5);
    recty = repmat(y,1,5);
    area = 0;
    perimeter = 0;
    return
  case 2
    % only two points. also simple.
    rectx = x([1 2 2 1 1]);
    recty = y([1 2 2 1 1]);
    area = 0;
    perimeter = 2*sqrt(diff(x).^2 + diff(y).^2);
    return
end
% 3 or more points.

% will need a 2x2 rotation matrix through an angle theta
Rmat = @(theta) [cos(theta) sin(theta);-sin(theta) cos(theta)];

% get the angle of each edge of the hull polygon.
ind = 1:(length(x)-1);
edgeangles = atan2(y(ind+1) - y(ind),x(ind+1) - x(ind));
% move the angle into the first quadrant.
edgeangles = unique(mod(edgeangles,pi/2));

% now just check each edge of the hull
nang = length(edgeangles);              
area = inf;                           
perimeter = inf;
met = inf;
xy = [x,y];
for i = 1:nang                         
  % rotate the data through -theta 
  rot = Rmat(-edgeangles(i));
  xyr = xy*rot;
  xymin = min(xyr,[],1);
  xymax = max(xyr,[],1);
  
  % The area is simple, as is the perimeter
  A_i = prod(xymax - xymin);
  P_i = 2*sum(xymax-xymin);
  
  if metric=='a'
    M_i = A_i;
  else
    M_i = P_i;
  end
  
  % new metric value for the current interval. Is it better?
  if M_i<met
    % keep this one
    met = M_i;
    area = A_i;
    perimeter = P_i;
    
    rect = [xymin;[xymax(1),xymin(2)];xymax;[xymin(1),xymax(2)];xymin];
    rect = rect*rot';
    rectx = rect(:,1);
    recty = rect(:,2);
  end
end
% get the final rect

% all done

end % mainline end

 

 
 

 

 
 
当然这段代码并没有获取到外接矩形的长和宽，下面我在写一个函数，就可以获得对应外接矩形的长和宽
 
 
function [ wid hei ] = minboxing( d_x , d_y )
%minboxing Summary of this function goes here
%   Detailed explanation goes here
dd = [d_x, d_y];
dd1 = dd([4 1 2 3],:);

ds = sqrt(sum((dd-dd1).^2,2));
wid = min(ds(1:2));
hei = max(ds(1:2));

end


 
这里默认为较短的距离为宽，较长的距离为长。 
 

 
 
调用代码如下：注（dataX, dataY为需要计算最小外接矩形的数据。）
 
 
[recty,rectx,area,perimeter] =  minboundrect(dataX, dataY);
 [wei hei] = minboxing(rectx(1:end-1),recty(1:end-1));

 

 
 

 
 

 
 

 

Opencv绘制最小外接矩形、最小外接圆
 
 
 
Opencv中求点集的最小外结矩使用方法minAreaRect，求点集的最小外接圆使用方法minEnclosingCircle。
 
minAreaRect方法原型：
 
RotatedRect minAreaRect( InputArray points );  
 
输入参数points是所要求最小外结矩的点集数组或向量；
 
minEnclosingCircle方法原型：
 
void minEnclosingCircle( InputArray points,  
                                      CV_OUT Point2f& center, CV_OUT float& radius );  
 
第一个参数points是所要求最小外结圆的点集数组或向量；
 
第二个参数Point2f类型的center是求得的最小外接圆的中心坐标；
 
第三个参数float类型的radius是求得的最小外接圆的半径；
  
 
使用minAreaRect和minEnclosingCircle方法分别求最小外接矩和圆：
 
#include "core/core.hpp"    
#include "highgui/highgui.hpp"    
#include "imgproc/imgproc.hpp"    
#include "iostream"  
  
using namespace std;   
using namespace cv;    
  
int main(int argc,char *argv[])    
{  
    Mat imageSource=imread(argv[1],0);  
    imshow("Source Image",imageSource);  
    Mat image;  
    blur(imageSource,image,Size(3,3));  
    threshold(image,image,0,255,CV_THRESH_OTSU);      
    imshow("Threshold Image",image);  
  
    //寻找最外层轮廓  
    vector<vector<Point>> contours;  
    vector<Vec4i> hierarchy;  
    findContours(image,contours,hierarchy,RETR_EXTERNAL,CHAIN_APPROX_NONE,Point());  
  
    Mat imageContours=Mat::zeros(image.size(),CV_8UC1); //最小外接矩形画布  
    Mat imageContours1=Mat::zeros(image.size(),CV_8UC1); //最小外结圆画布  
    for(int i=0;i<contours.size();i++)  
    {         
        //绘制轮廓  
        drawContours(imageContours,contours,i,Scalar(255),1,8,hierarchy);  
        drawContours(imageContours1,contours,i,Scalar(255),1,8,hierarchy);  
  
  
        //绘制轮廓的最小外结矩形  
        RotatedRect rect=minAreaRect(contours[i]);  
        Point2f P[4];  
        rect.points(P);  
        for(int j=0;j<=3;j++)  
        {  
            line(imageContours,P[j],P[(j+1)%4],Scalar(255),2);  
        }  
  
        //绘制轮廓的最小外结圆  
        Point2f center; float radius;  
        minEnclosingCircle(contours[i],center,radius);  
        circle(imageContours1,center,radius,Scalar(255),2);  
  
    }  
    imshow("MinAreaRect",imageContours);      
    imshow("MinAreaCircle",imageContours1);   
    waitKey(0);  
    return 0;  
 
 
 
作图步骤：
 
1. 对原始图像均值滤波并二值化；
 
2. 求图像的最外层轮廓；
 
3.  使用minAreaRect方法求轮廓的最小外接矩形，转化求得矩形的四个顶点坐标，并绘制矩形；
 
4.  使用minEnclosingCircle方法求轮廓的最小外接圆，获取圆心和半径信息，并绘制圆；
 
 
 
原始图像：
 
 
 
 
最小外接矩：
 
 
 
 
最小外接圆：
 

 
 
该函数计算并返回指定点集的最小区域边界斜矩形。
 

RotatedRect minAreaRect(InputArray points)
 points：输入信息，可以为包含点的容器(vector)或是Mat。 返回包覆输入信息的最小斜矩形，是一个Box2D结构rect：（最小外接矩形的中心（x，y），（宽度，高度），旋转角度），但是要绘制这个矩形，我们需要矩形的4个顶点坐标box, 通过函数 cv2.cv.BoxPoints() 获得，返回形式[ [x0,y0], [x1,y1], [x2,y2], [x3,y3] ]。得到的最小外接矩形的4个顶点顺序、中心坐标、宽度、高度、旋转角度（是度数形式，不是弧度数）的对应关系如下： 
 
注意：
 
旋转角度θ是水平轴（x轴）逆时针旋转，与碰到的矩形的第一条边的夹角。并且这个边的边长是width，另一条边边长是height。也就是说，在这里，width与height不是按照长短来定义的。
在opencv中，坐标系原点在左上角，相对于x轴，逆时针旋转角度为负，顺时针旋转角度为正。所以，θ∈（-90度，0]。
 
 参考博客： [1](https://blog.csdn.net/u013925378/article/details/84563011) [2](http://www.pianshen.com/article/4885281921/)