本文整理汇总了C++中cvFindCornerSubPix函数的典型用法代码示例。如果您正苦于以下问题：C++ cvFindCornerSubPix函数的具体用法？C++ cvFindCornerSubPix怎么用？C++ cvFindCornerSubPix使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了cvFindCornerSubPix函数的20个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的C++代码示例。
示例1: keyEvent
static void keyEvent( unsigned char key, int x, int y)
{
int i;
if( key == 0x1b || key == 'q' || key == 'Q' ) {
cleanup();
}
if( cornerFlag && key==' ' ) {
cvFindCornerSubPix( calibImageL, cornersL, chessboardCornerNumX*chessboardCornerNumY, cvSize(5,5),
cvSize(-1,-1), cvTermCriteria(CV_TERMCRIT_ITER, 100, 0.1) );
for( i = 0; i < chessboardCornerNumX*chessboardCornerNumY; i++ ) {
arParamObserv2Ideal(paramL.dist_factor, (double)cornersL[i].x, (double)cornersL[i].y,
&calibData[capturedImageNum].screenCoordL[i].x, &calibData[capturedImageNum].screenCoordL[i].y, paramL.dist_function_version);
}
cvFindCornerSubPix( calibImageR, cornersR, chessboardCornerNumX*chessboardCornerNumY, cvSize(5,5),
cvSize(-1,-1), cvTermCriteria(CV_TERMCRIT_ITER, 100, 0.1) );
for( i = 0; i < chessboardCornerNumX*chessboardCornerNumY; i++ ) {
arParamObserv2Ideal(paramR.dist_factor, (double)cornersR[i].x, (double)cornersR[i].y,
&calibData[capturedImageNum].screenCoordR[i].x, &calibData[capturedImageNum].screenCoordR[i].y, paramR.dist_function_version);
}
ARLOG("---------- %2d/%2d -----------\n", capturedImageNum+1, calibImageNum);
for( i = 0; i < chessboardCornerNumX*chessboardCornerNumY; i++ ) {
ARLOG(" %f, %f ---- %f, %f\n", calibData[capturedImageNum].screenCoordL[i].x, calibData[capturedImageNum].screenCoordL[i].y,
calibData[capturedImageNum].screenCoordR[i].x, calibData[capturedImageNum].screenCoordR[i].y);
}
ARLOG("---------- %2d/%2d -----------\n", capturedImageNum+1, calibImageNum);
capturedImageNum++;
if( capturedImageNum == calibImageNum ) {
calib();
cleanup();
}
}
}
开发者ID:kolzar，项目名称:artoolkit5，代码行数:35，代码来源:calib_stereo.cpp
示例2: findCorners
std::vector<CvPoint2D32f> findCorners(Image<PixRGB<byte> > &img, int rows, int cols)
{
int count = 0;
std::vector<CvPoint2D32f> corners(rows*cols);
Image<byte> in = luminance(img);
int result = cvFindChessboardCorners(img2ipl(in), cvSize(rows,cols),
&corners[0], &count,
CV_CALIB_CB_ADAPTIVE_THRESH |
CV_CALIB_CB_NORMALIZE_IMAGE |
CV_CALIB_CB_FILTER_QUADS);
// result = 0 if not all corners were found
// Find corners to an accuracy of 0.1 pixel
if(result != 0)
{
cvFindCornerSubPix(img2ipl(in),
&corners[0],
count,
cvSize(10,10), //win
cvSize(-1,-1), //zero_zone
cvTermCriteria(CV_TERMCRIT_ITER,1000,0.01) );
return corners;
} else {
return std::vector<CvPoint2D32f>();
}
}
开发者ID:ulyssesrr，项目名称:carmen_lcad，代码行数:32，代码来源:calibrateCamera.C
示例3: keyEvent
static void keyEvent( unsigned char key, int x, int y)
{
CvPoint2D32f *p1, *p2;
int i;
if( key == 0x1b || key == 'q' || key == 'Q' ) {
cleanup();
}
if( cornerFlag && key==' ' ) {
cvFindCornerSubPix( calibImage, corners, chessboardCornerNumX*chessboardCornerNumY, cvSize(5,5),
cvSize(-1,-1), cvTermCriteria (CV_TERMCRIT_ITER, 100, 0.1) );
p1 = &corners[0];
p2 = &cornerSet[capturedImageNum*chessboardCornerNumX*chessboardCornerNumY];
for( i = 0; i < chessboardCornerNumX*chessboardCornerNumY; i++ ) {
*(p2++) = *(p1++);
}
capturedImageNum++;
ARLOG("---------- %2d/%2d -----------\n", capturedImageNum, calibImageNum);
for( i = 0; i < chessboardCornerNumX*chessboardCornerNumY; i++ ) {
ARLOG(" %f, %f\n", corners[i].x, corners[i].y);
}
ARLOG("---------- %2d/%2d -----------\n", capturedImageNum, calibImageNum);
if( capturedImageNum == calibImageNum ) {
calib();
cleanup();
}
}
}
开发者ID:AkiraSoumi，项目名称:artoolkit5，代码行数:30，代码来源:calib_camera.cpp
示例4: cvGetSize
bool CybCamCalibration::generateDataToCalibration(IplImage *rgb_image) {
IplImage *view_gray;
int found = 0, count = 0;
img_size = cvGetSize(rgb_image);
found = cvFindChessboardCorners( rgb_image, board_size,
image_points_buf, &count, CV_CALIB_CB_ADAPTIVE_THRESH );
// improve the found corners' coordinate accuracy
view_gray = cvCreateImage( cvGetSize(rgb_image), 8, 1 );
cvCvtColor( rgb_image, view_gray, CV_BGR2GRAY );
cvFindCornerSubPix( view_gray, image_points_buf, count, cvSize(11,11),
cvSize(-1,-1), cvTermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1 ));
cvReleaseImage( &view_gray );
if( found )
{
cvSeqPush( image_points_seq, image_points_buf );
sprintf( imagename, "image%03d.png", image_points_seq->total - 1 );
cvSaveImage( imagename, rgb_image );
}
cvDrawChessboardCorners( rgb_image, board_size, image_points_buf, count, found );
return ((unsigned)image_points_seq->total >= (unsigned)image_count);
}
开发者ID:naneaa，项目名称:Cybermed-4.0，代码行数:31，代码来源:cybCamCalibration.cpp
示例5: analizarFlujo
public:bool analizarFlujo(IplImage *img, IplImage *imgAnterior, CvRect *rect) {
cvSetImageROI(img, *rect);
IplImage *imgA1 = cvCreateImage(cvGetSize(img), img->depth, img->nChannels);
cvCopy(img, imgA1);
cvSetImageROI(imgAnterior, *rect);
IplImage *imgB1 = cvCreateImage(cvGetSize(imgAnterior), imgAnterior->depth, imgAnterior->nChannels);
cvCopy(imgAnterior, imgB1);
cvResetImageROI(img);
cvResetImageROI(imgAnterior);
cvNamedWindow( "img", 1);
cvNamedWindow( "imgA", 1);
cvShowImage( "img", imgA1);
cvShowImage( "imgA", imgB1);
int py = imgA1->height;
int px = imgA1->width;
IplImage *imgA=cvCreateImage( cvSize(px,py),IPL_DEPTH_8U, 1);
IplImage *imgB=cvCreateImage( cvSize(px,py),IPL_DEPTH_8U, 1);
cvCvtColor( imgA1, imgA, CV_BGR2GRAY ); //
cvCvtColor( imgB1, imgB, CV_BGR2GRAY ); //
CvSize img_sz = cvGetSize( imgA );
/////////////////////////////
IplImage *eig_image = cvCreateImage( img_sz, IPL_DEPTH_32F, 1 );
IplImage *tmp_image = cvCreateImage( img_sz, IPL_DEPTH_32F, 1 );
int corner_count = MAX_CORNERS;
CvSize pyr_sz;
int win_size = 5;
cvGoodFeaturesToTrack(imgA,eig_image,tmp_image,cornersA,&corner_count,0.01,5.0,0,3,0,0.04);
cvFindCornerSubPix(imgA,cornersA,corner_count,cvSize(win_size,win_size),cvSize(-1,-1),cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,20,1));
// Call the Lucas Kanade algorithm
pyr_sz = cvSize( imgA->width+8, imgB->height/3 );
pyrA = cvCreateImage( pyr_sz, IPL_DEPTH_32F, 1 );
pyrB = cvCreateImage( pyr_sz, IPL_DEPTH_32F, 1 );
cvCalcOpticalFlowPyrLK(imgA,imgB,pyrA,pyrB,cornersA,cornersB,corner_count,cvSize( win_size,win_size ),5,features_found,feature_errors,cvTermCriteria( CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, .03 ),0);
// Now make some image of what we are looking at:
float dx=0.0;
for (int i=0; i<corner_count; i++) {
if( features_found[i]==0|| feature_errors[i]>100 ) {continue;}
dx=sqrt((cornersA[i].x-cornersB[i].x)*(cornersA[i].x-cornersB[i].x)+(cornersA[i].y-cornersB[i].y)*(cornersA[i].y-cornersB[i].y));
if(dx>1 && dx<50){
return true;
} else {
return false;
}
}
return false;
}
开发者ID:mrcportillo，项目名称:Guda，代码行数:60，代码来源:proceso.cpp
示例6: main
int main(int argc, char* argv[])
{
board_w = 5; // Board width in squares
board_h = 8; // Board height
n_boards = 8; // Number of boards
int board_n = board_w * board_h;
CvSize board_sz = cvSize( board_w, board_h );
CvCapture* capture = cvCreateCameraCapture( 0 );
assert( capture );
cvNamedWindow( "Calibration" );
// Allocate Sotrage
CvMat* image_points = cvCreateMat( n_boards*board_n, 2, CV_32FC1 );
CvMat* object_points = cvCreateMat( n_boards*board_n, 3, CV_32FC1 );
CvMat* point_counts = cvCreateMat( n_boards, 1, CV_32SC1 );
CvMat* intrinsic_matrix = cvCreateMat( 3, 3, CV_32FC1 );
CvMat* distortion_coeffs = cvCreateMat( 5, 1, CV_32FC1 );
CvPoint2D32f* corners = new CvPoint2D32f[ board_n ];
int corner_count;
int successes = 0;
int step, frame = 0;
IplImage *image = cvQueryFrame( capture );
IplImage *gray_image = cvCreateImage( cvGetSize( image ), 8, 1 );
// Capture Corner views loop until we've got n_boards
// succesful captures (all corners on the board are found)
while( successes < n_boards ){
// Skp every board_dt frames to allow user to move chessboard
if( frame++ % board_dt == 0 ){
// Find chessboard corners:
int found = cvFindChessboardCorners( image, board_sz, corners,
&corner_count, CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS );
// Get subpixel accuracy on those corners
cvCvtColor( image, gray_image, CV_BGR2GRAY );
cvFindCornerSubPix( gray_image, corners, corner_count, cvSize( 11, 11 ),
cvSize( -1, -1 ), cvTermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1 ));
// Draw it
cvDrawChessboardCorners( image, board_sz, corners, corner_count, found );
cvShowImage( "Calibration", image );
// If we got a good board, add it to our data
if( corner_count == board_n ){
step = successes*board_n;
for( int i=step, j=0; j < board_n; ++i, ++j ){
CV_MAT_ELEM( *image_points, float, i, 0 ) = corners[j].x;
CV_MAT_ELEM( *image_points, float, i, 1 ) = corners[j].y;
CV_MAT_ELEM( *object_points, float, i, 0 ) = j/board_w;
CV_MAT_ELEM( *object_points, float, i, 1 ) = j%board_w;
CV_MAT_ELEM( *object_points, float, i, 2 ) = 0.0f;
}
CV_MAT_ELEM( *point_counts, int, successes, 0 ) = board_n;
successes++;
}
}
开发者ID:Ashwaray，项目名称:Image-Processing-OpenCV，代码行数:59，代码来源:threshold.c
示例7: cvFindCornerSubPix
void cv::cornerSubPix( const Mat& image, vector<Point2f>& corners,
Size winSize, Size zeroZone,
TermCriteria criteria )
{
CvMat _image = image;
cvFindCornerSubPix(&_image, (CvPoint2D32f*)&corners[0], (int)corners.size(),
winSize, zeroZone, criteria );
}
开发者ID:NaterGator，项目名称:AndroidOpenCV_mods，代码行数:8，代码来源:cornersubpix.cpp
示例8: findCorners
//
// コーナーを検出する
//
// 引数:
// frameImage : キャプチャ画像用IplImage
// grayImage : グレースケール画像用IplImage
// corners : コーナーの位置を格納する変数
//
// 戻り値:
// 0 : コーナーがすべて検出できなかった場合
// 非0 : コーナーがすべて検出された場合
//
int findCorners( IplImage *frameImage, IplImage *grayImage, CvPoint2D32f *corners ) {
int cornerCount; // 検出したコーナーの数
int findChessboardCornersFlag; // cvFindChessboardCorners用フラグ
int findFlag; // コーナーがすべて検出できたかのフラグ
IplImage* m_image_binary;
IplImage* m_set_image;
m_image_binary = cvCreateImage(cvSize(frameImage->width, frameImage->height), IPL_DEPTH_8U, 1);
m_set_image = cvCreateImage(cvSize(frameImage->width, frameImage->height), IPL_DEPTH_8U, 3);
// cvChessboardCorners用フラグを生成する
findChessboardCornersFlag = createFindChessboardCornersFlag();
// 画像をBinaryImageとして変換する。
// コーナーを検出する
cvCvtColor( frameImage, grayImage, CV_BGR2GRAY );
// グレースケールから2値に変換する
cvThreshold( grayImage, m_image_binary, 128, 255, CV_THRESH_BINARY );
// Convert to 3channel image
cvMerge(m_image_binary, m_image_binary, m_image_binary, NULL, m_set_image);
findFlag=cvFindChessboardCorners(
m_set_image,
//m_set_image,
//cvSize( CORNER_WIDTH, CORNER_HEIGHT ),
board_sz,
corners,
&cornerCount,
findChessboardCornersFlag
);
if( findFlag != 0 ) {
// コーナーがすべて検出された場合
// 検出されたコーナーの位置をサブピクセル単位にする
CvTermCriteria criteria={ CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, MAX_ITERATIONS, EPSILON };
cvFindCornerSubPix(
grayImage,
corners,
cornerCount,
cvSize( SEARCH_WINDOW_HALF_WIDTH, SEARCH_WINDOW_HALF_HEIGHT ),
cvSize( DEAD_REGION_HALF_WIDTH, DEAD_REGION_HALF_HEIGHT ),
cvTermCriteria( CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, MAX_ITERATIONS, EPSILON )
);
}
// コーナーの位置を描く
cvDrawChessboardCorners( frameImage, board_sz, corners, cornerCount, findFlag );
cvReleaseImage(&m_set_image);
cvReleaseImage(&m_image_binary);
return findFlag;
}
开发者ID:fsi-katami，项目名称:RTCCatalog2010_OpenCV，代码行数:69，代码来源:ImageCalibration.cpp
示例9: opticalflow
int opticalflow( char * im1fname, char * im2fname, CvPoint2D32f * &source_points, CvPoint2D32f * &dest_points, char * &status )
{
int count = MAX_COUNT;
double quality = 0.15;
// double min_distance = 2;
double min_distance = 3;
int block_size = 7;
int use_harris = 0;
int win_size = 10;
int flags = 0;
source_points = (CvPoint2D32f*)cvAlloc(MAX_COUNT*sizeof(CvPoint2D32f));
dest_points = (CvPoint2D32f*)cvAlloc(MAX_COUNT*sizeof(CvPoint2D32f));
IplImage * image1 = cvLoadImage(im1fname, CV_LOAD_IMAGE_GRAYSCALE);
IplImage * eigenvalues = cvCreateImage(cvGetSize(image1), 32, 1);
IplImage * temp = cvCreateImage(cvGetSize(image1), 32, 1);
cvGoodFeaturesToTrack( image1, eigenvalues, temp, source_points, &count,
quality, min_distance, 0, block_size, use_harris, 0.04 );
printf("%d features\n",count);
setbuf(stdout, NULL);
printf("Finding corner subpix...");
cvFindCornerSubPix( image1, source_points, count,
cvSize(win_size,win_size), cvSize(-1,-1),
cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS, 20, 0.03));
printf("done.\n");
cvReleaseImage(&eigenvalues);
cvReleaseImage(&temp);
IplImage * image2 = cvLoadImage(im2fname, CV_LOAD_IMAGE_GRAYSCALE);
status = (char*)cvAlloc(sizeof(char)*MAX_COUNT);
IplImage * pyramid = cvCreateImage( cvGetSize(image1), IPL_DEPTH_8U, 1 );
IplImage * second_pyramid = cvCreateImage( cvGetSize(image2), IPL_DEPTH_8U, 1 );
printf("Computing optical flow...");
cvCalcOpticalFlowPyrLK(image1, image2, pyramid, second_pyramid, source_points,
dest_points, count, cvSize(win_size,win_size), 4, status, 0,
cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS, 20, 0.03),
flags);
printf("done.\n");
cvReleaseImage( &image1 );
cvReleaseImage( &image2 );
cvReleaseImage( &pyramid );
cvReleaseImage( &second_pyramid );
return count;
}
开发者ID:ryanfb，项目名称:homer，代码行数:57，代码来源:opticaltri.cpp
示例10: improve_precision
void improve_precision(IplImage *image, CvPoint2D32f * cornersArray, int cornersCount)
{
// subPix tool requires a gray scale:
IplImage * gray_image = cvCreateImage(cvSize(image->width,image->height), 8, 1);
cvCvtColor(image, gray_image, CV_BGR2GRAY);
// we use 2 different terminal criteria: nomber of iterations and/or precision (first to be reached)
cvFindCornerSubPix(gray_image, cornersArray, cornersCount,cvSize(11,11),cvSize(-1,-1), cvTermCriteria(CV_TERMCRIT_EPS +CV_TERMCRIT_ITER, 30, 0.1 ));
}
开发者ID:moumen19，项目名称:robotiquecartemere，代码行数:10，代码来源:cameraCalibration.c
示例11: bbox
void OpticalFlow::PrepareTracking(IplImage* rgbImage,
IplImage* currGrayImage, int curr_indx,
ProbDistrProvider* pProbProv,
const CuScanMatch& match,
ConstMaskIt mask,
int target_num_features,
int winsize_width,
int winsize_height,
double min_distance,
double max_feature_error)
{
m_pProbDistrProvider = pProbProv;
m_target_num_features = target_num_features;
m_num_features_tracked = 0;
m_prev_buf_meaningful = false;
m_winsize_width = winsize_width;
m_winsize_height = winsize_height;
m_min_distance = min_distance;
m_max_feature_error = max_feature_error;
// first find a big set of features that sits on corners
int num_corners = m_target_num_features*3;
CPointVector corners;
corners.resize(num_corners);
CRect bbox(match);
FindGoodFeatures(currGrayImage, bbox, corners);
// then play with the color probability distribution to pick
// the ones that are on skin color, or if those aren't enough,
// pick some additional ones on skin colored pixels
m_features[0].resize(m_target_num_features);
m_features[1].resize(m_target_num_features);
m_feature_status.resize(m_target_num_features);
m_errors.resize(m_target_num_features);
PickSkinColoredFeatures(rgbImage, corners, m_features[curr_indx], match, mask);
// fine-tune feature locations
cvFindCornerSubPix(currGrayImage,
(CvPoint2D32f*) &m_features[curr_indx][0],
m_target_num_features,
cvSize(5,5), cvSize(-1,-1),
cvTermCriteria( CV_TERMCRIT_ITER, 10, 0.1f ));
// set status right for these features
for (int i=0; i<m_target_num_features; i++) {
m_feature_status[i] = 1;
}
GetAverage(m_features[curr_indx], m_mean_feature_pos);
m_condens_is_tracking = false;
m_condens_init_rect = CRect(match);
m_prepared = true;
}
开发者ID:B12040331，项目名称:handvu，代码行数:54，代码来源:OpticalFlow.cpp
示例12: do_calibration
//borrowed from Patrick...
int do_calibration() {
IplImage* image = NULL;
int xc = 12;
int yc = 12;
int nc = xc*yc;
float side_length = 15;
CvSize board_sz = cvSize(xc, yc);
int ntrials = img_cnt;
char filename[128];
CvMat* object_points = cvCreateMat( ntrials * nc, 3, CV_32FC1 );
CvMat* image_points = cvCreateMat( ntrials * nc, 2, CV_32FC1 );
CvMat* point_counts = cvCreateMat( ntrials, 1, CV_32SC1 );
CvPoint2D32f* corners = new CvPoint2D32f[nc];
for(int t=1; t<=ntrials; t++) {
// load an image
sprintf(filename, "%s/Image%d.jpg", dir_name, t);
image = cvLoadImage(filename);
if(!image){
printf("Could not load image file: %s\n",filename);
exit(0);
}
int corner_count;
int found = cvFindChessboardCorners(image, board_sz, corners, &corner_count,
CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS);
IplImage* gray = cvCreateImage(cvSize(image->width, image->height), IPL_DEPTH_8U, 1);
cvCvtColor(image, gray, CV_BGR2GRAY);
cvFindCornerSubPix(gray, corners, corner_count,
cvSize(5, 5), cvSize(-1, -1),
cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS, 10, 0.01f ));
printf("Image: %d, %d / %d\n", t, corner_count, nc);
// get data points
if(corner_count == nc && found != 0) {
for(int c=0; c<nc; c++) {
CV_MAT_ELEM( *image_points, float, (t-1)*nc+c, 0 ) = corners[c].x;
CV_MAT_ELEM( *image_points, float, (t-1)*nc+c, 1 ) = corners[c].y;
CV_MAT_ELEM( *object_points, float, (t-1)*nc+c, 0 ) = (float)(c/xc)*side_length;
CV_MAT_ELEM( *object_points, float, (t-1)*nc+c, 1 ) = (float)(c%xc)*side_length;
CV_MAT_ELEM( *object_points, float, (t-1)*nc+c, 2 ) = 0.0f;
}
CV_MAT_ELEM( *point_counts, int, t-1, 0 ) = nc;
}
else printf("Bad board! How did this happen?\n");
}
开发者ID:goretkin，项目名称:kwc-ros-pkg，代码行数:55，代码来源:calibrator.cpp
示例13: CV_Assert
void cv::cornerSubPix( InputArray _image, InputOutputArray _corners,
Size winSize, Size zeroZone,
TermCriteria criteria )
{
Mat corners = _corners.getMat();
int ncorners = corners.checkVector(2);
CV_Assert( ncorners >= 0 && corners.depth() == CV_32F );
Mat image = _image.getMat();
CvMat c_image = image;
cvFindCornerSubPix( &c_image, (CvPoint2D32f*)corners.data, ncorners,
winSize, zeroZone, criteria );
}
开发者ID:09beezahmad，项目名称:opencv，代码行数:13，代码来源:cornersubpix.cpp
示例14: Calibrate
void Calibrate(){
CvPoint2D32f* corners = new CvPoint2D32f[ board_n ];
int corner_count;
int successes = 0;
int step, frame = 0;
IplImage *image = cvQueryFrame( capture );
/*(IplImage *image = cvQueryFrame( capture );
cvSetImageROI(image, cvRect(300, 300, 600, 600));
tmp = cvCreateImage(cvGetSize(image), image->depth, image->nChannels);
cvCopy(image, tmp, NULL);
cvResetImageROI(image);
image = cvCloneImage(tmp);//*/
IplImage *gray_image = cvCreateImage( cvGetSize( image ), 8, 1 );
// Capture Corner views loop until we've got n_boards
// successful captures (all corners on the board are found)
while( successes < n_boards ){
// Skp every board_dt frames to allow user to move chessboard
if( frame++ % board_dt == 0 ){
// Find chessboard corners:
int found = cvFindChessboardCorners( image, board_sz, corners,
&corner_count, CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS );
// Get subpixel accuracy on those corners
cvCvtColor( image, gray_image, CV_BGR2GRAY );
cvFindCornerSubPix( gray_image, corners, corner_count, cvSize( 11, 11 ),
cvSize( -1, -1 ), cvTermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1 ));
// Draw it
cvDrawChessboardCorners( image, board_sz, corners, corner_count, found );
//cvShowImage( "Calibration", image );
// If we got a good board, add it to our data
if( corner_count == board_n ){
step = successes*board_n;
for( int i=step, j=0; j < board_n; ++i, ++j ){
CV_MAT_ELEM( *image_points, float, i, 0 ) = corners[j].x;
CV_MAT_ELEM( *image_points, float, i, 1 ) = corners[j].y;
CV_MAT_ELEM( *object_points, float, i, 0 ) = j/board_w;
CV_MAT_ELEM( *object_points, float, i, 1 ) = j%board_w;
CV_MAT_ELEM( *object_points, float, i, 2 ) = 0.0f;
}
CV_MAT_ELEM( *point_counts, int, successes, 0 ) = board_n;
successes++;
}
}
开发者ID:sashanicolas，项目名称:TesteOpenCV，代码行数:50，代码来源:main.cpp
示例15: img2ipl
// ######################################################################
void NeoBrain::setTarget(const Point2D<int> loc, const Image<byte>& grey,
const int saliencyval, bool changeState)
{
if (!itsAllowTracking.getVal())
return;
#ifdef HAVE_OPENCV
count = MAX_COUNT;
IplImage* tmp = img2ipl(grey);
if (count > 1)
{
IplImage* eig = cvCreateImage(cvGetSize(tmp), 32, 1);
IplImage* temp = cvCreateImage(cvGetSize(tmp), 32, 1);
double quality = 0.01;
double min_distance = 5;
cvGoodFeaturesToTrack(tmp, eig, temp, points[1], &count,
quality, min_distance, 0, 3, 0, 0.04);
cvReleaseImage(&eig);
cvReleaseImage(&temp);
} else {
//get from the saliency map
points[1][0].x = loc.i;
points[1][0].y = loc.j;
}
cvFindCornerSubPix(tmp, points[1], count,
cvSize(win_size,win_size), cvSize(-1,-1),
cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,
20,0.03));
cvReleaseImageHeader(&tmp);
IplImage *swap_temp;
prev_grey = grey;
CV_SWAP( prev_pyramid, pyramid, swap_temp );
CV_SWAP( points[0], points[1], swap_points );
//LINFO("Init %i point (%f,%f)\n", count, points[1][0].x, points[1][0].y);
if (changeState)
itsState = CHECK_TARGET;
itsTracking = true;
#endif
if (saliencyval >= 0)
this->saySaliencyVal(byte(saliencyval));
}
开发者ID:ulyssesrr，项目名称:carmen_lcad，代码行数:51，代码来源:NeoBrainVss.C
示例16: get_calib
void get_calib(CvCapture* capture) {
int board_n = board_w * board_h;
CvSize board_sz = cvSize(board_w, board_h);
cvNamedWindow("Calibration");
CvMat* image_points = cvCreateMat(n_boards * board_n, 2, CV_32FC1);
CvMat* object_points = cvCreateMat(n_boards * board_n, 3, CV_32FC1);
CvMat* point_counts = cvCreateMat(n_boards, 1, CV_32FC1);
CvMat* intrinsic_matrix = cvCreateMat(3, 3, CV_32FC1);
CvMat* distortion_coeffs = cvCreateMat(5, 1, CV_32FC1);
CvPoint2D32f* corners = new CvPoint2D32f[board_n];
int corner_count;
int successes = 0;
int step, frame = 0;
IplImage *image = cvQueryFrame(capture);
IplImage *gray_image = cvCreateImage(cvGetSize(image), 8, 1);
while(successes < n_boards) {
if(frame++ % board_dt == 0) {
int found = cvFindChessboardCorners(
image, board_sz, corners, &corner_count,
CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS);
cvCvtColor(image, gray_image, CV_RGB2GRAY);
cvFindCornerSubPix(gray_image, corners, corner_count,
cvSize(11,11), cvSize(-1, -1),
cvTermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
cvDrawChessboardCorners(image, board_sz, corners, corner_count, found);
cvShowImage("Calibration", image);
//get a good board, add to data
if(corner_count == board_n) {
printf("here\n");
step = successes * board_n;
for(int i = step, j = 0; j < board_n; ++i, ++j) {
CV_MAT_ELEM(*image_points, float, i, 0) = corners[j].x;
CV_MAT_ELEM(*image_points, float, i, 1) = corners[j].y;
CV_MAT_ELEM(*object_points, float, i, 0) = j / board_w;
CV_MAT_ELEM(*object_points, float, i, 1) = j % board_w;
CV_MAT_ELEM(*object_points, float, i, 2) = 0.0f;
}
CV_MAT_ELEM(*point_counts, int, successes, 0) = board_n;
successes++;
printf("Nice shot!\n");
int k = cvWaitKey(-1);
while(k != 'n') k = cvWaitKey(-1);
}
}
开发者ID:AprilWong，项目名称:camera-calibration，代码行数:48，代码来源:camera.cpp
示例17: cvGetSize
int StereoVision::calibrationAddSample(IplImage* imageLeft,IplImage* imageRight) {
if(!calibrationStarted) return RESULT_FAIL;
IplImage* image[2] = {imageLeft,imageRight};
int succeses = 0;
for(int lr=0; lr<2; lr++) {
CvSize imageSize = cvGetSize(image[lr]);
if(imageSize.width != this->imageSize.width || imageSize.height != this->imageSize.height)
return RESULT_FAIL;
int cornersDetected = 0;
//FIND CHESSBOARDS AND CORNERS THEREIN:
int result = cvFindChessboardCorners(
image[lr], cvSize(cornersX, cornersY),
&ponintsTemp[lr][0], &cornersDetected,
CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_NORMALIZE_IMAGE
);
if(result && cornersDetected == cornersN) {
//Calibration will suffer without subpixel interpolation
cvFindCornerSubPix(
image[lr], &ponintsTemp[lr][0], cornersDetected,
cvSize(11, 11), cvSize(-1,-1),
cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30, 0.01)
);
succeses++;
}
}
if(2==succeses) {
for(int lr=0; lr<2; lr++) {
points[lr].resize((sampleCount+1)*cornersN);
copy( ponintsTemp[lr].begin(), ponintsTemp[lr].end(), points[lr].begin() + sampleCount*cornersN);
}
sampleCount++;
return RESULT_OK;
} else {
return RESULT_FAIL;
}
}
开发者ID:SiddharthTiwari，项目名称:destin，代码行数:47，代码来源:stereovision.cpp
示例18: cc
const CheckerboardDetector::Checkerboard &
CheckerboardDetector::detect(const Img8u &image){
const Img8u *useImage = ℑ
if(image.getFormat() != formatGray && image.getChannels() != 1){
m_data->grayBuf.setFormat(formatGray);
m_data->grayBuf.setSize(image.getSize());
cc(&image, &m_data->grayBuf);
useImage = &m_data->grayBuf;
}
img_to_ipl(useImage, &m_data->ipl);
std::vector<CvPoint2D32f> corners(m_data->cb.size.getDim());
CvSize s = {m_data->cb.size.width, m_data->cb.size.height };
int n = corners.size();
m_data->cb.found = cv::cvFindChessboardCorners(
m_data->ipl, s, corners.data(), &n,
cv::CALIB_CB_ADAPTIVE_THRESH | cv::CALIB_CB_FILTER_QUADS);
bool optSubPix = getPropertyValue("subpixel opt.enabled");
int radius = getPropertyValue("subpixel opt.radius");
int innerR = getPropertyValue("subpixel opt.inner radius");
if(innerR >= radius) innerR = radius -1;
if(innerR == 0) innerR = -1;
int maxIter = getPropertyValue("subpixel opt.max iterations");
float minErr = getPropertyValue("subpixel opt.min error");
if(m_data->cb.found && optSubPix){
cvFindCornerSubPix(m_data->ipl, corners.data(), corners.size(), cvSize(radius,radius),
cvSize(innerR, innerR),
cvTermCriteria(CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, maxIter, minErr));
}
if(m_data->cb.found){
m_data->cb.corners.resize(corners.size());
for(size_t i=0;i<corners.size();++i){
m_data->cb.corners[i] = Point32f(corners[i].x, corners[i].y);
}
}else{
m_data->cb.corners.clear();
}
return m_data->cb;
}
开发者ID:ethz-asl，项目名称:iclcv，代码行数:46，代码来源:CheckerboardDetector.cpp
示例19: cvSize
bool CalibrationFilter::findTarget()
{
int numExpectedPoints = chessBoardCalibObject.numPoints;
CvPoint2D32f* points = new CvPoint2D32f[numExpectedPoints];
int numFoundPoints;
#ifdef USE_CHESSBOARD
CvSize boardSize = cvSize(CHESSBOARD_CORNERS_X, CHESSBOARD_CORNERS_Y);
int found_target = cvFindChessBoardCorners(input.getCvImage(),
boardSize,
points,
&numFoundCorners
CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS);
#endif
if (found_target)
{
cvFindCornerSubPix(grayInput.getCvImage(),
points,
numFoundPoints,
cvSize(11,11), cvSize(-1,-1),
cvTermCriteria(
CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,
30, 0.1));
#ifdef USE_CHESSBOARD_ONLY
cvDrawChessboardCorners(input, boardSize, points, numFoundPoints, found_target);
#endif
CalibrationCapture* capture = new CalibrationCapture(chessBoardPoints);
capture.image = input;
capture.setPoints(points, numFoundPoints);
captures.push_back(capture);
}
delete points;
return found_target;
}
开发者ID:paulreimer，项目名称:DataFlower，代码行数:41，代码来源:CalibrationFilter.cpp
示例20: cvSize
void FkPaperKeyboard_TypeA::detectKeyButtonCorner(IplImage* srcImage){
//500,250
CvSize transSize = cvSize(640,480);
IplImage* eigImage = cvCreateImage(transSize, IPL_DEPTH_8U,1);
IplImage* tempImage = cvCreateImage(transSize, IPL_DEPTH_8U, 1);
IplImage* grayImage = cvCreateImage(transSize, IPL_DEPTH_8U, 1);
IplImage* dstImage = cvCreateImage(transSize, IPL_DEPTH_8U, 1);
int keyButtonCornerCount = 316;
cvCopy(srcImage, grayImage);
//cvShowImage("ssssssssssssssss",srcImage);
//cvShowImage("gggggggggggggggg",grayImage);
cvGoodFeaturesToTrack(grayImage, eigImage, tempImage, keyButtonCorner, &keyButtonCornerCount, 0.03, 7, NULL, 10, 0);
cvFindCornerSubPix (grayImage, keyButtonCorner, keyButtonCornerCount,cvSize (3, 3), cvSize (-1, -1), cvTermCriteria (CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03));
initKeyButtonCorner();
cvReleaseImage(&eigImage);
cvReleaseImage(&tempImage);
cvReleaseImage(&grayImage);
cvReleaseImage(&dstImage);
}
开发者ID:FingerKeyboard-jh-sm，项目名称:FingerKeyboard，代码行数:21，代码来源:FkPaperKeyboard_TypeA.cpp
注：本文中的cvFindCornerSubPix函数示例由纯净天空整理自Github/MSDocs等源码及文档管理平台，相关代码片段筛选自各路编程大神贡献的开源项目，源码版权归原作者所有，传播和使用请参考对应项目的License；未经允许，请勿转载。 |
客服电话
APP下载
官方微信
请发表评论