opencv perspectiveTransform

Opencv 投射变换代码，代码很简单，但是也记录一下

公式为



Dst x,y,z为变化过后的坐标
Src x,y,z为变换签坐标
H为投射矩阵

void cv::perspectiveTransform( InputArray _src, OutputArray _dst, InputArray _mtx )
{
Mat src = _src.getMat(), m = _mtx.getMat();//从接口类导出Mat
int depth = src.depth(), scn = src.channels(), dcn = m.rows-1;//获得深度及通道数
CV_Assert( scn + 1 == m.cols && (depth == CV_32F || depth == CV_64F));

_dst.create( src.size(), CV_MAKETYPE(depth, dcn) );//分配内存
Mat dst = _dst.getMat();

const int mtype
= CV_64F;
AutoBuffer<double> _mbuf;
double* mbuf = _mbuf;

if( !m.isContinuous() || m.type() != mtype )//判断数据存储是否连续，以及类型是否是64位浮点
{
_mbuf.allocate((dcn+1)*(scn+1));
Mat tmp(dcn+1, scn+1, mtype, (double*)_mbuf);
m.convertTo(tmp, mtype);
m = tmp;
}
else
mbuf = (double*)m.data;

TransformFunc func = depth == CV_32F ?
(TransformFunc)perspectiveTransform_32f :
(TransformFunc)perspectiveTransform_64f;//我理解这里其实就是一个函数指针，根据数据类型选择合适的函数
CV_Assert( func != 0 );

const Mat* arrays[] = {&src, &dst, 0};
uchar* ptrs[2];
NAryMatIterator it(arrays, ptrs);//作用等同于把src和dst的data地址给了ptrs，ptr[0]指向src
size_t i, total = it.size;

for( i = 0; i < it.nplanes; i++, ++it )
func( ptrs[0], ptrs[1], (uchar*)mbuf, (int)total, scn, dcn );//调用真正的变换函数
}

template<typename T> static void
perspectiveTransform_( const T* src, T* dst, const double*
m, int len, int scn, int dcn
)
{
const double eps
= FLT_EPSILON;//无穷小
int i;

if( scn == 2 && dcn == 2 )//如果都是二维坐标，函数可以处理二维或三维或混合坐标，三维坐标就是齐次坐标
{
for( i = 0; i < len*2; i += 2 )
{
T x = src[i], y = src[i + 1];
double w = x*m[6] + y*m[7] + m[8];//取得第三维度坐标，等会儿要归一化

if( fabs(w) > eps )//如果第三维坐标为0，表示无穷远
{
w = 1./w;//归一化，做乘法比做除法更快
dst[i] = (T)((x*m[0] + y*m[1] + m[2])*w);//计算变换后的坐标x
dst[i+1] = (T)((x*m[3] + y*m[4] + m[5])*w); //计算变换后的坐标y
}
else
dst[i] = dst[i+1] = (T)0;
}
}
else if(
scn == 3 && dcn == 3 )
{
for( i = 0; i < len*3; i += 3 )
{
T x = src[i], y = src[i + 1], z = src[i + 2];
double w = x*m[12] + y*m[13] + z*m[14] + m[15];

if( fabs(w) > eps )
{
w = 1./w;
dst[i] = (T)((x*m[0] + y*m[1] + z*m[2] + m[3]) * w);
dst[i+1] = (T)((x*m[4] + y*m[5] + z*m[6] + m[7]) * w);
dst[i+2] = (T)((x*m[8] + y*m[9] + z*m[10] + m[11]) * w);
}
else
dst[i] = dst[i+1] = dst[i+2] = (T)0;
}
}
else if(
scn == 3 && dcn == 2 )
{
for( i = 0; i < len; i++, src += 3, dst += 2 )
{
T x = src[0], y = src[1], z = src[2];
double w = x*m[8] + y*m[9] + z*m[10] + m[11];

if( fabs(w) > eps )
{
w = 1./w;
dst[0] = (T)((x*m[0] + y*m[1] + z*m[2] + m[3])*w);
dst[1] = (T)((x*m[4] + y*m[5] + z*m[6] + m[7])*w);
}
else
dst[0] = dst[1] = (T)0;
}
}
else
{
for( i = 0; i < len; i++, src += scn, dst += dcn )
{
const double*
_m = m + dcn*(scn + 1);
double w = _m[scn];
int j, k;
for( k = 0; k < scn; k++ )
w += _m[k]*src[k];
if( fabs(w) > eps )
{
_m = m;
for( j = 0; j < dcn; j++, _m += scn + 1 )
{
double s = _m[scn];
for( k = 0; k < scn; k++ )
s += _m[k]*src[k];
dst[j] = (T)(s*w);
}
}
else
for( j = 0; j < dcn; j++ )
dst[j] = 0;
}
}
}