openCV 의 findHomography 함수 분석 및 RANSAC 알고리즘 에 대한 상세 한 설명 (소스 코드 분석)
25746 단어 물체 인식
컴퓨터 시각 과 이미지 처리 등 여러 분야 에서 RANSAC 알고리즘 을 사용 해 야 한다.openCV 에 도 사람들 이 사용 할 수 있 도록 봉 인 된 RANSAC 알고리즘 이 있다.RANSAC 알고리즘 에 대한 응용 프로그램 은 제 다른 블 로 그 를 볼 수 있 습 니 다.
SIFT 와 RANSAC 알고리즘 (openCV 프레임 워 크) 을 이용 하여 물체 의 검 측 과 포 지 셔 닝 을 실현 하고 행렬 (find FundamentalMat 와 find Homography 의 비교) 을 구 합 니 다.
그러나 며칠 전 사제 가 openCV 가 자체 적 으로 가지 고 있 는 RANSAC 알고리즘 을 사용 할 때 실험의 운행 시간 이 입력 데이터 가 증가 함 에 따라 증가 하지 않 고 이론 적 으로 맞지 않 는 다 는 것 을 발견 했다.그래서 저 는 시간 이 좀 걸 려 서 openCV 에서 RANSAC 에 관 한 소스 코드 를 모두 복사 해서 연 구 했 습 니 다.RANSAC 알고리즘 의 실제 운행 과정 을 더욱 명확 하 게 이해 할 수 있 도록 합 니 다.
일단 두 가지 보 겠 습 니 다.
4. 567913. 위의 두 가지 유형 중에서 Cv 모델 Estimator 2 는 하나의 기본 적 인 유형 으로 이름 에서 알 수 있 듯 이 이 유형 은 모델 을 평가 하 는 데 사용 된다.안에서 많은 가상 함 수 를 제공 하 는 것 을 볼 수 있다. 이런 함 수 는 매우 많다. 예 를 들 어 runRANSAC 는 RANSAC 방법 으로 단 응 행렬 을 계산 하 는 것 이 고 runLMeDS 는 LMeDS 방법 으로 단 응 행렬 을 계산 하 는 것 이다. 우 리 는 여기 서 RANSAC 방법 만 설명 하기 때문에 다른 필요 하지 않 은 내용 은 내 가 직접 주석 을 달 았 다.
Cv Homography Estimator 는 Cv Model Estimator 2 에서 계승 되 었 습 니 다. 마찬가지 로 이름 에서 도 알 수 있 듯 이 이런 사용 은 단일 행렬 을 평가 할 수 있 습 니 다.
다음은 두 가지 유형의 구조 함수 와 분석 함수 입 니 다. 이것 은 더 이상 할 말 이 없습니다. 기본적으로 모두 기본 적 인 것 입 니 다.
// ，
// 0。99 2000
class CvModelEstimator2
{
public:
CvModelEstimator2(int _modelPoints, CvSize _modelSize, int _maxBasicSolutions);
virtual ~CvModelEstimator2();
virtual int runKernel( const CvMat* m1, const CvMat* m2, CvMat* model )=0;
//virtual bool runLMeDS( const CvMat* m1, const CvMat* m2, CvMat* model,
// CvMat* mask, double confidence=0.99, int maxIters=2000 );
virtual bool runRANSAC( const CvMat* m1, const CvMat* m2, CvMat* model,
CvMat* mask, double threshold,
double confidence=0.99, int maxIters=2000 );
virtual bool refine( const CvMat*, const CvMat*, CvMat*, int ) { return true; }
//virtual void setSeed( int64 seed );
protected:
virtual void computeReprojError( const CvMat* m1, const CvMat* m2,
const CvMat* model, CvMat* error ) = 0;
virtual int findInliers( const CvMat* m1, const CvMat* m2,
const CvMat* model, CvMat* error,
CvMat* mask, double threshold );
virtual bool getSubset( const CvMat* m1, const CvMat* m2,
CvMat* ms1, CvMat* ms2, int maxAttempts=1000 );
virtual bool checkSubset( const CvMat* ms1, int count );
CvRNG rng;
int modelPoints;
CvSize modelSize;
int maxBasicSolutions;
bool checkPartialSubsets;
};
//
class CvHomographyEstimator : public CvModelEstimator2
{
public:
CvHomographyEstimator( int modelPoints );
virtual int runKernel( const CvMat* m1, const CvMat* m2, CvMat* model );
virtual bool refine( const CvMat* m1, const CvMat* m2,
CvMat* model, int maxIters );
protected:
virtual void computeReprojError( const CvMat* m1, const CvMat* m2,
const CvMat* model, CvMat* error );
};//
CvModelEstimator2::CvModelEstimator2(int _modelPoints, CvSize _modelSize, int _maxBasicSolutions)
{
modelPoints = _modelPoints;
modelSize = _modelSize;
maxBasicSolutions = _maxBasicSolutions;
checkPartialSubsets = true;
rng = cvRNG(-1);
}
//
CvModelEstimator2::~CvModelEstimator2()
{
}
CvHomographyEstimator::CvHomographyEstimator(int _modelPoints)
: CvModelEstimator2(_modelPoints, cvSize(3,3), 1)
{
assert( _modelPoints == 4 || _modelPoints == 5 );
checkPartialSubsets = false;
}
。runRANSAC RANSAC
bool CvModelEstimator2::runRANSAC( const CvMat* m1, const CvMat* m2, CvMat* model,
CvMat* mask0, double reprojThreshold,
double confidence, int maxIters )
{
bool result = false;
cv::Ptr mask = cvCloneMat(mask0); // ，
cv::Ptr models, err, tmask;
cv::Ptr ms1, ms2;
int iter, niters = maxIters; // ， 2000
int count = m1->rows*m1->cols, maxGoodCount = 0;
CV_Assert( CV_ARE_SIZES_EQ(m1, m2) && CV_ARE_SIZES_EQ(m1, mask) );
if( count < modelPoints ) // RANSAC ，modelPoints 4
return false;
models = cvCreateMat( modelSize.height*maxBasicSolutions, modelSize.width, CV_64FC1 );
err = cvCreateMat( 1, count, CV_32FC1 );
tmask = cvCreateMat( 1, count, CV_8UC1 );
if( count > modelPoints )
{
ms1 = cvCreateMat( 1, modelPoints, m1->type );
ms2 = cvCreateMat( 1, modelPoints, m2->type );
}
else
{
niters = 1;
ms1 = cvCloneMat(m1);
ms2 = cvCloneMat(m2);
}
for( iter = 0; iter < niters; iter++ )
{
int i, goodCount, nmodels;
if( count > modelPoints )
{
bool found = getSubset( m1, m2, ms1, ms2, 300 );// ，300 ，
if( !found ) // 4 ，
{ //
if( iter == 0 )
return false;
break;
}
}
printf("------");
nmodels = runKernel( ms1, ms2, models );// 4
if( nmodels <= 0 )
continue;
for( i = 0; i < nmodels; i++ )
{
CvMat model_i;
cvGetRows( models, &model_i, i*modelSize.height, (i+1)*modelSize.height );
goodCount = findInliers( m1, m2, &model_i, err, tmask, reprojThreshold );
//
printf("%5d %5d %5d %5d
",iter,niters,goodCount,maxGoodCount);
if( goodCount > MAX(maxGoodCount, modelPoints-1) )
{
std::swap(tmask, mask);
cvCopy( &model_i, model );
maxGoodCount = goodCount;
// ，
niters = cvRANSACUpdateNumIters( confidence,
(double)(count - goodCount)/count, modelPoints, niters );
}
}
}
//printf("RANSAC %d
",niters);
if( maxGoodCount > 0 )
{
if( mask != mask0 )
cvCopy( mask, mask0 );
result = true;
}
return result;
}
niters 최초의 값 은 2000 입 니 다. 이것 이 바로 초기 RANSAC 알고리즘 의 순환 횟수 입 니 다. getSubset () 함 수 는 한 그룹의 대응 하 는 서열 에서 무 작위 로 4 그룹 을 선택 하 는 것 입 니 다. (3X3 의 행렬 을 계산 하려 면 적어도 4 개의 대응 하 는 좌표 가 필요 하기 때 문 입 니 다) m1 과 m2 는 우리 의 입력 서열 이 고 ms1 과 ms2 는 무 작위 로 선택 한 대응 하 는 4 그룹 이 일치 합 니 다.
무 작위 로 4 조 의 매 칭 을 선택 한 후 이 4 개의 매 칭 에 따라 해당 하 는 행렬 을 계산 해 야 하기 때문에 함수 runKernel () 은 4 조 의 매 칭 에 따라 행렬 을 계산 하 는 것 이 고 매개 변수 에 있 는 models 는 얻 은 행렬 입 니 다.이 행렬 은 하나의 가설 일 뿐 이 가설 을 검증 하기 위해 다른 점 으로 계산 하고 다른 점 이 내 점 인지 외 점 인지 봐 야 한다.
findInliers () 함 수 는 내 점 을 계산 하 는 데 쓰 인 다.앞에서 얻 은 행렬 을 이용 하여 모든 서열 을 가 져 와 서 어떤 것 이 내 점 이 고 어떤 것 이 외 점 인지 계산 할 수 있 습 니 다. 함수 의 반환 값 은 goodCount 입 니 다. 바로 이번에 계산 한 내 점 의 개수 입 니 다.함수 에 또 하나의 값 은 maxGoodCount 입 니 다. 매번 순환 하 는 내 점 개수 의 최대 값 은 이 값 에 저 장 됩 니 다. 추정 되 는 행렬 이 내 점 이 많 을 수록 이 행렬 은 정확 할 수 있 습 니 다.그래서 내 점 개 수 를 계산 한 다음 에 goodCount 와 maxGoodCount 의 크기 관 계 를 판단 하고 goodCount > maxGoodCount 가 있 으 면 goodCount 를 maxGoodCount 에 할당 합 니 다.값 을 부여 한 후의 코드 는 매우 중요 합 니 다. 우 리 는 단독으로 꺼 내 서 말 합 니 다. 코드 는 다음 과 같 습 니 다.
4. 567913. niters 는 원래 교체 의 횟수, 즉 순환 의 횟수 이다.그러나 이 코드 를 통 해 우 리 는 순환 할 때마다 niters 라 는 값 을 업데이트 하 는 것 을 발견 했다. 즉, 순환 할 때마다 순환 의 총 횟수 를 바 꾸 는 것 이다.cvRANSACUpdateNumIters () 함 수 는 confidence (신뢰 도) count (총 일치 개수) goodCount (현재 내 점 개수) niters (현재 총 교체 횟수) 라 는 매개 변 수 를 이용 하여 총 교체 횟수 의 크기 를 동적 으로 변경 합 니 다.이 함수 의 중심 사상 은 내 점 이 차지 하 는 비율 이 비교적 많 을 때 정확 한 평 가 를 찾 았 을 가능성 이 높 기 때문에 교체 횟수 를 적당 하 게 줄 여 시간 을 절약 하 는 것 이다.이 교체 횟수 의 감 소 는 지수 로 줄 어 들 기 때문에 절약 하 는 시간 비용 도 상당 하 다.따라서 최초 로 디자인 된 2000 의 교체 횟수 는 최종 교체 횟수 가 몇 십 에 불과 할 것 이다.마찬가지 로, 만약 당신 이 처음에 교체 횟수 를 10000 또는 더 크게 설정 했다 면, 몇 번 의 교체 에 들 어간 후에 niters 는 또 매우 작 아 질 것 입 니 다.그래서 초기 niters 설정 이 아무리 커 도 최종 운행 시간 에 영향 을 주지 않 습 니 다.저 는 제 프로그램 으로 간단하게 해 봤 습 니 다. 초기 값 이 2000, 10000, 20000 이 든 최종 교체 횟수 는 58 가 되 었 습 니 다!!
그래서 왜 입력 데이터 가 증가 하고 알고리즘 운행 시간 이 증가 하지 않 는 지 알 아야 한다.openCV 의 RANSAC 알고리즘 은 먼저 교체 횟수 를 2000 으로 설정 한 다음 에 교체 하 는 과정 에서 동태 적 으로 전체 교체 횟수 를 바 꿉 니 다. 입력 데이터 가 얼마 가 되 든 전체적인 교체 횟수 는 증가 하지 않 고 4 개의 매 칭 을 통 해 평가 하 는 행렬 의 시간 은 변 하지 않 습 니 다. 행렬 을 통 해 내 점 을 계산 합 니 다.이 방면 의 증가 한 시간 지출 은 기본적으로 소홀히 할 수 있다.그래서 최종 결 과 는 입력 점 이 얼마 가 되 든 연산 시간 은 크게 달라 지지 않 는 다 는 것 이다.
이상 은 RANSAC 알고리즘 의 핵심 코드 입 니 다. 그 중에서 사용 하 는 함수 들 은 다음 과 같 습 니 다.
1. 일괄 왼쪽 으로 전환 하면 길 어 보이 지만 완 성 된 기능 은 일반적인 좌 표를 일괄 좌표 로 전환 하여 이후 의 계산 을 편리 하 게 하 는 것 이다. ， m1 m2 ， ， ， ， ， ，RANSAC ， ， 。model ，mask ， m1，m2 ， m1 m2 ，mask 1， 0， ， mask ， 。reprojThreshold ， ， ， ，openCV 3， 。confidence ， ， RANSAC ， 。 0.995. maxIters ，RANSAC ， ， 2000
， ， 。 ， for 。 for 。 。
for( iter = 0; iter < niters; iter++ )
{
int i, goodCount, nmodels;
if( count > modelPoints )
{
bool found = getSubset( m1, m2, ms1, ms2, 300 );// ，300 ，
if( !found ) // 4 ，
{ //
if( iter == 0 )
return false;
break;
}
}
nmodels = runKernel( ms1, ms2, models );// 4
if( nmodels <= 0 )
continue;
for( i = 0; i < nmodels; i++ )
{
CvMat model_i;
cvGetRows( models, &model_i, i*modelSize.height, (i+1)*modelSize.height );
goodCount = findInliers( m1, m2, &model_i, err, tmask, reprojThreshold );
//
printf("%5d %5d %5d %5d
",iter,niters,goodCount,maxGoodCount);
if( goodCount > MAX(maxGoodCount, modelPoints-1) )
{
std::swap(tmask, mask);
cvCopy( &model_i, model );
maxGoodCount = goodCount;
// ，
niters = cvRANSACUpdateNumIters( confidence,
(double)(count - goodCount)/count, modelPoints, niters );
}
}
}
2. 교체 값 을 업데이트 하 는 함수.이 함 수 는 전체 교체 횟수 를 업데이트 하 는 것 으로 그 중에서 볼 수 있 듯 이 교체 값 은 지수 형식 으로 줄어든다.최초의 2000 의 교체 횟수 는 어떤 때 는 끊 임 없 는 업 데 이 트 를 거 쳐 최종 결 과 는 수 십 이 되 었 다. niters = cvRANSACUpdateNumIters( confidence,
(double)(count - goodCount)/count, modelPoints, niters );
3. 4 개의 매 칭 을 통 해 계산 단 응 행렬 은 4 개의 매 칭 을 주 는 것 입 니 다. 이 네 개의 매 칭 에 맞 는 행렬 을 계산 해 보 세 요.CV_IMPL void cvConvertPointsHomogeneous( const CvMat* src, CvMat* dst )
{
Ptr temp, denom;
int i, s_count, s_dims, d_count, d_dims;
CvMat _src, _dst, _ones;
CvMat* ones = 0;
if( !CV_IS_MAT(src) )
CV_Error( !src ? CV_StsNullPtr : CV_StsBadArg,
"The input parameter is not a valid matrix" );
if( !CV_IS_MAT(dst) )
CV_Error( !dst ? CV_StsNullPtr : CV_StsBadArg,
"The output parameter is not a valid matrix" );
if( src == dst || src->data.ptr == dst->data.ptr )
{
if( src != dst && (!CV_ARE_TYPES_EQ(src, dst) || !CV_ARE_SIZES_EQ(src,dst)) )
CV_Error( CV_StsBadArg, "Invalid inplace operation" );
return;
}
if( src->rows > src->cols )
{
if( !((src->cols > 1) ^ (CV_MAT_CN(src->type) > 1)) )
CV_Error( CV_StsBadSize, "Either the number of channels or columns or rows must be =1" );
s_dims = CV_MAT_CN(src->type)*src->cols;
s_count = src->rows;
}
else
{
if( !((src->rows > 1) ^ (CV_MAT_CN(src->type) > 1)) )
CV_Error( CV_StsBadSize, "Either the number of channels or columns or rows must be =1" );
s_dims = CV_MAT_CN(src->type)*src->rows;
s_count = src->cols;
}
if( src->rows == 1 || src->cols == 1 )
src = cvReshape( src, &_src, 1, s_count );
if( dst->rows > dst->cols )
{
if( !((dst->cols > 1) ^ (CV_MAT_CN(dst->type) > 1)) )
CV_Error( CV_StsBadSize,
"Either the number of channels or columns or rows in the input matrix must be =1" );
d_dims = CV_MAT_CN(dst->type)*dst->cols;
d_count = dst->rows;
}
else
{
if( !((dst->rows > 1) ^ (CV_MAT_CN(dst->type) > 1)) )
CV_Error( CV_StsBadSize,
"Either the number of channels or columns or rows in the output matrix must be =1" );
d_dims = CV_MAT_CN(dst->type)*dst->rows;
d_count = dst->cols;
}
if( dst->rows == 1 || dst->cols == 1 )
dst = cvReshape( dst, &_dst, 1, d_count );
if( s_count != d_count )
CV_Error( CV_StsUnmatchedSizes, "Both matrices must have the same number of points" );
if( CV_MAT_DEPTH(src->type) < CV_32F || CV_MAT_DEPTH(dst->type) < CV_32F )
CV_Error( CV_StsUnsupportedFormat,
"Both matrices must be floating-point (single or double precision)" );
if( s_dims < 2 || s_dims > 4 || d_dims < 2 || d_dims > 4 )
CV_Error( CV_StsOutOfRange,
"Both input and output point dimensionality must be 2, 3 or 4" );
if( s_dims < d_dims - 1 || s_dims > d_dims + 1 )
CV_Error( CV_StsUnmatchedSizes,
"The dimensionalities of input and output point sets differ too much" );
if( s_dims == d_dims - 1 )
{
if( d_count == dst->rows )
{
ones = cvGetSubRect( dst, &_ones, cvRect( s_dims, 0, 1, d_count ));
dst = cvGetSubRect( dst, &_dst, cvRect( 0, 0, s_dims, d_count ));
}
else
{
ones = cvGetSubRect( dst, &_ones, cvRect( 0, s_dims, d_count, 1 ));
dst = cvGetSubRect( dst, &_dst, cvRect( 0, 0, d_count, s_dims ));
}
}
if( s_dims <= d_dims )
{
if( src->rows == dst->rows && src->cols == dst->cols )
{
if( CV_ARE_TYPES_EQ( src, dst ) )
cvCopy( src, dst );
else
cvConvert( src, dst );
}
else
{
if( !CV_ARE_TYPES_EQ( src, dst ))
{
temp = cvCreateMat( src->rows, src->cols, dst->type );
cvConvert( src, temp );
src = temp;
}
cvTranspose( src, dst );
}
if( ones )
cvSet( ones, cvRealScalar(1.) );
}
else
{
int s_plane_stride, s_stride, d_plane_stride, d_stride, elem_size;
if( !CV_ARE_TYPES_EQ( src, dst ))
{
temp = cvCreateMat( src->rows, src->cols, dst->type );
cvConvert( src, temp );
src = temp;
}
elem_size = CV_ELEM_SIZE(src->type);
if( s_count == src->cols )
s_plane_stride = src->step / elem_size, s_stride = 1;
else
s_stride = src->step / elem_size, s_plane_stride = 1;
if( d_count == dst->cols )
d_plane_stride = dst->step / elem_size, d_stride = 1;
else
d_stride = dst->step / elem_size, d_plane_stride = 1;
denom = cvCreateMat( 1, d_count, dst->type );
if( CV_MAT_DEPTH(dst->type) == CV_32F )
{
const float* xs = src->data.fl;
const float* ys = xs + s_plane_stride;
const float* zs = 0;
const float* ws = xs + (s_dims - 1)*s_plane_stride;
float* iw = denom->data.fl;
float* xd = dst->data.fl;
float* yd = xd + d_plane_stride;
float* zd = 0;
if( d_dims == 3 )
{
zs = ys + s_plane_stride;
zd = yd + d_plane_stride;
}
for( i = 0; i < d_count; i++, ws += s_stride )
{
float t = *ws;
iw[i] = fabs((double)t) > FLT_EPSILON ? t : 1.f;
}
cvDiv( 0, denom, denom );
if( d_dims == 3 )
for( i = 0; i < d_count; i++ )
{
float w = iw[i];
float x = *xs * w, y = *ys * w, z = *zs * w;
xs += s_stride; ys += s_stride; zs += s_stride;
*xd = x; *yd = y; *zd = z;
xd += d_stride; yd += d_stride; zd += d_stride;
}
else
for( i = 0; i < d_count; i++ )
{
float w = iw[i];
float x = *xs * w, y = *ys * w;
xs += s_stride; ys += s_stride;
*xd = x; *yd = y;
xd += d_stride; yd += d_stride;
}
}
else
{
const double* xs = src->data.db;
const double* ys = xs + s_plane_stride;
const double* zs = 0;
const double* ws = xs + (s_dims - 1)*s_plane_stride;
double* iw = denom->data.db;
double* xd = dst->data.db;
double* yd = xd + d_plane_stride;
double* zd = 0;
if( d_dims == 3 )
{
zs = ys + s_plane_stride;
zd = yd + d_plane_stride;
}
for( i = 0; i < d_count; i++, ws += s_stride )
{
double t = *ws;
iw[i] = fabs(t) > DBL_EPSILON ? t : 1.;
}
cvDiv( 0, denom, denom );
if( d_dims == 3 )
for( i = 0; i < d_count; i++ )
{
double w = iw[i];
double x = *xs * w, y = *ys * w, z = *zs * w;
xs += s_stride; ys += s_stride; zs += s_stride;
*xd = x; *yd = y; *zd = z;
xd += d_stride; yd += d_stride; zd += d_stride;
}
else
for( i = 0; i < d_count; i++ )
{
double w = iw[i];
double x = *xs * w, y = *ys * w;
xs += s_stride; ys += s_stride;
*xd = x; *yd = y;
xd += d_stride; yd += d_stride;
}
}
}
}
4. 입력 시퀀스 를 지정 한 후 4 쌍 을 무 작위 로 선택 합 니 다.CV_IMPL int
cvRANSACUpdateNumIters( double p, double ep,
int model_points, int max_iters )
{
if( model_points <= 0 )
CV_Error( CV_StsOutOfRange, "the number of model points should be positive" );
p = MAX(p, 0.);
p = MIN(p, 1.);
ep = MAX(ep, 0.);
ep = MIN(ep, 1.);
// avoid inf's & nan's
double num = MAX(1. - p, DBL_MIN);
double denom = 1. - pow(1. - ep,model_points);
if( denom < DBL_MIN )
return 0;
num = log(num);
denom = log(denom);
return denom >= 0 || -num >= max_iters*(-denom) ?
max_iters : cvRound(num/denom);
}
5. 생 성 된 4 조 의 일치 에 대해 검 사 를 하고 요구 에 부합 되 는 지 관찰한다.
4. 567913. 6. 내 점 의 개 수 를 계산 하고 표기 서열 에서 어떤 점 이 내 점 인지 계산한다.// ，
int CvHomographyEstimator::runKernel( const CvMat* m1, const CvMat* m2, CvMat* H )
{
int i, count = m1->rows*m1->cols;
const CvPoint2D64f* M = (const CvPoint2D64f*)m1->data.ptr;
const CvPoint2D64f* m = (const CvPoint2D64f*)m2->data.ptr;
double LtL[9][9], W[9][1], V[9][9];
CvMat _LtL = cvMat( 9, 9, CV_64F, LtL );
CvMat matW = cvMat( 9, 1, CV_64F, W );
CvMat matV = cvMat( 9, 9, CV_64F, V );
CvMat _H0 = cvMat( 3, 3, CV_64F, V[8] );
CvMat _Htemp = cvMat( 3, 3, CV_64F, V[7] );
CvPoint2D64f cM={0,0}, cm={0,0}, sM={0,0}, sm={0,0};
for( i = 0; i < count; i++ )
{
cm.x += m[i].x; cm.y += m[i].y;
cM.x += M[i].x; cM.y += M[i].y;
}
cm.x /= count; cm.y /= count;
cM.x /= count; cM.y /= count;
for( i = 0; i < count; i++ )
{
sm.x += fabs(m[i].x - cm.x);
sm.y += fabs(m[i].y - cm.y);
sM.x += fabs(M[i].x - cM.x);
sM.y += fabs(M[i].y - cM.y);
}
if( fabs(sm.x) < DBL_EPSILON || fabs(sm.y) < DBL_EPSILON ||
fabs(sM.x) < DBL_EPSILON || fabs(sM.y) < DBL_EPSILON )
return 0;
sm.x = count/sm.x; sm.y = count/sm.y;
sM.x = count/sM.x; sM.y = count/sM.y;
double invHnorm[9] = { 1./sm.x, 0, cm.x, 0, 1./sm.y, cm.y, 0, 0, 1 };
double Hnorm2[9] = { sM.x, 0, -cM.x*sM.x, 0, sM.y, -cM.y*sM.y, 0, 0, 1 };
CvMat _invHnorm = cvMat( 3, 3, CV_64FC1, invHnorm );
CvMat _Hnorm2 = cvMat( 3, 3, CV_64FC1, Hnorm2 );
cvZero( &_LtL );
for( i = 0; i < count; i++ )
{
double x = (m[i].x - cm.x)*sm.x, y = (m[i].y - cm.y)*sm.y;
double X = (M[i].x - cM.x)*sM.x, Y = (M[i].y - cM.y)*sM.y;
double Lx[] = { X, Y, 1, 0, 0, 0, -x*X, -x*Y, -x };
double Ly[] = { 0, 0, 0, X, Y, 1, -y*X, -y*Y, -y };
int j, k;
for( j = 0; j < 9; j++ )
for( k = j; k < 9; k++ )
LtL[j][k] += Lx[j]*Lx[k] + Ly[j]*Ly[k];
}
cvCompleteSymm( &_LtL );
//cvSVD( &_LtL, &matW, 0, &matV, CV_SVD_MODIFY_A + CV_SVD_V_T );
cvEigenVV( &_LtL, &matV, &matW );
cvMatMul( &_invHnorm, &_H0, &_Htemp );
cvMatMul( &_Htemp, &_Hnorm2, &_H0 );
cvConvertScale( &_H0, H, 1./_H0.data.db[8] );
return 1;
}
7. 위의 함수 가 호출 하 는 일부 함수 들 은 어렵 지 않 기 때문에 아래 에 해당 하 는 것 을 열거 합 니 다.bool CvModelEstimator2::getSubset( const CvMat* m1, const CvMat* m2,
CvMat* ms1, CvMat* ms2, int maxAttempts ) //maxAttempts 300
{
cv::AutoBuffer _idx(modelPoints);
int* idx = _idx;
int i = 0, j, k, idx_i, iters = 0;
int type = CV_MAT_TYPE(m1->type), elemSize = CV_ELEM_SIZE(type);
const int *m1ptr = m1->data.i, *m2ptr = m2->data.i;
int *ms1ptr = ms1->data.i, *ms2ptr = ms2->data.i;
int count = m1->cols*m1->rows;
assert( CV_IS_MAT_CONT(m1->type & m2->type) && (elemSize % sizeof(int) == 0) );
elemSize /= sizeof(int);
for(; iters < maxAttempts; iters++)
{
for( i = 0; i < modelPoints && iters < maxAttempts; )
{
idx[i] = idx_i = cvRandInt(&rng) % count; // count ，count
for( j = 0; j < i; j++ ) //
if( idx_i == idx[j] )
break;
if( j < i )
continue;
for( k = 0; k < elemSize; k++ )
{
ms1ptr[i*elemSize + k] = m1ptr[idx_i*elemSize + k]; // ms1 ms2
ms2ptr[i*elemSize + k] = m2ptr[idx_i*elemSize + k];
}
if( checkPartialSubsets && (!checkSubset( ms1, i+1 ) || !checkSubset( ms2, i+1 ))) // checkSubset
{
iters++;
continue;
}
i++;
}
if( !checkPartialSubsets && i == modelPoints &&
(!checkSubset( ms1, i ) || !checkSubset( ms2, i )))
continue;
break;
}
return i == modelPoints && iters < maxAttempts;
}
8. 마지막 부분 이 관건 입 니 다.바로 FindHomography 함수 자체 입 니 다.이 함 수 는 cvFindHomography 함 수 를 다시 호출 했 습 니 다. openCV 의 서로 다른 버 전의 함수 일 것 입 니 다. 그 실현 기능 과 사상 은 모두 같 습 니 다.이 함수 내 부 는 기본적으로 넘 치 는 것 을 방지 하고 오 류 를 검사 하 며 변 수 를 검사 하고 형식 을 바 꾸 는 등 보조 적 인 내용 을 판단 하 는 것 입 니 다. 진정한 방법 적 인 코드 는 위 에서 언급 한 Cv Homography Estimator 류 입 니 다.bool CvModelEstimator2::checkSubset( const CvMat* m, int count )
{
int j, k, i, i0, i1;
CvPoint2D64f* ptr = (CvPoint2D64f*)m->data.ptr;
assert( CV_MAT_TYPE(m->type) == CV_64FC2 );
if( checkPartialSubsets )
i0 = i1 = count - 1;
else
i0 = 0, i1 = count - 1;
for( i = i0; i <= i1; i++ )
{
// check that the i-th selected point does not belong
// to a line connecting some previously selected points
for( j = 0; j < i; j++ )
{
double dx1 = ptr[j].x - ptr[i].x;
double dy1 = ptr[j].y - ptr[i].y;
for( k = 0; k < j; k++ )
{
double dx2 = ptr[k].x - ptr[i].x;
double dy2 = ptr[k].y - ptr[i].y;
if( fabs(dx2*dy1 - dy2*dx1) <= FLT_EPSILON*(fabs(dx1) + fabs(dy1) + fabs(dx2) + fabs(dy2)))
break;
}
if( k < j )
break;
}
if( j < i )
break;
}
return i >= i1;
}
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
openCV 의 findHomography 함수 분석 및 RANSAC 알고리즘 에 대한 상세 한 설명 (소스 코드 분석)컴퓨터 시각 과 이미지 처리 등 여러 분야 에서 RANSAC 알고리즘 을 사용 해 야 한다.openCV 에 도 사람들 이 사용 할 수 있 도록 봉 인 된 RANSAC 알고리즘 이 있다.RANSAC 알고리즘 에 대한 ...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.
좋은 웹페이지 즐겨찾기
