机器视觉算法之物体方位特征提取

机器视觉算法之物体方位特征提取

在机器视觉处理中，我们经常要对检测到的物体的方位特征进行评估。比如说，我们要 OCR 识别一个字符串。那么这个字符串与x轴的夹角就很重要，我们需要这个信息把这个字符串转正，然后才方便识别。

条形码识别也类似，尤其是当我们条形码不是很清晰时，首先将条形码转正，然后用各向异性的滤波器处理一下，可以让条形码变得更清晰易于读取。

这里给出一种基于统计参数的特征提取方法。这个方法已经有几十年历史了，算是个老方法，但是效果很不错，所以值得写篇文章来介绍介绍。

区域的矩

一片区域 R 的矩定义为：

mp,q=∑(r,c)∈Rrpcq

当p 和q 都取 0 时，得到的就是这片区域的面积。也就是：

a=m0,0

矩还可以归一化，也就是用上面的定义再除以面积 a。

np,q=1a∑(r,c)∈Rrpcq

(n1,0,n0,1) 表示的是这片区域的重心。可以用它来描述区域的位置。

归一化的矩回随区域在图像中的位置不同而变化，要去除这个影响，可以用中心矩，中心矩只反映区域本身的特征。

μp,q=1a∑(r,c)∈R(r−n1,0)p(c−n0,1)q

二阶中心距有三个，分别是 μ2,0, μ1,1, μ0,2，用这三个参数再加上重心(n1,0,n0,1) 就可以估算出区域的范围和方位。

具体的方法是将这个区域当作一个椭圆区域，那么用上面5个参量就可以计算出椭圆的长短轴和旋转角度。具体公式如下：

r1=2(μ2,0+μ0,2+(μ2,0−μ0,2)2+4μ21,1−−−−−−−−−−−−−−−−−√)−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−√

r1=2(μ2,0+μ0,2−(μ2,0−μ0,2)2+4μ21,1−−−−−−−−−−−−−−−−−√)−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−√

θ=−12arctan2μ1,1μ0,2−μ2,0

椭圆的这几个参数的图形解释如下图：



利用这几个参数就可以确定区域的方位和尺寸了。

比如我们有下面的一幅测试图像。



用上面方法计算出的椭圆如下：



可以看出结果非常的好。尤其是旋转角度，计算的非常准确。

下面是我的测试代码，供参考。用到了些 Qt 的功能。

#include <QApplication>
#include <QImage>
#include <QDebug>
#include <QPainter>
#include "picturebox.h"
#include <math.h>

QImage threshold(const QImage &image, quint8 th)
{
int height = image.height();
int width = image.width();
QImage ret(width, height, QImage::Format_Indexed8);
ret.setColorCount(256);
for(int i = 0; i < 256; i++)
{
ret.setColor(i, qRgb(i, i, i));
}

for(int i = 0; i < height; i ++)
{
const uchar *pSrc = (uchar *)image.constScanLine(i);
uchar *pDest = (uchar *)ret.scanLine(i);
for( int j = 0; j < width; j ++)
{
pDest[j] = (pSrc[j] > th)? 255: 0;
}
}
return ret;
}

QImage toGray( const QImage &image )
{
int height = image.height();
int width = image.width();
QImage ret(width, height, QImage::Format_Indexed8);
ret.setColorCount(256);
for(int i = 0; i < 256; i++)
{
ret.setColor(i, qRgb(i, i, i));
}

qDebug () << image.format();
switch(image.format())
{
case QImage::Format_Indexed8:
case QImage::Format_Grayscale8:
for(int i = 0; i < height; i ++)
{
const uchar *pSrc = (uchar *)image.constScanLine(i);
uchar *pDest = (uchar *)ret.scanLine(i);
memcpy(pDest, pSrc, width);
}
break;
case QImage::Format_RGB32:
case QImage::Format_ARGB32:
case QImage::Format_ARGB32_Premultiplied:
for(int i = 0; i < height; i ++)
{
const QRgb *pSrc = (QRgb *)image.constScanLine(i);
uchar *pDest = (uchar *)ret.scanLine(i);

for( int j = 0; j < width; j ++)
{
pDest[j] = qGray(pSrc[j]);
}
}
break;
}
return ret;
}

QPointF center(const QImage &image, int value)
{
if(image.isNull() || image.format() != QImage::Format_Indexed8)
{
return QPointF(-1, -1);
}
int width = image.width();
int height = image.height();
int x_mean = 0;
int y_mean = 0;
int count = 0;
for(int j = 0; j < height; j ++)
{
const uchar * p = image.constScanLine(j);
for(int i = 0; i < width; i++)
{
if( p[i] == value )
{
x_mean += i;
y_mean += j;
count++;
}
}
}
return QPointF((double)x_mean / count, (double)y_mean / count);

}

struct ELLIPSE_PARA
{
double x_mean; //椭圆的中心坐标 x
double y_mean; //椭圆的中心坐标 y
double r1; //椭圆的长轴半径
double r2; //椭圆的短轴半径
double theta; //椭圆的长轴与 x 轴的夹角（逆时针）
};

/**
* @brief ellipseFit 将一片区域当作椭圆来估计五个几何参数
* @param image
* @param value
* @param para
*/
bool ellipseFit(const QImage &image, int value, ELLIPSE_PARA * para)
{
if(image.isNull() || image.format() != QImage::Format_Indexed8)
{
return false;
}
QPointF c = center(image, value);

int width = image.width();
int height = image.height();
double n01 = c.x();
double n10 = c.y();

double mu20 = 0.0;
double mu02 = 0.0;
double mu11 = 0.0;

int count = 0;
for(int row = 0; row < height; row ++)
{
const uchar * p = image.constScanLine(row);
for(int col = 0; col < width; col++)
{
if( p[col] == value )
{
mu02 += (col - n01) * (col - n01);
mu20 += (row - n10) * (row - n10);
mu11 += (col - n01) * (row - n10);
count ++;
}
}
}
if(count == 0)
{
return false;
}
mu20 /= count;
mu02 /= count;
mu11 /= count;

double t1 = mu20 + mu02;
double t2 = mu20 - mu02;
double t3 = sqrt(t2 * t2 + 4 * mu11 * mu11);
double r1 = sqrt(2 * ( t1 + t3) );
double r2 = sqrt(2 * ( t1 - t3) );

double theta = - atan2(2 * mu11, mu02 - mu20) / 2.0;

para->r1 = r1;
para->r2 = r2;
para->theta = theta;
para->x_mean = n01;
para->y_mean = n10;

return true;
}

int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QImage image("D:/test55.png");
QImage imageGray = toGray(image);
//imageGray = threshold(imageGray, 128);
ELLIPSE_PARA para;
ellipseFit(imageGray, 0, ¶);

qDebug() << para.r1;
qDebug() << para.r2;
qDebug() << para.theta * 180 / 3.14159;
QPointF c(para.x_mean, para.y_mean);
qDebug() << c;
QPainter painter(&image);
painter.setPen(Qt::red);
painter.translate(c);
painter.rotate(-para.theta * 180 / 3.14159);
painter.drawEllipse(QPointF(0, 0), para.r1, para.r2 );

PictureBox box;
box.setImage(image);
box.show();
return a.exec();
}