int detect_multiple1( IplImage* img, CvRect* found_obj[], CvSize sz, int feature ) { static CvRect face_rect; IplImage *gray=NULL, *small_img=NULL; int tot=0; switch (feature) { case FACE: cascade=face_cascade; break; case NOSE: cascade=nose_cascade; break; case MOUTH: cascade=mouth_cascade; break; case EYE: case LEYE: cascade=leye_cascade; break; case REYE: cascade=reye_cascade; break; case PROFILE_FACE: cascade=profile_face_cascade; break; default: cascade = face_cascade; break; } if (feature == FACE) { //cvResetImageROI(img); if(gray) { cvResetImageROI(gray); cvReleaseImage(&gray); } if(small_img) { cvResetImageROI(small_img); cvReleaseImage(&small_img); } gray = cvCreateImage( cvSize(img->width,img->height), 8, 1 ); small_img = cvCreateImage( cvSize( cvRound (img->width/scale), cvRound (img->height/scale)), 8, 1 ); cvCvtColor( img, gray, CV_BGR2GRAY ); cvResize( gray, small_img, CV_INTER_LINEAR ); cvEqualizeHist( small_img, small_img ); } else{ cvSetImageROI(small_img, face_rect); // printf("found face (%d,%d,%d,%d) setting ROI to (%d,%d,%d,%d)\n",r->x,r->y,r->width,r->height,prev.x,prev.y,prev.width,prev.height); } cvClearMemStorage( storage ); // for(i=0;i<10;i++) { // double t = (double)cvGetTickCount(); CvSeq* objects = cvHaarDetectObjects( small_img, cascade, storage, 1.1, 2, 0 //1.2, 0, 0 // |CV_HAAR_FIND_BIGGEST_OBJECT // |CV_HAAR_DO_ROUGH_SEARCH // |CV_HAAR_DO_CANNY_PRUNING // |CV_HAAR_SCALE_IMAGE , sz); //cvSize(30, 30) ); // t = (double)cvGetTickCount() - t; // printf( "detection time = %gms, faces: %d\n", t/((double)cvGetTickFrequency()*1000.), faces->total ); tot=objects->total; int i=0; if(objects->total>0) { if(tot > MAX_RECT) tot=MAX_RECT; for(i=0; ((i < tot) &&( i < MAX_RECT)); i++) { CvRect* r = (CvRect*)cvGetSeqElem( objects, i ); if(feature == FACE) { if(i==0) face_rect = cvRect(r->x, r->y, r->width, r->height); } else { if(face_rect.width > 0 && face_rect.height > 0) { r->x += face_rect.x; r->y += face_rect.y; } } found_obj[i]->x = (int)((double)r->x * scale); found_obj[i]->y = (int)((double)r->y * scale); found_obj[i]->width = (int)((double)r->width * scale); found_obj[i]->height = (int)((double)r->height); if(feature == FACE) found_obj[i]->height = (int)((double)r->height * scale); } } if(feature != FACE) cvResetImageROI(small_img); // eyes are last if(feature == EYE) { cvReleaseImage(&gray); cvReleaseImage(&small_img); } return tot; }
void GetImageData(int w,int h,int bpp,int channels,unsigned char *rawArray) { int nWidth,nHeight,nBpp; unsigned char *ImgData = (unsigned char *)malloc(qhyusb->QCam.cameraW*qhyusb->QCam.cameraH*3*bpp/8); #ifdef QHYCCD_DEBUG printf("GetImageData:Malloc memory Size %d\n",qhyusb->QCam.cameraW*qhyusb->QCam.cameraH*3*bpp/8); #endif GetFrame(ImgData, &nWidth, &nHeight, &nBpp, NULL, NULL, NULL, NULL); #ifdef QHYCCD_DEBUG printf("GetImageData:nWidth %d nHeight %d nBpp %d\n",nWidth,nHeight,nBpp); #endif memcpy(rawArray, ImgData,nWidth*nHeight*nBpp/8); if(bpp != nBpp) { if((bpp == 8) && (nBpp ==16)) { int i = 1; int j = 0; while(j < w*h) { rawArray[j] = rawArray[i]; j += 1; i += 2; } } else if((bpp == 16) && (nBpp == 8)) { int i = 1; int j = 0; unsigned char *tempArray = (unsigned char *)malloc(w*h*2); memcpy(tempArray,rawArray,w*h); while(j < w*h) { tempArray[i] = rawArray[j]; tempArray[i-1] = 0; j += 1; i += 2; } memcpy(rawArray,tempArray,w*h*2); free(tempArray); } } if(channels == 3) { IplImage *img = cvCreateImage(cvSize(nWidth,nHeight),bpp,1); img->imageData = (char *)rawArray; IplImage *colorimg = cvCreateImage(cvSize(nWidth,nHeight),bpp,channels); if(qhyusb->QCam.CAMERA == DEVICETYPE_QHY5LII) { cvCvtColor(img,colorimg,CV_BayerGR2RGB); } memcpy(rawArray,colorimg->imageData,colorimg->imageSize); cvReleaseImage(&img); cvReleaseImage(&colorimg); } IplImage *img = cvCreateImage(cvSize(nWidth,nHeight),bpp,channels); img->imageData = (char *)rawArray; IplImage *rszimg = cvCreateImage(cvSize(w,h),bpp,channels); cvResize(img,rszimg,CV_INTER_NN); memcpy(rawArray,rszimg->imageData,rszimg->imageSize); cvReleaseImage(&rszimg); cvReleaseImage(&img); free(ImgData); }
IplImage* detect_and_draw(IplImage* img, double scale = 1.3) { IplImage* img1; char * str; static CvScalar colors[] = { {{0,0,255}}, {{0,128,255}},{{0,255,255}},{{0,255,0}}, {{255,128,0}},{{255,255,0}},{{255,0,0}}, {{255,0,255}} }; //Just some pretty colors to draw with // IMAGE PREPARATION: // IplImage* gray = cvCreateImage( cvSize(img->width,img->height), 8, 1 ); IplImage* small_img = cvCreateImage( cvSize( cvRound(img->width/scale), cvRound(img->height/scale)), 8, 1); cvCvtColor( img, gray, CV_BGR2GRAY ); cvResize( gray, small_img, CV_INTER_LINEAR ); cvEqualizeHist( small_img, small_img ); // DETECT OBJECTS IF ANY // cvClearMemStorage( storage ); fprintf(stderr,"size: %d %d\n",cvGetSize(small_img).width,cvGetSize(small_img).height); CvSeq* objects = cvHaarDetectObjects( small_img, cascade, storage, 1.1, 2, 0 , cvSize(35, 35) ); // LOOP THROUGH FOUND OBJECTS AND DRAW BOXES AROUND THEM // // for(int i = 0; i<(objects ? objects->total : 0); i++ ) fprintf(stderr,"size: %d %d\n",cvGetSize(small_img).width,cvGetSize(small_img).height); if( 0<(objects ? objects->total : 0)) { CvRect* r = (CvRect*)cvGetSeqElem( objects, 0 ); cvSetImageROI(img,*r); img1=cvCreateImage(cvSize(r->width,r->height),img->depth,img->nChannels); cvCopy(img,img1,NULL); cvRectangle( img, cvPoint(r->x,r->y), cvPoint(r->x+r->width,r->y+r->height), colors[0] ); cvResetImageROI(img); HAND=1; } else { HAND=0; img1=cvCreateImage(cvSize(100,100),img->depth,img->nChannels); } cvReleaseImage( &gray); cvReleaseImage( &small_img ); return img1; }
void *process2(void *arg) { do { frame2 = cvQueryFrame(capture2); // pointer to a cvCapture structure if(!frame2) break; cvShowImage("video2", frame2); roi2Image=cvCloneImage(frame2); if ((orig2.x != dest2.x) && (orig2.y != dest2.y)) { cvSetImageROI(roi2Image, cvRect(orig2.x<dest2.x?orig2.x:dest2.x, orig2.y<dest2.y?orig2.y:dest2.y, abs(dest2.x-orig2.x),abs(dest2.y-orig2.y))); roi2Adj = cvCreateImage(cvSize(abs(dest2.x-orig2.x)*input_resize_percent/100, abs(dest2.y-orig2.y)*input_resize_percent/100), roi2Image->depth, roi2Image->nChannels); } else { cvSetImageROI(roi2Image,cvRect(0,0,frame2->width,frame2->height)); roi2Adj = cvCreateImage(cvSize((int)((frame2->width*input_resize_percent)/100) , (int)((frame2->height*input_resize_percent)/100)), frame2->depth, frame2->nChannels); } cvResize(roi2Image, roi2Adj, CV_INTER_LINEAR); pthread_mutex_lock(&lock); if (!changing && !analiza1) { Ncarros=detect(roi2Adj); printf("Proceso 2 Numero de Carros: %d \n", Ncarros); if (Ncarros>= 4) { reset=true; pthread_create(&cambioSem,NULL,GreentoRed2,semaphore2); analiza2=false; analiza1=true; } } if (timeout && !analiza1) { timeout=false; pthread_create(&cambioSem,NULL,GreentoRed2,semaphore2); analiza2=false; analiza1=true; } pthread_mutex_unlock(&lock); cvShowImage("image2", roi2Adj); key = cvWaitKey(2); if(key == KEY_ESC) break; usleep(10000); }while(1); cvDestroyAllWindows(); pthread_cancel(proc1); pthread_cancel(timeOuts); pthread_cancel(cambioSem); cvReleaseImage(&frame1); cvReleaseImage(&roi1Image); cvReleaseImage(&roi1Adj); cvReleaseImage(&semaphore1); cvReleaseCapture(&capture1); cvReleaseImage(&frame2); cvReleaseImage(&roi2Image); cvReleaseImage(&roi2Adj); cvReleaseImage(&semaphore2); cvReleaseCapture(&capture2); cvReleaseHaarClassifierCascade(&cascade); cvReleaseMemStorage(&storage); finish=true; return NULL; }
int main(int argc, char* argv[]){ CCmdLine cmdLine; cmdLine.SplitLine(argc, argv); if ( !(cmdLine.HasSwitch("-i") && cmdLine.HasSwitch("-o") && (cmdLine.HasSwitch("-pos") || cmdLine.HasSwitch("-f") || cmdLine.HasSwitch("-pbOnly"))) ){ fprintf(stderr, "usage: %s -i <image> -o <output-directory> < -pos <x> <y> | -f <fixation-points-file> > [ -pb <probabilistic-boundary-prefix ] [ -flow <optical-flow-file> ] [ -sobel ]\n",argv[0]); fprintf(stderr, "OR \t %s -pbOnly -i <image> -o <output-probabilistic-boundary-prefix>\n",argv[0]); exit(1); } class segLayer frame1; char tmp[80]; strcpy (tmp, cmdLine.GetArgument("-i", 0).c_str()); int64 tic1,tic2,tic3,tic4; double ticFrequency = cvGetTickFrequency()*1000000; tic1=cvGetTickCount(); IplImage *im=cvLoadImage(tmp), *im2; #ifdef CUDA_SUPPORT int maxWidth=640; #else int maxWidth=640; #endif bool resized=false; float scale=1; if(cvGetSize(im).width>maxWidth){ scale=maxWidth/(double)(cvGetSize(im).width); printf("Image too big, resizing it for the segmentation...\n"); int newHeight=(int)(cvGetSize(im).height*scale); im2=cvCreateImage( cvSize(maxWidth,newHeight), IPL_DEPTH_8U, 3 ); cvResize(im,im2); resized=true; }else{ im2=im; } frame1.setImage(im2); if (cmdLine.HasSwitch("-pb")){ strcpy (tmp, cmdLine.GetArgument("-pb", 0).c_str()); frame1.readPbBoundary(tmp); }else{ // Edge detection! if (cmdLine.HasSwitch("-sobel")) frame1.edgeSobel(); else{ #ifdef CUDA_SUPPORT if(!get_lock()){ fprintf(stderr,"Impossible to get the lock...\n"); exit(1); } frame1.edgeGPU(false); if(!release_lock()){ fprintf(stderr,"Impossible to release the lock...\n"); exit(1); } #else frame1.edgeCGTG(); #endif } tic2=cvGetTickCount(); if (cmdLine.HasSwitch("-flow")){ strcpy (tmp, cmdLine.GetArgument("-flow", 0).c_str()); IplImage *flow=cvLoadImage(tmp); IplImage *flow32 = cvCreateImage(cvGetSize(flow), IPL_DEPTH_32F,3); IplImage *flowU = cvCreateImage(cvGetSize(flow), IPL_DEPTH_32F,1); IplImage *flowV = cvCreateImage(cvGetSize(flow), IPL_DEPTH_32F,1); cvConvertScale(flow, flow32, 40/255.,-20); cvSplit(flow32,flowU,NULL,NULL,NULL); cvSplit(flow32,NULL,flowV,NULL,NULL); frame1.setU(flowU); frame1.setV(flowV); cvReleaseImage(&flow); cvReleaseImage(&flow32); } frame1.generatePbBoundary(); } if (cmdLine.HasSwitch("-pbOnly")){ strcpy (tmp, cmdLine.GetArgument("-o", 0).c_str()); frame1.savePbBoundary(tmp); }else{ frame1.allocateMemForContours();// Don't forget to allocate memory to store the region contours. //select fixation point! if(cmdLine.HasSwitch("-pos")){ float x,y; sscanf(cmdLine.GetArgument("-pos", 0).c_str(),"%f",&x); sscanf(cmdLine.GetArgument("-pos", 1).c_str(),"%f",&y); frame1.assignFixPt((int)(x*scale), (int)(y*scale)); }else{ strcpy (tmp, cmdLine.GetArgument("-f", 0).c_str()); frame1.readFixPts(tmp,scale); } //segment frame1.segmentAllFixs(); tic3=cvGetTickCount(); //display! //frame1.displayCurrSegs(-1); strcpy (tmp, cmdLine.GetArgument("-o", 0).c_str()); //sprintf(tmp,"%s/",tmp); if(resized) frame1.saveResizedRegions(tmp,cvGetSize(im).width,cvGetSize(im).height); else frame1.saveRegions(tmp); //release memory! frame1.deallocateMemForContours(); } tic4=cvGetTickCount(); printf("\n\nTotal time = %f\n",(tic4-tic1)/ticFrequency); if(!cmdLine.HasSwitch("-pb")) printf("\t edges detection = %f\n",(tic2-tic1)/ticFrequency); if(!cmdLine.HasSwitch("-pbOnly")) printf("\t segmentation = %f\n",(tic3-tic2)/ticFrequency); return 0; }
/* main code */ int main(int argc, char** argv ){ CvCapture *capture; int i, key; //*struct tm *newtime; time_t second,milsecond; char rightfilename[100], leftfilename[100]; // ブーストされた分類器のカスケードを読み込む // cascade = (CvHaarClassifierCascade *) cvLoad (cascade_name, 0, 0, 0); righteye_cascade = (CvHaarClassifierCascade *) cvLoad (righteye_cascade_name, 0, 0, 0); lefteye_cascade = (CvHaarClassifierCascade *) cvLoad (lefteye_cascade_name, 0, 0, 0); /* initialize camera */ capture = cvCaptureFromCAM( 0 ); /* always check */ if( !capture ) return 1; /* get video properties, needed by template image */ frame = cvQueryFrame( capture ); if ( !frame ) return 1; /* create template image */ tpl = cvCreateImage( cvSize( TPL_WIDTH, TPL_HEIGHT ), frame->depth, frame->nChannels ); /* create image for template matching result */ tm = cvCreateImage( cvSize( WINDOW_WIDTH - TPL_WIDTH + 1, WINDOW_HEIGHT - TPL_HEIGHT + 1 ), IPL_DEPTH_32F, 1 ); //eyezone eyezone1 = cvCreateImage(cvSize(50,50), IPL_DEPTH_8U, 1); minieyezone1 = cvCreateImage(cvSize(16,16), IPL_DEPTH_8U, 1); output1 = cvCreateImage(cvSize(512,512), IPL_DEPTH_8U, 1); eyezone2 = cvCreateImage(cvSize(50,50), IPL_DEPTH_8U, 1); minieyezone2 = cvCreateImage(cvSize(16,16), IPL_DEPTH_8U, 1); output2 = cvCreateImage(cvSize(512,512), IPL_DEPTH_8U, 1); /* create a window and install mouse handler */ cvNamedWindow( "video", CV_WINDOW_AUTOSIZE ); cvSetMouseCallback( "video", mouseHandler, NULL ); cvNamedWindow("output1", CV_WINDOW_AUTOSIZE); cvNamedWindow("output2", CV_WINDOW_AUTOSIZE); gray = cvCreateImage (cvGetSize (frame), IPL_DEPTH_8U, 1); righteye_storage = cvCreateMemStorage (0); lefteye_storage = cvCreateMemStorage (0); CvPoint righteye_center, lefteye_center; // eye candidate CvRect righteye_cand1, righteye_cand2, lefteye_cand1, lefteye_cand2, right, left; int eye_candidate_num = 0; while( key != 'q' ) { eye_candidate_num = 0; /* get a frame */ frame = cvQueryFrame( capture ); /* always check */ if( !frame ) break; /* 'fix' frame */ /* cvFlip( frame, frame, -1 ); */ frame->origin = 0; /* perform tracking if template is available */ if( is_tracking ) trackObject(); cvClearMemStorage (righteye_storage); cvClearMemStorage (lefteye_storage); cvCvtColor (frame, gray, CV_BGR2GRAY); cvEqualizeHist (gray, gray); righteye = cvHaarDetectObjects (gray, righteye_cascade, righteye_storage, 1.11, 4, 0, cvSize (40, 40), cvSize(40,40)); lefteye = cvHaarDetectObjects (gray, lefteye_cascade, lefteye_storage, 1.11, 4, 0, cvSize (40, 40), cvSize(40,40)); //右目を円で描画 for (i = 0; i < (righteye ? righteye->total : 0); i++) { CvRect *r = (CvRect *) cvGetSeqElem (righteye, i); CvPoint center; int radius; center.x = cvRound (r->x + r->width * 0.5); center.y = cvRound (r->y + r->height * 0.5); radius = cvRound ((r->width + r->height) * 0.25); cvCircle (frame, center, radius, colors[i % 8], 3, 8, 0); //右目候補 if(i == 0){ righteye_cand1 = *r; } if(i == 1){ righteye_cand2 = *r; } } //左目を死角で描画 for (i = 0; i < (lefteye ? lefteye->total : 0); i++) { CvRect *r = (CvRect *) cvGetSeqElem (lefteye, i); CvPoint apex1, apex2; apex1 = cvPoint(r->x, r->y); apex2.x = cvRound(r->x + r->width); apex2.y = cvRound(r->y + r->height); cvRectangle (frame,apex1, apex2, colors[i % 8], 3, 8, 0); //左目候補 if(i == 0){ lefteye_cand1 = *r; } if(i == 1){ lefteye_cand2 = *r; } } //候補しぼり if(righteye->total >= 1){ if(righteye->total >= 2){ if(righteye_cand1.x <= righteye_cand2.x){ right = righteye_cand1; righteye_center.x = cvRound(right.x + right.width*0.5); righteye_center.y = cvRound(right.y + right.height*0.5); } else{ right = righteye_cand2; righteye_center.x = cvRound(right.x + right.width*0.5); righteye_center.y = cvRound(right.y + right.height*0.5); } } else{ right = righteye_cand1; righteye_center.x = cvRound(right.x + right.width*0.5); righteye_center.y = cvRound(right.y + right.height*0.5); } eyezone1 = cvCreateImage(cvSize(right.width, right.height), IPL_DEPTH_8U, 1); cvGetRectSubPix(gray, eyezone1, cvPointTo32f(righteye_center)); cvEqualizeHist(eyezone1, eyezone1); cvResize(eyezone1, minieyezone1, CV_INTER_LINEAR); cvResize(minieyezone1, output1, CV_INTER_NN); } if(lefteye->total >= 1){ if(lefteye->total >= 2){ if(lefteye_cand1.x >= lefteye_cand2.x){ left = lefteye_cand1; lefteye_center.x = cvRound(left.x + left.width*0.5); lefteye_center.y = cvRound(left.y + left.height*0.5); } else{ left = lefteye_cand2; lefteye_center.x = cvRound(left.x + left.width*0.5); lefteye_center.y = cvRound(right.y + left.height*0.5); } } else{ left = lefteye_cand1; lefteye_center.x = cvRound(left.x + left.width*0.5); lefteye_center.y = cvRound(left.y + left.height*0.5); } eyezone2 = cvCreateImage(cvSize(left.width, left.height), IPL_DEPTH_8U, 1); cvGetRectSubPix(gray, eyezone2, cvPointTo32f(lefteye_center)); cvEqualizeHist(eyezone2, eyezone2); cvResize(eyezone2, minieyezone2, CV_INTER_LINEAR); cvResize(minieyezone2, output2, CV_INTER_NN); } printf("righteye width = %d, height = %d\n", right.width, right.height); printf("lefteye width = %d, height = %d\n", left.width, left.height); // printf("righteye x = %d\n", right.x); // printf("lefteye x = %d\n", left.x); /* display frame */ cvShowImage( "video", frame); //cvShowImage( "eyezone1", eyezone1); //cvShowImage( "eyezone2", eyezone2); cvShowImage( "output1", output1); cvShowImage( "output2", output2); //ファイル出力,時間計測 time(&second); milsecond = clock(); // printf("時間[sec] = %ld\n", second); printf("経過時間[usec] = %ld\n", milsecond); //sprintf(filename, "%ld.bmp",second); //printf("sprintf = %s\n", filename); //cvSaveImage(filename, frame,0); if(key == 'n'){ sprintf(rightfilename, "n_right%ld.bmp", milsecond); sprintf(leftfilename, "n_left%ld.bmp", milsecond); printf("fileoutput %s, %s\n", rightfilename, leftfilename); cvSaveImage(rightfilename, minieyezone1, 0); cvSaveImage(leftfilename, minieyezone2, 0); } if(key == 'h'){ sprintf(rightfilename, "h_right%ld.bmp", milsecond); sprintf(leftfilename, "h_left%ld.bmp", milsecond); printf("fileoutput %s, %s\n", rightfilename, leftfilename); cvSaveImage(rightfilename, minieyezone1, 0); cvSaveImage(leftfilename, minieyezone2, 0); } if(key == 'j'){ sprintf(rightfilename, "j_right%ld.bmp", milsecond); sprintf(leftfilename, "j_left%ld.bmp", milsecond); printf("fileoutput %s, %s\n", rightfilename, leftfilename); cvSaveImage(rightfilename, minieyezone1, 0); cvSaveImage(leftfilename, minieyezone2, 0); } if(key == 'k'){ sprintf(rightfilename, "k_right%ld.bmp", milsecond); sprintf(leftfilename, "k_left%ld.bmp", milsecond); printf("fileoutput %s, %s\n", rightfilename, leftfilename); cvSaveImage(rightfilename, minieyezone1, 0); cvSaveImage(leftfilename, minieyezone2, 0); } if(key == 'l'){ sprintf(rightfilename, "l_right%ld.bmp", milsecond); sprintf(leftfilename, "l_left%ld.bmp", milsecond); printf("fileoutput %s, %s\n", rightfilename, leftfilename); cvSaveImage(rightfilename, minieyezone1, 0); cvSaveImage(leftfilename, minieyezone2, 0); } /* exit if user press 'q' */ key = cvWaitKey( 1 ); } /* free memory */ cvDestroyWindow( "video" ); cvDestroyWindow( "output1"); cvDestroyWindow( "output2"); cvReleaseCapture( &capture ); cvReleaseImage( &tpl ); cvReleaseImage( &tm ); cvReleaseImage( &gray); cvReleaseImage( &eyezone1); cvReleaseImage( &eyezone2); cvReleaseImage( &minieyezone1); cvReleaseImage( &minieyezone2); cvReleaseImage( &output1); cvReleaseImage( &output2); return 0; }
void getHoGOpenMP(IplImage* src, double* feat) { IplImage* img = cvCreateImage(cvSize(RESIZE_X,RESIZE_Y), IPL_DEPTH_8U, 1); cvResize(src, img); const int width = RESIZE_X; const int height = RESIZE_Y; double hist[CELL_WIDTH][CELL_HEIGHT][CELL_BIN]; memset(hist, 0, CELL_WIDTH*CELL_HEIGHT*CELL_BIN*sizeof(double)); #pragma omp parallel for for(int y=0; y<height; y++){ for(int x=0; x<width; x++){ if(x==0 || y==0 || x==width-1 || y==height-1){ continue; } double dx = img->imageData[y*img->widthStep+(x+1)] - img->imageData[y*img->widthStep+(x-1)]; double dy = img->imageData[(y+1)*img->widthStep+x] - img->imageData[(y-1)*img->widthStep+x]; double m = sqrt(dx*dx+dy*dy); double deg = (atan2(dy, dx)+CV_PI) * 180.0 / CV_PI; int bin = CELL_BIN * deg/360.0; if(bin < 0) bin=0; if(bin >= CELL_BIN) bin = CELL_BIN-1; hist[(int)(x/CELL_X)][(int)(y/CELL_Y)][bin] += m; } } #pragma omp parallel for for(int y=0; y<BLOCK_HEIGHT; y++){ for(int x=0; x<BLOCK_WIDTH; x++){ double vec[BLOCK_DIM]; memset(vec, 0, BLOCK_DIM*sizeof(double)); //#pragma omp for for(int j=0; j<BLOCK_Y; j++){ for(int i=0; i<BLOCK_X; i++){ for(int d=0; d<CELL_BIN; d++){ int index = j*(BLOCK_X*CELL_BIN) + i*CELL_BIN + d; vec[index] = hist[x+i][y+j][d]; } } } double norm = 0.0; //#pragma omp for reduction(+:norm) for(int i=0; i<BLOCK_DIM; i++){ norm += vec[i]*vec[i]; } //#pragma omp for for(int i=0; i<BLOCK_DIM; i++){ vec[i] /= sqrt(norm + 1.0); } //#pragma omp for for(int i=0; i<BLOCK_DIM; i++){ int index = y*BLOCK_WIDTH*BLOCK_DIM + x*BLOCK_DIM + i; feat[index] = vec[i]; } } } cvReleaseImage(&img); return; }
void ASEF::ComputeEyeLocations(IplImage *img, CvRect bb){ assert(img->nChannels==1); IplImage *roi = cvCreateImage(cvSize(this->nCols, this->nRows), img->depth, 1); cvSetImageROI(img, bb); cvResize(img, roi, CV_INTER_LINEAR); cvResetImageROI(img); IplImage *roi_64 = cvCreateImage(cvGetSize(roi), IPL_DEPTH_64F, 1); cvConvertScale(roi, roi_64, 1./255., 0.); FaceNormIllu::do_NormIlluRETINA(roi_64, this->face_real, 5.0); cvMerge(this->face_real, this->face_im, 0, 0, this->complex_data); // do DFT cvDFT(this->complex_data, this->F, CV_DXT_FORWARD, this->complex_data->height); // G left cvMulSpectrums(this->F, this->LeftEyeDetector, this->Gl, CV_DXT_ROWS); cvDFT(this->Gl, this->Gl, CV_DXT_INV_SCALE, this->Gl->height); cvSplit(this->Gl, this->gl, 0, 0, 0); // G right cvMulSpectrums(this->F, this->RightEyeDetector, this->Gr, CV_DXT_ROWS); cvDFT(this->Gr, this->Gr, CV_DXT_INV_SCALE, this->Gl->height); cvSplit(this->Gr, this->gr,0,0,0); // add both responses double minV, maxV; cvMinMaxLoc(this->gl, &minV, &maxV); cvConvertScale(this->gl, this->gl, 1./(maxV-minV), -minV/(maxV-minV)); cvMinMaxLoc(this->gr, &minV, &maxV); cvConvertScale(this->gr, this->gr, 1./(maxV-minV), -minV/(maxV-minV)); cvAdd(this->gl, this->gr, this->g); cvMul(this->g, this->LeftEyeMask, this->gl); cvMul(this->g, this->RightEyeMask, this->gr); /////////////////////////////////////////////////// // Compute Eye Locations /////////////////////////////////////////////////// float scale; cvSetImageROI(this->gl, cvRect(0,0, this->nCols>>1, this->nRows>>1)); cvMinMaxLoc(this->gl, 0,0,0, &this->pEyeL); cvResetImageROI(this->gl); scale = (float)bb.width/(float)this->nCols; this->pEyeL.x=cvRound((float)this->pEyeL.x * scale + bb.x); this->pEyeL.y=cvRound((float)this->pEyeL.y * scale + bb.y); cvSetImageROI(this->gr, cvRect(this->nCols>>1, 0, this->nCols>>1, this->nRows>>1)); cvMinMaxLoc(this->gr, 0,0,0, &this->pEyeR); cvResetImageROI(this->gr); scale = (float)bb.height/(float)this->nRows; this->pEyeR.x=cvRound((float)(this->pEyeR.x + this->nCols*0.5)* scale + bb.x); this->pEyeR.y=cvRound((float)this->pEyeR.y * scale + bb.y); cvReleaseImage(&roi); cvReleaseImage(&roi_64); }
void faceDetector::runFaceDetector(IplImage *input) { double t = (double)cvGetTickCount(); static tracker faceTracker; static CvPoint fp1,fp2; faceInformation.LT= cvPoint(0,0); faceInformation.RB= cvPoint(0,0); faceInformation.Width=0; faceInformation.Height=0; if (input==0) return; IplImage *gray, *small_img; int i, j; int scale=1; gray = cvCreateImage( cvSize(input->width,input->height), 8, 1 ); small_img = cvCreateImage( cvSize( cvRound (input->width/scale), cvRound (input->height/scale)), 8, 1 ); cvCvtColor( input, gray, CV_BGR2GRAY ); cvResize( gray, small_img, CV_INTER_LINEAR ); cvClearMemStorage( storage ); if ( cascade ) { CvSeq* faces = cvHaarDetectObjects( small_img, cascade, storage, 1.4, 2, 0 // |CV_HAAR_FIND_BIGGEST_OBJECT // |CV_HAAR_DO_ROUGH_SEARCH |CV_HAAR_DO_CANNY_PRUNING //|CV_HAAR_SCALE_IMAGE , cvSize(80/scale, 80/scale) ); int maxI=-1; int max0=0; for ( i = 0; i < (faces ? faces->total : 0); i++ ) { CvRect* r = (CvRect*)cvGetSeqElem( faces, maxI); if (max0<(r->width*r->height)); { max0=(r->width*r->height); maxI=i; } } if (maxI!=-1) { CvRect* r = (CvRect*)cvGetSeqElem( faces, maxI); faceInformation.LT.x=(r->x)*scale; faceInformation.LT.y=(r->y)*scale; faceInformation.RB.x=(r->x+ r->width)*scale; faceInformation.RB.y=(r->y+ r->height)*scale; faceInformation.Width=(r->width)*scale; faceInformation.Height=(r->height)*scale; IplImage *in=clipDetectedFace(input); //faceTracker.setModel(in); fp1=faceInformation.LT; fp2=faceInformation.RB; // cvRectangle( input, faceInformation.LT, faceInformation.RB, CV_RGB(255,0,0), 3, 8, 0 ); } // else // cvRectangle( input, faceInformation.LT, faceInformation.RB, CV_RGB(0,255,0), 3, 8, 0 ); } cvReleaseImage(&gray); cvReleaseImage(&small_img); double t1 = (double)cvGetTickCount(); //printf( "detection time = %gms\n",(t1-t)/((double)cvGetTickFrequency()*1000.)); }
void process_image(IplImage* frame, int draw) { int i, j; float t; uint8_t* pixels; int nrows, ncols, ldim; #define MAXNDETECTIONS 2048 int ndetections; float rcsq[4*MAXNDETECTIONS]; static IplImage* gray = 0; static IplImage* pyr[5] = {0, 0, 0, 0, 0}; /* ... */ // if(!pyr[0]) { // gray = cvCreateImage(cvSize(frame->width, frame->height), frame->depth, 1); // pyr[0] = gray; pyr[1] = cvCreateImage(cvSize(frame->width/2, frame->height/2), frame->depth, 1); pyr[2] = cvCreateImage(cvSize(frame->width/4, frame->height/4), frame->depth, 1); pyr[3] = cvCreateImage(cvSize(frame->width/8, frame->height/8), frame->depth, 1); pyr[4] = cvCreateImage(cvSize(frame->width/16, frame->height/16), frame->depth, 1); } // get grayscale image if(frame->nChannels == 3) cvCvtColor(frame, gray, CV_RGB2GRAY); else cvCopy(frame, gray, 0); // perform detection with the pico library t = getticks(); if(usepyr) { int nd; // pyr[0] = gray; pixels = (uint8_t*)pyr[0]->imageData; nrows = pyr[0]->height; ncols = pyr[0]->width; ldim = pyr[0]->widthStep; ndetections = find_objects(rcsq, MAXNDETECTIONS, cascade, angle, pixels, nrows, ncols, ldim, scalefactor, stridefactor, MAX(16, minsize), MIN(128, maxsize)); for(i=1; i<5; ++i) { cvResize(pyr[i-1], pyr[i], CV_INTER_LINEAR); pixels = (uint8_t*)pyr[i]->imageData; nrows = pyr[i]->height; ncols = pyr[i]->width; ldim = pyr[i]->widthStep; nd = find_objects(&rcsq[4*ndetections], MAXNDETECTIONS-ndetections, cascade, angle, pixels, nrows, ncols, ldim, scalefactor, stridefactor, MAX(64, minsize>>i), MIN(128, maxsize>>i)); for(j=ndetections; j<ndetections+nd; ++j) { rcsq[4*j+0] = (1<<i)*rcsq[4*j+0]; rcsq[4*j+1] = (1<<i)*rcsq[4*j+1]; rcsq[4*j+2] = (1<<i)*rcsq[4*j+2]; } ndetections = ndetections + nd; } } else {
void LegsDetector::update(const std::vector< laser_t >& laserBuffer) { // first remove high peaks due to absorving materials laser_t laser[BUFFERLENGTH]; for (int i = 0; i < _bufferLength; i++) { laser[i].range = DBL_MAX; double angle = laser[i].angle = laserBuffer[i].angle; for (int k = max(0, i-_delta); k <= min( _bufferLength-1, i+_delta); k++) { double range; if (laserBuffer[k].range < laser[i].range) { range = laser[i].range = laserBuffer[k].range; laser[i].x = range * cos(angle); laser[i].y = range * sin(angle); } } } // (0) // | // | // | // (+90)------------------|-------------------(-90) // reading from right to left i.e. from -90 to +90 // // start extracting all the vertical edges of interest // remembering the scan goes from right (-PI/2) to left (+PI/2) // left and right edges correspond to the robot's point of view // // -(p1) (p1)- // | (p1)-(p1) | // | | | | // | | l| |r // | | | | // L| |R (p2)--(p2) // | | // | | // (p2)--(p2) // vector< edge_t<point_t> > vEdge; double prevRange = laser[0].range; for (int id = 1; id < _bufferLength; id++) { double range = laser[id].range; //if ( range == MAXIMUM_RANGE || prevRange == MAXIMUM_RANGE ) ; if ((prevRange - range) > MIN_LONG_EDGE) // possible left long edge { edge_t<point_t> e = {Point(laser[id-1].x, laser[id-1].y, laser[id-1].range, laser[id-1].angle), Point(laser[id].x, laser[id].y, laser[id].range, laser[id].angle), 'R'}; vEdge.push_back(e); } else if ((range - prevRange) > MIN_LONG_EDGE) // possible right long edge { edge_t<point_t> e = {Point(laser[id].x, laser[id].y, laser[id].range, laser[id].angle), Point(laser[id-1].x, laser[id-1].y, laser[id-1].range, laser[id-1].angle), 'L'}; vEdge.push_back(e); } else if ((prevRange - range) > MIN_SHORT_EDGE) // possible left short edge { edge_t<point_t> e = {Point(laser[id-1].x, laser[id-1].y, laser[id-1].range, laser[id-1].angle), Point(laser[id].x, laser[id].y, laser[id].range, laser[id].angle), 'r'}; vEdge.push_back(e); } else if ((range - prevRange) > MIN_SHORT_EDGE) // possible right short edge { edge_t<point_t> e = {Point(laser[id].x, laser[id].y, laser[id].range, laser[id].angle), Point(laser[id-1].x, laser[id-1].y, laser[id-1].range, laser[id-1].angle), 'l'}; vEdge.push_back(e); } prevRange = range; } // remove edges too close to each other if ( vEdge.empty() ) return; vector<edge_t<point_t> >::iterator first = vEdge.begin(); vector<edge_t<point_t> >::iterator second = first + 1; double d1, d2; char t1, t2; while (second < vEdge.end()) { t1 = toupper(first->type); t2 = toupper(second->type); d1 = getDistance(second->p1, first->p2); d2 = getDistance(first->p1, second->p2); if ( t1 == 'R' && t2 == 'R' && d1 < MIN_EDGE_DIST ) { first->p2 = second->p2; first->type = 'R'; second = vEdge.erase(second); } else if ( t1 == 'L' && t2 == 'L' && d2 < MIN_EDGE_DIST ) { first->p1 = second->p1; first->type = 'L'; second = vEdge.erase(second); } else { first++; second++; } } if ( vEdge.empty() ) return; // draw some stuff for debugging... (must be done now, before vEdge is modified) if (_debug) { CvPoint start; cvSet(_tmpImg, cvScalar(255,255,255)); start = cvPoint(DEBUG_WINDOW_WIDTH/2, 0); cvCircle(_tmpImg, start, 1*DEBUG_WINDOW_WIDTH/80, cvScalar(255,0,0)); cvCircle(_tmpImg, start, 1*DEBUG_WINDOW_WIDTH/16, cvScalar(255,0,0)); cvCircle(_tmpImg, start, 2*DEBUG_WINDOW_WIDTH/16, cvScalar(255,0,0)); cvCircle(_tmpImg, start, 3*DEBUG_WINDOW_WIDTH/16, cvScalar(255,0,0)); cvCircle(_tmpImg, start, 4*DEBUG_WINDOW_WIDTH/16, cvScalar(255,0,0)); cvCircle(_tmpImg, start, 5*DEBUG_WINDOW_WIDTH/16, cvScalar(255,0,0)); cvCircle(_tmpImg, start, 6*DEBUG_WINDOW_WIDTH/16, cvScalar(255,0,0)); cvCircle(_tmpImg, start, 7*DEBUG_WINDOW_WIDTH/16, cvScalar(255,0,0)); cvCircle(_tmpImg, start, 8*DEBUG_WINDOW_WIDTH/16, cvScalar(255,0,0)); start = cvPoint(METER2PIXEL(laser[0].y) + DEBUG_WINDOW_WIDTH/2, METER2PIXEL(laser[0].x)); // draw the laser data for (int i = 1; i < _bufferLength; i++) { CvPoint end = cvPoint(METER2PIXEL(laser[i].y) + DEBUG_WINDOW_WIDTH/2, METER2PIXEL(laser[i].x)); if (laser[i].range == MAXIMUM_RANGE && laser[i-1].range == MAXIMUM_RANGE) cvLine(_tmpImg, start, end, cvScalar(0,0,0)); if (laser[i].range < MAXIMUM_RANGE && laser[i-1].range < MAXIMUM_RANGE) cvLine(_tmpImg, start, end, cvScalar(0,0,0)); start = end; } // draw the extremes for (unsigned int i = 0; i < vEdge.size(); i++) { CvScalar color; switch (vEdge[i].type) { case 'R': color = cvScalar(0,0,255); // red break; case 'L': color = cvScalar(255,0,0); // blue break; case 'r': color = cvScalar(0,196,255); // yellow break; case 'l': color = cvScalar(64,255,0); // green break; } // draw min extremes CvPoint center = cvPoint(METER2PIXEL(vEdge[i].p1.y) + DEBUG_WINDOW_WIDTH/2, METER2PIXEL(vEdge[i].p1.x)); cvCircle(_tmpImg, center, 2, color); // draw max extremes CvPoint c1 = cvPoint(METER2PIXEL(vEdge[i].p2.y) - 3 + DEBUG_WINDOW_WIDTH/2, METER2PIXEL(vEdge[i].p2.x) - 3); CvPoint c2 = cvPoint(METER2PIXEL(vEdge[i].p2.y) + 3 + DEBUG_WINDOW_WIDTH/2, METER2PIXEL(vEdge[i].p2.x) + 3); cvRectangle(_tmpImg, c1, c2, color); } } // extract the horizontal lines of interest vector< edge_t<point_t> > hEdge; int temp = 1; while ( temp > 0 ) { temp = getUpattern(vEdge, hEdge); } temp = 1; while ( _selectivity < 2 && temp > 0 ) { temp = getPpattern(vEdge, hEdge);} temp = 1; while ( _selectivity < 1 && temp > 0 ) { temp = getOpattern(vEdge, hEdge);} // finally calculate distance and direction of each horizontal line _target.clear(); vector< edge_t<point_t> >::iterator itend = hEdge.end(); for (vector< edge_t<point_t> >::iterator it = hEdge.begin(); it < itend; it++) { target_t t; // the distance is an average between the two points double xm = ((it->p1).x + (it->p2).x) / 2; double ym = ((it->p1).y + (it->p2).y) / 2; t.distance = sqrt(sqr(xm) + sqr(ym)); // left PI/2, right -PI/2 t.bearing = atan2(ym, xm); // no height information of course... t.pattern = it->type; _target.push_back(t); } // final number of detected people _howMany = _target.size(); // draw the last things for debugging if (_debug) { // draw horizontal edges for (unsigned int i = 0; i < hEdge.size(); i++) { CvPoint p1 = cvPoint(METER2PIXEL(hEdge[i].p1.y) + DEBUG_WINDOW_WIDTH/2, METER2PIXEL(hEdge[i].p1.x)); CvPoint p2 = cvPoint(METER2PIXEL(hEdge[i].p2.y) + DEBUG_WINDOW_WIDTH/2, METER2PIXEL(hEdge[i].p2.x)); // cvLine(_tmpImg, p1, p2, cvScalar(0,128,255), 2); CvPoint pm = cvPoint((p1.x + p2.x) / 2, (p1.y + p2.y) / 2); int thick; if (hEdge[i].type == 'U') thick = 3; else if (hEdge[i].type == 'P') thick = 2; else thick = 1; cvLine(_tmpImg, cvPoint(DEBUG_WINDOW_WIDTH/2, 0), pm, cvScalar(0,128,255), thick); } cvFlip(_tmpImg, NULL, -1); cvResize(_tmpImg, _debugImage, CV_INTER_NN); cvShowImage("Legs detector", _debugImage); if (_delay) cvWaitKey(_delay); // handles event processing of HIGHGUI library } return; }
int main() { CvPoint pt1b,pt2b, pt1t,pt2t,ptarry[4]; int tempwidth,tempheight; CvRect regt,rectROIbot,rectROItop; rectROItop=cvRect(0,0,80,10); rectROIbot=cvRect(0,50,80,10); CvPoint b_cir_center,t_cir_center; CvPoint frame_center; CvPoint A,B,C,D; CvPoint temp; double angle,spinsize; int cir_radius=1; int frame_width=160, frame_height=120; IplImage* frame; IplImage* threshframe; IplImage* hsvframe; IplImage* threshframebot; IplImage* threshframetop; IplImage* modframe; IplImage* dilframetop; IplImage* dilframebot; int moddiv=2,seq=0,seqdiv=2; int release=0, rmax=100; int modfheight, modfwidth; unsigned char sendBuf;/* int serial; serial = openSerial("/dev/ttyACM0"); if (serial == -1) serial = openSerial("/dev/ttyACM1"); if (serial == -1) serial = openSerial("/dev/ttyACM2"); if (serial == -1) serial = openSerial("/dev/ttyACM3"); if (serial == -1) serial = openSerial("/dev/ttyACM4"); if (serial == -1) serial = openSerial("/dev/ttyACM5"); if (serial == -1) serial = openSerial("/dev/ttyACM6"); if (serial == -1) serial = openSerial("/dev/ttyACM7"); if (serial == -1) serial = openSerial("/dev/ttyACM8"); if( serial == -1 ) { return -1; }*/ //CvCapture* capture = cvCaptureFromCAM( CV_CAP_ANY ); CvCapture* capture = cvCaptureFromCAM( 1 ); if ( !capture ) { fprintf(stderr, "ERROR: capture is NULL \n" ); getchar(); return -1; } cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH,frame_width);// 120x160 cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT,frame_height); // cvSetCaptureProperty(capture, CV_CAP_PROP_FPS,10); // cvSetCaptureProperty(capture,CV_CAP_PROP_POS_FRAMES,5); // Create a window in which the captured images will be presented cvNamedWindow( "mywindow", CV_WINDOW_AUTOSIZE ); // Show the image captured from the camera in the window and repeat while ( 1 ) { // Get one frame frame = cvQueryFrame( capture ); if ( !frame ) { fprintf( stderr, "ERROR: frame is null...\n" ); getchar(); break; } modfheight = frame->height; modfwidth = frame->width; modframe = cvCreateImage(cvSize((int)(modfwidth/moddiv),(int)(modfheight/moddiv)),frame->depth,frame->nChannels); //cvCreateImage(size of frame, depth, noofchannels) cvResize(frame, modframe,CV_INTER_LINEAR); // create HSV(Hue, Saturation, Value) frame hsvframe = cvCreateImage(cvGetSize(modframe),8, 3); cvCvtColor(modframe, hsvframe, CV_BGR2HSV); //cvCvtColor(input frame,outputframe,method) threshframe = cvCreateImage(cvGetSize(hsvframe),8,1); // cvInRangeS(hsvframe,cvScalar(0, 180, 140),cvScalar(15, 230, 235),threshframe); //cvInRangeS(input frame, cvScalar(min range),cvScalar(max range),output frame) red cvInRangeS(hsvframe,cvScalar(70, 180, 40),cvScalar(100, 230, 90),threshframe); //cvInRangeS(input frame, cvScalar(min range),cvScalar(max range),output frame) threshframebot=cvCloneImage(threshframe); cvSetImageROI(threshframebot,rectROIbot); threshframetop=cvCloneImage(threshframe); cvSetImageROI(threshframetop,rectROItop); ////////////////////////////////////////////////////////////////////////////////////////// if (seq==0) { threshframebot=cvCloneImage(threshframe); cvSetImageROI(threshframebot,rectROIbot); dilframebot = cvCreateImage(cvGetSize(threshframebot),8,1); cvDilate(threshframebot,dilframebot,NULL,2); //cvDilate(input frame, // tempwidth=cvGetSize(dilframebot).width; // tempheight=cvGetSize(dilframebot).height; // printf("dilframe: %d, %d \n",tempwidth,tempheight); CBlobResult blobs_bot; blobs_bot = CBlobResult(dilframebot,NULL,0); // CBlobresult(inputframe, mask, threshold) Will filter all white parts of image blobs_bot.Filter(blobs_bot,B_EXCLUDE,CBlobGetArea(),B_LESS,50);//blobs.Filter(input, cond, criteria, cond, const) Filter all images whose area is less than 50 pixels CBlob biggestblob_bot; blobs_bot.GetNthBlob(CBlobGetArea(),0,biggestblob_bot); //GetNthBlob(criteria, number, output) Get only the largest blob based on CblobGetArea() // get 4 points to define the rectangle pt1b.x = biggestblob_bot.MinX()*moddiv; pt1b.y = biggestblob_bot.MinY()*moddiv+100; pt2b.x = biggestblob_bot.MaxX()*moddiv; pt2b.y = biggestblob_bot.MaxY()*moddiv+100; b_cir_center.x=(pt1b.x+pt2b.x)/2; b_cir_center.y=(pt1b.y+pt2b.y)/2;} ////////////////////////////////////////////////////////////////////////////////////////// if(seq==seqdiv){ threshframetop=cvCloneImage(threshframe); cvSetImageROI(threshframetop,rectROItop); dilframetop = cvCreateImage(cvGetSize(threshframetop),8,1); cvDilate(threshframetop,dilframetop,NULL,2); //cvDilate(input frame, CBlobResult blobs_top; blobs_top = CBlobResult(dilframetop,NULL,0); // CBlobresult(inputframe, mask, threshold) Will filter all white parts of image blobs_top.Filter(blobs_top,B_EXCLUDE,CBlobGetArea(),B_LESS,50);//blobs.Filter(input, cond, criteria, cond, const) Filter all images whose area is less than 50 pixels CBlob biggestblob_top; blobs_top.GetNthBlob(CBlobGetArea(),0,biggestblob_top); //GetNthBlob(criteria, number, output) Get only the largest blob based on CblobGetArea() // get 4 points to define the rectangle pt1t.x = biggestblob_top.MinX()*moddiv; pt1t.y = biggestblob_top.MinY()*moddiv; pt2t.x = biggestblob_top.MaxX()*moddiv; pt2t.y = biggestblob_top.MaxY()*moddiv; t_cir_center.x=(pt1t.x+pt2t.x)/2; t_cir_center.y=(pt1t.y+pt2t.y)/2;} ////////////////////////////////////////////////////////////////////////////////////// if(seq==seqdiv+2) { frame_center.x=frame_width/2; frame_center.y=frame_height/2; A.x=frame_center.x-4; A.y=frame_center.y; B.x=frame_center.x+4; B.y=frame_center.y; C.y=frame_center.y-4; C.x=frame_center.x; D.y=frame_center.y+4; D.x=frame_center.x; cvRectangle(frame,pt1t,pt2t,cvScalar(255,0,0),1,8,0); cvRectangle(frame,pt1b,pt2b,cvScalar(255,0,0),1,8,0); // draw rectangle around the biggest blob //cvRectangle(frame,pt1,pt2,cvScalar(255,0,0),1,8,0); cvCircle( frame, b_cir_center, cir_radius, cvScalar(0,255,255), 1, 8, 0 ); // center point of the rectangle cvLine(frame, A, B,cvScalar(255,0,255),2,8,0); cvLine(frame, C, D,cvScalar(255,0,255),2,8,0); if (b_cir_center.x!=0&&b_cir_center.y!=100) { cvLine(frame, b_cir_center, frame_center,cvScalar(0,255,0),1,8,0); } if(t_cir_center.x!=0&&t_cir_center.y!=0) { cvLine(frame, frame_center, t_cir_center,cvScalar(255,255,0),1,8,0); } if ((b_cir_center.x!=0&&b_cir_center.y!=100)&&(t_cir_center.x!=0&&t_cir_center.y!=0)) { cvLine(frame, b_cir_center, t_cir_center,cvScalar(0,255,255),1,8,0); printf("%d, %d, %d, %d\n",t_cir_center.x,t_cir_center.y,b_cir_center.x,b_cir_center.y); } } seq++; seq=seq%(seqdiv+4); cvShowImage( "mywindow", frame); // show output image cvShowImage( "bot", threshframebot); cvShowImage( "top", threshframetop); // cvShowImage("croped",cropped); //cvShowImage( "mywindow3", dilframeROI); // Do not release the frame! //If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version), //remove higher bits using AND operator if ( (cvWaitKey(10) & 255) == 27 ) break; } // Release the capture device housekeeping cvReleaseCapture( &capture ); cvDestroyWindow( "mywindow" ); return 0; }
bool CxFaceAnalyzer::Face_Detection(IplImage *pImgSrc,int nMin_FaceSize = 80, char *ThumbnailImgFilename=NULL) { if(pImgSrc == NULL) return false; if( m_pImgGray != NULL ) cvReleaseImage( &m_pImgGray ); m_pImgGray = cvCreateImage(cvGetSize(pImgSrc), IPL_DEPTH_8U, 1); if( pImgSrc->nChannels == 4 ) cvCvtColor( pImgSrc, m_pImgGray, CV_BGRA2GRAY ); if( pImgSrc->nChannels == 3 ) cvCvtColor( pImgSrc, m_pImgGray, CV_BGR2GRAY ); if( pImgSrc->nChannels == 1 ) cvCopy( pImgSrc, m_pImgGray ); SetFaceSizeRange(m_nFaceDetectorNo, nMin_FaceSize, pImgSrc->width*0.5); // do face tracking //m_face_num = m_Facedetector->detect( m_pImgGray, m_rects, MAX_FACES); FdRect FaceArea[MAX_FACES]; //m_face_num = FrontalView_FaceDetection(m_nFaceDetectorNo, m_pImgGray, FaceArea); m_face_num = FrontalView_ColorImage_FaceDetection(m_nFaceDetectorNo, m_pImgGray, FaceArea, 0); for(int i=0;i<m_face_num;i++) { m_rects[i].rc.x = FaceArea[i].x; m_rects[i].rc.y = FaceArea[i].y; m_rects[i].rc.width = FaceArea[i].width; m_rects[i].rc.height = FaceArea[i].height; m_rects[i].angle = FaceArea[i].view; } ClearFaceSizeRange(m_nFaceDetectorNo); //detect and recognize each face int nLargest_Face_Size = -1; int nLargest_ID = -1; bool bLandmark; CvRect rect; CvPoint2D32f* landmark6 ; int angle; for( int i=0; i < m_face_num; i++ ) { m_cutface_flag[i] = 0; // init // get face rect and id from tracker rect = m_rects[i].rc; angle = m_rects[i].angle; if(rect.x+rect.width > m_pImgGray->width || rect.x < 0) continue; if(rect.y+rect.height > m_pImgGray->height || rect.y < 0) continue; if(rect.width<nMin_FaceSize) continue; // detect landmark landmark6 = m_ldmks[i]; bLandmark = false; bLandmark = m_plandmarkDetector->detect( m_pImgGray, &rect, landmark6, NULL, angle ); if(bLandmark ==false) continue; if(rect.width> nLargest_Face_Size) { nLargest_Face_Size = rect.width; nLargest_ID = i; } } if(nLargest_ID>-1) { landmark6 = m_ldmks[nLargest_ID]; rect = m_rects[nLargest_ID].rc; alignFace2(m_pImgGray, landmark6, &rect, m_cutface_big->width, m_cutface_big->height, false, m_age_sclxyud, m_cutface_big); cvResize(m_cutface_big, m_cutface_small); IplImage *lpTest = alignFace3(pImgSrc, landmark6, &rect, m_cutface_big->width * 2, m_cutface_big->height * 2, false, m_age_sclxyud, NULL); cvSaveImage(ThumbnailImgFilename,lpTest); cvReleaseImage(&lpTest); } cvReleaseImage(&m_pImgGray); m_pImgGray = NULL; if(nLargest_ID>-1) return true; else return false; }
int main(int argc, char** argv) { // GLOBAL SETTINGS static int framecounter=0; const CvSize imsize = cvSize(320,240); int delay = 0; const int win_size = 10; CvSize pyr_sz = cvSize( imsize.width+8, imsize.height/3 ); IplImage * pyrA = cvCreateImage( pyr_sz, IPL_DEPTH_32F, 1 ); IplImage * pyrB = cvCreateImage( pyr_sz, IPL_DEPTH_32F, 1 ); IplImage * rawImage_resized = cvCreateImage( imsize, IPL_DEPTH_8U, 3); cvNamedWindow("Test"); CvGenericTracker tracker; // LOAD INPUT FILE CvCapture * capture = NULL; if (argc==1) { capture = cvCreateCameraCapture(0); cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, imsize.width); cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, imsize.height); }else{ capture = cvCreateFileCapture(argv[1]); } if (!capture) {fprintf(stderr, "Error: fail to open source video!\n");return 0;} cvSetCaptureProperty(capture, CV_CAP_PROP_POS_FRAMES, framecounter); // START ENDLESS LOOP while(1) { // GET NEXT FRAME if (1){ cvSetCaptureProperty(capture, CV_CAP_PROP_POS_FRAMES, framecounter++); }else{ framecounter++; } IplImage * rawImage = cvQueryFrame(capture); cvResize(rawImage,rawImage_resized); if (!rawImage) {fprintf(stderr, "Info: end of video!\n"); break;} if (tracker.initialized()){ tracker.update(rawImage_resized); }else{ tracker.initialize(rawImage_resized); tracker.m_framecounter=framecounter; } // START PROCESSING HERE { // Initialize, load two images from the file system, and // allocate the images and other structures we will need for // results. CvMat * imgA = tracker.m_currImage; IplImage * imgB = tracker.m_nextImage; IplImage * imgC = cvCloneImage(rawImage_resized); // The first thing we need to do is get the features // we want to track. IplImage * eig_image = cvCreateImage( imsize, IPL_DEPTH_32F, 1 ); IplImage * tmp_image = cvCreateImage( imsize, IPL_DEPTH_32F, 1 ); int corner_count = MAX_CORNERS; CvPoint2D32f* cornersA = new CvPoint2D32f[ MAX_CORNERS ]; 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,0.03)); // Call the Lucas Kanade algorithm char features_found[ MAX_CORNERS ]; float feature_errors[ MAX_CORNERS ]; CvPoint2D32f * cornersB = new CvPoint2D32f[ MAX_CORNERS ]; 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, .3 ), (framecounter<2)?0:CV_LKFLOW_PYR_B_READY); // Now make some image of what we are looking at: for( int i=0; i<corner_count; i++ ) { if( features_found[i]==0|| feature_errors[i]>550 ) { fprintf(stderr,"error=%f\n",feature_errors[i]);continue; } CvPoint p0 = cvPoint(cvRound( cornersA[i].x ),cvRound( cornersA[i].y )); CvPoint p1 = cvPoint(cvRound( cornersB[i].x ),cvRound( cornersB[i].y )); cvLine( imgC, p0, p1, CV_RGB(255,0,0), 1 ); } cvShowImage("Test",imgC); cvReleaseImage(&imgC); cvReleaseImage(&eig_image); cvReleaseImage(&tmp_image); delete [] cornersA; delete [] cornersB; } // DISPLAY PROCESSING RESULT int key = cvWaitKey(delay)&0xff; if (key==27){ break; }else if (key==' '){ if (delay){ delay = 0; }else{ delay = 30; } }else if (key=='f'){ // skip to next frame }else if (key=='S'){ // skip to next frame framecounter+=10;fprintf(stderr,"framecount:%d\n",framecounter); }else if (key=='Q'){ // skip to next frame framecounter=MAX(1,framecounter-10);fprintf(stderr,"framecount:%d\n",framecounter); }else if (key!=0xff){ fprintf(stderr, "Warning: Unknown key press : %c\n", key); } // end of key press processing } // end of video cvReleaseImage(&pyrA); cvReleaseImage(&pyrB); cvReleaseImage(&rawImage_resized); return 0; }
// Function to detect and draw any faces that is present in an image void detect_and_draw( IplImage* temp ) { IplImage *grey = cvCreateImage(cvGetSize(temp), 8, 1); cvCvtColor(temp, grey, CV_RGB2GRAY); IplImage* face = cvCreateImage(cvSize(100,100), 8, 1); IplImage *faces_hist[NUM_FACES]; int i,j; for(i=0;i<NUM_FACES;i++) { faces_hist[i] = cvCreateImage(cvSize(100,100), 8, 1); cvZero(faces_hist[i]); } cvZero(face); // Create two points to represent the face locations CvPoint pt1, pt2, e_pt1, e_pt2; // Clear the memory storage which was used before cvClearMemStorage( storage ); // Find whether the cascade is loaded, to find the faces. If yes, then: if( cascade ) { // There can be more than one face in an image. So create a growable sequence of faces. // Detect the objects and store them in the sequence CvSeq* faces = cvHaarDetectObjects( grey, cascade, storage, 1.1, 2, CV_HAAR_DO_CANNY_PRUNING, cvSize(40, 40) ); // Loop the number of faces found. if (faces) printf("Number of faces: %d\n", faces->total); for( i = 0; i < (faces ? faces->total : 0); i++ ) { // Create a new rectangle for drawing the face CvRect* r = (CvRect*)cvGetSeqElem( faces, i ); // Find the dimensions of the face,and scale it if necessary pt1.x = r->x; pt2.x = (r->x+r->width); pt1.y = r->y; pt2.y = (r->y+r->height); cvSetImageROI(grey, cvRect(pt1.x, pt1.y, r->width, r->height)); CvSeq* eyes = cvHaarDetectObjects(grey, cascade_eyes, storage, 1.1, 5, 0, cvSize(25,15)); printf("Eyes: %p num: %d\n", eyes, eyes->total); for( j=0;j < (eyes ? eyes->total : 0); j++ ) { CvRect *e = (CvRect*)cvGetSeqElem(eyes, j); e_pt1.x = e->x; e_pt2.x = (e->x+e->width); e_pt1.y = e->y; e_pt2.y = (e->y+e->height); cvRectangle(grey, e_pt1, e_pt2, CV_RGB(255,255,255), 3, 8, 0); } cvResize(grey, face, CV_INTER_LINEAR); cvResetImageROI(grey); if (i < NUM_FACES) cvEqualizeHist(face, faces_hist[i]); // Draw the rectangle in the input image cvRectangle( grey, pt1, pt2, CV_RGB(255,0,0), 3, 8, 0 ); } } // Show the image in the window named "result" //cvShowImage( "result", temp ); cvShowManyImages("result", 6, temp, grey, face, faces_hist[0], faces_hist[1], faces_hist[2]); // Release the temp image created. cvReleaseImage( &face ); cvReleaseImage( &grey ); for(i=0;i<NUM_FACES;i++) cvReleaseImage(&faces_hist[i]); }
IplImage * camera_control_query_frame(CameraControl* cc) { IplImage* result; #if defined(CAMERA_CONTROL_USE_CL_DRIVER) // assign buffer-pointer to address of buffer cvGetRawData(cc->frame4ch, &cc->pCapBuffer, 0, 0); CLEyeCameraGetFrame(cc->camera, cc->pCapBuffer, 2000); // convert 4ch image to 3ch image const int from_to[] = { 0, 0, 1, 1, 2, 2 }; const CvArr** src = (const CvArr**) &cc->frame4ch; CvArr** dst = (CvArr**) &cc->frame3ch; cvMixChannels(src, 1, dst, 1, from_to, 3); result = cc->frame3ch; #else long start = psmove_util_get_ticks(); result = cvQueryFrame(cc->capture); psmove_DEBUG("cvQueryFrame: %ld ms\n", psmove_util_get_ticks() - start); #endif #if defined(PSMOVE_USE_DEINTERLACE) /** * Dirty hack follows: * - Clone image * - Hack internal variables to make an image of all odd lines **/ IplImage *tmp = cvCloneImage(result); tmp->imageData += tmp->widthStep; // odd lines tmp->widthStep *= 2; tmp->height /= 2; /** * Use nearest-neighbor to be faster. In my tests, this does not * cause a speed disadvantage, and tracking quality is still good. * * This will scale the half-height image "tmp" to the original frame * size by doubling lines (so we can still do normal circle tracking). **/ cvResize(tmp, result, CV_INTER_NN); /** * Need to revert changes in tmp from above, otherwise the call * to cvReleaseImage would cause a crash. **/ tmp->height = result->height; tmp->widthStep = result->widthStep; tmp->imageData -= tmp->widthStep; // odd lines cvReleaseImage(&tmp); #endif // undistort image if (cc->mapx && cc->mapy) { cvRemap(result, cc->frame3chUndistort, cc->mapx, cc->mapy, CV_INTER_LINEAR | CV_WARP_FILL_OUTLIERS, cvScalarAll(0)); result = cc->frame3chUndistort; } return result; }
/** * process_and_show_images * * show the different images and save a video file with the results * */ int process_and_show_images (const char* name_output_video, track_t list_of_tracks [MAX_CAM - MIN_CAM][MAX_FRAMES]) { IplImage *ground_plane_image = NULL, *cam[MAX_CAM - MIN_CAM]; char cam_name [5][255]; IplImage *DispImage; int current_frame, i, j ,k; float x_fused = 0.0, y_fused = 0.0, x_fused_errors = 0.0, y_fused_errors = 0.0; CvVideoWriter *writer = NULL; CvSize s = cvSize (X_RESOLUTION, Y_RESOLUTION); int contcam[MAX_CAM - MIN_CAM] = {0, 0, 0, 0, 0}; float acumcam_x[MAX_CAM - MIN_CAM] = {0.0, 0.0, 0.0, 0.0, 0.0}; float acumcam_y[MAX_CAM - MIN_CAM] = {0.0, 0.0, 0.0, 0.0, 0.0}; #ifdef DEBUG printf ("process_and_show_images() \n"); #endif #ifdef SHOW_IMAGE printf ("Creating output video file: %s\n", name_output_video); writer = cvCreateVideoWriter (name_output_video, CV_FOURCC ('M', 'J', 'P', 'G'), 15, s, 1); //writer = cvCreateVideoWriter (name_output_video, -1, 15, s, 1); cvNamedWindow ("Apidis", CV_WINDOW_AUTOSIZE); DispImage = cvCreateImage (cvSize (X_RESOLUTION, Y_RESOLUTION), IPL_DEPTH_8U, 3); #endif /* for each frame */ for (current_frame = 0; current_frame < MAX_FRAMES; current_frame++) { printf ("."); fflush (stdout); #ifdef SHOW_IMAGE sprintf (cam_name[0], "%s-%04d.jpeg", LOCATION_CAM1_IMAGES, current_frame); sprintf (cam_name[1], "%s-%04d.jpeg", LOCATION_CAM2_IMAGES, current_frame); sprintf (cam_name[2], "%s-%04d.jpeg", LOCATION_CAM4_IMAGES, current_frame); /* Note that cam3 and cam4 are mapped to camera 6 and camera 7 images */ sprintf (cam_name[3], "%s-%04d.jpeg", LOCATION_CAM6_IMAGES, current_frame); sprintf (cam_name[4], "%s-%04d.jpeg", LOCATION_CAM7_IMAGES, current_frame); for (i = 0; i < MAX_CAM; i++) { cam[i] = cvLoadImage (cam_name[i], CV_LOAD_IMAGE_COLOR); if (cam[i] == NULL) { printf ("Error opening image: %s \n", cam_name[i]); exit (-1); } } if (ground_plane_image == NULL) ground_plane_image = cvLoadImage (LOCATION_GROUND_PLANE_IMAGE, CV_LOAD_IMAGE_COLOR); cvSetImageROI (DispImage, cvRect (0, 0, 400, 300)); #endif for (i = 0; i < MAX_CAM; i++) { if (track_x (i, current_frame) != 0) { /* if camera 1 in current frame have information */ #ifdef SHOW_IMAGE cvRectangle (cam[i], cvPoint ((int) track_x (i, current_frame), (int) track_y (i, current_frame)), cvPoint ((int) track_x (i, current_frame) + track_w (i, current_frame), (int) track_y (i, current_frame) + track_h (i, current_frame)), CV_RGB (255,255,0), 2, 8, 0); cvRectangle (cam[i], cvPoint ((int) track_x_kalman (i, current_frame), (int) track_y_kalman (i, current_frame)), cvPoint ((int) track_x_kalman (i, current_frame) + track_w_kalman (i, current_frame), (int) track_y_kalman (i, current_frame) + track_h_kalman (i, current_frame)), CV_RGB (255,0,0), 2, 8, 0); #endif if (contcam[i] < 5) /* wait for having 5 values */ contcam[i]++; if (contcam[i] == 5) {/* save stats */ /* get the current mean */ acumcam_x[i] = 0.0; acumcam_y[i] = 0.0; for (j = 0; j< 5; j++) { acumcam_x[i] += track_px_global_kalman (i, current_frame - j); acumcam_y[i] += track_py_global_kalman (i, current_frame - j); } px_global_mean_5 (i, current_frame) = acumcam_x[i] / (float) contcam[i]; py_global_mean_5 (i, current_frame) = acumcam_y[i] / (float) contcam[i]; for (j = 0; j < 5; j++) { px_global_var_5 (i, current_frame) += pow(track_px_global (i, current_frame-j) - px_global_mean_5 (i, current_frame),2); py_global_var_5 (i, current_frame) += pow(track_py_global (i, current_frame-j) - py_global_mean_5 (i, current_frame),2); } px_global_var_5 (i, current_frame) = px_global_var_5 (i, current_frame) / 5.0; py_global_var_5 (i, current_frame) = py_global_var_5 (i, current_frame) / 5.0; } } /* if we lost the objective initialize */ if (track_x (i, current_frame) == 0) contcam[i] = 0; #ifdef SHOW_IMAGE cvResize (cam[i], DispImage, CV_INTER_AREA); cvResetImageROI (DispImage); if (i == 0) cvSetImageROI (DispImage, cvRect (400, 0, 400, 300)); if (i == 1) cvSetImageROI (DispImage, cvRect (800, 0, 400, 300)); if (i == 2) cvSetImageROI (DispImage, cvRect (0, 300, 400, 300)); if (i == 3) cvSetImageROI (DispImage, cvRect (400, 300, 400, 300)); if (i == 4) cvSetImageROI (DispImage, cvRect (800, 300, 400, 300)); #endif } /* for each camera */ x_fused = fused_px_global (current_frame, list_of_tracks); y_fused = fused_py_global (current_frame, list_of_tracks); x_fused_errors = fused_px_global_errors (current_frame, list_of_tracks); y_fused_errors = fused_py_global_errors (current_frame, list_of_tracks); /* for each camera, save the fused data in the data structure list_of_tracks */ for (k = 0; k < (MAX_CAM - MIN_CAM); k++) { track_fused_x (k, current_frame) = x_fused; track_fused_y (k, current_frame) = y_fused; } /* save the fused error (difference between filtered data and fused data) */ for (k = 0; k < (MAX_CAM - MIN_CAM); k++) { if (track_py_local (k, current_frame) > 0) { track_error_x (k, current_frame) = abs (track_fused_x (k, current_frame) - track_px_global_kalman (k, current_frame)); track_error_y (k, current_frame) = abs (track_fused_y (k, current_frame) - track_py_global_kalman (k, current_frame)); } } /* get the absolute errors between local data and fused data */ obtain_track_errors (current_frame, list_of_tracks); #ifdef SHOW_IMAGE /* drawing the player positions on the ground plane */ cvCircle (ground_plane_image, cvPoint (((int)(track_px_global (1, current_frame)/SCALE_X)), ((int) (track_py_global(1, current_frame)/SCALE_Y))) , 4, CV_RGB(255, 0, 0), CV_FILLED, CV_AA, 0); printf ("Frame:%d, establishing player @: %f,%f --%f,%f --%f,%f\n", current_frame, track_fused_x(0, current_frame), track_fused_y(0, current_frame), x_fused, y_fused, track_px_global(1, current_frame), track_py_global (1, current_frame)); cvResize (ground_plane_image, DispImage, CV_INTER_AREA); cvResetImageROI (DispImage); cvShowImage ("Apidis", DispImage); cvWriteFrame (writer, DispImage); /* free the memory */ for (i = 0; i < MAX_CAM; i++) cvReleaseImage (&cam[i]); cvWaitKey(2); #endif } /* for each frame */ /* get the mean errors of each camera */ obtain_mean_errors (list_of_tracks); #ifdef SHOW_IMAGE cvReleaseImage (&ground_plane_image); cvReleaseVideoWriter (&writer); cvDestroyWindow ("Apidis"); #endif return 0; }
int process_image(IplImage* frame, int draw, int print) { int i, j; float t; uint8_t* pixels; int nrows, ncols, ldim; #define MAXNDETECTIONS 2048 int ndetections=0; float qs[MAXNDETECTIONS], rs[MAXNDETECTIONS], cs[MAXNDETECTIONS], ss[MAXNDETECTIONS]; static IplImage* gray = 0; static IplImage* pyr[5] = {0, 0, 0, 0, 0}; /* IMPORTANT: * these parameters are highly specific for each detection cascade (determine them experimentally) */ // * this function should be generated with picogen from a detection cascade output by picolrn int (*run_detection_cascade)(float*, int, int, int, void*, int, int, int) = run_facefinder; // * detection quality threshold (must be >= 0.0f) // * you can vary the TPR and FPR with this value // * if you're experiencing too many false positives, try a larger number here (for example, 7.5f) float qthreshold = 5.0f; // * how much to rescale the window during the multiscale detection process // * increasing this value leads to lower number of detections and higher processing speed // * for example, set to 1.2f if you're using pico on a mobile device float scalefactor = 1.1f; // * how much to move the window between neighboring detections // * increasing this value leads to lower number of detections and higher processing speed // * for example, set to 0.05f if you want really high recall float stridefactor = 0.1f; // * coarse image pyramid support // * can improve noise and aliasing problems in some applications // * set to 1 if pico fails to detect large objects int usepyr = 0; /* ... */ // if(!pyr[0]) { // gray = cvCreateImage(cvSize(frame->width, frame->height), frame->depth, 1); // pyr[0] = gray; pyr[1] = cvCreateImage(cvSize(frame->width/2, frame->height/2), frame->depth, 1); pyr[2] = cvCreateImage(cvSize(frame->width/4, frame->height/4), frame->depth, 1); pyr[3] = cvCreateImage(cvSize(frame->width/8, frame->height/8), frame->depth, 1); pyr[4] = cvCreateImage(cvSize(frame->width/16, frame->height/16), frame->depth, 1); } // get grayscale image if(frame->nChannels == 3) cvCvtColor(frame, gray, CV_RGB2GRAY); else cvCopy(frame, gray, 0); // perform detection with the pico library t = getticks(); if(usepyr) { int nd; // pyr[0] = gray; pixels = (uint8_t*)pyr[0]->imageData; nrows = pyr[0]->height; ncols = pyr[0]->width; ldim = pyr[0]->widthStep; ndetections = find_objects(rs, cs, ss, qs, MAXNDETECTIONS, run_detection_cascade, pixels, nrows, ncols, ldim, scalefactor, stridefactor, MAX(16, minsize), MIN(128, maxsize)); for(i=1; i<5; ++i) { cvResize(pyr[i-1], pyr[i], CV_INTER_LINEAR); pixels = (uint8_t*)pyr[i]->imageData; nrows = pyr[i]->height; ncols = pyr[i]->width; ldim = pyr[i]->widthStep; nd = find_objects(&rs[ndetections], &cs[ndetections], &ss[ndetections], &qs[ndetections], MAXNDETECTIONS-ndetections, run_detection_cascade, pixels, nrows, ncols, ldim, scalefactor, stridefactor, MAX(64, minsize>>i), MIN(128, maxsize>>i)); for(j=ndetections; j<ndetections+nd; ++j) { rs[j] = (1<<i)*rs[j]; cs[j] = (1<<i)*cs[j]; ss[j] = (1<<i)*ss[j]; } ndetections = ndetections + nd; } } else {
int main (int argc, const char * argv[]) { float scale = 1.15; int elements = 7; // Array IplImage* images[10]; images[0] = cvLoadImage("megusta.png"); images[1] = cvLoadImage("foreveralone.png"); images[2] = cvLoadImage("pokerface.png"); images[3] = cvLoadImage("trollface.png"); images[4] = cvLoadImage("fuckyeah.png"); images[5] = cvLoadImage("gordo.png"); images[6] = cvLoadImage("yuno.png"); srand(time(NULL)); int j = (int)rand() % elements; clock_t actual = clock(); clock_t anterior = clock(); capture = cvCreateCameraCapture(0); IplImage* originalImg; char *filename = "haarcascade_frontalface_alt.xml"; cascade = ( CvHaarClassifierCascade* )cvLoad( filename, 0, 0, 0 ); storage = cvCreateMemStorage( 0 ); cvNamedWindow( "image", CV_WINDOW_AUTOSIZE ); if( capture ) { for(;;) { actual = clock(); if(actual - anterior > (5*CLOCKS_PER_SEC)){ j = (int)rand() % elements; anterior = actual; } cvGrabFrame(capture); originalImg = cvRetrieveFrame(capture); if(!originalImg) break; CvSeq *faces = cvHaarDetectObjects(originalImg,cascade,storage,1.1,3,0,cvSize( 40, 40 ) ); for( int i = 0 ; i < ( faces ? faces->total : 0 ) ; i++ ) { CvRect *r = ( CvRect* )cvGetSeqElem( faces, i ); IplImage *tmp = cvCreateImage(cvSize(r->width*scale, r->height*scale), images[j]->depth,images[j]->nChannels); cvResize(images[j], tmp, CV_INTER_CUBIC); cvSetImageROI(originalImg,cvRect(r->x-r->width/7,r->y-r->height/15,tmp->width,tmp->height)); cvAdd(originalImg, tmp, originalImg); cvReleaseImage(&tmp); cvResetImageROI(originalImg); } cvShowImage("image", originalImg); char c = cvWaitKey(10); if( c == 27 ) break; } cvReleaseCapture(&capture); } cvDestroyWindow("image"); return 0; }
static void cvImageWidget_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { CvImageWidget *image_widget; //printf("cvImageWidget_size_allocate\n"); g_return_if_fail (widget != NULL); g_return_if_fail (CV_IS_IMAGE_WIDGET (widget)); g_return_if_fail (allocation != NULL); #if defined (GTK_VERSION3) gtk_widget_set_allocation(widget, allocation); #else widget->allocation = *allocation; #endif //GTK_VERSION3 image_widget = CV_IMAGE_WIDGET (widget); if( (image_widget->flags & CV_WINDOW_AUTOSIZE)==0 && image_widget->original_image ){ // (re) allocated scaled image if( image_widget->flags & CV_WINDOW_NO_IMAGE ){ cvImageWidget_set_size( widget, image_widget->original_image->cols, image_widget->original_image->rows); } else{ cvImageWidget_set_size( widget, allocation->width, allocation->height ); } cvResize( image_widget->original_image, image_widget->scaled_image, CV_INTER_AREA ); } if (gtk_widget_get_realized (widget)) { image_widget = CV_IMAGE_WIDGET (widget); if( image_widget->original_image && ((image_widget->flags & CV_WINDOW_AUTOSIZE) || (image_widget->flags & CV_WINDOW_NO_IMAGE)) ) { #if defined (GTK_VERSION3) allocation->width = image_widget->original_image->cols; allocation->height = image_widget->original_image->rows; gtk_widget_set_allocation(widget, allocation); #else widget->allocation.width = image_widget->original_image->cols; widget->allocation.height = image_widget->original_image->rows; #endif //GTK_VERSION3 gdk_window_move_resize( gtk_widget_get_window(widget), allocation->x, allocation->y, image_widget->original_image->cols, image_widget->original_image->rows ); if(image_widget->flags & CV_WINDOW_NO_IMAGE){ image_widget->flags &= ~CV_WINDOW_NO_IMAGE; gtk_widget_queue_resize( GTK_WIDGET(widget) ); } } else{ gdk_window_move_resize (gtk_widget_get_window(widget), allocation->x, allocation->y, allocation->width, allocation->height ); } } }
/** * buffer header callback function for video * * @param port Pointer to port from which callback originated * @param buffer mmal buffer header pointer */ static void video_buffer_callback(MMAL_PORT_T *port, MMAL_BUFFER_HEADER_T *buffer) { MMAL_BUFFER_HEADER_T *new_buffer; PORT_USERDATA *pData = (PORT_USERDATA *)port->userdata; if (pData) { if (buffer->length) { mmal_buffer_header_mem_lock(buffer); // // *** PR : OPEN CV Stuff here ! // int w=pData->pstate->width; // get image size int h=pData->pstate->height; int h4=h/4; memcpy(py->imageData,buffer->data,w*h); // read Y if (pData->pstate->graymode==0) { memcpy(pu->imageData,buffer->data+w*h,w*h4); // read U memcpy(pv->imageData,buffer->data+w*h+w*h4,w*h4); // read v cvResize(pu, pu_big, CV_INTER_NN); cvResize(pv, pv_big, CV_INTER_NN); //CV_INTER_LINEAR looks better but it's slower cvMerge(py, pu_big, pv_big, NULL, image); cvCvtColor(image,dstImage,CV_YCrCb2RGB); // convert in RGB color space (slow) cvShowImage("camcvWin", dstImage ); } else { cvShowImage("camcvWin", py); // display only gray channel } cvWaitKey(1); nCount++; // count frames displayed mmal_buffer_header_mem_unlock(buffer); } else vcos_log_error("buffer null"); } else { vcos_log_error("Received a encoder buffer callback with no state"); } // release buffer back to the pool mmal_buffer_header_release(buffer); // and send one back to the port (if still open) if (port->is_enabled) { MMAL_STATUS_T status; new_buffer = mmal_queue_get(pData->pstate->video_pool->queue); if (new_buffer) status = mmal_port_send_buffer(port, new_buffer); if (!new_buffer || status != MMAL_SUCCESS) vcos_log_error("Unable to return a buffer to the encoder port"); } }
DEFINE_THREAD_ROUTINE(video_stage, data) { C_RESULT res; vp_api_io_pipeline_t pipeline; vp_api_io_data_t out; vp_api_io_stage_t stages[NB_STAGES]; vp_api_picture_t picture; video_com_config_t icc; vlib_stage_decoding_config_t vec; vp_stages_yuv2rgb_config_t yuv2rgbconf; #ifdef RECORD_VIDEO video_stage_recorder_config_t vrc; #endif /// Picture configuration picture.format = PIX_FMT_YUV420P; picture.width = QVGA_WIDTH; picture.height = QVGA_HEIGHT; picture.framerate = 30; picture.y_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT ); picture.cr_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 ); picture.cb_buf = vp_os_malloc( QVGA_WIDTH * QVGA_HEIGHT / 4 ); picture.y_line_size = QVGA_WIDTH; picture.cb_line_size = QVGA_WIDTH / 2; picture.cr_line_size = QVGA_WIDTH / 2; vp_os_memset(&icc, 0, sizeof( icc )); vp_os_memset(&vec, 0, sizeof( vec )); vp_os_memset(&yuv2rgbconf, 0, sizeof( yuv2rgbconf )); icc.com = COM_VIDEO(); icc.buffer_size = 100000; icc.protocol = VP_COM_UDP; COM_CONFIG_SOCKET_VIDEO(&icc.socket, VP_COM_CLIENT, VIDEO_PORT, wifi_ardrone_ip); vec.width = QVGA_WIDTH; vec.height = QVGA_HEIGHT; vec.picture = &picture; vec.block_mode_enable = TRUE; vec.luma_only = FALSE; yuv2rgbconf.rgb_format = VP_STAGES_RGB_FORMAT_RGB24; #ifdef RECORD_VIDEO vrc.fp = NULL; #endif pipeline.nb_stages = 0; stages[pipeline.nb_stages].type = VP_API_INPUT_SOCKET; stages[pipeline.nb_stages].cfg = (void *)&icc; stages[pipeline.nb_stages].funcs = video_com_funcs; pipeline.nb_stages++; #ifdef RECORD_VIDEO stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vrc; stages[pipeline.nb_stages].funcs = video_recorder_funcs; pipeline.nb_stages++; #endif // RECORD_VIDEO stages[pipeline.nb_stages].type = VP_API_FILTER_DECODER; stages[pipeline.nb_stages].cfg = (void*)&vec; stages[pipeline.nb_stages].funcs = vlib_decoding_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_FILTER_YUV2RGB; stages[pipeline.nb_stages].cfg = (void*)&yuv2rgbconf; stages[pipeline.nb_stages].funcs = vp_stages_yuv2rgb_funcs; pipeline.nb_stages++; stages[pipeline.nb_stages].type = VP_API_OUTPUT_SDL; stages[pipeline.nb_stages].cfg = NULL; stages[pipeline.nb_stages].funcs = vp_stages_output_gtk_funcs; pipeline.nb_stages++; pipeline.stages = &stages[0]; /* Processing of a pipeline */ if( !ardrone_tool_exit() ) { PRINT("Video stage thread initialization\n"); res = vp_api_open(&pipeline, &pipeline_handle); // PRINT("VP_API OPENED\n"); if( SUCCEED(res) ) { int loop = SUCCESS; out.status = VP_API_STATUS_PROCESSING; cvStartWindowThread(); #define frontWindow "DroneView" cvNamedWindow(frontWindow, CV_WINDOW_AUTOSIZE); frontImgStream = cvCreateImage(cvSize(picture.width, picture.height), IPL_DEPTH_8U, 3); #define bottomWindow "BomberView" if(extractBottomImage) cvNamedWindow(bottomWindow, CV_WINDOW_AUTOSIZE); bottomImgStream = cvCreateImage(cvSize(bottomWidth, bottomHeight), IPL_DEPTH_8U, 3); IplImage *frame; CvCapture *capture; if(USEWEBCAM) { capture = cvCaptureFromCAM(WEBCAMINDEX); if(!capture) { printf("ERROR: Cannot Initialize Webcam.\n"); loop = !SUCCESS; } } while( !ardrone_tool_exit() && (loop == SUCCESS) ) { if(!USEWEBCAM) { if( SUCCEED(vp_api_run(&pipeline, &out)) ) { if (vec.controller.num_frames==0) continue; /*int i; for(i = 0; i < (picture.width)*(picture.height); i++) { frontImgStream->imageData[i*3] = picture.y_buf[i]; frontImgStream->imageData[i*3+1] = picture.y_buf[i]; frontImgStream->imageData[i*3+2] = picture.y_buf[i]; } */ cvCvtColor(rgbHeader, frontImgStream, CV_RGB2BGR); //[for colour] if(extractBottomImage) { int j = 0, i; for(i = 0; j < bottomHeight*bottomWidth; i = i%picture.width >= bottomWidth-1 ? i - (i%picture.width) + picture.width : i+1) { bottomImgStream->imageData[j*3] = frontImgStream->imageData[i*3]; bottomImgStream->imageData[j*3+1] = frontImgStream->imageData[i*3+1]; bottomImgStream->imageData[j*3+2] = frontImgStream->imageData[i*3+2]; frontImgStream->imageData[i*3] = 0; frontImgStream->imageData[i*3+1] = 0; frontImgStream->imageData[i*3+2] = 0; j++; } } //cvLine(frontImgStream, cvPoint(picture.width/2, 0), cvPoint(picture.width/2, picture.height), CV_RGB(0,255,0), 1, CV_AA, 0 ); cvShowImage(frontWindow, frontImgStream); if(extractBottomImage) cvShowImage(bottomWindow, bottomImgStream); if(CAPTUREIMAGESTREAM) { char filename[256]; struct timeval t; gettimeofday(&t, NULL); sprintf(filename, "%d.%06d.jpg", (int)t.tv_sec, (int)t.tv_usec); if(frontImgStream != NULL && cvSaveImage(filename, cvCloneImage(frontImgStream), 0)) printf("Image dumped to %s\n", filename); else printf("Error dumping image...\n"); if(extractBottomImage) { sprintf(filename, "%d.%06dbottom.jpg", (int)t.tv_sec, (int)t.tv_usec); if(bottomImgStream != NULL && cvSaveImage(filename, cvCloneImage(bottomImgStream), 0)) printf("Bottom Image dumped to %s\n", filename); else printf("Error dumping bottom image...\n"); } } } else loop = -1; } else //use webcam { frame = cvQueryFrame(capture); if(!frame) break; cvResize(frame, frontImgStream, CV_INTER_LINEAR); cvShowImage(frontWindow, frontImgStream); cvWaitKey(1); } } cvDestroyWindow(frontWindow); if(extractBottomImage) cvDestroyWindow(bottomWindow); //cvReleaseImage(&imgBottom); //cvDestroyWindow(bottomWindow); cvReleaseImage(&frontImgStream); vp_api_close(&pipeline, &pipeline_handle); } } PRINT(" Video stage thread ended\n\n"); return (THREAD_RET)0; }
void MotionCapture::HUD(char* title, int nArgs, ...) { // img - Used for getting the arguments IplImage *img; // DispImage - the image in which input images are to be copied IplImage *DispImage; int size; int i; int m, n; int x, y; // w - Maximum number of images in a row // h - Maximum number of images in a column int w, h; // scale - How much we have to resize the image float scale; int max; // If the number of arguments is lesser than 0 or greater than 12 // return without displaying if(nArgs <= 0) { printf("Number of arguments too small....\n"); return; } else if(nArgs > 12) { printf("Number of arguments too large....\n"); return; } // Determine the size of the image, // and the number of rows/cols // from number of arguments else if (nArgs == 1) { w = h = 1; size = 300; } else if (nArgs == 2) { w = 2; h = 1; size = 300; } else if (nArgs == 3 || nArgs == 4) { w = 2; h = 2; size = 350; } else if (nArgs == 5 || nArgs == 6) { w = 3; h = 2; size = 200; } else if (nArgs == 7 || nArgs == 8) { w = 4; h = 2; size = 200; } else { w = 4; h = 3; size = 150; } // Create a new 3 channel image DispImage = cvCreateImage( cvSize( 50 + size*w, 60 + size*h), 8, 3 ); // Used to get the arguments passed va_list args; va_start(args, nArgs); // Loop for nArgs number of arguments for (i = 0, m = 20, n = 20; i < nArgs; i++, m += (20 + size)) { // Get the Pointer to the IplImage img = va_arg(args, IplImage*); // Check whether it is NULL or not // If it is NULL, release the image, and return if(img == 0) { printf("Invalid arguments"); cvReleaseImage(&DispImage); return; } // Find the width and height of the image x = img->width; y = img->height; // Find whether height or width is greater in order to resize the image max = (x > y)? x: y; // Find the scaling factor to resize the image scale = (float) ( (float) max / size ); // Used to Align the images if( i % w == 0 && m!= 20) { m = 20; n+= 20 + size; } // Set the image ROI to display the current image cvSetImageROI(DispImage, cvRect(m, n, (int)( x/scale ), (int)( y/scale ))); // Resize the input image and copy the it to the Single Big Image cvResize( img, DispImage ); // Reset the ROI in order to display the next image cvResetImageROI(DispImage); } // Create a new window, and show the Single Big Image cvNamedWindow( title, 1 ); cvShowImage( title, DispImage); //cvWaitKey(); //cvDestroyWindow(title); // End the number of arguments va_end(args); // Release the Image Memory //cvReleaseImage(&DispImage); }
int main(int argc, char* argv[]){ cvNamedWindow("Color detection",CV_WINDOW_AUTOSIZE); cvNamedWindow("Binaria",CV_WINDOW_AUTOSIZE); CvCapture* capture=cvCaptureFromCAM(0); frame = cvQueryFrame(capture); result = cvCreateImage( cvGetSize(frame), 8, 3 ); IplImage* destination = cvCreateImage( cvGetSize(frame), 8, 3 ); CvFont font; cvInitFont(&font, CV_FONT_VECTOR0, 2.0, 2.0, 0, 3, CV_AA); boolean calibratMa = false; boolean calibratVenda = false; int input; while( (input = cvWaitKey(50))!= 118 ) { frame = cvQueryFrame(capture); if(!calibratMa){ if(input == 32){ calibrarMa(); calibratMa = true; } else cvRectangle( frame, cvPoint(200, 100), cvPoint(300, 200), CV_RGB(255,0,0), 2 ); /*Es mostra un rectangle per posar a sobre la mà*/ } else if(!calibratVenda){ if(input == 32){ calibrarVenda(); calibratVenda = true; } else cvRectangle( frame, cvPoint(200, 250), cvPoint(250, 300), CV_RGB(0,255,255), 2 ); /*Es mostra un rectangle per posar a sobre la mà*/ } else{ int step =frame->widthStep; int canals = frame->nChannels; uchar* imgData = (uchar*) frame->imageData; uchar* imgDataResult = (uchar*) result->imageData; int num_ma = 0; int num_venda = 0; int sum_ma[2] = {0,0}; int sum_venda[2] = {0,0}; int i = 0, j = 0; for( i = 0; i < frame->height; i++) for( j = 0; j < frame->width; j++) if( ((imgData[i*step+j*canals]) >= blue[0] && (imgData[i*step+j*canals]) <= blue[1]) && ((imgData[i*step+j*canals+1]) >= green[0] && (imgData[i*step+j*canals+1]) <= green[1] ) && ((imgData[i*step+j*canals+2]) >= red[0] && (imgData[i*step+j*canals+2]) <= red[1] )){ /*Mà*/ imgDataResult[i*result->widthStep+j*result->nChannels]=255; imgDataResult[i*result->widthStep+j*result->nChannels+1]=0; imgDataResult[i*result->widthStep+j*result->nChannels+2]=0; num_ma ++; sum_ma[0] += j; sum_ma[1] += i; } else if(((imgData[i*step+j*canals]) >= vblue[0] && (imgData[i*step+j*canals]) <= vblue[1]) && ((imgData[i*step+j*canals+1]) >= vgreen[0] && (imgData[i*step+j*canals+1]) <= vgreen[1] ) && ((imgData[i*step+j*canals+2]) >= vred[0] && (imgData[i*step+j*canals+2]) <= vred[1] )){ /*Venda*/ imgDataResult[i*result->widthStep+j*result->nChannels]=255; imgDataResult[i*result->widthStep+j*result->nChannels+1]=255; imgDataResult[i*result->widthStep+j*result->nChannels+2]=0; num_venda++; sum_venda[0] += j; sum_venda[1] += i; } else{/*Background*/ imgDataResult[i*result->widthStep+j*result->nChannels]=0; imgDataResult[i*result->widthStep+j*result->nChannels+1]=0; imgDataResult[i*result->widthStep+j*result->nChannels+2]=0; } cvSmooth(result, result, CV_MEDIAN, 3, 3 ); if(num_ma > 0 && num_venda > 0){ /*S'obté el punt central de la mà i la venda*/ float mig[2] = {sum_ma[0]/num_ma,sum_ma[1]/num_ma}; float vmig[2] = {sum_venda[0]/num_venda,sum_venda[1]/num_venda}; cvRectangle( frame, cvPoint(mig[0], mig[1]), cvPoint(mig[0]+10, mig[1]+10), CV_RGB(0,0,0), -1 ); cvRectangle( frame, cvPoint(vmig[0], vmig[1]), cvPoint(vmig[0]+10, vmig[1]+10), CV_RGB(0,0,0), -1 ); /*Es calcula la distància entre els dos punts*/ double dist = sqrt(pow(mig[0]-vmig[0],2) + pow(mig[1]-vmig[1], 2)); /*Es normalitza la imatge, s'adapta la seva mida*/ destination = cvCreateImage(cvSize((int)(frame->width*distOK/dist) , (int)(frame->height*distOK/dist) ),frame->depth, frame->nChannels ); cvResize(result, destination, CV_INTER_LINEAR); int step =destination->widthStep; int canals = destination->nChannels; uchar* imgData = (uchar*) destination->imageData; /*S'obté el nombre de píxels que pertanyen a la mà*/ int num_ma = 0; for( i = 0; i < destination->height; i++) for( j = 0; j < destination->width; j++) if((imgData[i*step+j*canals]) == 255 && (imgData[i*step+j*canals+1]) == 0 && (imgData[i*step+j*canals+2]) == 0 ){ num_ma++; } /*Comparació del gest actual amb la resta de possibles segons la seva àreea*/ char num[1]; strcpy(num, "0"); if(num_ma > 14000) { /*5 dits*/ strcpy(num, "5"); } else if(num_ma > 10000) { /*4 dits*/ strcpy(num, "4"); } else if(num_ma > 7500) { /*3 dits*/ strcpy(num, "3"); } else if(num_ma > 6000) { /*2 dits*/ strcpy(num, "2"); } else if(num_ma > 4500) { /*1 dit*/ strcpy(num, "1"); } else { /*Cap dit*/ strcpy(num, "0"); } cvPutText(frame, num, cvPoint(10, 50), &font, cvScalar(255, 255, 255, 0)); } } cvShowImage("Color detection", frame); cvShowImage("Binaria", result); } cvDestroyAllWindows(); return 0; }
LPWSTR APIENTRY picxdel(char* fileName) { QRcodeImage * QR_image; ContentDecoder * QR_Decode; BYTE m_CodeData[MAX_MODULESIZE][MAX_MODULESIZE]; // 存储条形码位数据 int m_nCodeSize;//编码区域大小 //int m_nMoudleSize;//模块大小 int m_nVersion;//版本号 //int m_nLevel;//纠错等级 //POINT leftup; //POINT right; //POINT down; //int nShowSize; try{ if( fileName==NULL) { LPWSTR QRstring1=_T("文件名不能为空"); return QRstring1; } //IplImage *img=cvLoadImage(fileName,CV_LOAD_IMAGE_GRAYSCALE); //cvThreshold(img,img,50,255,CV_THRESH_BINARY_INV); ////cvShowImage(fileName.c_str(),img); //cvSaveImage("D:\\1.bmp",img); //cvReleaseImage(&img); IplImage *src=0, *dst=0; src=cvLoadImage(fileName,1); if(src==NULL ) { CString s =fileName;//或 s=s+"文件载入错误。"; LPCTSTR lp = (LPCTSTR)(s); LPWSTR QRstring1=(LPWSTR)lp; return QRstring1; } //这是图片本身的问题,有一道白色边框 //先清理周边的点,这是为了防止区域截取时候矩形区域大于图像造成无效 for (int y=0;y<src->height;y++) { uchar *ptr=(uchar*)(src->imageData+y*src->widthStep); for (int x=0;x<src->width;x++) { if(x>3&&x<(src->width-3)&&y>3&&y<(src->height-3)){ //范围内 }else{ ptr[src->nChannels*x]=0; ptr[src->nChannels*x+1]=0; ptr[src->nChannels*x+2]=0; } } } if(src->width<360){ int scale =3; //缩放倍数为3倍 CvSize dst_cvsize; //目标图像尺寸 dst_cvsize.width =scale*src->width; //目标图像的宽为源图象宽的scale倍 dst_cvsize.height = scale*src->height; //目标图像的高为源图象高的scale倍 dst = cvCreateImage(dst_cvsize, src->depth, src->nChannels); //构造目标图象 } else dst = cvCreateImage(cvGetSize(src), src->depth, src->nChannels); //构造目标图象 cvResize(src, dst); //缩放源图像到目标图像 RecDect *rd=new RecDect(dst); //声明对象 rd->RfindSquaresRect(0.1f,0.81f);//第一次调用,获取图像轮廓定点坐标:此步获取图像大概位置,然后进行区域选择 /*此时已经获得pt,进行区域截取并对歪掉图像进行旋转*/ rd->AreaRotate(); //cvShowImage("dfdf",rd->img); int angle=rd->recognVersion(rd->findSquares4() );//位置探测图形提取并计算版本号,angle为矫正正确位置的角度 if(angle!=0){//这是为旋转不到位的图像准备的 rd->FitRotate(rd->img,angle); rd->FitRotate(rd->img0,angle); rd->RfindSquaresRect(0.36f,0.9);//获取图像轮廓定点坐标:此步获取图像大概位置,chongxin dingweidingdian pt weizhi,keyi youhua ,xianzai meishijian angle=rd->recognVersion(rd->findSquares4() );//位置探测图形提取并计算版本号 } //rd->drawSquares(); IplImage * loadImage=rd->drawGrid(); if(loadImage==NULL){ // MessageBox(_T("红外QR码转化过程出错"),_T("QR码识别")); cvReleaseImage( &src ); ////释放图像 cvReleaseImage( &dst ); LPWSTR QRstring1=_T("识别过程出现异常"); return QRstring1; } cvSaveImage(fileName,loadImage); QR_image = new QRcodeImage(loadImage); //cvReleaseImage(&loadImage); QR_image->GetImageData(); m_nVersion = QR_image->finderPattern->m_version; m_nCodeSize = m_nVersion * 4 +17; for(int i=0;i<m_nCodeSize;i++) for(int j=0;j<m_nCodeSize;j++) m_CodeData[i][j]=QR_image->bitMatrix[i][j]; //解码 QR_Decode = new ContentDecoder; QR_Decode->DecodeData(m_nCodeSize,m_nVersion,m_CodeData); QRstring=(QR_Decode->m_strData).GetBuffer(QR_Decode->m_strData.GetLength()); //显示结果 //GetDlgItem(IDC_EDIT_TEXT)->SetWindowText(QR_Decode->m_strData);//"由于解码功能尚未完成,暂时无法显示!!!" ; QRversion=QR_Decode->m_nVersion; char str; switch(QR_Decode->m_nLevel) { case QR_LEVEL_L:str='L';break; case QR_LEVEL_M:str='M';break; case QR_LEVEL_Q:str='Q';break; case QR_LEVEL_H:str='H';break; } //GetDlgItem(IDC_STATIC_LEVEL)->SetWindowText("纠错等级:"+str); QRLevel=str; cvReleaseImage( &src ); ////释放图像 cvReleaseImage( &dst ); cvReleaseImage( &loadImage ); return QRstring; }catch(...) { LPWSTR QRstring1=_T("识别过程出现异常"); return QRstring1; } }
void graphicalJoystick(int joy_idx, SDL_Joystick *joy, FILE* fichierKernel){ const char* original = "FAJA" ; char key ; CvCapture *capture ; IplImage* cap ; IplImage* cap_resize ; capture = cvCreateCameraCapture(CV_CAP_ANY); if(!capture){ printf("! Error while capturing from camera !\n"); exit(1); } CvFont cross,faja; cvInitFont(&cross,CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, 1,1,0,1,1); cvInitFont(&faja,CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, 1,1,0,2,3); cap = cvQueryFrame(capture); cap_resize = cvCreateImage(cvSize(1366,768), cap->depth, cap->nChannels); cvNamedWindow(original, CV_WINDOW_NORMAL); cvMoveWindow(original, 0, 0); cvSetWindowProperty(original, CV_WND_PROP_FULLSCREEN, CV_WINDOW_FULLSCREEN); int num_axes = SDL_JoystickNumAxes(joy) -1; int num_buttons = SDL_JoystickNumButtons(joy); int num_hats = SDL_JoystickNumHats(joy); FILE* f = NULL; f=fopen("/dev/servoblaster", "w"); if (f == NULL) exit(1); int quit = 0; SDL_Event event; while(!quit) { SDL_Delay(10); bool something_new = false; while (SDL_PollEvent(&event)) { cap = cvQueryFrame(capture); cvPutText (cap,"+",cvPoint(cap->width/2,cap->height/2), &cross, cvScalar(0,255,0,0)); cvPutText (cap,"FAJA - Mode manuel",cvPoint(10,30), &faja, cvScalar(255,0,0,0)); cvResize(cap, cap_resize, CV_INTER_LINEAR); cvShowImage(original, cap_resize); something_new = true; switch(event.type) { case SDL_JOYAXISMOTION: assert(event.jaxis.axis < num_axes+1); axes[event.jaxis.axis] = event.jaxis.value; break; case SDL_JOYBUTTONDOWN: case SDL_JOYBUTTONUP: assert(event.jbutton.button < num_buttons); buttons[event.jbutton.button] = event.jbutton.state; break; case SDL_JOYHATMOTION: assert(event.jhat.hat < num_hats); hats[event.jhat.hat] = event.jhat.value; break; case SDL_QUIT: quit = 1; printf("Recieved interrupt, exiting\n"); break; default: fprintf(stderr, "Error: Unhandled event type: %d\n", event.type); break; } } if (something_new) { //clear(); res = 50+(((-1 * (axes[0])+32768)*190)/65535); fprintf(f,"1=%i\n",(int)res); printf("echo 1=%i > /dev/servoblaster\n", (int) res); fflush(f); res = 50+(((-1 * (axes[1])+32768)*190)/65535); fprintf(f,"0=%i\n", (int)res); printf("echo 0=%i > /dev/servoblaster\n", (int) res); fflush(f); } } } // while
void* captureThread(void* args) { CvCapture* capture = NULL; IplImage* frame; IplImage* frame_copy; IplImage* gray; ChessBoard chess; int pointsPerScene; CvPoint2D32f* points; int pointsNum[1]; CvMat* cornerPoints; CvMat* objectPoints; CvMat pointsNumMat; CvMat* intrinsic = cvCreateMat( 3, 3, CV_64F ); CvMat* distortion = cvCreateMat( 4, 1, CV_64F ); CvMat* rotation = cvCreateMat( 3, 3, CV_64F ); CvMat* translation = cvCreateMat( 3, 1, CV_64F ); loadIntrinsicParams("intrinsic_param_ref.txt", intrinsic, distortion ); capture = cvCreateCameraCapture(0); if(capture == NULL){ fprintf(stderr, "ERROR: Could not open Camera Device\n"); exit(1); } frame = cvQueryFrame(capture); if(frame == NULL){ fprintf(stderr, "ERROR: Could not query frame\n"); exit(1); } frame_copy = cvCreateImage(cvGetSize(frame), frame->depth, 3); gray = cvCreateImage(cvGetSize(frame_copy), frame_copy->depth, 1); cvNamedWindow(captureWinName, CV_WINDOW_AUTOSIZE); cvMoveWindow(captureWinName, graphicsWinWidth + 10, 0); chess.dx = CHESS_ROW_DX; chess.dy = CHESS_COL_DY; chess.patternSize.width = CHESS_ROW_NUM; chess.patternSize.height = CHESS_COL_NUM; pointsPerScene = chess.patternSize.width * chess.patternSize.height; cornerPoints = cvCreateMat(pointsPerScene, 2, CV_32F); objectPoints = cvCreateMat(pointsPerScene, 3, CV_32F); pointsNum[0] = pointsPerScene; pointsNumMat = cvMat(1, 1, CV_32S, pointsNum); points = (CvPoint2D32f*)malloc( sizeof(CvPoint2D32f) * pointsPerScene ); while(1){ int allPointsFound = 0; int detectedPointsNum; frame = cvQueryFrame( capture ); if( !frame ) { fprintf(stderr, "could not query frame\n"); exit(1); } cvResize(frame, frame_copy, CV_INTER_NN); cvCvtColor(frame_copy, gray, CV_BGR2GRAY); if( cvFindChessboardCorners( gray, chess.patternSize, points, &detectedPointsNum, CV_CALIB_CB_ADAPTIVE_THRESH ) ){ cvFindCornerSubPix(gray, points, detectedPointsNum, cvSize(5, 5), cvSize(-1, -1), cvTermCriteria(CV_TERMCRIT_ITER, 100, 0.1)); allPointsFound = 1; } else { allPointsFound = 0; } cvDrawChessboardCorners( frame_copy, chess.patternSize, points, detectedPointsNum, allPointsFound ); if( allPointsFound ){ double cameraPosition[3]; double cameraOriVec[4]; store2DCoordinates( cornerPoints, points, chess, 0 ); store3DCoordinates( objectPoints, chess, 0 ); calibrate( cornerPoints, objectPoints, intrinsic, distortion, rotation, translation ); getCameraPosition(rotation, translation, cameraPosition); printf("cam pos relative to chess board: %.1f, %.1f, %.1f\n", cameraPosition[0], cameraPosition[1], cameraPosition[2]); convertCv2Gl(cameraPosition, transGL); getCameraOriVec(rotation, rotGL); } cvShowImage( captureWinName, frame_copy); if(cvWaitKey(10) == KEY_ESC){ exit(1); } } free(points); cvReleaseMat(&intrinsic); cvReleaseMat(&distortion); cvReleaseMat(&rotation); cvReleaseMat(&translation); cvReleaseMat(&cornerPoints); cvReleaseMat(&objectPoints); cvDestroyWindow(captureWinName); cvReleaseImage(&frame_copy); cvReleaseImage(&gray); cvReleaseCapture(&capture); }
// Main function, defines the entry point for the program. int main( int argc, char** argv ) { int scale = 2; // Structure for getting video from camera or avi CvCapture* capture = 0; // Images to capture the frame from video or camera or from file IplImage *frame = 0, *frame_copy = 0; // Used for calculations int optlen = strlen("--cascade="); // Input file name for avi or image file. const char* input_name; // Check for the correct usage of the command line if( argc > 1 && strncmp( argv[1], "--cascade=", optlen ) == 0 ) { cascade_name = argv[1] + optlen; input_name = argc > 2 ? argv[2] : 0; } else if (strncmp(argv[1], "train", 5) == 0) { learn_eigenfaces(); exit(0); } else if (strncmp(argv[1], "test", 4) == 0) { recognize_eigenfaces(); exit(0); } else { fprintf( stderr, "Usage: facedetect --cascade=\"<cascade_path>\" [filename|camera_index]\n" ); return -1; /*input_name = argc > 1 ? argv[1] : 0;*/ } // Load the HaarClassifierCascade cascade = (CvHaarClassifierCascade*)cvLoad( cascade_name, 0, 0, 0 ); // Check whether the cascade has loaded successfully. Else report and error and quit if( !cascade ) { fprintf( stderr, "ERROR: Could not load classifier cascade\n" ); return -1; } cascade_eyes = (CvHaarClassifierCascade*)cvLoad(cascade_eyes_name, 0, 0, 0 ); if (!cascade_eyes) { fprintf(stderr, "ERROR: failed to load eye classifier cascade\n" ); return -1; } char *ext = strrchr(input_name, '.'); // Allocate the memory storage storage = cvCreateMemStorage(0); // Find whether to detect the object from file or from camera. if( !input_name || (isdigit(input_name[0]) && input_name[1] == '\0') ){ capture = cvCaptureFromCAM( !input_name ? 0 : input_name[0] - '0' ); } else if (ext && strncmp(ext, ".txt", 4) == 0) { capture = NULL; } else capture = cvCaptureFromAVI( input_name ); // Create a new named window with title: result cvNamedWindow( "result", 1 ); // Find if the capture is loaded successfully or not. // If loaded succesfully, then: if( capture ) { // Capture from the camera. for(;;) { // Capture the frame and load it in IplImage if( !cvGrabFrame( capture )) break; frame = cvRetrieveFrame( capture, 0 ); // If the frame does not exist, quit the loop if( !frame ) break; if (!frame_copy) { printf("Allocate image\n"); frame_copy = cvCreateImage(cvSize(frame->width/2,frame->height/2), 8, 3); } cvResize(frame, frame_copy, CV_INTER_LINEAR); //cvCopy(frame, frame_copy,0); // Call the function to detect and draw the face //detect_and_draw( frame_copy ); process_image(frame_copy); //cvShowImage("result", frame_copy); // Wait for a while before proceeding to the next frame cvWaitKey(1); //if( cvWaitKey( 10 ) >= 0 ) // break; } // Release the images, and capture memory cvReleaseImage( &frame_copy ); //cvReleaseImage( &frame_resized ); cvReleaseCapture( &capture ); } // If the capture is not loaded succesfully, then: else { still = 1; // Assume the image to be lena.jpg, or the input_name specified const char* filename = input_name ? input_name : (char*)"lena.jpg"; IplImage* image = NULL; printf("%s\n", filename); if (strncmp(strrchr(filename, '.')+1, "txt", 3) != 0) { // Load the image from that filename image = cvLoadImage( filename, 1 ); // If Image is loaded succesfully, then: //if( image ) //{ // Detect and draw the face //detect_and_draw( image ); process_image(image); // Wait for user input cvWaitKey(0); // Release the image memory cvReleaseImage( &image ); } else { printf("Not an image\n"); /* assume it is a text file containing the list of the image filenames to be processed - one per line */ FILE* f = fopen( filename, "rt" ); if( f ) { char buf[1000+1]; // Get the line from the file while( fgets( buf, 1000, f ) ) { // Remove the spaces if any, and clean up the name int len = (int)strlen(buf); while( len > 0 && isspace(buf[len-1]) ) len--; buf[len] = '\0'; // Load the image from the filename present in the buffer image = cvLoadImage( buf, 1 ); // If the image was loaded succesfully, then: if( image ) { // Detect and draw the face from the image //detect_and_draw( image ); process_image(image); // Wait for the user input, and release the memory cvWaitKey(0); cvReleaseImage( &image ); } } // Close the file fclose(f); } } } // Destroy the window previously created with filename: "result" cvDestroyWindow("result"); // return 0 to indicate successfull execution of the program return 0; }
int main(int argc, char *argv[]) { // Variable to store the keyboard input char d; // Initialize flags to false. These flags are used for keyboard input (keys q, r, g and b) bool Q = false; bool R = false; bool G = false; bool B = false; // Set the capture device. Please change the integer value "0" to appropriate value for the capture device. CvCapture* capture = cvCaptureFromCAM(0); // Allocate memory for all images IplImage *src_img; IplImage *histogram; IplImage *disp_img; IplImage *gray_img; IplImage *red_img, *red_histogram; IplImage *green_img, *green_histogram; IplImage *blue_img, *blue_histogram; // Initialize historgrams int hist_size = 256; float range[] = {0,256}; float *ranges[] = {range}; /* cvCreateHist function is used to create the histograms. Following is the explanation of the various arguments of the function 1. First argument: Defines how many dimensions the histogram will have. To keep things simple this tutorial only uses one dimensional histograms. 2. Second argument: Defines the size of the dimensions. If we were using higher dimensional histograms we would have to pass an array of sizes, one for each dimension, but we are only using one dimension so the array we pass only has one value in it. We choose to make the size of the dimension 256 because the depth of the images we are working with is 8 bit, meaning that we will get one bin for each intensity level. We could have chosen to have less bins but the histogram would have less resolution. We could have chosen more bins but we would not show any more information. 3. Third argument: Tells OpenCV how to store the data in the histogram. There are two options for this: CV_HIST_ARRAY and CV_HIST_SPARSE. The second option is useful for storing multidimensional histograms that will have most of their bins with counts of zero. Since we are using a one dimensional histogram, we don’t expect sparse data so we choose the first option. 4. Fourth argument: Used to specify the range of values for each dimension. Each range is stored as an array of two values, the minimum and maximum value for that dimension. Again we are using one dimension so it looks a bit redundant to make an array of arrays, but only with one array. We have to do this though, because this fourth argument expects an array to 2 value arrays. It is important to know how OpenCV creates the bins based on the range values and the histogram size. OpenCV will take the value supplied in ranges and break it into as many sub intervals as defined in hist_size. 5. Fifth argument: Defines if the sub intervals are to be split uniformly or not. For this case we definitely want each bin to be the same width as the others so we choose this argument to be 1. */ CvHistogram* hist_red = cvCreateHist(1, &hist_size, CV_HIST_ARRAY, ranges, 1); CvHistogram* hist_blue = cvCreateHist(1, &hist_size, CV_HIST_ARRAY, ranges, 1); CvHistogram* hist_green = cvCreateHist(1, &hist_size, CV_HIST_ARRAY, ranges, 1); double max_value = 0; double max_value_red = 0; double max_value_green = 0; double max_value_blue = 0; double find_max = 0; // Create the windows // "mainWin" shows the actual captured image cvNamedWindow("mainWin", CV_WINDOW_AUTOSIZE); cvMoveWindow("mainWin", 5, 5); // "histogramWin" shows the histogram cvNamedWindow("histogramWin", CV_WINDOW_AUTOSIZE); cvMoveWindow("histogramWin", 435, 5); // Print instructions for keyboard input printf("RGB Histogram\n\n"); printf("To toggle red channel ON/OFF press: 'r'\n"); printf("To toggle green channel ON/OFF press: 'g'\n"); printf("To toggle blue channel ON/OFF press: 'b'\n"); printf("To quit press: 'q'\n"); // Do the following inside while loop forever while(1) { // Clear all max values to 0 max_value = 0; max_value_red = 0; max_value_green = 0; max_value_blue = 0; // Load a bmp image with the histogram axis. Instead of having OpenCV draw the axis, the axis is drawn in paint and then loaded as an image. // You can download the picture here: http://uowteaminvincible.files.wordpress.com/2010/02/histogram_scale.png // Be sure to change the path below to wherever you choose to save the image. Also use \\ instead of \ to separate directories. histogram = cvLoadImage( "histogram_scale.png" ); // Initialize three images that will show each histogram red_histogram = cvCreateImage( cvGetSize(histogram), IPL_DEPTH_8U, 3 ); green_histogram = cvCreateImage( cvGetSize(histogram), IPL_DEPTH_8U, 3 ); blue_histogram = cvCreateImage( cvGetSize(histogram), IPL_DEPTH_8U, 3 ); // Get the source frame by querying the capture and resize it for display src_img=cvQueryFrame(capture); disp_img = cvCreateImage(cvSize((src_img->width)/1.6,(src_img->height)/1.6),IPL_DEPTH_8U,3); cvResize(src_img,disp_img,CV_INTER_LINEAR); // Create 3 single channel images to store each channels data and split the source image into the RGB channels. /* Note that each channel is given an image with the same size (width and height) as the source. The depth is 8 bits and these new images have only one channel (since they are storing only one channel). The function cvCvtPixToPlane actually separates the source into its three channels and stores them in the images we just created.*/ blue_img = cvCreateImage( cvGetSize(src_img), IPL_DEPTH_8U, 1 ); green_img = cvCreateImage( cvGetSize(src_img), IPL_DEPTH_8U, 1 ); red_img = cvCreateImage( cvGetSize(src_img), IPL_DEPTH_8U, 1 ); cvCvtPixToPlane( src_img, blue_img, green_img, red_img, 0 ); // Calculate a histogram for each channel. /*The first argument takes the image we would like to calculate the histogram for. Note that cvCalcHist can only take a one channel image. The next argument says which histogram will be populated. The third argument turns on or off accumulator mode. Since we want the histogram to update for each frame we want to clear the contents before adding new ones and the accumulator mode should be off. The final parameter is a mask that can tell cvCalcHist to unly calculate a certain part of the image. By setting the mask null we calculate for the whole image.*/ cvCalcHist( &red_img, hist_red, 0, NULL ); cvCalcHist( &blue_img, hist_blue, 0, NULL ); cvCalcHist( &green_img, hist_green, 0, NULL ); // Search through the histograms for their maximum value and store it. /* The code for finding the maximum value for the red channel is shown above. The other two channels are very similar and shown in the source code. It is done with a simple for loop that checks every value in each bin. The function used to get the values out of the histogram is cvQueryHistValue_1D. This function is made for getting values out of a one dimensional histogram. Its arguments are the histogram you want to look into, and the bin number you want to see. The reason we need to find this max value is that we will scale the y-axis of the histogram so that it fits on the screen. We do this by dividing each bin value by the max value (this is done in the next step).*/ for( int i = 0; i < hist_size; i++ ) { find_max = cvQueryHistValue_1D(hist_red,i); if (find_max > max_value_red) { max_value_red = find_max; } } for( int i = 0; i < hist_size; i++ ) { find_max = cvQueryHistValue_1D(hist_green,i); if (find_max > max_value_green) { max_value_green = find_max; } } for( int i = 0; i < hist_size; i++ ) { find_max = cvQueryHistValue_1D(hist_blue,i); if (find_max > max_value_blue) { max_value_blue = find_max; } } // The largest value in all the histograms is found. max_value = max(max(max_value_red,max_value_green),max_value_blue); // Draw the histogram for each channel, if the flag for that channel is set /* First we see an if statement that controls whether or not we draw the histogram. It is based on a flag that is set in the next step by user input. This allows the user to select which channel or combination of channels that they want to see. The next step is the scaling. The function cvScale is used. Its first argument is the source to be scaled and the second is the destination for result. Here we used the same place for source and destination meaning that the bins are scaled and then stored back in the same place. The last argument is the scale factor. A factor of 438/max_value was used because the highest bar that we want to draw is 438 pixels high (so it does not go out of the bounds of the picture we used for the axis). Inside the for loop we see a complicated line of code that draws all the rectangles. The function cvRectangle is used for this. It requires that we pass it which image to draw on, two points to define the rectangles, the colour and line thickness. We specify line thickness as -1 which means a filled rectangle. The last function used is cvAdd which is used to simplify drawind the multiple histograms with overlap. By adding colours on top of each other no extar code is required to deal with the overlap.*/ if (R) { cvScale( hist_red->bins, hist_red->bins, 438/max_value); for( int i= 0; i < hist_size; i++ ) { cvRectangle( red_histogram, cvPoint(i*3+ 15, 448),cvPoint(i*3+16, 448 - cvRound(cvQueryHistValue_1D(hist_red,i))),cvScalar(0x00,0x00,0xff,0), -1); } cvAdd(histogram,red_histogram,histogram,0); } if (G) { cvScale( hist_green->bins, hist_green->bins, 438/max_value); for( int i= 0; i < hist_size; i++ ) { cvRectangle( green_histogram, cvPoint(i*3+ 15, 448),cvPoint(i*3+16, 448 - cvRound(cvQueryHistValue_1D(hist_green,i))),cvScalar(0x00,0xff,0x00,0), -1); } cvAdd(histogram,green_histogram,histogram,0); } if (B) { cvScale( hist_blue->bins, hist_blue->bins, 438/max_value); for( int i= 0; i < hist_size; i++ ) { cvRectangle( blue_histogram, cvPoint(i*3+ 15, 448),cvPoint(i*3+16, 448 - cvRound(cvQueryHistValue_1D(hist_blue,i))),cvScalar(0xff,0x00,0x00,0), -1); } cvAdd(histogram,blue_histogram,histogram,0); } // Show the images in the windows cvShowImage("mainWin", disp_img); cvShowImage("histogramWin", histogram); // Set flags d=cvWaitKey(15); /* A simple case statement takes the input from the keyboard and sets the flags accordingly. The R, G and B flags are XOR’ed with 1 to change state each time r, g, or b is pressed. This makes r g and b into toggle switches.*/ switch (d) { case 'r': R = R^1; break; case 'g': G = G^1; break; case 'b': B = B^1; break; case 'q': Q = true; break; default: break; } if(Q)break; //quit program // Release the images that we created cvReleaseImage(&disp_img ); cvReleaseImage(&red_img ); cvReleaseImage(&green_img ); cvReleaseImage(&blue_img ); cvReleaseImage(&red_histogram ); cvReleaseImage(&green_histogram ); cvReleaseImage(&blue_histogram ); cvReleaseImage(&histogram ); } return 0; }
void detect_and_draw( IplImage* img, CvRect* found_face, CvSize sz ) { static CvRect prev; if(!gray) { gray = cvCreateImage( cvSize(img->width,img->height), 8, 1 ); small_img = cvCreateImage( cvSize( cvRound (img->width/scale), cvRound (img->height/scale)), 8, 1 ); } if(prev.width > 0 && prev.height > 0) { cvSetImageROI(small_img, prev); CvRect tPrev = cvRect(prev.x * scale, prev.y * scale, prev.width * scale, prev.height * scale); cvSetImageROI(img, tPrev); cvSetImageROI(gray, tPrev); } else { cvResetImageROI(img); cvResetImageROI(small_img); cvResetImageROI(gray); } cvCvtColor( img, gray, CV_BGR2GRAY ); cvResize( gray, small_img, CV_INTER_LINEAR ); cvEqualizeHist( small_img, small_img ); cvClearMemStorage( storage ); // for(i=0;i<10;i++) { // double t = (double)cvGetTickCount(); CvSeq* faces = mycvHaarDetectObjects( small_img, cascade, storage, 1.2, 0, 0 |CV_HAAR_FIND_BIGGEST_OBJECT |CV_HAAR_DO_ROUGH_SEARCH //|CV_HAAR_DO_CANNY_PRUNING //|CV_HAAR_SCALE_IMAGE ,sz); //cvSize(30, 30) ); // t = (double)cvGetTickCount() - t; // printf( "detection time = %gms, faces: %d\n", t/((double)cvGetTickFrequency()*1000.), faces->total ); if(faces->total>0) { CvRect* r = (CvRect*)cvGetSeqElem( faces, 0 ); int startX,startY; if(prev.width > 0 && prev.height > 0) { r->x += prev.x; r->y += prev.y; } startX = MAX(r->x - PAD_FACE,0); startY = MAX(r->y - PAD_FACE,0); int w = small_img->width - startX - r->width - PAD_FACE_2; int h = small_img->height - startY - r->height - PAD_FACE_2; int sw = r->x - PAD_FACE, sh = r->y - PAD_FACE; prev = cvRect(startX, startY, r->width + PAD_FACE_2 + ((w < 0) ? w : 0) + ((sw < 0) ? sw : 0), r->height + PAD_FACE_2 + ((h < 0) ? h : 0) + ((sh < 0) ? sh : 0)); // printf("found face (%d,%d,%d,%d) setting ROI to (%d,%d,%d,%d)\n",r->x,r->y,r->width,r->height,prev.x,prev.y,prev.width,prev.height); found_face->x = (int)((double)r->x * scale); found_face->y = (int)((double)r->y * scale); found_face->width = (int)((double)r->width * scale); found_face->height = (int)((double)r->height * scale); } else { prev.width = prev.height = found_face->width = found_face->height = 0; } }