generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

a big patch; use special proxy types (Input/OutputArray, Input/OutputArrayOfArrays) for passing in vectors, matrices etc.

Browse Source
This commit is contained in:
Vadim Pisarevsky
2011-04-17 13:14:45 +00:00
parent 335370a7c0
commit abeeb40d46
94 changed files with 10831 additions and 9631 deletions
Download Patch File Download Diff File Expand all files Collapse all files

139
modules/calib3d/src/fundam.cpp
View File

@@ -1044,114 +1044,95 @@ CV_IMPL void cvConvertPointsHomogeneous( const CvMat* src, CvMat* dst )
}
}
namespace cv
cv::Mat cv::findHomography( const InputArray& _points1, const InputArray& _points2,
int method, double ransacReprojThreshold, OutputArray _mask )
{
static Mat _findHomography( const Mat& points1, const Mat& points2,
int method, double ransacReprojThreshold,
vector<uchar>* mask )
{
CV_Assert(points1.isContinuous() && points2.isContinuous() &&
points1.type() == points2.type() &&
((points1.rows == 1 && points1.channels() == 2) ||
points1.cols*points1.channels() == 2) &&
((points2.rows == 1 && points2.channels() == 2) ||
points2.cols*points2.channels() == 2));
Mat points1 = _points1.getMat(), points2 = _points2.getMat();
int npoints = points1.checkVector(2);
CV_Assert( npoints >= 0 && points2.checkVector(2) == npoints &&
points1.type() == points2.type());
Mat H(3, 3, CV_64F);
CvMat _pt1 = Mat(points1), _pt2 = Mat(points2);
CvMat matH = H, _mask, *pmask = 0;
if( mask )
CvMat _pt1 = points1, _pt2 = points2;
CvMat matH = H, c_mask, *p_mask = 0;
if( _mask.needed() )
{
mask->resize(points1.cols*points1.rows*points1.channels()/2);
pmask = &(_mask = cvMat(1, (int)mask->size(), CV_8U, (void*)&(*mask)[0]));
_mask.create(npoints, 1, CV_8U, -1, true);
p_mask = &(c_mask = _mask.getMat());
}
bool ok = cvFindHomography( &_pt1, &_pt2, &matH, method, ransacReprojThreshold, pmask ) > 0;
bool ok = cvFindHomography( &_pt1, &_pt2, &matH, method, ransacReprojThreshold, p_mask ) > 0;
if( !ok )
H = Scalar(0);
return H;
}
static Mat _findFundamentalMat( const Mat& points1, const Mat& points2,
cv::Mat cv::findFundamentalMat( const InputArray& _points1, const InputArray& _points2,
int method, double param1, double param2,
vector<uchar>* mask )
OutputArray _mask )
{
CV_Assert(points1.checkVector(2) >= 0 && points2.checkVector(2) >= 0 &&
(points1.depth() == CV_32F || points1.depth() == CV_32S) &&
points1.depth() == points2.depth());
Mat points1 = _points1.getMat(), points2 = _points2.getMat();
int npoints = points1.checkVector(2);
CV_Assert( npoints >= 0 && points2.checkVector(2) == npoints &&
points1.type() == points2.type());
Mat F(3, 3, CV_64F);
CvMat _pt1 = Mat(points1), _pt2 = Mat(points2);
CvMat matF = F, _mask, *pmask = 0;
if( mask )
CvMat _pt1 = points1, _pt2 = points2;
CvMat matF = F, c_mask, *p_mask = 0;
if( _mask.needed() )
{
mask->resize(points1.cols*points1.rows*points1.channels()/2);
pmask = &(_mask = cvMat(1, (int)mask->size(), CV_8U, (void*)&(*mask)[0]));
_mask.create(npoints, 1, CV_8U, -1, true);
p_mask = &(c_mask = _mask.getMat());
}
int n = cvFindFundamentalMat( &_pt1, &_pt2, &matF, method, param1, param2, pmask );
int n = cvFindFundamentalMat( &_pt1, &_pt2, &matF, method, param1, param2, p_mask );
if( n <= 0 )
F = Scalar(0);
return F;
}
void cv::computeCorrespondEpilines( const InputArray& _points, int whichImage,
const InputArray& _Fmat, OutputArray _lines )
{
Mat points = _points.getMat();
int npoints = points.checkVector(2);
CV_Assert( npoints >= 0 && (points.depth() == CV_32F || points.depth() == CV_32S));
}
cv::Mat cv::findHomography( const Mat& srcPoints, const Mat& dstPoints,
vector<uchar>& mask, int method,
double ransacReprojThreshold )
{
return _findHomography(srcPoints, dstPoints, method, ransacReprojThreshold, &mask);
_lines.create(npoints, 1, CV_32FC3, -1, true);
CvMat c_points = points, c_lines = _lines.getMat(), c_F = _Fmat.getMat();
cvComputeCorrespondEpilines(&c_points, whichImage, &c_F, &c_lines);
}
cv::Mat cv::findHomography( const Mat& srcPoints, const Mat& dstPoints,
int method, double ransacReprojThreshold )
void cv::convertPointsFromHomogeneous( const InputArray& _src, OutputArray _dst )
{
return _findHomography(srcPoints, dstPoints, method, ransacReprojThreshold, 0);
}
Mat src = _src.getMat();
int npoints = src.checkVector(3), cn = 3;
if( npoints < 0 )
{
npoints = src.checkVector(4);
if( npoints >= 0 )
cn = 4;
}
CV_Assert( npoints >= 0 && (src.depth() == CV_32F || src.depth() == CV_32S));
cv::Mat cv::findFundamentalMat( const Mat& points1, const Mat& points2,
vector<uchar>& mask, int method, double param1, double param2 )
{
return _findFundamentalMat( points1, points2, method, param1, param2, &mask );
_dst.create(npoints, 1, CV_MAKETYPE(CV_32F, cn-1));
CvMat c_src = src, c_dst = _dst.getMat();
cvConvertPointsHomogeneous(&c_src, &c_dst);
}
cv::Mat cv::findFundamentalMat( const Mat& points1, const Mat& points2,
int method, double param1, double param2 )
void cv::convertPointsToHomogeneous( const InputArray& _src, OutputArray _dst )
{
return _findFundamentalMat( points1, points2, method, param1, param2, 0 );
}
void cv::computeCorrespondEpilines( const Mat& points, int whichImage,
const Mat& F, vector<Vec3f>& lines )
{
CV_Assert(points.checkVector(2) >= 0 &&
(points.depth() == CV_32F || points.depth() == CV_32S));
Mat src = _src.getMat();
int npoints = src.checkVector(2), cn = 2;
if( npoints < 0 )
{
npoints = src.checkVector(3);
if( npoints >= 0 )
cn = 3;
}
CV_Assert( npoints >= 0 && (src.depth() == CV_32F || src.depth() == CV_32S));
lines.resize(points.cols*points.rows*points.channels()/2);
CvMat _points = points, _lines = Mat(lines), matF = F;
cvComputeCorrespondEpilines(&_points, whichImage, &matF, &_lines);
}
void cv::convertPointsHomogeneous( const Mat& src, vector<Point3f>& dst )
{
int srccn = src.checkVector(2) >= 0 ? 2 : src.checkVector(4) >= 0 ? 4 : -1;
CV_Assert( srccn > 0 && (src.depth() == CV_32F || src.depth() == CV_32S));
dst.resize(src.cols*src.rows*src.channels()/srccn);
CvMat _src = src, _dst = Mat(dst);
cvConvertPointsHomogeneous(&_src, &_dst);
}
void cv::convertPointsHomogeneous( const Mat& src, vector<Point2f>& dst )
{
CV_Assert(src.checkVector(3) >= 0 &&
(src.depth() == CV_32F || src.depth() == CV_32S));
dst.resize(src.cols*src.rows*src.channels()/3);
CvMat _src = Mat(src), _dst = Mat(dst);
cvConvertPointsHomogeneous(&_src, &_dst);
_dst.create(npoints, 1, CV_MAKETYPE(CV_32F, cn+1));
CvMat c_src = src, c_dst = _dst.getMat();
cvConvertPointsHomogeneous(&c_src, &c_dst);
}
/* End of file. */