void FaceDetection::AddContours2Rect(CvSeq *seq, int color, int iLayer) { assert(m_mstgRects != NULL); assert(m_seqRects != NULL); CvContourRect cr; for (CvSeq* external = seq; external; external = external->h_next) { cr.r = cvContourBoundingRect(external, 1 ); cr.pCenter.x = cr.r.x + cr.r.width / 2; cr.pCenter.y = cr.r.y + cr.r.height / 2; cr.iNumber = iLayer; cr.iType = 6; cr.iFlags = 0; cr.seqContour = external; cr.iContourLength = external->total; cr.iColor = color; cvSeqPush(m_seqRects, &cr); for (CvSeq* internal = external->v_next; internal; internal = internal->h_next) { cr.r = cvContourBoundingRect(internal, 0); cr.pCenter.x = cr.r.x + cr.r.width / 2; cr.pCenter.y = cr.r.y + cr.r.height / 2; cr.iNumber = iLayer; cr.iType = 12; cr.iFlags = 0; cr.seqContour = internal; cr.iContourLength = internal->total; cr.iColor = color; cvSeqPush(m_seqRects, &cr); } } }// void FaceDetection::AddContours2Rect(CvSeq *seq, int color, int iLayer)
// the function draws all the squares in the image void drawSquares(IplImage* imgSrc, CvSeq* squares) { CvSeqReader reader; IplImage* imgCopy = cvCloneImage(imgSrc); int i; // initialize reader of the sequence cvStartReadSeq(squares, &reader, 0); // read 4 sequence elements at a time (all vertices of a square) printf("Found %d rectangles in image\n", squares->total / 4); for (i = 0; i < squares->total; i += 4) { CvPoint* pntRect = gPnt; int pntCount = 4; CvSeq* seqRect = cvCreateSeq(CV_32SC2, sizeof(CvSeq), sizeof(CvPoint), gStorage); // read 4 vertices memcpy(gPnt, reader.ptr, squares->elem_size); CV_NEXT_SEQ_ELEM(squares->elem_size, reader); cvSeqPush(seqRect, &pntRect[0]); memcpy(gPnt + 1, reader.ptr, squares->elem_size); CV_NEXT_SEQ_ELEM(squares->elem_size, reader); cvSeqPush(seqRect, &pntRect[1]); memcpy(gPnt + 2, reader.ptr, squares->elem_size); CV_NEXT_SEQ_ELEM(squares->elem_size, reader); cvSeqPush(seqRect, &pntRect[2]); memcpy(gPnt + 3, reader.ptr, squares->elem_size); CV_NEXT_SEQ_ELEM(squares->elem_size, reader); cvSeqPush(seqRect, &pntRect[3]); // draw the square as a closed polyline cvPolyLine(imgCopy, &pntRect, &pntCount, 1, 1, CV_RGB(0, 255, 0), 1, CV_AA, 0); // draw the min outter rect CvBox2D box = cvMinAreaRect2(seqRect, NULL); CvPoint2D32f ptBox[4]; cvBoxPoints(box, ptBox); for(int i = 0; i < 4; ++i) { cvLine(imgCopy, cvPointFrom32f(ptBox[i]), cvPointFrom32f(ptBox[((i+1)%4)?(i+1):0]), CV_RGB(255,0,0)); } } // show the resultant image cvShowImage(wndname, imgCopy); cvReleaseImage(&imgCopy); }
void FaceDetection::CreateResults(CvSeq * lpSeq) { Face * tmp; double Max = 0; double CurStat = 0; FaceData tmpData; if (m_bBoosting) { tmp = m_pFaceList->GetData(); tmp->CreateFace(&tmpData); CvFace tmpFace; tmpFace.MouthRect = tmpData.MouthRect; tmpFace.LeftEyeRect = tmpData.LeftEyeRect; tmpFace.RightEyeRect = tmpData.RightEyeRect; cvSeqPush(lpSeq,&tmpFace); }else { while ( (tmp = m_pFaceList->GetData()) != 0 ) { CurStat = tmp->GetWeight(); if (CurStat > Max) Max = CurStat; } while ( (tmp = m_pFaceList->GetData()) != 0 ) { tmp->CreateFace(&tmpData); CurStat = tmp->GetWeight(); if (CurStat == Max) { CvFace tmpFace; tmpFace.MouthRect = tmpData.MouthRect; tmpFace.LeftEyeRect = tmpData.LeftEyeRect; tmpFace.RightEyeRect = tmpData.RightEyeRect; cvSeqPush(lpSeq,&tmpFace); } } } }// void FaceDetection::DrawResult(IplImage* img)
void CalcFourierDescriptorCoeff(CvSeq* seq_pts, int n_fourier,CvSeq* seq_fourier) { int count = seq_pts->total; double *coeff_cos, *coeff_sin; coeff_cos = (double*)malloc(count*sizeof(double)); coeff_sin = (double*)malloc(count*sizeof(double)); int i; for(i = 0; i < count; i++) { coeff_sin[i] = sin(2*i*CV_PI/count); coeff_cos[i] = cos(2*i*CV_PI/count); } cvClearSeq(seq_fourier); for(int u = 0; u < n_fourier; u++) { CvPoint2D32f point_coeff = cvPoint2D32f(0, 0); for(i = 0; i < count; i+=4) { CvPoint* pt = (CvPoint*)cvGetSeqElem(seq_pts, i); point_coeff.x += (float)(pt->x*coeff_cos[(i*u)%count] + pt->y*coeff_sin[(i*u)%count]); point_coeff.y += (float)(pt->y*coeff_cos[(i*u)%count] - pt->x*coeff_sin[(i*u)%count]); } //point_coeff.x/=count; //point_coeff.y/=count; cvSeqPush(seq_fourier, &point_coeff); } free(coeff_cos); free(coeff_sin); }
void CalcBoundary(CvSeq* seq_fourier, int n_Pts, CvSeq* seq_pts) { int count = seq_fourier->total; double *coeff_cos, *coeff_sin; coeff_cos = (double*)malloc(n_Pts*sizeof(double)); coeff_sin = (double*)malloc(n_Pts*sizeof(double)); int i; for(i = 0; i < n_Pts; i++) { coeff_sin[i] = sin(2*i*CV_PI/n_Pts); coeff_cos[i] = cos(2*i*CV_PI/n_Pts); } cvClearSeq(seq_pts); for(i = 0; i < n_Pts; i++) { CvPoint pt = cvPoint(0, 0); double sumx = 0, sumy = 0; for(int u = 0; u < count; u++) { CvPoint2D32f* point_coeff = (CvPoint2D32f*)cvGetSeqElem(seq_fourier, u); sumx += point_coeff->x*coeff_cos[(i*u)%n_Pts] - point_coeff->y*coeff_sin[(i*u)%n_Pts]; sumy += point_coeff->y*coeff_cos[(i*u)%n_Pts] + point_coeff->x*coeff_sin[(i*u)%n_Pts]; } pt.x = cvRound(sumx/count); pt.y = cvRound(sumy/count); cvSeqPush(seq_pts, &pt); } free(coeff_cos); free(coeff_sin); }
VALUE rb_seq_push(VALUE self, VALUE args, int flag) { CvSeq *seq = CVSEQ(self); VALUE klass = seqblock_class(seq), object; void *buffer = NULL; for (int i = 0; i < RARRAY_LEN(args); i++) { object = RARRAY_PTR(args)[i]; if (CLASS_OF(object) == klass) { if (flag == CV_FRONT) cvSeqPushFront(seq, DATA_PTR(object)); else cvSeqPush(seq, DATA_PTR(object)); } else if (rb_obj_is_kind_of(object, rb_klass) && CLASS_OF(rb_first(object)) == klass) { // object is CvSeq buffer = cvCvtSeqToArray(CVSEQ(object), cvAlloc(CVSEQ(object)->total * CVSEQ(object)->elem_size)); cvSeqPushMulti(seq, buffer, CVSEQ(object)->total, flag); cvFree(&buffer); } else { rb_raise(rb_eTypeError, "arguments should be %s or %s which includes %s.", rb_class2name(klass), rb_class2name(rb_klass), rb_class2name(klass)); } } return self; }
CvSeq *reghand::filthull2(CvSeq *filted_elimhull) { //CvSeq *filtedhullseq=cvCloneSeq(filted_elimhull); float maxdis=0;CvPoint **fingpt;CvScalar mean,std=cvScalarAll(0); CvMat *dismat=cvCreateMat(1,filted_elimhull->total,CV_32FC1); CvPoint2D32f center=minrect.center; for (int i=0;i<filted_elimhull->total;i++) { CvPoint **data=CV_GET_SEQ_ELEM(CvPoint*,filted_elimhull,i); CvPoint pt=**data; float dis=sqrt(pow(pt.x-center.x,2)+pow(pt.y-center.y,2)); dismat->data.fl[i]=dis; if(dis>maxdis){maxdis=dis;fingpt=data;} } cvAvgSdv(dismat,&mean,&std); if(filted_elimhull->total==1&&maxdis>fingerTh*0.5) return filted_elimhull; if(filted_elimhull->total==2&&maxdis>fingerTh*0.5&&std.val[0]<10) { CvPoint startpt=**CV_GET_SEQ_ELEM(CvPoint*,filted_elimhull,0); CvPoint endpt=**CV_GET_SEQ_ELEM(CvPoint*,filted_elimhull,1);; double bfang=atan(double(startpt.y-handcenter.y)/(startpt.x-handcenter.x))*180/PI; if(bfang<0)bfang+=180; double afang=atan(double(endpt.y-handcenter.y)/(endpt.x-handcenter.x))*180/PI; if(afang<0)afang+=180; if(fabs(bfang-afang)>60) {cvClearSeq(filted_elimhull);cvSeqPush(filted_elimhull,fingpt);return filted_elimhull;} else return filted_elimhull; }
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); }
void EdgeDetection::getEdge(CvSeq *seq) { int nWidth = pImage->width; int nHeight = pImage->height; int widthStep=pImage->widthStep; //计算直方图 int histab[256]; for(int i=0;i<256;i++) histab[i]=0; for(int j=1;j<nHeight-1;j++) { for(int i=1;i<nWidth-1;i++) { double temp=(pImage->imageData+nWidth*j)[i]; if(temp<0) temp+=256; histab[(int)temp]++; } } for(int i=0;i<256;i++) probability[i]=(float)(histab[i]/((nHeight-2)*(nWidth-2)*1.0)); double edgethreadhold=moment_shresh_sel1(probability);//计算边缘二值化的分割阈值 for(int j=0;j<nHeight;j++)//将sobel检测出来的边缘进行二值化,滤去值过小的边缘点 { for(int i=0;i<nWidth;i++) { if(i<1||j<1||j==nHeight-1||i==nWidth-1) { (pImage->imageData+nWidth*j)[i]=0; } else { double temp=(pImage->imageData+nWidth*j)[i]; if(temp<0) temp+=256; if(temp>edgethreadhold) { (pImage->imageData+nWidth*j)[i]=255; CvPoint2D32f sample; sample.x=j; sample.y=i; cvSeqPush(seq,&sample); } else (pImage->imageData+nWidth*j)[i]=0; } } } cvNamedWindow( "Segment2_边缘图", 1 );//创建窗口 cvShowImage( "Segment2_边缘图", pImage );//显示图像 }
void bContourFinder::findConvexHulls(){ CvMemStorage *stor = cvCreateMemStorage(); CvSeq * ptseq = cvCreateSeq( CV_SEQ_KIND_CURVE|CV_32SC2, sizeof(CvContour), sizeof(CvPoint), stor ); CvSeq * hull; CvPoint pt; this->convexBlobs.clear(); for(int i = 0 ; i < this->blobs.size(); i++){ this->convexBlobs.push_back(ofxCvBlob()); this->convexBlobs[i] = this->blobs[i]; this->convexBlobs[i].pts.clear(); // get blob i for(int j = 0; j < this->blobs[i].pts.size(); j++){ // fill in blob points pt.x = this->blobs[i].pts[j].x; pt.y = this->blobs[i].pts[j].y; cvSeqPush( ptseq, &pt); } hull = cvConvexHull2(ptseq, 0, CV_CLOCKWISE, 0); // get the points for the blob: CvPoint pt = **CV_GET_SEQ_ELEM( CvPoint*, hull, hull->total - 1 ); for( int j=0; j < hull->total; j++ ) { pt = **CV_GET_SEQ_ELEM( CvPoint*, hull, j ); convexBlobs[i].pts.push_back( ofPoint((float)pt.x, (float)pt.y) ); } convexBlobs[i].nPts = convexBlobs[i].pts.size(); } cvClearMemStorage( stor ); }
int main (int argc, char **argv) { CvMemStorage *storage = cvCreateMemStorage( 0 ); CvSeq *points = cvCreateSeq( CV_SEQ_ELTYPE_POINT, sizeof( CvSeq ), sizeof( CvPoint ), storage ); cvSeqPush( points, &cvPoint( 100, 50 ) ); cvSeqPush( points, &cvPoint( 50, 100 ) ); cvSeqPush( points, &cvPoint( 50, 150 ) ); cvSeqPush( points, &cvPoint( 150, 50 ) ); CvRect rect = cvBoundingRect( points ); cvPrintRect( rect ); cvReleaseMemStorage( &storage ); return 0; }
CV_IMPL CvSeq* cvSegmentMotion( const CvArr* mhimg, CvArr* segmaskimg, CvMemStorage* storage, double timestamp, double segThresh ) { cv::Mat mhi = cv::cvarrToMat(mhimg); const cv::Mat segmask = cv::cvarrToMat(segmaskimg); std::vector<cv::Rect> brs; cv::segmentMotion(mhi, segmask, brs, timestamp, segThresh); CvSeq* seq = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvConnectedComp), storage); CvConnectedComp comp; memset(&comp, 0, sizeof(comp)); for( size_t i = 0; i < brs.size(); i++ ) { cv::Rect roi = brs[i]; float compLabel = (float)(i+1); int x, y, area = 0; cv::Mat part = segmask(roi); for( y = 0; y < roi.height; y++ ) { const float* partptr = part.ptr<float>(y); for( x = 0; x < roi.width; x++ ) area += partptr[x] == compLabel; } comp.value = cv::Scalar(compLabel); comp.rect = roi; comp.area = area; cvSeqPush(seq, &comp); } return seq; }
/* Detects features at extrema in DoG scale space. Bad features are discarded based on contrast and ratio of principal curvatures. @param dog_pyr DoG scale space pyramid @param octvs octaves of scale space represented by dog_pyr @param intvls intervals per octave @param contr_thr low threshold on feature contrast @param curv_thr high threshold on feature ratio of principal curvatures @param storage memory storage in which to store detected features @return Returns an array of detected features whose scales, orientations, and descriptors are yet to be determined. */ CvSeq* scale_space_extrema( IplImage*** dog_pyr, int octvs, int intvls, double contr_thr, int curv_thr, CvMemStorage* storage ) { CvSeq* features; double prelim_contr_thr = 0.5 * contr_thr / intvls; struct feature* feat; struct detection_data* ddata; int o, i, r, c; features = cvCreateSeq( 0, sizeof(CvSeq), sizeof(struct feature), storage ); for( o = 0; o < octvs; o++ ) for( i = 1; i <= intvls; i++ ) for(r = SIFT_IMG_BORDER; r < dog_pyr[o][0]->height-SIFT_IMG_BORDER; r++) for(c = SIFT_IMG_BORDER; c < dog_pyr[o][0]->width-SIFT_IMG_BORDER; c++) /* perform preliminary check on contrast */ if( ABS( pixval32f( dog_pyr[o][i], r, c ) ) > prelim_contr_thr ) if( is_extremum( dog_pyr, o, i, r, c ) ) { feat = interp_extremum(dog_pyr, o, i, r, c, intvls, contr_thr); if( feat ) { ddata = feat_detection_data( feat ); if( ! is_too_edge_like( dog_pyr[ddata->octv][ddata->intvl], ddata->r, ddata->c, curv_thr ) ) { cvSeqPush( features, feat ); } else free( ddata ); free( feat ); } } return features; }
// This function reads data and responses from the file <filename> static int read_num_class_data( const char* filename, int var_count, CvMat** data, CvMat** responses ) { const int M = 1024; FILE* f = fopen( filename, "rt" ); CvMemStorage* storage; CvSeq* seq; char buf[M+2]; float* el_ptr; CvSeqReader reader; int i, j; if( !f ) return 0; el_ptr = new float[var_count+1]; storage = cvCreateMemStorage(); seq = cvCreateSeq( 0, sizeof(*seq), (var_count+1)*sizeof(float), storage ); for(;;) { char* ptr; if( !fgets( buf, M, f ) || !strchr( buf, ',' ) ) break; el_ptr[0] = buf[0]; ptr = buf+2; for( i = 1; i <= var_count; i++ ) { int n = 0; sscanf( ptr, "%f%n", el_ptr + i, &n ); ptr += n + 1; } if( i <= var_count ) break; cvSeqPush( seq, el_ptr ); } fclose(f); *data = cvCreateMat( seq->total, var_count, CV_32F ); *responses = cvCreateMat( seq->total, 1, CV_32F ); cvStartReadSeq( seq, &reader ); for( i = 0; i < seq->total; i++ ) { const float* sdata = (float*)reader.ptr + 1; float* ddata = data[0]->data.fl + var_count*i; float* dr = responses[0]->data.fl + i; for( j = 0; j < var_count; j++ ) ddata[j] = sdata[j]; *dr = sdata[-1]; CV_NEXT_SEQ_ELEM( seq->elem_size, reader ); } cvReleaseMemStorage( &storage ); delete[] el_ptr; return 1; }
void plot_scan_image(IplImage* image, Two_dimensional_vector* scan_image) { CvSeq *points; CvPoint pt; CvMemStorage *storage = cvCreateMemStorage (0); points = cvCreateSeq (CV_SEQ_ELTYPE_POINT, sizeof (CvSeq), sizeof (CvPoint), storage); for (int i = 0; i < (int)scan_image->x.size(); i++) { if(0 > scan_image->x[i] || scan_image->x[i] > 639) { continue; } if(0 > scan_image->y[i] || scan_image->y[i] > 479) { continue; } pt.x = scan_image->x[i]; pt.y = scan_image->y[i]; cvSeqPush (points, &pt); cvCircle(image, pt, 2, CV_RGB (0, 255, 0), CV_FILLED, 8, 0); } cvClearSeq(points); cvReleaseMemStorage(&storage); }
/* Adds features to an array for every orientation in a histogram greater than a specified threshold. @param features new features are added to the end of this array @param hist orientation histogram @param n number of bins in hist @param mag_thr new features are added for entries in hist greater than this @param feat new features are clones of this with different orientations */ static void add_good_ori_features( CvSeq* features, double* hist, int n, double mag_thr, struct feature* feat ) { struct feature* new_feat; double bin, PI2 = CV_PI * 2.0; int l, r, i; //遍历直方图 for( i = 0; i < n; i++ ) { l = ( i == 0 )? n - 1 : i-1;//前一个(左边的)bin的下标 r = ( i + 1 ) % n;//后一个(右边的)bin的下标 //若当前的bin是局部极值(比前一个和后一个bin都大),并且值大于给定的幅值阈值,则新生成一个特征点并添加到特征点序列末尾 if( hist[i] > hist[l] && hist[i] > hist[r] && hist[i] >= mag_thr ) { //根据左、中、右三个bin的值对当前bin进行直方图插值 bin = i + interp_hist_peak( hist[l], hist[i], hist[r] ); bin = ( bin < 0 )? n + bin : ( bin >= n )? bin - n : bin;//将插值结果规范到[0,n]内 new_feat = clone_feature( feat );//克隆当前特征点为新特征点 new_feat->ori = ( ( PI2 * bin ) / n ) - CV_PI;//新特征点的方向 cvSeqPush( features, new_feat );//插入到特征点序列末尾 free( new_feat ); } } }
void CvBlobTrackSeq::AddBlobTrack(int TrackID, int StartFrame) { CvBlobTrack N; N.TrackID = TrackID; N.StartFrame = StartFrame; N.pBlobSeq = new CvBlobSeq; cvSeqPush(m_pSeq,&N); }
/* * This function generates an illumination montage containing a square in worm space * at a location specified. * * This function is most useful when it takes input from a slider bar. * * In that manner the user can specify a rectangular (in worm space) region of illumination * at run time. * */ int GenerateSimpleIllumMontage(CvSeq* montage, CvPoint origin, CvSize radius, CvSize gridSize){ /** If the square has no length or width, then there is nothing to do **/ if (radius.width == 0 || radius.height == 0) return 0; /** If the y value extends off the worm, we need to crop it.. (otherwise it wraps... weird!)**/ cvClearSeq(montage); WormPolygon* polygon=CreateWormPolygon(montage->storage,gridSize); CvPoint curr; /** Lower Left **/ curr=cvPoint(origin.x-radius.width, CropNumber(1,gridSize.height-1,origin.y-radius.height)); cvSeqPush(polygon->Points,&curr); /** Lower Right **/ curr=cvPoint(origin.x+radius.width, CropNumber(1,gridSize.height-1,origin.y-radius.height)); cvSeqPush(polygon->Points,&curr); /** Upper Right **/ curr=cvPoint(origin.x+radius.width, CropNumber(1,gridSize.height-1,origin.y+radius.height)); cvSeqPush(polygon->Points,&curr); /** Upper Left **/ curr=cvPoint(origin.x-radius.width, CropNumber(1,gridSize.height-1,origin.y+radius.height)); cvSeqPush(polygon->Points,&curr); /** Push this sparse polygon onto the temp montage **/ CvSeq* tempMontage= CreateIlluminationMontage(montage->storage); cvSeqPush(tempMontage,&polygon); /** Convert the sparse polygon into a contour-polygon **/ CvtPolyMontage2ContourMontage(tempMontage,montage); cvClearSeq(tempMontage); return 1; }
/*! \fn CvBinGabAdaFeatureSelect::loadweaks(const char* filename) */ void CvBinGabAdaFeatureSelect::loadweaks(const char* filename) { //clear(); { delete new_pool; weaks.clear(); } CvMemStorage* fstorage = cvCreateMemStorage( 0 ); CvFileStorage *fs; fs = cvOpenFileStorage( filename, fstorage, CV_STORAGE_READ ); CvFileNode *root = cvGetRootFileNode( fs, 0); char *weakname = new char[20]; int i = 0; CvMemStorage* storage = cvCreateMemStorage(0); CvSeq* seq = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvGaborTree), storage ); while(1) { sprintf( weakname, "weak_%d", i); CvFileNode *weaknode = cvGetFileNodeByName( fs, root, weakname); if (!weaknode) break; CvGaborTree tree; weaknode2tree(weaknode, fs, &tree); cvSeqPush( seq, &tree ); i++; } /* from squence to vector weaks*/ new_pool = new CvGaborFeaturePool; for (int i = 0; i <seq->total; i++) { CvGaborTree *atree = (CvGaborTree*)cvGetSeqElem(seq, i); CvWeakLearner *weak = new CvWeakLearner; weak->setType( weaklearner_type ); weak->setthreshold(atree->threshold); weak->setparity(atree->parity); weaks.push_back(*weak); CvGaborFeature *feature = new CvGaborFeature(atree->x, atree->y, atree->Mu, atree->Nu); new_pool->add(feature); alphas.push_back(atree->alpha); delete weak; delete feature; } cvReleaseMemStorage( &storage ); cvReleaseFileStorage(&fs); cvReleaseMemStorage( &fstorage ); delete [] weakname; /* set member variables */ current = new_pool->getSize(); falsepositive = 0.0; nexpfeatures = new_pool->getSize(); nselecfeatures = new_pool->getSize(); printf(" %d weak classifiers have been loaded!\n", nselecfeatures); }
CvLCMNode* _cvTreatExeptionalCase(CvLCM* pLCM, CvLCMData* pLCMInputData) { CvVoronoiEdge2D* pEdge = pLCMInputData->pedge; CvVoronoiSite2D* pSite = pLCMInputData->psite; CvVoronoiNode2D* pNode = CV_VORONOIEDGE2D_BEGINNODE(pEdge,pSite); CvLCMNode* pLCMNode = _cvCreateLCMNode(pLCM); cvSeqPush((CvSeq*)pLCMNode->contour,&pNode->pt); return pLCMNode; }//end of _cvConstructLCMEdge
void getconvexhull() { hull = cvConvexHull2( contours, 0, CV_CLOCKWISE, 0 ); pt0 = **CV_GET_SEQ_ELEM( CvPoint*, hull, hull->total - 1 ); for(int i = 0; i < hull->total; i++ ) { pt = **CV_GET_SEQ_ELEM( CvPoint*, hull, i ); //printf("%d,%d\n",pt.x,pt.y); cvLine( frame, pt0, pt, CV_RGB( 128, 128, 128 ),2,8,0); pt0 = pt; } defect = cvConvexityDefects(contours,hull,defectstorage); //��M�ʳ� for(int i=0;i<defect->total;i++) { CvConvexityDefect* d=(CvConvexityDefect*)cvGetSeqElem(defect,i); // if(d->depth < 50) // { // p.x = d->start->x; // p.y = d->start->y; // cvCircle(frame,p,5,CV_RGB(255,255,255),-1,CV_AA,0); // p.x = d->end->x; // p.y = d->end->y; // cvCircle(frame,p,5,CV_RGB(255,255,255),-1,CV_AA,0); // } if(d->depth > 10) { p.x = d->depth_point->x; p.y = d->depth_point->y; cvCircle(frame,p,5,CV_RGB(255,255,0),-1,CV_AA,0); cvSeqPush(palm,&p); } } //if(palm->total>1) //{ // cvMinEnclosingCircle(palm,&mincirclecenter,&radius); // cvRound(radius); // mincirclecenter2.x = cvRound(mincirclecenter.x); // mincirclecenter2.y = cvRound(mincirclecenter.y); // cvCircle(frame,mincirclecenter2,cvRound(radius),CV_RGB(255,128,255),4,8,0); // cvCircle(frame,mincirclecenter2,10,CV_RGB(255,128,255),4,8,0); // palmcenter = cvMinAreaRect2(palm,0); // center.x = cvRound(palmcenter.center.x); // center.y = cvRound(palmcenter.center.y); // cvEllipseBox(frame,palmcenter,CV_RGB(128,128,255),2,CV_AA,0); // cvCircle(frame,center,10,CV_RGB(128,128,255),-1,8,0); //} }
void CvGBTrees::read( CvFileStorage* fs, CvFileNode* node ) { CV_FUNCNAME( "CvGBTrees::read" ); __BEGIN__; CvSeqReader reader; CvFileNode* trees_fnode; CvMemStorage* storage; int i, ntrees; cv::String s; clear(); read_params( fs, node ); if( !data ) EXIT; base_value = (float)cvReadRealByName( fs, node, "base_value", 0.0 ); class_count = cvReadIntByName( fs, node, "class_count", 1 ); weak = new pCvSeq[class_count]; for (int j=0; j<class_count; ++j) { s = cv::format("trees_%d", j); trees_fnode = cvGetFileNodeByName( fs, node, s.c_str() ); if( !trees_fnode || !CV_NODE_IS_SEQ(trees_fnode->tag) ) CV_ERROR( CV_StsParseError, "<trees_x> tag is missing" ); cvStartReadSeq( trees_fnode->data.seq, &reader ); ntrees = trees_fnode->data.seq->total; if( ntrees != params.weak_count ) CV_ERROR( CV_StsUnmatchedSizes, "The number of trees stored does not match <ntrees> tag value" ); CV_CALL( storage = cvCreateMemStorage() ); weak[j] = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvDTree*), storage ); for( i = 0; i < ntrees; i++ ) { CvDTree* tree = new CvDTree(); CV_CALL(tree->read( fs, (CvFileNode*)reader.ptr, data )); CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader ); cvSeqPush( weak[j], &tree ); } } __END__; }
void CPolygonalRegion::AddPoint(double x, double y) { auto Pos = cvPoint((int)x,(int)y); cvSeqPush(_pPointsOuter, &Pos); // cvSeqPush(_pPointsOuter, &cvPoint2D32f(x,y)); //なおすならcvGetSeqElemも. _dXMin = std::min(x, _dXMin); _dXMax = std::max(x, _dXMax); _dYMin = std::min(y, _dYMin); _dYMax = std::max(y, _dYMax); }
int main(int argc, char** argv) { const char* filename = argv[1]; int x; int y; int size; sscanf(argv[2], "%d", &x); sscanf(argv[3], "%d", &y); sscanf(argv[4], "%d", &size); int SURF_EXTENDED = 0; int SURF_HESSIAN_THRESHOLD = 500; int SURF_NOCTAVES = 2; int SURF_NOCTAVELAYERS = 2; int MATCH_THRESHOLD = 20; CvSURFParams params = cvSURFParams(SURF_HESSIAN_THRESHOLD, SURF_EXTENDED); params.nOctaves=SURF_NOCTAVES; params.nOctaveLayers=SURF_NOCTAVELAYERS; CvMemStorage* storage = cvCreateMemStorage(0); IplImage* image = cvLoadImage(filename, CV_LOAD_IMAGE_GRAYSCALE ); CvSeq *objectKeypoints = 0, *objectDescriptors = 0; // set up the keypoint int useProvidedKeyPoints = 1; CvMemStorage* kp_storage = cvCreateMemStorage(0); CvSeq* surf_kp = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvSURFPoint), kp_storage); int laplacian = 1; int direction = 0; int hessian = SURF_HESSIAN_THRESHOLD+1; CvSURFPoint point = cvSURFPoint(cvPoint2D32f(x, y), laplacian, size, direction, hessian); cvSeqPush(surf_kp, &point); // extract descriptor cvExtractSURF(image, 0, &surf_kp, &objectDescriptors, storage, params, useProvidedKeyPoints); // print to stdout /* // if keypoint info also wanted CvSeqReader kp_reader; cvStartReadSeq(surf_kp, &kp_reader); const CvSURFPoint* kp = (const CvSURFPoint*)kp_reader.ptr; printf("%.2f %.2f %.2f %d %d",kp->pt.x,kp->pt.y,kp->hessian,kp->laplacian,kp->size); */ const float* des = (const float*)cvGetSeqElem(objectDescriptors, 0); for (int i=0;i<64;i++){ printf("%.5f ",des[i]); } cvReleaseImage( &image ); }
//Wrapper de C a CPP void HandDetection::findConvexityDefects(vector<Point>& contour, vector<int>& hull, vector<CvConvexityDefect>& convexDefects){ if(hull.size() > 0 && contour.size() > 0){ //Conversion de objetos CPP a C CvSeq* contourPoints; CvSeq* defects; CvMemStorage* storage; CvMemStorage* strDefects; CvMemStorage* contourStr; CvConvexityDefect *defectArray = 0; strDefects = cvCreateMemStorage(); defects = cvCreateSeq( CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvSeq),sizeof(CvPoint), strDefects ); //Empezamos con los contornos: los pasamos a un array de objetos Seq contourStr = cvCreateMemStorage(); contourPoints = cvCreateSeq(CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvSeq), sizeof(CvPoint), contourStr); for(int i=0; i<(int)contour.size(); i++) { CvPoint cp = {contour[i].x, contour[i].y}; cvSeqPush(contourPoints, &cp); } //Ahora con los puntos del poligono convexo int count = (int)hull.size(); //int hullK[count]; int* hullK = (int*)malloc(count*sizeof(int)); for(int i=0; i<count; i++){hullK[i] = hull.at(i);} CvMat hullMat = cvMat(1, count, CV_32SC1, hullK); //Inicializamos la salida storage = cvCreateMemStorage(0); defects = cvConvexityDefects(contourPoints, &hullMat, storage); defectArray = (CvConvexityDefect*)malloc(sizeof(CvConvexityDefect)*defects->total); cvCvtSeqToArray(defects, defectArray, CV_WHOLE_SEQ); //Conversion de C a CPP //float cutoff = lower - (lower - upper) * 0.3f; for(int i = 0; i<defects->total; i++){ convexDefects.push_back(defectArray[i]); } //Liberar vectores con cvReleaseMemStorage //No olvides hacer un free //free(hullK); cvReleaseMemStorage(&contourStr); cvReleaseMemStorage(&strDefects); cvReleaseMemStorage(&storage); //Devolvemos el vector de puntos con los defectos de convexidad //return defects; } //return defectArray; }
CPolygonalRegion::CPolygonalRegion(const CPolygonalRegion &r) { _storage1 = cvCreateMemStorage (0); _pPointsOuter = cvCreateSeq (CV_SEQ_ELTYPE_POINT, sizeof (CvSeq), sizeof (CvPoint), _storage1); _dXMin = r._dXMin; _dXMax = r._dXMax; _dYMin = r._dYMin; _dYMax = r._dYMax; for (int i=0; i<r._pPointsOuter->total; ++i) { CvPoint *pt = (CvPoint*)cvGetSeqElem(r._pPointsOuter, i); cvSeqPush(_pPointsOuter, pt); } }
CPolygonalRegion & CPolygonalRegion::operator = (const CPolygonalRegion &r) { Reset(); _dXMin = r._dXMin; _dXMax = r._dXMax; _dYMin = r._dYMin; _dYMax = r._dYMax; for (int i=0; i<r._pPointsOuter->total; ++i) { CvPoint *pt = (CvPoint*)cvGetSeqElem(r._pPointsOuter, i); cvSeqPush(_pPointsOuter, pt); } return *this; }
void CvFaceElement::MergeRects(int d) { int nRects = m_seqRects->total; CvSeqReader reader, reader2; cvStartReadSeq( m_seqRects, &reader ); int i, j; for (i = 0; i < nRects; i++) { CvTrackingRect* pRect1 = (CvTrackingRect*)(reader.ptr); cvStartReadSeq( m_seqRects, &reader2 ); cvSetSeqReaderPos(&reader2, i + 1); for (j = i + 1; j < nRects; j++) { CvTrackingRect* pRect2 = (CvTrackingRect*)(reader2.ptr); if (abs(pRect1->ptCenter.y - pRect2->ptCenter.y) < d && abs(pRect1->r.height - pRect2->r.height) < d) { CvTrackingRect rNew; rNew.iColor = (pRect1->iColor + pRect2->iColor + 1) / 2; rNew.r.x = min(pRect1->r.x, pRect2->r.x); rNew.r.y = min(pRect1->r.y, pRect2->r.y); rNew.r.width = max(pRect1->r.x + pRect1->r.width, pRect2->r.x + pRect2->r.width) - rNew.r.x; rNew.r.height = min(pRect1->r.y + pRect1->r.height, pRect2->r.y + pRect2->r.height) - rNew.r.y; if (rNew.r != pRect1->r && rNew.r != pRect2->r) { rNew.ptCenter = Center(rNew.r); cvSeqPush(m_seqRects, &rNew); } } CV_NEXT_SEQ_ELEM( sizeof(CvTrackingRect), reader2 ); } CV_NEXT_SEQ_ELEM( sizeof(CvTrackingRect), reader ); } // delete equal rects for (i = 0; i < m_seqRects->total; i++) { CvTrackingRect* pRect1 = (CvTrackingRect*)cvGetSeqElem(m_seqRects, i); int j_begin = i + 1; for (j = j_begin; j < m_seqRects->total;) { CvTrackingRect* pRect2 = (CvTrackingRect*)cvGetSeqElem(m_seqRects, j); if (pRect1->r == pRect2->r) cvSeqRemove(m_seqRects, j); else j++; } } }//void CvFaceElement::MergeRects(int d)
CvSeq *reghand::elimNeighborHulls(CvSeq *hullseq) { int disthreshold=handradis/3; CvSeq *filtedhullseq=cvCloneSeq(hullseq); if(hullseq->total<=1) return filtedhullseq; cvClearSeq(filtedhullseq); CvPoint **curdata;CvPoint currpt,nextpt; for(int i=0;i<hullseq->total-1;i++) { curdata=CV_GET_SEQ_ELEM(CvPoint*,hullseq,i); currpt=**curdata; nextpt=**CV_GET_SEQ_ELEM(CvPoint*,hullseq,i+1); double distance=sqrt(pow(double(currpt.x-nextpt.x),2)+pow(double(currpt.y-nextpt.y),2)); if(distance>disthreshold) cvSeqPush(filtedhullseq,curdata); } // if(hullseq->total==2)return filtedhullseq; curdata=CV_GET_SEQ_ELEM(CvPoint*,hullseq,hullseq->total-1); currpt=**curdata; nextpt=**CV_GET_SEQ_ELEM(CvPoint*,hullseq,0); double distance=sqrt(pow(double(currpt.x-nextpt.x),2)+pow(double(currpt.y-nextpt.y),2)); if(distance>disthreshold) cvSeqPush(filtedhullseq,curdata); return filtedhullseq; }
void ConvexityClassifier::findConvexityDefects(vector<Point>& contour, vector<int>& hull, vector<Point>& convexDefects){ if(hull.size() > 0 && contour.size() > 0){ CvSeq* contourPoints; CvSeq* defects; CvMemStorage* storage; CvMemStorage* strDefects; CvMemStorage* contourStr; CvConvexityDefect *defectArray = 0; strDefects = cvCreateMemStorage(); defects = cvCreateSeq( CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvSeq),sizeof(CvPoint), strDefects ); //We transform our vector<Point> into a CvSeq* object of CvPoint. contourStr = cvCreateMemStorage(); contourPoints = cvCreateSeq(CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvSeq), sizeof(CvPoint), contourStr); for(int i=0; i<(int)contour.size(); i++) { CvPoint cp = {contour[i].x, contour[i].y}; cvSeqPush(contourPoints, &cp); } //Now, we do the same thing with the hull index int count = (int)hull.size(); //int hullK[count]; int* hullK = (int*)malloc(count*sizeof(int)); for(int i=0; i<count; i++){hullK[i] = hull.at(i);} CvMat hullMat = cvMat(1, count, CV_32SC1, hullK); //We calculate convexity defects storage = cvCreateMemStorage(0); defects = cvConvexityDefects(contourPoints, &hullMat, storage); defectArray = (CvConvexityDefect*)malloc(sizeof(CvConvexityDefect)*defects->total); cvCvtSeqToArray(defects, defectArray, CV_WHOLE_SEQ); //printf("DefectArray %i %i\n",defectArray->end->x, defectArray->end->y); //We store defects points in the convexDefects parameter. for(int i = 0; i<defects->total; i++){ CvPoint ptf; ptf.x = defectArray[i].depth_point->x; ptf.y = defectArray[i].depth_point->y; convexDefects.push_back(ptf); } //We release memory cvReleaseMemStorage(&contourStr); cvReleaseMemStorage(&strDefects); cvReleaseMemStorage(&storage); } }