int main() { CvPoint pt1,pt2; CvRect regt; CvPoint 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; 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( 0 ); 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 IplImage* frame = cvQueryFrame( capture ); if ( !frame ) { fprintf( stderr, "ERROR: frame is null...\n" ); getchar(); break; } int modfheight, modfwidth; modfheight = frame->height; modfwidth = frame->width; // create modified frame with 1/4th the original size IplImage* modframe = cvCreateImage(cvSize((int)(modfwidth/4),(int)(modfheight/4)),frame->depth,frame->nChannels); //cvCreateImage(size of frame, depth, noofchannels) cvResize(frame, modframe,CV_INTER_LINEAR); // create HSV(Hue, Saturation, Value) frame IplImage* hsvframe = cvCreateImage(cvGetSize(modframe),8, 3); cvCvtColor(modframe, hsvframe, CV_BGR2HSV); //cvCvtColor(input frame,outputframe,method) // create a frame within threshold. IplImage* threshframe = cvCreateImage(cvGetSize(hsvframe),8,1); cvInRangeS(hsvframe,cvScalar(10, 180, 130),cvScalar(40, 240, 245),threshframe); //cvInRangeS(input frame, cvScalar(min range),cvScalar(max range),output frame) // created dilated image IplImage* dilframe = cvCreateImage(cvGetSize(threshframe),8,1); cvDilate(threshframe,dilframe,NULL,2); //cvDilate(input frame, output frame, mask, number of times to dilate) CBlobResult blobs; blobs = CBlobResult(dilframe,NULL,0); // CBlobresult(inputframe, mask, threshold) Will filter all white parts of image blobs.Filter(blobs,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; blobs.GetNthBlob(CBlobGetArea(),0,biggestblob); //GetNthBlob(criteria, number, output) Get only the largest blob based on CblobGetArea() // get 4 points to define the rectangle pt1.x = biggestblob.MinX()*4; pt1.y = biggestblob.MinY()*4; pt2.x = biggestblob.MaxX()*4; pt2.y = biggestblob.MaxY()*4; cir_center.x=(pt1.x+pt2.x)/2; cir_center.y=(pt1.y+pt2.y)/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,pt1,pt2,cvScalar(255,0,0),1,8,0); // draw rectangle around the biggest blob cvCircle( frame, 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 (cir_center.x!=0&&cir_center.y!=0){ spinsize=sqrt((cir_center.x-frame_center.x)*(cir_center.x-frame_center.x) +(cir_center.y-frame_center.y)*(cir_center.y-frame_center.y)); angle = atan2((double)cir_center.y-frame_center.y,(double)cir_center.x-frame_center.x); //printf("%f, %f \n",angle*180/3.1416,spinsize/10); temp.x=(int)(frame_center.x+spinsize/5*cos(angle+3.1416/4)); temp.y=(int)(frame_center.y+spinsize/5*sin(angle+3.1415/4)); cvLine(frame, temp, frame_center,cvScalar(0,255,0),1,8,0); temp.x=(int)(frame_center.x+spinsize/5*cos(angle-3.1416/4)); temp.y=(int)(frame_center.y+spinsize/5*sin(angle-3.1415/4)); cvLine(frame, temp, frame_center,cvScalar(0,255,0),1,8,0); cvLine(frame, cir_center, frame_center,cvScalar(0,255,0),1,8,0); sendBuf=88; write(serial, &sendBuf,1); sendBuf=cir_center.x; write(serial, &sendBuf,1); sendBuf=89; write(serial, &sendBuf,1); sendBuf=cir_center.y; write(serial, &sendBuf,1); //printf("%d %d %f\n",cir_center.x,cir_center.y, angle*180/3.1415); //sendvalue(serial, angle*180/3.1416); //cvCircle( frame, frame_center, cir_radius, cvScalar(0,255,255), 2, 8, 0 ); } cvShowImage( "mywindow", frame); // show output image // 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; }
/* ** ================ BEGIN MAIN SECTION ======================= */ void camera_capture( int argc, char** argv ) { double t1, t2, t3, t4, fps; int targ_selected = 0; int camera_img_height, camera_img_width, camera_img_fps; int waitkey_delay = 2; CvMat *image_gray = 0; CvMat *image_binary = 0; IplConvKernel *morph_kernel; CvSeq *contours; int i; CvSize imgSize; CvVideoWriter *writer; /* ** See if we can catch signals */ if ( signal(SIGTERM, sig_handler) == SIG_IGN) signal(SIGTERM, SIG_IGN); if ( signal(SIGHUP, sig_handler) == SIG_IGN) signal(SIGHUP, SIG_IGN); if ( signal(SIGINT, sig_handler) == SIG_IGN) signal(SIGINT, SIG_IGN); /* ** Capture images from webcam /dev/video0 ** /dev/video0 = 0 ** /dev/video1 = 1 */ if ( argc == 1 || (argc == 2 && strlen(argv[1]) == 1 && isdigit(argv[1][0]))) { printf(" Capturing image from camera\n"); camera=cvCaptureFromCAM( argc == 2 ? argv[1][0] - '0' : 0 ); } else { /* ** Capture image from file at command line ** useful for playback video and testing */ camera = cvCaptureFromFile( argv[1] ); } /* ** Check and see if camera/file capture is valid */ if (!camera) { printf("camera or image is null\n"); return; } /* ** Get camera properties */ camera_img_width = cvGetCaptureProperty(camera, CV_CAP_PROP_FRAME_WIDTH); camera_img_height = cvGetCaptureProperty(camera, CV_CAP_PROP_FRAME_HEIGHT); camera_img_fps = cvGetCaptureProperty(camera, CV_CAP_PROP_FPS); cvSetCaptureProperty( camera, CV_CAP_PROP_EXPOSURE, 500.0); cvSetCaptureProperty( camera, CV_CAP_PROP_EXPOSURE, 500.0); cvSetCaptureProperty( camera, CV_CAP_PROP_AUTO_EXPOSURE, 0.0); imgSize.width = camera_img_width; imgSize.height = camera_img_height; /* ** Parse the config file */ T456_parse_vision( "../config/t456-vision.ini" ); T456_print_camera_and_tracking_settings(); /* ** Start server listening on port 8080 */ T456_start_server(); printf("camera_img_fps: %d\n", camera_img_fps); if (camera_img_fps < 0 ) { camera_img_fps = 30; printf("camera_img_fps: %d\n", camera_img_fps); } pid = (int) getpid(); sprintf(filename,"/home/panda/Videos/pts_out_%05d.mjpg",pid); writer = cvCreateVideoWriter( filename, CV_FOURCC('M','J','P','G'), // CV_FOURCC('Y','U','Y','2'), // CV_FOURCC('A','V','I'), camera_img_fps, imgSize, 1 ); /* ** Time estimation variable */ t1 = (double)cvGetTickCount(); /* ** Process images until key press */ while (1) { /* ** Grab initial frame from image or movie file */ image = cvQueryFrame(camera); if ( !image ) { done(); return; } cvWriteFrame(writer, image); /* ** pass selected target information into target message ** for the webservice */ target_message_length = snprintf(target_message, sizeof(target_message), "%06d,-99,000000,000000,000000,0000", frame_cnt); /* ** keep time of processing */ t2 = (double)cvGetTickCount(); fps = 1000.0 / ((t2-t1)/(cvGetTickFrequency()*1000.)); fps_sum = fps_sum + fps; frame_cnt++; if ( (frame_cnt % 30) == 0 ) printf("frame: %d time: %gms fps: %.2g\n", frame_cnt, (t2-t1)/(cvGetTickFrequency()*1000.),fps); t1 = t2; /* ** If we catch a stop or kill signal */ if ( STOP ) { break; } } /* ** Release camera resources */ cvReleaseVideoWriter(&writer); cvReleaseCapture(&camera); /* ** Print out timing information */ done(); /* ** Stop server listening on port 8080 */ T456_stop_server(); }
/*! Stop the acquisition of images and free the camera. */ void vpOpenCVGrabber::close() { init = false; cvReleaseCapture( &capture ); capture = NULL; }
Capture::~Capture() { cvReleaseCapture(&capture); }
int main(int argc, char **argv) { int i,index=0; int width_img=0; // Frame width int height_img=0; // Frame height double fps=0.0; // FPS (Frames Per Second) int frame=0; // Frame number (index) int msec; int total_frames=0; // Total frames int marked_frames=0; // Marked frame int *check_frames; // Contains indeces of marked frames int *list_of_frames; // List of frames double *ecr; IplImage *previous_frame; // Previous frame IplImage *current_frame; // Current frame IplImage *bgr_frame; // Frame IplImage *new_frame; // Frame CvCapture* capture=0; // Capture struct CvSize size; // Size of frame (width x height) FILE *fp; // TXT file pointer clock_t start, stop, diff; // Timer // Text variables CvScalar black = CV_RGB(255,0,0); CvFont font1; int thickness = 2.0; char text1[20] = "0"; // frame number char text2[20] = "0"; // frame msec positiion double hscale = 1.0; double vscale = 1.0; double shear = 0.0; // Check if the user gave arguments if(argc != 4) { fprintf(stderr, "\nUSAGE: %s <input_video_file> <output_video_file> <output_TXT_file>\n", argv[0]); return EXIT_FAILURE; } /**** STAGE 1: PROCESS FRAMES ****/ capture = cvCreateFileCapture(argv[1]); // Open video file to start capture if(!capture) { printf("Error opening video file! (cvCreateFileCapture)\n"); return EXIT_FAILURE; } fp=fopen(argv[3],"w"); // Open file to write stats if(fp == NULL) { printf("Error opening file! (fopen)\n"); return EXIT_FAILURE; } fps = cvGetCaptureProperty(capture,CV_CAP_PROP_FPS); // Get FPS width_img = cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH); // Get frame width height_img = cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT); // Get frame height total_frames = cvGetCaptureProperty(capture,CV_CAP_PROP_FRAME_COUNT); // Get total frames size = cvSize(width_img,height_img); // Get size of frames check_frames = (int *)malloc(sizeof(*check_frames) * total_frames); list_of_frames = (int *)malloc(sizeof(*list_of_frames) * total_frames); ecr = (double *)malloc(sizeof(*ecr) * total_frames); if (check_frames == NULL || list_of_frames == NULL || ecr == NULL) { printf("Error allocating memory!\n"); return EXIT_FAILURE; } // Initialize arrays for(i=0;i<total_frames;i++) { ecr[i]=0.0; check_frames[i]=0; list_of_frames[i]=0; } cvInitFont(&font1,CV_FONT_HERSHEY_SIMPLEX,hscale,vscale,shear,thickness,CV_AA); CvPoint pt1 = cvPoint(5,30); CvPoint pt2 = cvPoint(5,70); fprintf(fp,"Filename\t:\t%s\n\nFrame width\t:\t%d\nFrame height\t:\t%d\nFPS\t\t:\t%f\nTotal frames\t:\t%d\n\n\n\n",argv[1],width_img,height_img,fps,total_frames); printf("Filename\t:\t%s\n\nFrame width\t:\t%d\nFrame height\t:\t%d\nFPS\t\t:\t%f\nTotal frames\t:\t%d\n\n\n\n",argv[1],width_img,height_img,fps,total_frames); printf("Start processing frames...\n\n"); start = clock(); // Start timer bgr_frame=cvQueryFrame(capture); // Grab first frame previous_frame = cvCreateImage(size, bgr_frame->depth, bgr_frame->nChannels); // Create the previous frame current_frame = cvCreateImage(size, bgr_frame->depth, bgr_frame->nChannels); // Create the current frame cvCopy(bgr_frame,previous_frame,NULL); // Save the copy // Grab frames from the video until NULL while((bgr_frame=cvQueryFrame(capture)) != NULL) { /* When entering this loop, we have already grabbed a frame * so the frame counter starts from 2 */ frame = cvGetCaptureProperty(capture,CV_CAP_PROP_POS_FRAMES); // Get the current frame number cvCopy(bgr_frame,current_frame,NULL); // Save the copy /**** START PROCESSING ****/ ecrdiff_v2(current_frame, previous_frame, size, frame, fp, &index); /**** END PROCESSING ****/ cvCopy(bgr_frame,previous_frame,NULL); // Save the copy if(index==1) { check_frames[frame]=1; // It means that the specific frame is marked } printf("Processing frame %d...\r",frame); fflush(stdout); } cvReleaseImage(&bgr_frame); // Release bgr_frame cvReleaseImage(&previous_frame); // Release previous_frame cvReleaseImage(¤t_frame); // Release current_frame cvReleaseCapture(&capture); // Release capture stop = clock(); // Stop timer diff = stop - start; // Get difference between start time and current time; printf("\n\nTotal time processing frames : %f minutes\t%f seconds\n", (((float)diff)/CLOCKS_PER_SEC)/60, ((float)diff)/CLOCKS_PER_SEC); printf("Processing completed!\n"); fprintf(fp,"\n\n\n\nMarked frames\n\n"); printf("\n\n\n\nMarked frames\n\n"); for(i=0;i<total_frames;i++) { if(check_frames[i]==1) { list_of_frames[i]=i; fprintf(fp,"frame %d\n",i); // Write to file only marked frames printf("frame %d\n",i); // Write to file only marked frames marked_frames++; } } fprintf(fp,"\n\nTotal marked frames\t:\t%d\n",marked_frames); printf("\n\nTotal marked frames\t:\t%d\n\n",marked_frames); //If there is no markeed frames, exit if(marked_frames == 0) { return EXIT_SUCCESS; } /**** STAGE 2: WRITE VIDEO ****/ capture = cvCreateFileCapture(argv[1]); // Re-Open video file to start capture if(!capture) { printf("Error opening video file! (cvCreateFileCapture)\n"); return EXIT_FAILURE; } CvVideoWriter *writer = cvCreateVideoWriter(argv[2],CV_FOURCC('F','M','P','4'),fps,size,1); printf("Start writing frames...\n\n"); start = clock(); // Start timer bgr_frame = cvQueryFrame(capture); // Retrieve frame new_frame = cvCreateImage(size, bgr_frame->depth, bgr_frame->nChannels); // Create the new frame do { frame = cvGetCaptureProperty(capture,CV_CAP_PROP_POS_FRAMES); // Get the current frame number msec = cvGetCaptureProperty(capture,CV_CAP_PROP_POS_MSEC); msec=msec/1000; // If the index number of the current frame is equal to the frame we want, then write it to the stream. if(frame == list_of_frames[frame]) { cvCopy(bgr_frame,new_frame,NULL); // Save the copy sprintf(text1,"%d frame",frame); // int to char via sprintf() cvPutText(new_frame,text1,pt1,&font1,black); // frame number sprintf(text2,"%d sec",msec); // int to char via sprintf() cvPutText(new_frame,text2,pt2,&font1,black); // frame msec position cvWriteFrame(writer, new_frame); // Write frame to video stream } else { cvWriteFrame(writer, new_frame); // Write frame to video stream } printf("Writing frame %d...\r",frame); fflush(stdout); // For '/r' to work we have to flush the output stream } while((bgr_frame=cvQueryFrame(capture)) != NULL); stop = clock(); // Stop timer diff = stop - start; // Get difference between start time and current time; printf("\n\nTotal time writing frames : %f minutes\t%f seconds\n", (((float)diff)/CLOCKS_PER_SEC)/60, ((float)diff)/CLOCKS_PER_SEC); printf("Writing completed!\n\n"); fclose(fp); // Close file pointer free(list_of_frames); // Free list_of_frames free(check_frames); // Free check_frames free(ecr); // Free ecr cvReleaseImage(&bgr_frame); // Release bgr_frame cvReleaseImage(&new_frame); // Release new_frame cvReleaseCapture(&capture); // Release capture return EXIT_SUCCESS; }
int main() { // Initialize capturing live feed from the camera CvCapture* capture = 0; capture = cvCaptureFromCAM(1); //depending on from which camera you are Capturing // Couldn't get a device? Throw an error and quit if(!capture) { printf("Could not initialize capturing...\n"); return -1; } // The two windows we'll be using cvNamedWindow("video"); cvNamedWindow("thresh"); // This image holds the "scribble" data... // the tracked positions of the ball IplImage* imgScribble = NULL; // An infinite loop while(true) { // Will hold a frame captured from the camera IplImage* frame = 0; frame = cvQueryFrame(capture); // If we couldn't grab a frame... quit if(!frame) break; // If this is the first frame, we need to initialize it if(imgScribble == NULL) { imgScribble = cvCreateImage(cvGetSize(frame), 8, 3); } // Holds the yellow thresholded image (yellow = white, rest = black) IplImage* imgYellowThresh = GetThresholdedImage(frame); // Calculate the moments to estimate the position of the ball CvMoments *moments = (CvMoments*)malloc(sizeof(CvMoments)); cvMoments(imgYellowThresh, moments, 1); // The actual moment values double moment10 = cvGetSpatialMoment(moments, 1, 0); double moment01 = cvGetSpatialMoment(moments, 0, 1); double area = cvGetCentralMoment(moments, 0, 0); // Holding the last and current ball positions static int posX = 0; static int posY = 0; int lastX = posX; int lastY = posY; posX = moment10/area; posY = moment01/area; // Print it out for debugging purposes printf("position (%d,%d)\n", posX, posY); // We want to draw a line only if its a valid position if(lastX>0 && lastY>0 && posX>0 && posY>0) { // Draw a yellow line from the previous point to the current point cvLine(imgScribble, cvPoint(posX, posY), cvPoint(lastX, lastY), cvScalar(0,255,255), 5); } // Add the scribbling image and the frame... and we get a combination of the two cvAdd(frame, imgScribble, frame); cvShowImage("thresh", imgYellowThresh); cvShowImage("video", frame); // Wait for a keypress int c = cvWaitKey(10); if(c!=-1) { // If pressed, break out of the loop break; } // Release the thresholded image... we need no memory leaks.. please cvReleaseImage(&imgYellowThresh); delete moments; } // We're done using the camera. Other applications can now use it cvReleaseCapture(&capture); return 0; }
int mainMatch(void) { // Initialise capture device CvCapture* capture = cvCaptureFromCAM( CV_CAP_ANY ); if(!capture) error("No Capture"); // Declare Ipoints and other stuff IpPairVec matches; IpVec ipts, ref_ipts; // This is the reference object we wish to find in video frame // Replace the line below with IplImage *img = cvLoadImage("Images/object.jpg"); // where object.jpg is the planar object to be located in the video IplImage *img = cvLoadImage("Images/object.jpg"); if (img == NULL) error("Need to load reference image in order to run matching procedure"); CvPoint src_corners[4] = {{0,0}, {img->width,0}, {img->width, img->height}, {0, img->height}}; CvPoint dst_corners[4]; // Extract reference object Ipoints surfDetDes(img, ref_ipts, false, 3, 4, 3, 0.004f); drawIpoints(img, ref_ipts); showImage(img); // Create a window cvNamedWindow("OpenSURF", CV_WINDOW_AUTOSIZE ); // Main capture loop while( true ) { // Grab frame from the capture source img = cvQueryFrame(capture); // Detect and describe interest points in the frame surfDetDes(img, ipts, false, 3, 4, 3, 0.004f); // Fill match vector getMatches(ipts,ref_ipts,matches); // This call finds where the object corners should be in the frame if (translateCorners(matches, src_corners, dst_corners)) { // Draw box around object for(int i = 0; i < 4; i++ ) { CvPoint r1 = dst_corners[i%4]; CvPoint r2 = dst_corners[(i+1)%4]; cvLine( img, cvPoint(r1.x, r1.y), cvPoint(r2.x, r2.y), cvScalar(255,255,255), 3 ); } for (unsigned int i = 0; i < matches.size(); ++i) drawIpoint(img, matches[i].first); } // Draw the FPS figure drawFPS(img); // Display the result cvShowImage("OpenSURF", img); // If ESC key pressed exit loop if( (cvWaitKey(10) & 255) == 27 ) break; } // Release the capture device cvReleaseCapture( &capture ); cvDestroyWindow( "OpenSURF" ); return 0; }
public:void principal() { CvCapture* capture = 0; IplImage *frame, *frame_copy = 0; IplImage *frameAnterior; cascade = (CvHaarClassifierCascade*)cvLoad(cascadeFile, 0, 0, 0 ); if( !cascade ) { fprintf( stderr,"ERROR: Could not load classifier cascade\n" ); } storageHaart = cvCreateMemStorage(0); capture = cvCaptureFromAVI(aviFile); cvNamedWindow( "Detecta", 1 ); cvNamedWindow( "bluedetect", 1 ); cvNamedWindow( "onlyhaart", 1 ); if (capture) { for(int c=0; c<1; c++) { if( !cvGrabFrame( capture )) break; frame = cvRetrieveFrame( capture ); CvSize size = cvSize(frame->width,frame->height); // get current frame size if( !frame ) break; if( !frame_copy ) { frame_copy = cvCreateImage(size, IPL_DEPTH_8U, frame->nChannels ); frameAnterior = cvCreateImage(size, IPL_DEPTH_8U, frame->nChannels ); } if( frame->origin == IPL_ORIGIN_TL ) { cvCopy( frame, frame_copy, 0 ); } else { cvFlip( frame, frame_copy, 0 ); } if( cvWaitKey( 10 ) >= 0 ){ break; } if( !mhi) { if( buf == 0 ) { buf = (IplImage**)malloc(N*sizeof(buf[0])); memset( buf, 0, N*sizeof(buf[0])); } for(int i = 0; i < N; i++ ) { cvReleaseImage( &buf[i] ); buf[i] = cvCreateImage( size, IPL_DEPTH_8U, 1 ); cvZero( buf[i] ); } cvReleaseImage( &mhi ); cvReleaseImage( &orient ); cvReleaseImage( &segmask ); cvReleaseImage( &mask ); mhi = cvCreateImage( size, IPL_DEPTH_32F, 1 ); cvZero( mhi ); // clear MHI at the beginning orient = cvCreateImage( size, IPL_DEPTH_32F, 1 ); segmask = cvCreateImage( size, IPL_DEPTH_32F, 1 ); mask = cvCreateImage( size, IPL_DEPTH_8U, 1 ); } detect_and_draw(frame_copy, frameAnterior); } cvReleaseImage( &frame_copy ); cvReleaseImage( &frameAnterior ); cvReleaseCapture( &capture ); } cvDestroyWindow("Detecta"); cvDestroyWindow("bluedetect"); cvDestroyWindow("onlyhaart"); }
void THISCLASS::OnStop() { if (mCapture) { cvReleaseCapture(&mCapture); } }
int main( int argc, char** argv ) # { # CvCapture *capture; # int key; # # /* 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 ); # # /* create a window and install mouse handler */ # cvNamedWindow( "video", CV_WINDOW_AUTOSIZE ); # cvSetMouseCallback( "video", mouseHandler, NULL ); # # while( key != 'q' ) { # /* 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(); # # /* display frame */ # cvShowImage( "video", frame ); # # /* exit if user press 'q' */ # key = cvWaitKey( 1 ); # } # # /* free memory */ # cvDestroyWindow( "video" ); # cvReleaseCapture( &capture ); # cvReleaseImage( &tpl ); # cvReleaseImage( &tm ); # # return 0; # }
void camera_contours_display(int num, Straightener & straight) { int c; IplImage* color_img; CvCapture* cv_cap = cvCaptureFromCAM(num); cvNamedWindow("Video", 0); // create window resizeWindow("Video", 700,700); for(;;) { color_img = cvQueryFrame(cv_cap); // get frame if(color_img != 0) { Mat cam_mat(color_img); Mat result; cam_mat.copyTo(result); if(straight.doAll(cam_mat, result)) { ///Apply blur blur(result, result, Size(3,3)); ///Apply Canny to destination Matrix Canny(result, result, 50, 50, 3); /// Vectors for storing contours vector<vector<Point> > contours; //contours of the paper sheet vector<vector<Point> > approx_contours; //approx contours of the paper sheet vector<Vec4i> hierarchy; int erosion_type = 2; int erosion_size = 3; Mat element = getStructuringElement(erosion_type, Size( 2*erosion_size + 1, 2*erosion_size+1), Point( erosion_size, erosion_size)); dilate(result, result, element); /// Cut 20 px from each side to avoid paper borders detection result = result(Rect(10, 10, result.cols-20, result.rows-20)); findContours(result, contours, hierarchy, CV_RETR_CCOMP, CV_CHAIN_APPROX_NONE, Point(0, 0)); /// Draw contours Mat drawing = Mat::zeros( result.size(), CV_8UC3 ); /// https://github.com/Itseez/opencv/blob/master/samples/cpp/contours2.cpp // approx_contours.resize(contours.size()); for(unsigned int i = 0; i < contours.size(); i++) { /// Area of more than 20 and no parent if(contourArea(contours[i]) > 20 && hierarchy[i][3] == -1) { vector<Point> tmp_contour; approxPolyDP(Mat(contours[i]), tmp_contour, 3, true); approx_contours.push_back(tmp_contour); } } for(unsigned int i=0; i < approx_contours.size(); i++) { Scalar color; if(approx_contours[i].size() == 4) { color = Scalar( 255, 255, 255); drawContours( drawing, approx_contours, i, color, 1, 8, NULL, 0, Point() ); } else { color = Scalar( 0, 255, 0); drawContours( drawing, approx_contours, i, color, 1, 8, NULL, 0, Point() ); } } imshow("Video", drawing); } } c = cvWaitKey(10); // wait 10 ms or for key stroke if(c == 27) break; // if ESC, break and quit } /* clean up */ cvReleaseCapture( &cv_cap ); cvDestroyWindow("Video"); }
int main( int argc, char** argv ) { CvCapture* capture = 0; IplImage *frame, *frame_copy = 0; IplImage *image = 0; const char* scale_opt = "--scale="; int scale_opt_len = (int)strlen(scale_opt); const char* cascade_opt = "--cascade="; int cascade_opt_len = (int)strlen(cascade_opt); const char* nested_cascade_opt = "--nested-cascade"; int nested_cascade_opt_len = (int)strlen(nested_cascade_opt); int i; const char* input_name = 0; for( i = 1; i < argc; i++ ) { if( strncmp( argv[i], cascade_opt, cascade_opt_len) == 0 ) cascade_name = argv[i] + cascade_opt_len; else if( strncmp( argv[i], nested_cascade_opt, nested_cascade_opt_len ) == 0 ) { if( argv[i][nested_cascade_opt_len] == '=' ) nested_cascade_name = argv[i] + nested_cascade_opt_len + 1; nested_cascade = (CvHaarClassifierCascade*)cvLoad( nested_cascade_name, 0, 0, 0 ); if( !nested_cascade ) fprintf( stderr, "WARNING: Could not load classifier cascade for nested objects\n" ); } else if( strncmp( argv[i], scale_opt, scale_opt_len ) == 0 ) { if( !sscanf( argv[i] + scale_opt_len, "%lf", &scale ) || scale < 1 ) scale = 1; } else if( argv[i][0] == '-' ) { fprintf( stderr, "WARNING: Unknown option %s\n", argv[i] ); } else input_name = argv[i]; } cascade = (CvHaarClassifierCascade*)cvLoad( cascade_name, 0, 0, 0 ); if( !cascade ) { fprintf( stderr, "ERROR: Could not load classifier cascade\n" ); fprintf( stderr, "Usage: facedetect [--cascade=\"<cascade_path>\"]\n" " [--nested-cascade[=\"nested_cascade_path\"]]\n" " [--scale[=<image scale>\n" " [filename|camera_index]\n" ); return -1; } storage = cvCreateMemStorage(0); if( !input_name || (isdigit(input_name[0]) && input_name[1] == '\0') ) capture = cvCaptureFromCAM( !input_name ? 0 : input_name[0] - '0' ); else if( input_name ) { image = cvLoadImage( input_name, 1 ); if( !image ) capture = cvCaptureFromAVI( input_name ); } else image = cvLoadImage( "lena.jpg", 1 ); cvNamedWindow( "result", 1 ); if( capture ) { for(;;) { if( !cvGrabFrame( capture )) break; frame = cvRetrieveFrame( capture ); if( !frame ) break; if( !frame_copy ) frame_copy = cvCreateImage( cvSize(frame->width,frame->height), IPL_DEPTH_8U, frame->nChannels ); if( frame->origin == IPL_ORIGIN_TL ) cvCopy( frame, frame_copy, 0 ); else cvFlip( frame, frame_copy, 0 ); detect_and_draw( frame_copy ); if( cvWaitKey( 10 ) >= 0 ) goto _cleanup_; } cvWaitKey(0); _cleanup_: cvReleaseImage( &frame_copy ); cvReleaseCapture( &capture ); } else { if( image ) { detect_and_draw( image ); cvWaitKey(0); cvReleaseImage( &image ); } else if( input_name ) { /* assume it is a text file containing the list of the image filenames to be processed - one per line */ FILE* f = fopen( input_name, "rt" ); if( f ) { char buf[1000+1]; while( fgets( buf, 1000, f ) ) { int len = (int)strlen(buf), c; while( len > 0 && isspace(buf[len-1]) ) len--; buf[len] = '\0'; printf( "file %s\n", buf ); image = cvLoadImage( buf, 1 ); if( image ) { detect_and_draw( image ); c = cvWaitKey(0); if( c == 27 || c == 'q' || c == 'Q' ) break; cvReleaseImage( &image ); } } fclose(f); } } } cvDestroyWindow("result"); return 0; }
int main(int argc, char* argv[]) { CvSize size640x480 = cvSize(640, 480); // use a 640 x 480 size for all windows, also make sure your webcam is set to 640x480 !! CvCapture* p_capWebcam; // we will assign our web cam video stream to this later . . . IplImage* p_imgOriginal; // pointer to an image structure, this will be the input image from webcam IplImage* p_imgProcessed; // pointer to an image structure, this will be the processed image /* IPL is short for Intel Image Processing Library, this is the structure used in OpenCV 1.x to work with images */ CvMemStorage* p_strStorage; // necessary storage variable to pass into cvHoughCircles() CvSeq* p_seqCircles; // pointer to an OpenCV sequence, will be returned by cvHough Circles() and will contain all circles // call cvGetSeqElem(p_seqCircles, i) will return a 3 element array of the ith circle (see next variable) float* p_fltXYRadius; // pointer to a 3 element array of floats // [0] => x position of detected object // [1] => y position of detected object // [2] => radius of detected object int i; // loop counter char charCheckForEscKey; // char for checking key press (Esc exits program) p_capWebcam = cvCreateCameraCapture(-1); // 0 => use 1st webcam, may have to change to a different number if you have multiple cameras if(p_capWebcam == NULL) { // if capture was not successful . . . printf("error: capture is NULL \n"); // error message to standard out . . . getchar(); // getchar() to pause for user see message . . . return(-1); // exit program } // declare 2 windows cvNamedWindow("Original", CV_WINDOW_AUTOSIZE); // original image from webcam cvNamedWindow("Processed", CV_WINDOW_AUTOSIZE); // the processed image we will use for detecting circles p_imgProcessed = cvCreateImage(size640x480, // 640 x 480 pixels (CvSize struct from earlier) IPL_DEPTH_8U, // 8-bit color depth 1); // 1 channel (grayscale), if this was a color image, use 3 while(1) { // for each frame . . . p_imgOriginal = cvQueryFrame(p_capWebcam); // get frame from webcam if(p_imgOriginal == NULL) { // if frame was not captured successfully . . . printf("error: frame is NULL \n"); // error message to std out getchar(); break; } cvInRangeS(p_imgOriginal, // function input CV_RGB(175, 0, 0), // min filtering value (if color is greater than or equal to this) CV_RGB(256,100,100), // max filtering value (if color is less than this) p_imgProcessed); // function output p_strStorage = cvCreateMemStorage(0); // allocate necessary memory storage variable to pass into cvHoughCircles() // smooth the processed image, this will make it easier for the next function to pick out the circles cvSmooth(p_imgProcessed, // function input p_imgProcessed, // function output CV_GAUSSIAN, // use Gaussian filter (average nearby pixels, with closest pixels weighted more) 9, // smoothing filter window width 9); // smoothing filter window height // fill sequential structure with all circles in processed image p_seqCircles = cvHoughCircles(p_imgProcessed, // input image, nothe that this has to be grayscale (no color) p_strStorage, // provide function with memory storage, makes function return a pointer to a CvSeq CV_HOUGH_GRADIENT, // two-pass algorithm for detecting circles, this is the only choice available 2, // size of image / 2 = "accumulator resolution", i.e. accum = res = size of image / 2 p_imgProcessed->height / 4, // min distance in pixels between the centers of the detected circles 100, // high threshold of Canny edge detector, called by cvHoughCircles 50, // low threshold of Canny edge detector, called by cvHoughCircles 10, // min circle radius, in pixels 400); // max circle radius, in pixels for(i=0; i < p_seqCircles->total; i++) { // for each element in sequential circles structure (i.e. for each object detected) p_fltXYRadius = (float*)cvGetSeqElem(p_seqCircles, i); // from the sequential structure, read the ith value into a pointer to a float printf("ball %d position x = %f, y = %f, r = %f \n",i, //naming e ball p_fltXYRadius[0], // x position of center point of circle p_fltXYRadius[1], // y position of center point of circle p_fltXYRadius[2]); // radius of circle // draw a small green circle at center of detected object cvCircle(p_imgOriginal, // draw on the original image cvPoint(cvRound(p_fltXYRadius[0]), cvRound(p_fltXYRadius[1])), // center point of circle 3, // 3 pixel radius of circle CV_RGB(0,255,0), // draw pure green CV_FILLED); // thickness, fill in the circle // draw a red circle around the detected object cvCircle(p_imgOriginal, // draw on the original image cvPoint(cvRound(p_fltXYRadius[0]), cvRound(p_fltXYRadius[1])), // center point of circle cvRound(p_fltXYRadius[2]), // radius of circle in pixels CV_RGB(255,0,0), // draw pure red 3); // thickness of circle in pixels } // end for cvShowImage("Original", p_imgOriginal); // original image with detectec ball overlay cvShowImage("Processed", p_imgProcessed); // image after processing cvReleaseMemStorage(&p_strStorage); // deallocate necessary storage variable to pass into cvHoughCircles charCheckForEscKey = cvWaitKey(1); // delay (in ms), and get key press, if any if(charCheckForEscKey == 27) break; // if Esc key (ASCII 27) was pressed, jump out of while loop } // end while cvReleaseCapture(&p_capWebcam); // release memory as applicable cvReleaseImage(&p_imgProcessed); cvReleaseImage(&p_imgOriginal); cvDestroyWindow("Original"); cvDestroyWindow("Processed"); return(0); }
void face_detect( void ) { CvCapture *capture = 0; IplImage *frame = 0; IplImage *frame_copy = 0; double height = 480; double width = 640; int c; CvRect last_rect = {0}; CvHaarClassifierCascade* cvHCC = (CvHaarClassifierCascade*)cvLoad(filename); CvMemStorage* cvMStr = cvCreateMemStorage(0); CvSeq* face; capture = cvCreateCameraCapture (0); cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_WIDTH, width); cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_HEIGHT, height); cvNamedWindow ("capture_face_detect", CV_WINDOW_AUTOSIZE); open_tonnel(); while (1) { CvRect near_rect = {0}; frame = cvQueryFrame (capture); frame_copy = cvCreateImage(cvSize(frame->width, frame->height), IPL_DEPTH_8U, frame->nChannels); if(frame->origin == IPL_ORIGIN_TL) { cvCopy(frame, frame_copy); } else { cvFlip(frame, frame_copy); } IplImage* gray = cvCreateImage(cvSize(frame_copy->width, frame_copy->height), IPL_DEPTH_8U, 1); IplImage* detect_frame = cvCreateImage(cvSize((frame_copy->width / SCALE), (frame_copy->height / SCALE)), IPL_DEPTH_8U, 1); cvCvtColor(frame_copy, gray, CV_BGR2GRAY); cvResize(gray, detect_frame, CV_INTER_LINEAR); cvEqualizeHist(detect_frame, detect_frame); face = cvHaarDetectObjects(detect_frame, cvHCC, cvMStr, 1.1, 2, CV_HAAR_DO_CANNY_PRUNING, cvSize(30, 30) ); CvScalar detect_color = CV_RGB(255, 0, 0); double d = 1000000000000000.0; for (int i = 0; i < face->total; i++) { CvRect* faceRect = (CvRect*)cvGetSeqElem(face, i); if(last_rect.x == 0 && last_rect.y == 0) { } else { double x = abs(last_rect.x - faceRect->x); double y = abs(last_rect.y - faceRect->y); double e = sqrt( x*x+y*y ); if( d > e) { last_rect.x = faceRect->x; last_rect.y = faceRect->y; last_rect.width = faceRect->width; last_rect.height = faceRect->height; printf("x\n"); } } // rect cvRectangle(frame_copy, cvPoint(faceRect->x * SCALE, faceRect->y * SCALE), cvPoint((faceRect->x + faceRect->width) * SCALE, (faceRect->y + faceRect->height) * SCALE), detect_color, 3, CV_AA); detect_color = CV_RGB(0, 0, 255); } // send to server { char str[1024]; sprintf_s(str, "[{ \"x\" : %f, \"y\" : %f}]", last_rect.x * SCALE, last_rect.y * SCALE); printf("%s", str); send_tunnel(str); } cvShowImage ("capture_face_detect", frame_copy); cvReleaseImage(&gray); cvReleaseImage(&detect_frame); // key event c = cvWaitKey (16); if (c == 'e') { break; } if( c == 's') { CvRect* faceRect = (CvRect*)cvGetSeqElem(face, 0); if(faceRect != NULL) { last_rect.x = faceRect->x; last_rect.y = faceRect->y; last_rect.width = faceRect->width; last_rect.height = faceRect->height; } } } close_tunnel(); /* free */ cvReleaseMemStorage(&cvMStr); cvReleaseCapture (&capture); cvDestroyWindow("capture_face_detect"); cvReleaseHaarClassifierCascade(&cvHCC); }
void* Run(void*) { int size = ivWidth*ivHeight; // Initialize MultiObjectTLD #if LOADCLASSIFIERATSTART MultiObjectTLD p = MultiObjectTLD::loadClassifier((char*)CLASSIFIERFILENAME); #else MOTLDSettings settings(COLOR_MODE_RGB); settings.useColor = true; MultiObjectTLD p(ivWidth, ivHeight, settings); #endif Matrix maRed; Matrix maGreen; Matrix maBlue; unsigned char img[size*3]; #ifdef FORCE_RESIZING CvSize wsize = {ivWidth, ivHeight}; IplImage* frame = cvCreateImage(wsize, IPL_DEPTH_8U, 3); #endif while(!ivQuit) { /* if(reset){ p = *(new MultiObjectTLD(ivWidth, ivHeight, COLOR_MODE_RGB)); reset = false; } if(load){ p = MultiObjectTLD::loadClassifier(CLASSIFIERFILENAME); load = false; } */ // Grab an image if(!cvGrabFrame(capture)){ std::cout << "error grabbing frame" << std::endl; break; } #ifdef FORCE_RESIZING IplImage* capframe = cvRetrieveFrame(capture); cvResize(capframe, frame); #else IplImage* frame = cvRetrieveFrame(capture); #endif for(int j = 0; j<size; j++){ img[j] = frame->imageData[j*3+2]; img[j+size] = frame->imageData[j*3+1]; img[j+2*size] = frame->imageData[j*3]; } // Process it with motld p.processFrame(img); // Add new box if(mouseMode == MOUSE_MODE_ADD_BOX){ p.addObject(mouseBox); mouseMode = MOUSE_MODE_IDLE; } // Display result HandleInput(); p.getDebugImage(img, maRed, maGreen, maBlue, drawMode); FromRGB(maRed, maGreen, maBlue); cvShowImage("MOCTLD", curImage); p.enableLearning(learningEnabled); if(save){ p.saveClassifier((char*)CLASSIFIERFILENAME); save = false; } } //delete[] img; cvReleaseCapture(&capture); return 0; }
THISCLASS::~ComponentInputFileAVI() { if (mCapture) { cvReleaseCapture(&mCapture); } }
////////////////////////////////// // closeCapture() // void closeCapture() { // Terminate video capture and free capture resources cvReleaseCapture( &pCapture ); return; }
void MultiGrab::Cam::setCam(CvCapture *c, int _width, int _height, int _detect_width, int _detect_height, int desired_capture_fps ) { if (cam) { if ( mtc ) delete mtc; mtc = 0; cvReleaseCapture(&cam); } if (c==0) return; cam = c; // avoid saturating the firewire bus cvSetCaptureProperty(cam, CV_CAP_PROP_FPS, desired_capture_fps); cout << "setting cv capture property for size to " << _width << "x" << _height << endl; int res1 = cvSetCaptureProperty(cam, CV_CAP_PROP_FRAME_WIDTH, _width); int res2 = cvSetCaptureProperty(cam, CV_CAP_PROP_FRAME_HEIGHT, _height); printf("cvSetCaptureProperty: results %i %i\n", res1, res2 ); // optionally downsample the video to accelerate computation detect_width = _detect_width; detect_height = _detect_height; printf("cvGetCaptureProperty gives: %i %i\n", (int)cvGetCaptureProperty(cam, CV_CAP_PROP_FRAME_WIDTH), (int)cvGetCaptureProperty(cam, CV_CAP_PROP_FRAME_HEIGHT ) ); printf("calling cvQueryFrame...\n"); IplImage* test_image = cvQueryFrame( cam ); printf("test_image was %lx\n", (unsigned long)test_image ); if ( test_image != 0 ) { printf(" width %i, height %i, depth %i, channels %i\n", test_image->width, test_image->height, test_image->depth, test_image->nChannels ); } // now mtc mtc = new MultiThreadCapture( cam ); mtc->setupResolution( detect_width, detect_height, /*grayscale*/ 1, desired_capture_fps ); mtc->startCapture(); IplImage* f = NULL; int timeout = 20*1000; printf("MultiGrab::Cam::setCam waiting for camera to become ready... (20s timeout)\n"); bool got = false; while ( timeout >= 0 && !got ) { // 50ms jumps usleep( 50*1000 ); timeout -= 50; got = mtc->getCopyOfLastFrame( &f ); } assert(f != 0 && "camera did not become ready"); width = f->width; //cvRound(cvGetCaptureProperty(cam, CV_CAP_PROP_FRAME_WIDTH)); height = f->height; //cvRound(cvGetCaptureProperty(cam, CV_CAP_PROP_FRAME_HEIGHT)); cout << "Camera capturing " << width << "x" << height << " at " << desired_capture_fps << " fps, " << f->nChannels << " channels.\n" " Detecting at "<< detect_width <<"x" << detect_height << endl; cvReleaseImage(&f); }
void opencvWebcam::stopCamera() { if(capture!=0) cvReleaseCapture( &capture ); }
int _tmain(int argc, char *argv[], char *envp[]) { CvCapture *cv_cap = cvCaptureFromCAM(CV_CAP_ANY); if (!cv_cap) { printf("Could not open camera\n"); cvWaitKey(0); return -1; } int cam_width = (int)cvGetCaptureProperty(cv_cap, CV_CAP_PROP_FRAME_WIDTH); int cam_height = (int)cvGetCaptureProperty(cv_cap, CV_CAP_PROP_FRAME_HEIGHT); CvSize cam_size = cvSize(cam_width, cam_height); Userdata userdata = getSessionUserdata(cam_size); cvNamedWindow(INPUT_WINDOW, 0); cvResizeWindow(INPUT_WINDOW, cam_width, cam_height); cvNamedWindow(OUTPUT_WINDOW, 0); cvResizeWindow(OUTPUT_WINDOW, cam_width, cam_height); cvSetMouseCallback(INPUT_WINDOW, mouseCallback, &userdata); setupWindows(&userdata); IplImage *input = userdata.input[0]; IplImage *output = userdata.output[0]; int use_cam = 1; int flip = 1; while ((userdata.key = cvWaitKey(userdata.timestep)) != 27) { // wait 50 ms (20 FPS) or for ESC key IplImage *cam = cvQueryFrame(cv_cap); // get frame if (!cam) { printf("no input\n"); continue; } switch (userdata.key) { case ' ': use_cam = !use_cam; break; case 'F': flip = !flip; break; } if (!use_cam) { operateImage(&userdata); } else { cvCopy(cam, input, NULL); if (flip) { cvFlip(input, NULL, 1); } operateImage(&userdata); } //cvResizeWindow(INPUT_WINDOW, input->width, input->height); cvShowImage(INPUT_WINDOW, input); //cvResizeWindow(OUTPUT_WINDOW, output->width, output->height); cvShowImage(OUTPUT_WINDOW, output); cvResizeWindow(OUTPUT_WINDOW, cam_width / 2, cam_height / 2); } /* clean up */ cvReleaseCapture(&cv_cap); freeSessionUserdata(&userdata); destroyWindows(); cvDestroyWindow(INPUT_WINDOW); cvDestroyWindow(OUTPUT_WINDOW); return 0; }
int main() { int c;//to store ascii value of key pressed int i,j,h,s,v; CvCapture *capture=cvCreateCameraCapture(0);//initiate camera //because of recursively updating frame , here we dont need to wait for camera as for some ms frame will be black and then as camera starts , frame will update and shaw image IplImage *frame; IplImage* outputred; IplImage* outputone; IplImage* outputtwo; // IplImage* outputblue; IplImage* outputwhite; // IplImage* outputorange; uchar *ptemp; // uchar *poutputorange; uchar *poutputred; uchar *poutputwhite; // uchar *poutputblue; uchar *poutputone; uchar *poutputtwo; if(capture!=NULL) { frame=cvQueryFrame(capture);//take current image in camera and give it to frame pointer cvNamedWindow("img"); while(1) { cvShowImage("img",frame); frame=cvQueryFrame(capture); temp=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,3); cvCvtColor(frame,temp,CV_BGR2HSV); //frame rate time period (if not given system will hang as system processing speed is very fast // cvNamedWindow("output",1); //cvShowImage("output",temp); cvSetMouseCallback("img", my_mouse_callback, NULL); c=cvWaitKey(1); outputred=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1); outputone=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1); outputtwo=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1); // outputblue=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1); outputwhite=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1); // outputorange=cvCreateImage(cvGetSize(frame),IPL_DEPTH_8U,1); cvCvtColor(frame,temp,CV_BGR2HSV); ptemp = (uchar*)temp->imageData; poutputone = (uchar*)outputone->imageData; poutputtwo = (uchar*)outputtwo->imageData; // poutputblue = (uchar*)outputblue->imageData; poutputwhite = (uchar*)outputwhite->imageData; poutputred = (uchar*)outputred->imageData; // poutputorange = (uchar*)outputorange->imageData; for(i=0;i<frame->height;i++) for(j=0;j<frame->width;j++) { h=ptemp[i*temp->widthStep + j*temp->nChannels+0]; s=ptemp[i*temp->widthStep + j*temp->nChannels+1]; v=ptemp[i*temp->widthStep + j*temp->nChannels+2]; if((h>=157&&h<=178)&&s>=110 && s<=255 &&v>=90)//red poutputred[i*outputred->widthStep + j]=255; else poutputred[i*outputred->widthStep + j]=0; if((h==0 && s==0 &&v<150 && v>9)||(h>=25 &&h<=110 && s>=20&&s<=200&& v>=13 && v<=120))//one poutputone[i*outputone->widthStep + j]=255; else poutputone[i*outputone->widthStep + j]=0; /* if((h>=145 &&h<=160)&&s>=175 && s<=255 && v>=80 && v<=150)//one poutputone[i*outputone->widthStep + j]=255; else poutputone[i*outputone->widthStep + j]=0; */ if(h>=110 &&h<=153&&s>=90&&v>=7 && v<=150)//two poutputtwo[i*outputtwo->widthStep + j]=255; else poutputtwo[i*outputtwo->widthStep + j]=0; if( (h==0 && s==0 && v>=250) || (((h>=0 && h<=30)) && s>=50&&s<=200&&v>=110) )//white poutputwhite[i*outputwhite->widthStep + j]=255; else poutputwhite[i*outputwhite->widthStep + j]=0; } //cvNamedWindow("output",1); cvNamedWindow("outputred",1); cvNamedWindow("outputone",1); cvNamedWindow("outputtwo",1); // cvNamedWindow("outputblue",1); cvNamedWindow("outputwhite",1); //cvNamedWindow("outputorange",1); //cvShowImage("output",temp); cvShowImage("outputred",outputred); cvShowImage("outputone",outputone); cvShowImage("outputtwo",outputtwo); // cvShowImage("outputblue",outputblue); cvShowImage("outputwhite",outputwhite); // cvShowImage("outputorange",outputorange); cvWaitKey(1); /* imgOutred=cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,3); labelImgred=cvCreateImage(cvGetSize(input),IPL_DEPTH_LABEL,1); CvBlobs blobsred; cvLabel(outputred, labelImgred, blobsred); cvRenderBlobs(labelImgred, blobsred, input, imgOutred); cvFilterByArea(blobsred,PIXEL_MIN,PIXEL_MAX); imgOutone=cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,3); labelImgone=cvCreateImage(cvGetSize(input),IPL_DEPTH_LABEL,1); CvBlobs blobsone; cvLabel(outputone, labelImgone, blobsone); cvRenderBlobs(labelImgone, blobsone, input, imgOutone); cvFilterByArea(blobsone,PIXEL_MIN,PIXEL_MAX); imgOuttwo=cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,3); labelImgtwo=cvCreateImage(cvGetSize(input),IPL_DEPTH_LABEL,1); CvBlobs blobstwo; cvLabel(outputtwo, labelImgtwo, blobstwo); cvRenderBlobs(labelImgtwo, blobstwo, input, imgOuttwo); cvFilterByArea(blobstwo,PIXEL_MIN,PIXEL_MAX); imgOutblue=cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,3); labelImgblue=cvCreateImage(cvGetSize(input),IPL_DEPTH_LABEL,1); CvBlobs blobsblue; cvLabel(outputblue, labelImgblue, blobsblue); cvRenderBlobs(labelImgblue, blobsblue, input, imgOutblue); cvFilterByArea(blobsblue,PIXEL_MIN,PIXEL_MAX); imgOutwhite=cvCreateImage(cvGetSize(input),IPL_DEPTH_8U,3); labelImgwhite=cvCreateImage(cvGetSize(input),IPL_DEPTH_LABEL,1); CvBlobs blobswhite; cvLabel(outputwhite, labelImgwhite, blobswhite); cvRenderBlobs(labelImgwhite, blobswhite, input, imgOutwhite); cvFilterByArea(blobswhite,PIXEL_MINWHITE,PIXEL_MAX); */ cvReleaseImage( &outputred ); cvReleaseImage( &outputone ); cvReleaseImage( &outputtwo ); //cvReleaseImage( &outputblue ); cvReleaseImage( &outputwhite ); //cvReleaseImage( &outputorange ); cvReleaseImage(&temp ); //cvDestroyWindow( "output" ); if(c>0&&c<255) { cvDestroyWindow( "img" ); cvReleaseImage( &frame ); cvReleaseCapture(&capture); // cvDestroyWindow( "outputred" ); //cvDestroyWindow( "output" ); // cvDestroyWindow( "outputone" ); // cvDestroyWindow( "outputtwo" ); //cvDestroyWindow( "outputblue" ); // cvDestroyWindow( "outputwhite" ); //cvDestroyWindow( "outputorange" ); cvReleaseImage( &outputred ); cvReleaseImage( &outputone ); cvReleaseImage( &outputtwo ); //cvReleaseImage( &outputblue ); cvReleaseImage( &outputwhite ); //cvReleaseImage( &outputorange ); return 0; } } } }
VideoBackground::~VideoBackground(void) { cvReleaseCapture(&m_capture); }
// Runs the dot detector and sends detected dots to server on port TODO Implement headless. Needs more config options and/or possibly a config file first though int run( const char *serverAddress, const int serverPort, char headless ) { char calibrate_exposure = 0, show = ~0, flip = 0, vflip = 0, done = 0, warp = 0; //"Boolean" values used in this loop char noiceReduction = 2; //Small counter, so char is still ok. int i, sockfd; //Generic counter int dp = 0, minDist = 29, param1 = 0, param2 = 5; // Configuration variables for circle detection int minDotRadius = 1; int detected_dots; //Detected dot counter int returnValue = EXIT_SUCCESS; int captureControl; //File descriptor for low-level camera controls int currentExposure = 150; int maxExposure = 1250; //Maximum exposure supported by the camera TODO Get this from the actual camera Color min = { 0, 70, 0, 0 }; //Minimum color to detect Color max = { 255, 255, 255, 0 }; //Maximum color to detect CvScalar colorWhite = cvScalar( WHITE ); //Color to draw detected dots on black and white surface BoundingBox DD_mask; //The box indicating what should and what should not be considered for dot search BoundingBox DD_transform; //The box indicating the plane we are looking at( and as such is the plane we would transform from ) BoundingBox DD_transform_to; //The plane we are transforming to CvCapture *capture = NULL; //The camera CvMemStorage *storage; //Low level memory area used for dynamic structures in OpenCV CvSeq *seq; //Sequence to store detected dots in IplImage *grabbedImage = NULL; //Raw image from camera( plus some overlay in the end ) IplImage *imgThreshold = NULL; //Image with detected dots IplImage *mask = NULL; //Mask to be able to remove uninteresting areas IplImage *coloredMask = NULL; //Mask to be able to indicate above mask on output image CvFont font; //Font for drawing text on images SendQueue *queue; //Head of the linked list that is the send queue char strbuf[255]; //Generic buffer for text formatting( with sprintf()) struct timeval oldTime, time, diff; //Structs for measuring FPS float lastKnownFPS = 0; //Calculated FPS CvMat* pointRealMat = cvCreateMat( 1,1,CV_32FC2 ); //Single point matrix for point transformation CvMat* pointTransMat = cvCreateMat( 1,1,CV_32FC2 ); //Single point matrix for point transformation CvMat* transMat = cvCreateMat( 3,3,CV_32FC1 ); //Translation matrix for transforming input to a straight rectangle ClickParams clickParams = { TOP_LEFT, NULL, &DD_transform_to, transMat }; //Struct holding data needed by mouse-click callback function // Set up network sockfd = initNetwork( serverAddress, serverPort ); if( sockfd == -1 ) { fprintf( stderr, "ERROR: initNetwork returned -1\n"); return EXIT_FAILURE; } queue = initSendQueue(); if( openCamera( &capture, &captureControl ) == 0 ) { fprintf( stderr, "ERROR: capture is NULL \n" ); return EXIT_FAILURE; } if( ( disableAutoExposure( captureControl ) ) == -1 ) { fprintf( stderr, "ERROR: Cannot disable auto exposure \n" ); //return EXIT_FAILURE; } if( ( updateAbsoluteExposure( captureControl, currentExposure ) ) == 0 ) { fprintf( stderr, "ERROR: Cannot set exposure\n"); } // Create a window in which the captured images will be presented cvNamedWindow( imagewindowname, CV_WINDOW_AUTOSIZE | CV_WINDOW_KEEPRATIO | CV_GUI_NORMAL ); // Create a window to hold the configuration sliders and the detection frame TODO This is kind of a hack. Make a better solution cvNamedWindow( configwindowname, CV_WINDOW_AUTOSIZE | CV_WINDOW_KEEPRATIO | CV_GUI_NORMAL ); // Create a window to hold the transformed image. Handy to see how the dots are translated, but not needed for functionality if( warp ) cvNamedWindow( warpwindowname, CV_WINDOW_AUTOSIZE | CV_WINDOW_KEEPRATIO | CV_GUI_NORMAL ); // Create sliders to adjust the lower color boundry cvCreateTrackbar( red_lable , configwindowname, &min.red, 255, NULL ); cvCreateTrackbar( green_lable, configwindowname, &min.green, 255, NULL ); cvCreateTrackbar( blue_lable , configwindowname, &min.blue, 255, NULL ); //Create sliters for the contour based dot detection cvCreateTrackbar( min_area_lable, configwindowname, &minDotRadius,255, NULL ); /* Slider for manual exposure setting */ cvCreateTrackbar( exposure_lable, configwindowname, ¤tExposure, maxExposure, NULL ); //Create the memory storage storage = cvCreateMemStorage( 0 ); // void cvInitFont( font, font_face, hscale, vscale, shear=0, thickness=1, line_type=8 ) cvInitFont( &font, CV_FONT_HERSHEY_PLAIN, 1, 1, 0, 1, 8 ); // Grab an initial image to be able to fetch image size before the main loop. grabbedImage = cvQueryFrame( capture ); //Move the two windows so both are visible at the same time cvMoveWindow( imagewindowname, 0, 10 ); cvMoveWindow( configwindowname, grabbedImage->width+2, 10 ); //TODO Move these three inits to a function // Set masking defaults TODO load from file? Specify file for this file loading? DD_mask.topLeft.x = 0; DD_mask.topLeft.y = 0; DD_mask.topRight.x = grabbedImage->width-1; DD_mask.topRight.y = 0; DD_mask.bottomLeft.x = 0; DD_mask.bottomLeft.y = grabbedImage->height-1; DD_mask.bottomRight.x = grabbedImage->width-1; DD_mask.bottomRight.y = grabbedImage->height-1; // Set transformation defaults TODO load from file? Specify file for this file loading? DD_transform.topLeft.x = 0; DD_transform.topLeft.y = 0; DD_transform.topRight.x = grabbedImage->width-1; DD_transform.topRight.y = 0; DD_transform.bottomLeft.x = 0; DD_transform.bottomLeft.y = grabbedImage->height-1; DD_transform.bottomRight.x = grabbedImage->width-1; DD_transform.bottomRight.y = grabbedImage->height-1; // Set the transformation destination DD_transform_to.topLeft.x = 0; DD_transform_to.topLeft.y = 0; DD_transform_to.topRight.x = grabbedImage->width-1; DD_transform_to.topRight.y = 0; DD_transform_to.bottomLeft.x = 0; DD_transform_to.bottomLeft.y = grabbedImage->height-1; DD_transform_to.bottomRight.x = grabbedImage->width-1; DD_transform_to.bottomRight.y = grabbedImage->height-1; calculateTransformationMatrix( &DD_transform, &DD_transform_to, transMat ); // Set callback function for mouse clicks cvSetMouseCallback( imagewindowname, calibrateClick, ( void* ) &clickParams ); gettimeofday( &oldTime, NULL ); // Main loop. Grabbs an image from cam, detects dots, sends dots,and prints dots to images and shows to user while( !done ) { //PROFILING_PRO_STAMP(); //Uncomment this and the one in the end of the while-loop, and comment all other PROFILING_* to profile main-loop // ------ Common actions cvClearMemStorage( storage ); detected_dots = 0; //Grab a fram from the camera PROFILING_PRO_STAMP(); grabbedImage = cvQueryFrame( capture ); PROFILING_POST_STAMP( "cvQueryFrame"); if( grabbedImage == NULL ) { fprintf( stderr, "ERROR: frame is null...\n" ); getchar(); returnValue = EXIT_FAILURE; break; } //Flip images to act as a mirror. if( show && flip ) { cvFlip( grabbedImage, grabbedImage, 1 ); } if( show && vflip ) { cvFlip( grabbedImage, grabbedImage, 0 ); } // ------ State based actions switch( state ) { case GRAB_DOTS: //Create detection image imgThreshold = cvCreateImage( cvGetSize( grabbedImage ), 8, 1 ); cvInRangeS( grabbedImage, cvScalar( DD_COLOR( min )), cvScalar( DD_COLOR( max )), imgThreshold ); //Mask away anything not in our calibration area mask = cvCreateImage( cvGetSize( grabbedImage ), 8, 1 ); cvZero( mask ); cvFillConvexPoly( mask, ( CvPoint* ) &DD_mask, 4, cvScalar( WHITE ), 1, 0 ); cvAnd( imgThreshold, mask, imgThreshold, NULL ); // Invert mask, increase the number of channels in it and overlay on grabbedImage //TODO Tint the mask red before overlaying cvNot( mask, mask ); coloredMask = cvCreateImage( cvGetSize( grabbedImage ), grabbedImage->depth, grabbedImage->nChannels ); cvCvtColor( mask, coloredMask, CV_GRAY2BGR ); cvAddWeighted( grabbedImage, 0.95, coloredMask, 0.05, 0.0, grabbedImage ); // Reduce noise. // Erode is kind of floor() of pixels, dilate is kind of ceil() // I'm not sure which gives the best result. switch( noiceReduction ) { case 0: break; //No noice reduction at all case 1: cvErode( imgThreshold, imgThreshold, NULL, 2 ); break; case 2: cvDilate( imgThreshold, imgThreshold, NULL, 2 ); break; } // Warp the warp-image. We are reusing the coloredMask variable to save some space PROFILING_PRO_STAMP(); if( show && warp ) cvWarpPerspective( grabbedImage, coloredMask, transMat, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, cvScalarAll( 0 )); PROFILING_POST_STAMP( "Warping perspective" ); // Find all dots in the image PROFILING_PRO_STAMP(); // Clear old data from seq seq = 0; // Find the dots cvFindContours( imgThreshold, storage, &seq, sizeof( CvContour ), CV_RETR_LIST, CV_CHAIN_APPROX_SIMPLE, cvPoint( 0,0 ) ); // cvFindContours destroys the original image, so we wipe it here // and then repaints the detected dots later cvZero( imgThreshold ); PROFILING_POST_STAMP( "Dot detection" ); //Process all detected dots PROFILING_PRO_STAMP(); for( ; seq != 0; seq = seq->h_next ) { // Calculate radius of the detected contour CvRect rect =( ( CvContour * )seq )->rect; float relCenterX = rect.width / 2; float relCenterY = rect.height / 2; // Make sure the dot is big enough if( relCenterX < minDotRadius || relCenterY < minDotRadius ) { continue; } // Note that we have found another dot ++detected_dots; // Transform the detected dot according to transformation matrix. float absCenter[] = { rect.x + relCenterX, rect.y + relCenterY }; pointRealMat->data.fl = absCenter; cvPerspectiveTransform( pointRealMat, pointTransMat, transMat ); // Draw the detected contour back to imgThreshold // Draw the detected dot both to real image and to warped( if warp is active ) if( show ) { cvDrawContours( imgThreshold, seq, colorWhite, colorWhite, -1, CV_FILLED, 8, cvPoint( 0,0 ) ); drawCircle( absCenter[0], absCenter[1], ( relCenterX + relCenterY ) / 2, grabbedImage ); if( warp ) { drawCircle( pointTransMat->data.fl[0], pointTransMat->data.fl[1], ( relCenterX + relCenterY ) / 2, coloredMask ); } } // Add detected dot to to send queue addPointToSendQueue( pointTransMat->data.fl, queue ); } PROFILING_POST_STAMP("Painting dots"); //Calculate framerate gettimeofday( &time, NULL ); timeval_subtract( &diff, &time, &oldTime ); lastKnownFPS = lastKnownFPS * 0.7 + ( 1000000.0 / diff.tv_usec ) * 0.3; //We naïvly assume we have more then 1 fps oldTime = time; //Send the dots detected this frame to the server PROFILING_PRO_STAMP(); sendQueue( sockfd, queue ); clearSendQueue( queue ); PROFILING_POST_STAMP( "Sending dots" ); /* If calibrating, do the calibration */ if( calibrate_exposure ) { int ret; ret = calibrateExposureLow( captureControl, detected_dots, ¤tExposure, DD_MAX_EXPOSURE, lastKnownFPS ); switch( ret ) { case 0: // We are done. Let's leave calibration mode calibrate_exposure = 0; printf( "done\n" ); break; case -1: // We hit the upper limit with no detected dots fprintf( stderr, "Reached upper limit (%d). Aborting!\n", DD_MAX_EXPOSURE ); calibrate_exposure = 0; break; case -2: // We hit lower limit with more then one dot detected fprintf( stderr, "Too bright. More then one dot found even with minimal exposure. Aborting!\n"); calibrate_exposure = 0; break; case -3: //No conclusive results. fprintf( stderr, "No conclusive results. Giving up\n" ); calibrate_exposure = 0; break; } } break; //End of GRAB_DOTS case SELECT_TRANSFORM: //Falling through here. Poor man's multi-case clause. Not putting this in default as we might //want to do different things in these two some day. case SELECT_MASK: snprintf( strbuf, sizeof( strbuf ), "Select %s point", pointTranslationTable[clickParams.currentPoint]); cvDisplayOverlay( imagewindowname, strbuf, 5 ); break; //End of SELECT_MASK and SELECT_TRANSFORM } // Paint the corners of the detecting area and the calibration area paintOverlayPoints( grabbedImage, &DD_transform ); //Print some statistics to the image if( show ) { snprintf( strbuf, sizeof( strbuf ), "Dots: %i", detected_dots ); //Print number of detected dots to the screen cvPutText( grabbedImage, strbuf, cvPoint( 10, 20 ), &font, cvScalar( WHITE )); snprintf( strbuf, sizeof( strbuf ), "FPS: %.1f", lastKnownFPS ); cvPutText( grabbedImage, strbuf, cvPoint( 10, 40 ), &font, cvScalar( WHITE )); cvCircle( grabbedImage, cvPoint( 15, 55 ), minDotRadius, cvScalar( min.blue, min.green, min.red, min.alpha ), -1, 8, 0 ); // Colors given in order BGR-A, Blue, Green, Red, Alpha } //Show images PROFILING_PRO_STAMP(); if( show ) { cvShowImage( configwindowname, imgThreshold ); cvShowImage( imagewindowname, grabbedImage ); if( warp ) cvShowImage( warpwindowname, coloredMask ); } PROFILING_POST_STAMP("Showing images"); //Release the temporary images cvReleaseImage( &imgThreshold ); cvReleaseImage( &mask ); cvReleaseImage( &coloredMask ); /* Update exposure if needed */ updateAbsoluteExposure( captureControl, currentExposure ); cvSetTrackbarPos( exposure_lable, configwindowname, currentExposure ); //If ESC key pressed, Key=0x10001B under OpenCV 0.9.7( linux version ), //remove higher bits using AND operator i = ( cvWaitKey( 10 ) & 0xff ); switch( i ) { case 'g': makeCalibrate( &DD_transform, &DD_transform_to, transMat, capture, captureControl, 20 ); updateAbsoluteExposure( captureControl, currentExposure+1 ); break; case 'e': toggleCalibrationMode( &calibrate_exposure, ¤tExposure ); break; /* Toggles calibration mode */ case 'c': openCamera( &capture, &captureControl ); break; case 's': show = ~show; break; //Toggles updating of the image. Can be useful for performance of slower machines... Or as frame freeze case 'm': state = SELECT_MASK; clickParams.currentPoint = TOP_LEFT; clickParams.DD_box = &DD_mask; break; //Starts selection of masking area. Will return to dot detection once all four points are set case 't': state = SELECT_TRANSFORM; clickParams.currentPoint = TOP_LEFT; clickParams.DD_box = &DD_transform; break; //Starts selection of the transformation area. Returns to dot detection when done. case 'f': flip = ~flip; break; //Toggles horizontal flipping of the image case 'v': vflip = ~vflip; break; //Toggles vertical flipping of the image case 'w': warp = ~warp; toggleWarpOutput( warp ); break; //Toggles showing the warped image case 'n': noiceReduction = ( noiceReduction + 1 ) % 3; break; //Cycles noice reduction algorithm case 'q': //falling through here to quit case 27: done = 1; break; //ESC. Kills the whole thing( in a nice and controlled manner ) } fflush( stdout ); //Make sure everything in the buffer is printed before we go on //PROFILING_POST_STAMP("Main loop"); } //End of main while-loop // Release the capture device and do some housekeeping cvReleaseImage( &grabbedImage ); cvReleaseCapture( &capture ); cvReleaseMemStorage( &storage ); cvDestroyWindow( imagewindowname ); cvDestroyWindow( configwindowname ); if( warp ) cvDestroyWindow( warpwindowname ); //If now warp it is already destroyed destroySendQueue( queue ); close( sockfd ); close( captureControl ); return returnValue; }
int main( int argc, char** argv ){ CvCapture* capture = NULL; IplImage* src = NULL; IplImage* src2 = NULL; IplImage* gray = NULL; IplImage* output = NULL; CvMat* cornerPoints; CvMat* objectPoints; CvMat pointsNumMat; CvPoint2D32f* points; int pointsNum[1]; ChessBoard chess; int pointsPerScene; int detectedPointsNum; int allPointsFound; int i, j; char key; int camID; char* windowName = "extrinsic calibration"; capture = cvCreateCameraCapture(0); if(!capture) { fprintf(stderr, "ERROR: capture is NULL \n"); return(-1); } 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 ) ; src = cvQueryFrame(capture); if(src == NULL){ fprintf(stderr, "Could not grab and retrieve frame...\n"); return(-1); } src2 = cvCreateImage(cvSize(src->width, src->height), src->depth, 3); output = cvCreateImage(cvSize(src->width, src->height), src->depth, 3); cvCopy( src, src2, NULL ); gray = cvCreateImage(cvSize(src2->width, src2->height), src2->depth, 1); cvNamedWindow( windowName, CV_WINDOW_AUTOSIZE ); while( 1 ){ src = cvQueryFrame(capture); if( !src ) { break; } cvCopy( src, src2, NULL ); cvCopy( src2, output, NULL ); cvCvtColor(src2, 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( src2, chess.patternSize, points, detectedPointsNum, allPointsFound ); cvShowImage(windowName, src2); key = cvWaitKey( 20 ); if(key == RETURN && allPointsFound ){ store2DCoordinates( cornerPoints, points, chess, 0 ); store3DCoordinates( objectPoints, chess, 0 ); calibrateCamera("intrinsic_param_ref.txt", "extrinsic_param.txt", cornerPoints, objectPoints ); cvSaveImage( "board.jpg", output, 0 ); break; } else if(key == ESCAPE) { break; } } cvDestroyWindow( windowName ); cvReleaseCapture(&capture); free(points); cvReleaseMat(&cornerPoints); cvReleaseMat(&objectPoints); cvReleaseImage(&gray); cvReleaseImage(&src2); return(0); }
int main(int argc, char* argv[]) { printf("[i] Start...\n"); register_signal_handlers(); roboipc::CommunicatorServer communicator; roboipc::CommunicatorClient client; if( communicator.init(EYE_SOCKET_NAME) ) { fprintf(stderr, "[!] Error: cant create communication: %s!\n", EYE_SOCKET_NAME); return -1; } int res = 0; #if defined(USE_KEYBOARD_INPUT) && defined(LINUX) // Use termios to turn off line buffering termios term; tcgetattr(STDIN_FILENO, &term); term.c_lflag &= ~ICANON; tcsetattr(STDIN_FILENO, TCSANOW, &term); setbuf(stdin, NULL); #endif CmdEyeData cmd_eye; memset(&cmd_eye, 0, sizeof(cmd_eye)); CvCapture* capture = cvCreateCameraCapture( 200 ); if(!capture) { fprintf(stderr, "[!] Error: cant create camera capture!\n"); } cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, EYE_FRAME_WIDTH); cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, EYE_FRAME_HEIGHT); double width = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH); double height = cvGetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT); printf("[i] Capture: %.0f x %.0f\n", width, height ); IplImage* frame = 0; printf("[i] Capture images...\n"); // frame counter int counter = 0; double fps = 0; double begin = 0; double end = 0; while( !terminated ) { #if defined(USE_KEYBOARD_INPUT) int key = console::waitKey(30); if(key != 0 ) printf( "[i] Key: %c (%d)\n", key ,key ); if(key == 27) { //ESC break; } #endif //#if defined(USE_KEYBOARD_INPUT) begin = (double)cvGetTickCount(); frame = cvQueryFrame( capture ); calc_hsv_colors(frame); end = (double)cvGetTickCount(); // calculate current FPS counter++; fps = (end-begin) / (cvGetTickFrequency()*1000.0); // will print out Inf until sec is greater than 0 printf("[i] FPS = %.2f\n", fps); #if 1 SOCKET sockfd = SOCKET_ERROR; if( (sockfd = communicator.connected(30)) != SOCKET_ERROR ) { printf("[i] Client connected...\n"); client.close(); client.sockfd = sockfd; } if(client.sockfd != SOCKET_ERROR) { strncpy(cmd_eye.sig, "eyedat", CMD_SIG_SIZE); res = client.write(&cmd_eye, sizeof(cmd_eye)); printf( "[i] Send Eye data (%d)...\n", res); } #endif } // while( !terminated ) { cvReleaseCapture( &capture ); printf("[i] End.\n"); return 0; }
int main(int argc, char* argv[]) { // Default capture size - 640x480 CvSize size = cvSize(640,480); // Open capture device. 0 is /dev/video0, 1 is /dev/video1, etc. CvCapture* capture = cvCaptureFromCAM( 0 ); if( !capture ) { fprintf( stderr, "ERROR: capture is NULL \n" ); getchar(); return -1; } // Create a window in which the captured images will be presented cvNamedWindow( "Camera", CV_WINDOW_AUTOSIZE ); cvNamedWindow( "HSV", CV_WINDOW_AUTOSIZE ); cvNamedWindow( "EdgeDetection", CV_WINDOW_AUTOSIZE ); // Detect a red ball int hl = 60, hu = 75, sl = 255, su = 256, vl = 170, vu = 256; IplImage * hsv_frame = cvCreateImage(size, IPL_DEPTH_8U, 3); IplImage* thresholded = cvCreateImage(size, IPL_DEPTH_8U, 1); while( 1 ) { // Get one frame IplImage* frame = cvQueryFrame( capture ); if( !frame ) { fprintf( stderr, "ERROR: frame is null...\n" ); getchar(); break; } CvScalar hsv_min = cvScalar(hl, sl, vl, 0); CvScalar hsv_max = cvScalar(hu, su, vu, 0); // Covert color space to HSV as it is much easier to filter colors in the HSV color-space. cvCvtColor(frame, hsv_frame, CV_RGB2HSV); // Filter out colors which are out of range. cvInRangeS(hsv_frame, hsv_min, hsv_max, thresholded); // Memory for hough circles CvMemStorage* storage = cvCreateMemStorage(0); // hough detector works better with some smoothing of the image cvDilate(thresholded, thresholded, NULL, 3); cvSmooth( thresholded, thresholded, CV_GAUSSIAN, 9, 9 ); cvErode(thresholded, thresholded, NULL, 3); CvSeq* circles = cvHoughCircles(thresholded, storage, CV_HOUGH_GRADIENT, 1, thresholded->height/4, 400, 10, 20, 400); int maxRadius = 0; int x = 0, y = 0; bool found = false; for (int i = 0; i < circles->total; i++) { float* p = (float*)cvGetSeqElem( circles, i ); if (p[2] > maxRadius){ maxRadius = p[2]; x = p[0]; y = p[1]; found = true; } } if (found){ //printf("Ball! x=%f y=%f r=%f\n\r",p[0],p[1],p[2] ); cvCircle( frame, cvPoint(cvRound(x),cvRound(y)), 3, CV_RGB(0,255,0), -1, 8, 0 ); cvCircle( frame, cvPoint(cvRound(x),cvRound(y)), cvRound(maxRadius), CV_RGB(255,0,0), 3, 8, 0 ); } cvShowImage( "Camera", frame ); // Original stream with detected ball overlay cvShowImage( "HSV", hsv_frame); // Original stream in the HSV color space cvShowImage( "After Color Filtering", thresholded ); // The stream after color filtering cvReleaseMemStorage(&storage); // Do not release the frame! //If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version), //remove higher bits using AND operator int key = cvWaitKey(10); switch(key){ case 'q' : hu += 5; break; case 'Q' : hu -= 5; break; case 'a' : hl -= 5; break; case 'A' : hl += 5; break; case 'w' : su += 5; break; case 'W' : su -= 5; break; case 's' : sl -= 5; break; case 'S' : sl += 5; break; case 'e' : vu += 5; break; case 'E' : vu -= 5; break; case 'd' : vl -= 5; break; case 'D' : vl += 5; break; } if (key != -1){ printf("H: %i, S: %i, V: %i\nH: %i, S: %i, V: %i\n\n", hu, su, vu, hl, sl, vl); } } // Release the capture device housekeeping cvReleaseCapture( &capture ); cvDestroyWindow( "mywindow" ); return 0; }
/** * @brief Main principal * @param argc El número de argumentos del programa * @param argv Cadenas de argumentos del programa * @return Nada si es correcto o algún número negativo si es incorrecto */ int main( int argc, char** argv ) { if( argc < 4 ) return -1; // Declaración de variables gsl_rng *rng; IplImage *frame, *hsv_frame; histogram **ref_histos, *histo_aux; CvCapture *video; particle **particles, **aux, **nuevas_particulas; CvScalar color_rojo = CV_RGB(255,0,0), color_azul = CV_RGB(0,0,255); CvRect *regions; int num_objects = 0; int i = 1, MAX_OBJECTS = atoi(argv[3]), PARTICLES = atoi(argv[2]); FILE *datos; char name[45], num[3], *p1, *p2; clock_t t_ini, t_fin; double ms; video = cvCaptureFromFile( argv[1] ); if( !video ) { printf("No se pudo abrir el fichero de video %s\n", argv[1]); exit(-1); } first_frame = cvQueryFrame( video ); num_objects = get_regions( ®ions, MAX_OBJECTS, argv[1] ); if( num_objects == 0 ) exit(-1); t_ini = clock(); hsv_frame = bgr2hsv( first_frame ); histo_aux = (histogram*) malloc( sizeof(histogram) ); histo_aux->n = NH*NS + NV; nuevas_particulas = (particle**) malloc( num_objects * sizeof( particle* ) ); for( int j = 0; j < num_objects; ++j ) nuevas_particulas[j] = (particle*) malloc( PARTICLES * sizeof( particle ) ); // Computamos los histogramas de referencia y distribuimos las partículas iniciales ref_histos = compute_ref_histos( hsv_frame, regions, num_objects ); particles = init_distribution( regions, num_objects, PARTICLES ); // Mostramos el tracking if( show_tracking ) { // Mostramos todas las partículas if( show_all ) for( int k = 0; k < num_objects; ++k ) for( int j = 0; j < PARTICLES; ++j ) display_particle( first_frame, particles[k][j], color_azul ); // Dibujamos la partícula más prometedora de cada objeto for( int k = 0; k < num_objects; ++k ) display_particle( first_frame, particles[k][0], color_rojo ); cvNamedWindow( "Video", 1 ); cvShowImage( "Video", first_frame ); cvWaitKey( 5 ); } // Exportamos los histogramas de referencia y los frames if( exportar ) { export_ref_histos( ref_histos, num_objects ); export_frame( first_frame, 1 ); for( int k = 0; k < num_objects; ++k ) { sprintf( num, "%02d", k ); strcpy( name, REGION_BASE); p1 = strrchr( argv[1], '/' ); p2 = strrchr( argv[1], '.' ); strncat( name, (++p1), p2-p1 ); strcat( name, num ); strcat( name, ".txt" ); datos = fopen( name, "a+" ); if( ! datos ) { printf("Error creando fichero para datos\n"); return -1; } fprintf( datos, "%d\t%f\t%f\n", 0, particles[k][0].x, particles[k][0].y ); fclose( datos ); } } cvReleaseImage( &hsv_frame ); // Inicializamos el generador de números aleatorios gsl_rng_env_setup(); rng = gsl_rng_alloc( gsl_rng_mt19937 ); gsl_rng_set(rng, (unsigned long) time(NULL)); // Recordar que frame no se puede liberar debido al cvQueryFrame while( frame = cvQueryFrame( video ) ) { hsv_frame = bgr2hsv( frame ); // Realizamos la predicción y medición de probabilidad para cada partícula for( int k = 0; k < num_objects; ++k ) for( int j = 0; j < PARTICLES; ++j ) { transition( &particles[k][j], frame->width, frame->height, rng ); particles[k][j].w = likelihood( hsv_frame, &particles[k][j], ref_histos[k], histo_aux ); } // Normalizamos los pesos y remuestreamos un conjunto de partículas no ponderadas normalize_weights( particles, num_objects, PARTICLES ); for (int k = 0; k < num_objects; ++k ) resample( particles[k], PARTICLES, nuevas_particulas[k] ); aux = particles; particles = nuevas_particulas; nuevas_particulas = aux; // Mostramos el tracking if( show_tracking ) { // Mostramos todas las partículas if( show_all ) for( int k = 0; k < num_objects; ++k ) for( int j = 0; j < PARTICLES; ++j ) display_particle( frame, particles[k][j], color_azul ); // Dibujamos la partícula más prometedora de cada objeto for( int k = 0; k < num_objects; ++k ) display_particle( frame, particles[k][0], color_rojo ); cvNamedWindow( "Video", 1 ); cvShowImage( "Video", frame ); cvWaitKey( 5 ); } // Exportamos los histogramas de referencia y los frames if( exportar ) { export_frame( frame, i+1 ); for( int k = 0; k < num_objects; ++k ) { sprintf( num, "%02d", k ); strcpy( name, REGION_BASE); p1 = strrchr( argv[1], '/' ); p2 = strrchr( argv[1], '.' ); strncat( name, (++p1), p2-p1 ); strcat( name, num ); strcat( name, ".txt" ); datos = fopen( name, "a+" ); if( ! datos ) { printf("Error abriendo fichero para datos\n"); return -1; } fprintf( datos, "%d\t%f\t%f\n", i, particles[k][0].x, particles[k][0].y ); fclose( datos ); } } cvReleaseImage( &hsv_frame ); ++i; } // Liberamos todos los recursos usados (mallocs, gsl y frames) cvReleaseCapture( &video ); gsl_rng_free( rng ); free( histo_aux ); free( regions ); for( int i = 0; i < num_objects; ++i ) { free( ref_histos[i] ); free( particles[i] ); free( nuevas_particulas[i] ); } free( particles ); free( nuevas_particulas ); t_fin = clock(); ms = ((double)(t_fin - t_ini) / CLOCKS_PER_SEC) * 1000.0; printf("%d\t%d\t%.10g\n", PARTICLES, num_objects, ms); }
//main function int main() { //declare variables for image IplImage * input1; IplImage * output1; char nameim[100]="../project/dbase/males/1/mvc-001f.jpg"; CvSize s1= {48,48}; output1=cvCreateImage(s1,IPL_DEPTH_8U,3); CvSVM SVM; float a; SVM.load("../project/temp/SVM_hap_neu_sad.txt"); FILE *fp; float feat[18432]; char str[50]="./gabor ../project/temp/temp1.jpg "; IplImage * happy; IplImage * sad; IplImage * neutral; IplImage * temp; CvSize s2= {400,400}; happy=cvCreateImage(s2,IPL_DEPTH_8U,3); sad=cvCreateImage(s2,IPL_DEPTH_8U,3); neutral=cvCreateImage(s2,IPL_DEPTH_8U,3); temp = cvLoadImage("../project/data/Images/happy.jpeg", CV_LOAD_IMAGE_UNCHANGED); cvResize(temp,happy); temp = cvLoadImage("../project/data/Images/sad.jpeg", CV_LOAD_IMAGE_UNCHANGED); cvResize(temp,sad); temp = cvLoadImage("../project/data/Images/neutral.jpeg", CV_LOAD_IMAGE_UNCHANGED); cvResize(temp,neutral); CvCapture *capture=cvCreateCameraCapture(0); if(capture!=NULL) //camera has begun starting itself for(;;) { input1=cvQueryFrame(capture);//take current image in camera and give it to input pointer //get input from camera (input) //input1 = cvLoadImage(nameim, CV_LOAD_IMAGE_UNCHANGED); face_detect_crop(input1,output1); cvSaveImage("../project/temp/temp1.jpg",output1); //_______________________________________________________________// fp=popen(str,"r"); for(int i=0; i<18432; i++) { fscanf(fp,"%f",&feat[i]); //std::cout<<feat[i]<<" "; } pclose(fp); //_______________________________________________________________// cvNamedWindow("Emotion", 1); cv::Mat testmat(1, 18432, CV_32FC1, feat); a=SVM.predict(testmat); if( a<1.1 && a>0.9) { std::cout<<"happy\n"; cvShowImage("Emotion",happy); if( cv::waitKey( 10 ) >= 0 )break; } else if(a>-1.1 && a<-0.9) { std::cout<<"sad\n"; cvShowImage("Emotion",sad); if( cv::waitKey( 10 ) >= 0 )break; } else { std::cout<<"neutral\n"; cvShowImage("Emotion",neutral); if( cv::waitKey( 10 ) >= 0 )break; } cvNamedWindow("O-O", 1); cvShowImage("O-O",input1); if( cv::waitKey( 10 ) >= 0 )break; } cvReleaseCapture( &capture ); return 0; }
int main(int argc, char* argv[]) { CvMemStorage *contStorage = cvCreateMemStorage(0); CvSeq *contours; CvTreeNodeIterator polyIterator; CvMemStorage *mallet_storage; CvSeq *mallet_circles = 0; float *mallet_p; int mi; int found = 0; int i; CvPoint poly_point; int fps=30; int npts[2] = { 4, 12 }; CvPoint **pts; pts = (CvPoint **) cvAlloc (sizeof (CvPoint *) * 2); pts[0] = (CvPoint *) cvAlloc (sizeof (CvPoint) * 4); pts[1] = (CvPoint *) cvAlloc (sizeof (CvPoint) * 12); pts[0][0] = cvPoint(0,0); pts[0][1] = cvPoint(160,0); pts[0][2] = cvPoint(320,240); pts[0][3] = cvPoint(0,240); pts[1][0] = cvPoint(39,17); pts[1][1] = cvPoint(126,15); pts[1][2] = cvPoint(147,26); pts[1][3] = cvPoint(160,77); pts[1][4] = cvPoint(160,164); pts[1][5] = cvPoint(145,224); pts[1][6] = cvPoint(125,233); pts[1][7] = cvPoint(39,233); pts[1][8] = cvPoint(15,217); pts[1][9] = cvPoint(0,133); pts[1][10] = cvPoint(0,115); pts[1][11] = cvPoint(17,28); // ポリライン近似 CvMemStorage *polyStorage = cvCreateMemStorage(0); CvSeq *polys, *poly; // OpenCV variables CvFont font; printf("start!\n"); //pwm initialize if(gpioInitialise() < 0) return -1; //pigpio CW/CCW pin setup //X:18, Y1:14, Y2:15 gpioSetMode(18, PI_OUTPUT); gpioSetMode(14, PI_OUTPUT); gpioSetMode(15, PI_OUTPUT); //pigpio pulse setup //X:25, Y1:23, Y2:24 gpioSetMode(25, PI_OUTPUT); gpioSetMode(23, PI_OUTPUT); gpioSetMode(24, PI_OUTPUT); //limit-switch setup gpioSetMode(5, PI_INPUT); gpioWrite(5, 0); gpioSetMode(6, PI_INPUT); gpioWrite(6, 0); gpioSetMode(7, PI_INPUT); gpioWrite(7, 0); gpioSetMode(8, PI_INPUT); gpioWrite(8, 0); gpioSetMode(13, PI_INPUT); gpioSetMode(19, PI_INPUT); gpioSetMode(26, PI_INPUT); gpioSetMode(21, PI_INPUT); CvCapture* capture_robot_side = cvCaptureFromCAM(0); CvCapture* capture_human_side = cvCaptureFromCAM(1); if(capture_robot_side == NULL){ std::cout << "Robot Side Camera Capture FAILED" << std::endl; return -1; } if(capture_human_side ==NULL){ std::cout << "Human Side Camera Capture FAILED" << std::endl; return -1; } // size設定 cvSetCaptureProperty(capture_robot_side,CV_CAP_PROP_FRAME_WIDTH,CAM_PIX_WIDTH); cvSetCaptureProperty(capture_robot_side,CV_CAP_PROP_FRAME_HEIGHT,CAM_PIX_HEIGHT); cvSetCaptureProperty(capture_human_side,CV_CAP_PROP_FRAME_WIDTH,CAM_PIX_WIDTH); cvSetCaptureProperty(capture_human_side,CV_CAP_PROP_FRAME_HEIGHT,CAM_PIX_HEIGHT); //fps設定 cvSetCaptureProperty(capture_robot_side,CV_CAP_PROP_FPS,fps); cvSetCaptureProperty(capture_human_side,CV_CAP_PROP_FPS,fps); // 画像の表示用ウィンドウ生成 //cvNamedWindow("Previous Image", CV_WINDOW_AUTOSIZE); cvNamedWindow("Now Image", CV_WINDOW_AUTOSIZE); cvNamedWindow("pack", CV_WINDOW_AUTOSIZE); cvNamedWindow("mallet", CV_WINDOW_AUTOSIZE); cvNamedWindow ("Poly", CV_WINDOW_AUTOSIZE); //Create trackbar to change brightness int iSliderValue1 = 50; cvCreateTrackbar("Brightness", "Now Image", &iSliderValue1, 100); //Create trackbar to change contrast int iSliderValue2 = 50; cvCreateTrackbar("Contrast", "Now Image", &iSliderValue2, 100); //pack threthold 0, 50, 120, 220, 100, 220 int iSliderValuePack1 = 54; //80; cvCreateTrackbar("minH", "pack", &iSliderValuePack1, 255); int iSliderValuePack2 = 84;//106; cvCreateTrackbar("maxH", "pack", &iSliderValuePack2, 255); int iSliderValuePack3 = 100;//219; cvCreateTrackbar("minS", "pack", &iSliderValuePack3, 255); int iSliderValuePack4 = 255;//175; cvCreateTrackbar("maxS", "pack", &iSliderValuePack4, 255); int iSliderValuePack5 = 0;//29; cvCreateTrackbar("minV", "pack", &iSliderValuePack5, 255); int iSliderValuePack6 = 255;//203; cvCreateTrackbar("maxV", "pack", &iSliderValuePack6, 255); //mallet threthold 0, 255, 100, 255, 140, 200 int iSliderValuemallet1 = 107; cvCreateTrackbar("minH", "mallet", &iSliderValuemallet1, 255); int iSliderValuemallet2 = 115; cvCreateTrackbar("maxH", "mallet", &iSliderValuemallet2, 255); int iSliderValuemallet3 = 218;//140 cvCreateTrackbar("minS", "mallet", &iSliderValuemallet3, 255); int iSliderValuemallet4 = 255; cvCreateTrackbar("maxS", "mallet", &iSliderValuemallet4, 255); int iSliderValuemallet5 = 0; cvCreateTrackbar("minV", "mallet", &iSliderValuemallet5, 255); int iSliderValuemallet6 = 255; cvCreateTrackbar("maxV", "mallet", &iSliderValuemallet6, 255); // 画像ファイルポインタの宣言 IplImage* img_robot_side = cvQueryFrame(capture_robot_side); IplImage* img_human_side = cvQueryFrame(capture_human_side); IplImage* img_all_round = cvCreateImage(cvSize(CAM_PIX_WIDTH, CAM_PIX_2HEIGHT), IPL_DEPTH_8U, 3); IplImage* tracking_img = cvCreateImage(cvGetSize(img_all_round), IPL_DEPTH_8U, 3); IplImage* img_all_round2 = cvCreateImage(cvGetSize(img_all_round), IPL_DEPTH_8U, 3); IplImage* show_img = cvCreateImage(cvGetSize(img_all_round), IPL_DEPTH_8U, 3); cv::Mat mat_frame1; cv::Mat mat_frame2; cv::Mat dst_img_v; cv::Mat dst_bright_cont; int iBrightness = iSliderValue1 - 50; double dContrast = iSliderValue2 / 50.0; IplImage* dst_img_frame = cvCreateImage(cvGetSize(img_all_round), IPL_DEPTH_8U, 3); IplImage* grayscale_img = cvCreateImage(cvGetSize(img_all_round), IPL_DEPTH_8U, 1); IplImage* poly_tmp = cvCreateImage( cvGetSize( img_all_round), IPL_DEPTH_8U, 1); IplImage* poly_dst = cvCreateImage( cvGetSize( img_all_round), IPL_DEPTH_8U, 3); IplImage* poly_gray = cvCreateImage( cvGetSize(img_all_round),IPL_DEPTH_8U,1); int rotate_times = 0; //IplImage* -> Mat mat_frame1 = cv::cvarrToMat(img_robot_side); mat_frame2 = cv::cvarrToMat(img_human_side); //上下左右を反転。本番環境では、mat_frame1を反転させる cv::flip(mat_frame1, mat_frame1, 0); //水平軸で反転(垂直反転) cv::flip(mat_frame1, mat_frame1, 1); //垂直軸で反転(水平反転) vconcat(mat_frame2, mat_frame1, dst_img_v); dst_img_v.convertTo(dst_bright_cont, -1, dContrast, iBrightness); //1枚にした画像をコンバート //画像の膨張と縮小 // cv::Mat close_img; // cv::Mat element(3,3,CV_8U, cv::Scalar::all(255)); // cv::morphologyEx(dst_img_v, close_img, cv::MORPH_CLOSE, element, cv::Point(-1,-1), 3); // cv::imshow("morphologyEx", dst_img_v); // dst_img_v.convertTo(dst_bright_cont, -1, dContrast, iBrightness); //1枚にした画像をコンバート //明るさ調整した結果を変換(Mat->IplImage*)して渡す。その後解放。 *img_all_round = dst_bright_cont; cv_ColorExtraction(img_all_round, dst_img_frame, CV_BGR2HSV, 0, 11, 180, 255, 0, 255); cvCvtColor(dst_img_frame, grayscale_img, CV_BGR2GRAY); cv_Labelling(grayscale_img, tracking_img); cvCvtColor(tracking_img, poly_gray, CV_BGR2GRAY); cvCopy( poly_gray, poly_tmp); cvCvtColor( poly_gray, poly_dst, CV_GRAY2BGR); //画像の膨張と縮小 //cvMorphologyEx(tracking_img, tracking_img,) // 輪郭抽出 found = cvFindContours( poly_tmp, contStorage, &contours, sizeof( CvContour), CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE); // ポリライン近似 polys = cvApproxPoly( contours, sizeof( CvContour), polyStorage, CV_POLY_APPROX_DP, 8, 10); cvInitTreeNodeIterator( &polyIterator, ( void*)polys, 10); poly = (CvSeq *)cvNextTreeNode( &polyIterator); printf("sort before by X\n"); for( i=0; i<poly->total; i++) { poly_point = *( CvPoint*)cvGetSeqElem( poly, i); cvCircle( poly_dst, poly_point, 1, CV_RGB(255, 0 , 255), -1); cvCircle( poly_dst, poly_point, 8, CV_RGB(255, 0 , 255)); std::cout << "x:" << poly_point.x << ", y:" << poly_point.y << std::endl; } printf("Poly FindTotal:%d\n",poly->total); //枠の座標決定 //左上 の 壁サイド側 upper_left_f //左上 の ゴール寄り upper_left_g //右上 の 壁サイド側 upper_right_f //右上 の ゴール寄り upper_right_g //左下 の 壁サイド側 lower_left_f //左下 の ゴール寄り lower_left_g //右下 の 壁サイド側 lower_right_f //右下 の ゴール寄り lower_right_g CvPoint upper_left_f, upper_left_g, upper_right_f, upper_right_g, lower_left_f, lower_left_g, lower_right_f, lower_right_g, robot_goal_left, robot_goal_right; CvPoint frame_points[8]; // if(poly->total == 8){ // for( i=0; i<8; i++){ // poly_point = *( CvPoint*)cvGetSeqElem( poly, i); // frame_points[i] = poly_point; // } // qsort(frame_points, 8, sizeof(CvPoint), compare_cvpoint); // printf("sort after by X\n"); // for( i=0; i<8; i++){ // std::cout << "x:" << frame_points[i].x << ", y:" << frame_points[i].y << std::endl; // } // if(frame_points[0].y < frame_points[1].y){ // upper_left_f = frame_points[0]; // lower_left_f = frame_points[1]; // } // else{ // upper_left_f = frame_points[1]; // lower_left_f = frame_points[0]; // } // if(frame_points[2].y < frame_points[3].y){ // upper_left_g = frame_points[2]; // lower_left_g = frame_points[3]; // } // else{ // upper_left_g = frame_points[3]; // lower_left_g = frame_points[2]; // } // if(frame_points[4].y < frame_points[5].y){ // upper_right_g = frame_points[4]; // lower_right_g = frame_points[5]; // } // else{ // upper_right_g = frame_points[5]; // lower_right_g = frame_points[4]; // } // if(frame_points[6].y < frame_points[7].y){ // upper_right_f = frame_points[6]; // lower_right_f = frame_points[7]; // } // else{ // upper_right_f = frame_points[7]; // lower_right_f = frame_points[6]; // } // } // else{ printf("Frame is not 8 Point\n"); upper_left_f = cvPoint(26, 29); upper_right_f = cvPoint(136, 29); lower_left_f = cvPoint(26, 220); lower_right_f = cvPoint(136, 220); upper_left_g = cvPoint(38, 22); upper_right_g = cvPoint(125, 22); lower_left_g = cvPoint(38, 226); lower_right_g = cvPoint(125, 226); robot_goal_left = cvPoint(60, 226); robot_goal_right = cvPoint(93, 226); // cvCopy(img_all_round, show_img); // cvLine(show_img, upper_left_f, upper_right_f, CV_RGB( 255, 255, 0 )); // cvLine(show_img, lower_left_f, lower_right_f, CV_RGB( 255, 255, 0 )); // cvLine(show_img, upper_right_f, lower_right_f, CV_RGB( 255, 255, 0 )); // cvLine(show_img, upper_left_f, lower_left_f, CV_RGB( 255, 255, 0 )); // // cvLine(show_img, upper_left_g, upper_right_g, CV_RGB( 0, 255, 0 )); // cvLine(show_img, lower_left_g, lower_right_g, CV_RGB( 0, 255, 0 )); // cvLine(show_img, upper_right_g, lower_right_g, CV_RGB( 0, 255, 0 )); // cvLine(show_img, upper_left_g, lower_left_g, CV_RGB( 0, 255, 0 )); //while(1){ //cvShowImage("Now Image", show_img); //cvShowImage ("Poly", poly_dst); //if(cv::waitKey(1) >= 0) { //break; //} //} //return -1; // } printf("upper_left_fX:%d, Y:%d\n",upper_left_f.x, upper_left_f.y); printf("upper_left_gX:%d, Y:%d\n",upper_left_g.x, upper_left_g.y); printf("upper_right_fX:%d,Y:%d\n", upper_right_f.x, upper_right_f.y); printf("upper_right_gX:%d, Y:%d\n" , upper_right_g.x, upper_right_g.y); printf("lower_left_fX:%d, Y:%d\n", lower_left_f.x, lower_left_f.y); printf("lower_left_gX:%d, Y:%d\n", lower_left_g.x, lower_left_g.y); printf("lower_right_fX:%d, Y:%d\n", lower_right_f.x, lower_right_f.y); printf("lower_right_gX:%d, Y:%d\n", lower_right_g.x, lower_right_g.y); printf("robot_goal_left:%d, Y:%d\n", robot_goal_left.x, robot_goal_left.y); printf("robot_goal_right:%d, Y:%d\n", robot_goal_right.x, robot_goal_right.y); cvReleaseImage(&dst_img_frame); cvReleaseImage(&grayscale_img); cvReleaseImage(&poly_tmp); cvReleaseImage(&poly_gray); cvReleaseMemStorage(&contStorage); cvReleaseMemStorage(&polyStorage); //return 1; // Init font cvInitFont(&font,CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC, 0.4,0.4,0,1); bool is_pushed_decision_button = 1;//もう一方のラズパイ信号にする while(1){ //決定ボタンが押されたらスタート if(gpioRead(8)==0 && is_pushed_decision_button==1){ cvCopy(img_all_round, img_all_round2); cvCopy(img_all_round, show_img); img_robot_side = cvQueryFrame(capture_robot_side); img_human_side = cvQueryFrame(capture_human_side); //IplImage* -> Mat mat_frame1 = cv::cvarrToMat(img_robot_side); mat_frame2 = cv::cvarrToMat(img_human_side); //上下左右を反転。本番環境では、mat_frame1を反転させる cv::flip(mat_frame1, mat_frame1, 0); //水平軸で反転(垂直反転) cv::flip(mat_frame1, mat_frame1, 1); //垂直軸で反転(水平反転) vconcat(mat_frame2, mat_frame1, dst_img_v); iBrightness = iSliderValue1 - 50; dContrast = iSliderValue2 / 50.0; dst_img_v.convertTo(dst_bright_cont, -1, dContrast, iBrightness); //1枚にした画像をコンバート //明るさ調整した結果を変換(Mat->IplImage*)して渡す。その後解放。 *img_all_round = dst_bright_cont; mat_frame1.release(); mat_frame2.release(); dst_img_v.release(); cvFillPoly(img_all_round, pts, npts, 2, CV_RGB(0, 0, 0)); IplImage* dst_img_mallet = cvCreateImage(cvGetSize(img_all_round), IPL_DEPTH_8U, 3); IplImage* dst_img_pack = cvCreateImage(cvGetSize(img_all_round), IPL_DEPTH_8U, 3); IplImage* dst_img2_mallet = cvCreateImage(cvGetSize(img_all_round2), IPL_DEPTH_8U, 3); IplImage* dst_img2_pack = cvCreateImage(cvGetSize(img_all_round2), IPL_DEPTH_8U, 3); cv_ColorExtraction(img_all_round, dst_img_pack, CV_BGR2HSV, iSliderValuePack1, iSliderValuePack2, iSliderValuePack3, iSliderValuePack4, iSliderValuePack5, iSliderValuePack6); cv_ColorExtraction(img_all_round, dst_img_mallet, CV_BGR2HSV, iSliderValuemallet1, iSliderValuemallet2, iSliderValuemallet3, iSliderValuemallet4, iSliderValuemallet5, iSliderValuemallet6); cv_ColorExtraction(img_all_round2, dst_img2_pack, CV_BGR2HSV, iSliderValuePack1, iSliderValuePack2, iSliderValuePack3, iSliderValuePack4, iSliderValuePack5, iSliderValuePack6); //CvMoments moment_mallet; CvMoments moment_pack; CvMoments moment_mallet; CvMoments moment2_pack; //cvSetImageCOI(dst_img_mallet, 1); cvSetImageCOI(dst_img_pack, 1); cvSetImageCOI(dst_img_mallet, 1); cvSetImageCOI(dst_img2_pack, 1); //cvMoments(dst_img_mallet, &moment_mallet, 0); cvMoments(dst_img_pack, &moment_pack, 0); cvMoments(dst_img_mallet, &moment_mallet, 0); cvMoments(dst_img2_pack, &moment2_pack, 0); //座標計算 double m00_before = cvGetSpatialMoment(&moment2_pack, 0, 0); double m10_before = cvGetSpatialMoment(&moment2_pack, 1, 0); double m01_before = cvGetSpatialMoment(&moment2_pack, 0, 1); double m00_after = cvGetSpatialMoment(&moment_pack, 0, 0); double m10_after = cvGetSpatialMoment(&moment_pack, 1, 0); double m01_after = cvGetSpatialMoment(&moment_pack, 0, 1); double gX_before = m10_before/m00_before; double gY_before = m01_before/m00_before; double gX_after = m10_after/m00_after; double gY_after = m01_after/m00_after; double m00_mallet = cvGetSpatialMoment(&moment_mallet, 0, 0); double m10_mallet = cvGetSpatialMoment(&moment_mallet, 1, 0); double m01_mallet = cvGetSpatialMoment(&moment_mallet, 0, 1); double gX_now_mallet = m10_mallet/m00_mallet; double gY_now_mallet = m01_mallet/m00_mallet; int target_direction = -1; //目標とする向き 時計回り=1、 反時計回り=0 //円の大きさは全体の1/10で描画 cvCircle(show_img, cvPoint(gX_before, gY_before), CAM_PIX_HEIGHT/10, CV_RGB(0,0,255), 6, 8, 0); cvCircle(show_img, cvPoint(gX_now_mallet, gY_now_mallet), CAM_PIX_HEIGHT/10, CV_RGB(0,0,255), 6, 8, 0); cvLine(show_img, cvPoint(gX_before, gY_before), cvPoint(gX_after, gY_after), cvScalar(0,255,0), 2); cvLine(show_img, robot_goal_left, robot_goal_right, cvScalar(0,255,255), 2); printf("gX_after: %f\n",gX_after); printf("gY_after: %f\n",gY_after); printf("gX_before: %f\n",gX_before); printf("gY_before: %f\n",gY_before); printf("gX_now_mallet: %f\n",gX_now_mallet); printf("gY_now_mallet: %f\n",gY_now_mallet); int target_destanceY = CAM_PIX_2HEIGHT - 30; //Y座標の距離を一定にしている。ディフェンスライン。 //パックの移動は直線のため、一次関数の計算を使って、その後の軌跡を予測する。 double a_inclination; double b_intercept; int closest_frequency; int target_coordinateX; int origin_coordinateY; int target_coordinateY; double center_line = (lower_right_f.x + lower_right_g.x + lower_left_f.x + lower_left_g.x)/4; int left_frame = (upper_left_f.x + lower_left_f.x)/2; int right_frame = (upper_right_f.x + lower_right_f.x)/2; double y_line = (upper_left_f.y + lower_right_f.y)/3; double waiting_position = (robot_goal_left.x + lower_left_g.x) / 2; if(gY_after - gY_before < -1){ gpioPWM(25, 128); closest_frequency = gpioSetPWMfrequency(25, 600); target_coordinateX = waiting_position; if(waiting_position + 5 < gX_now_mallet){ target_direction = 0;//反時計回り } else if(gX_now_mallet < waiting_position - 5){ target_direction = 1;//時計回り } } /*else if(robot_goal_right.x < gX_now_mallet){ gpioPWM(25, 128); closest_frequency = gpioSetPWMfrequency(25, 1000); target_direction = 0;//反時計回り } else if(gX_now_mallet < robot_goal_left.x){ gpioPWM(25, 128); closest_frequency = gpioSetPWMfrequency(25, 1000); target_direction = 1;//時計回り }*/ else if(y_line < gY_after && y_line > gY_before){ clock_t start = clock(); clock_t end; end = start + 0.5 * (target_coordinateX - robot_goal_left.x) / 10; target_direction = 1; gpioPWM(25, 128); gpioWrite(18, target_direction); closest_frequency = gpioSetPWMfrequency(25, 1500); while(end - start < 0);//時間がくるまでループ } else{ gpioPWM(25, 0); closest_frequency = gpioSetPWMfrequency(25, 0); } if(target_direction != -1){ gpioWrite(18, target_direction); } //防御ラインの描画 cvLine(show_img, cvPoint(CAM_PIX_WIDTH, target_destanceY), cvPoint(0, target_destanceY), cvScalar(255,255,0), 2); //マレットの動きの描画 cvLine(show_img, cvPoint((int)gX_now_mallet, (int)gY_now_mallet), cvPoint((int)target_coordinateX, target_destanceY), cvScalar(0,0,255), 2); /* int amount_movement = target_coordinateX - gX_now_mallet; //reacted limit-switch and target_direction rotate // if(gpioRead(6) == 1){//X軸右 // gpioPWM(25, 128); // closest_frequency = gpioSetPWMfrequency(25, 1500); // target_direction = 0;//反時計回り // printf("X軸右リミット!反時計回り\n"); // } // else if(gpioRead(26) == 1){//X軸左 gpioPWM(25, 128); closest_frequency = gpioSetPWMfrequency(25, 1500); target_direction = 1;//時計回り printf("X軸左リミット!時計回り\n"); } else if(gpioRead(5) == 1){//Y軸右上 gpioPWM(23, 128); gpioSetPWMfrequency(23, 1500); gpioWrite(14, 0); printf("Y軸右上リミット!時計回り\n"); } else if(gpioRead(13) == 1){//Y軸右下 gpioPWM(23, 128); gpioSetPWMfrequency(23, 1500); gpioWrite(14, 1); printf("Y軸右下リミット!反時計回り\n"); } else if(gpioRead(19) == 1){//Y軸左下 gpioPWM(24, 128); gpioSetPWMfrequency(24, 1500); gpioWrite(15, 0); printf("Y軸左下リミット!時計回り\n"); } else if(gpioRead(21) == 1){//Y軸左上 gpioPWM(24, 0); gpioSetPWMfrequency(24, 1500); gpioWrite(15, 1); printf("Y軸左上リミット!反時計回り\n"); } else{ //Y軸固定のため gpioSetPWMfrequency(23, 0); gpioSetPWMfrequency(24, 0); if(amount_movement > 0){ target_direction = 1;//時計回り } else if(amount_movement < 0){ target_direction = 0;//反時計回り } } if(target_direction != -1){ gpioWrite(18, target_direction); } else{ gpioPWM(24, 0); gpioSetPWMfrequency(24, 0); } printf("setting_frequency: %d\n", closest_frequency);*/ // 指定したウィンドウ内に画像を表示する //cvShowImage("Previous Image", img_all_round2); cvShowImage("Now Image", show_img); cvShowImage("pack", dst_img_pack); cvShowImage("mallet", dst_img_mallet); cvShowImage ("Poly", poly_dst); cvReleaseImage (&dst_img_mallet); cvReleaseImage (&dst_img_pack); cvReleaseImage (&dst_img2_mallet); cvReleaseImage (&dst_img2_pack); if(cv::waitKey(1) >= 0) { break; } } else{ //リセット信号が来た場合 is_pushed_decision_button = 0; } } gpioTerminate(); cvDestroyAllWindows(); //Clean up used CvCapture* cvReleaseCapture(&capture_robot_side); cvReleaseCapture(&capture_human_side); //Clean up used images cvReleaseImage(&poly_dst); cvReleaseImage(&tracking_img); cvReleaseImage(&img_all_round); cvReleaseImage(&img_human_side); cvReleaseImage(&img_all_round2); cvReleaseImage(&show_img); cvReleaseImage(&img_robot_side); cvFree(&pts[0]); cvFree(&pts[1]); cvFree(pts); return 0; }
/************************************************* vision-serverの本体 Cameraデータの取得、画像処理、ソケット通信待ち受けを行う ************************************************/ int main (int argc, char **argv){ CvSize size; int step; CvCapture *cap; IplImage *capture_image; IplImage *frame_image; IplImage *processed_image; IplImage *grayImage; IplImage *binaryImage; unsigned char* binarydata; CvFont font; char text[50]; char hostname[30]; int s, i, port = 9000; pthread_t tid; /*** socket通信のための処理(ここから) ***/ for (i=1;i<argc;i++){ if (strcmp("-port", argv[i]) == 0) { port=atoi(argv[++i]); }} gethostname(hostname, sizeof(hostname)); s = init_socket_server(hostname, &port); fprintf(stderr, "hostname %s\n", hostname); for (i=0; i< MAX_SOCKET ; i++) sockets[i].type=0; //threadで待ちうけ fprintf(stderr, "Waiting connection...\n"); pthread_create(&tid, NULL, acceptor, (void *)s); /*** socket通信のための処理(ここまで) ***/ /** semaphoreの準備 ***/ raw_semaphore = semget((key_t)1111, 1, 0666|IPC_CREAT); if(raw_semaphore == -1){ perror("semget failure"); exit(EXIT_FAILURE); } process_semaphore = semget((key_t)1111, 1, 0666|IPC_CREAT); if(process_semaphore == -1){ perror("semget failure"); exit(EXIT_FAILURE); } union semun semunion; semunion.val = 0; //semaphoreの初期値 if(semctl(raw_semaphore, 0, SETVAL, semunion) == -1){ perror("semctl(init) failure"); exit(EXIT_FAILURE); } if(semctl(process_semaphore, 0, SETVAL, semunion) == -1){ perror("semctl(init) failure"); exit(EXIT_FAILURE); } /** semaphoreの準備(ここまで) ***/ /** cameraや画像取得の用意(ここから) ***/ //camera initialization if((cap = cvCreateCameraCapture(-1))==NULL){ printf("Couldn't find any camera.\n"); return -1; } capture_image = cvQueryFrame(cap); width = capture_image->width; height = capture_image->height; fprintf(stderr, "height %d, width %d\n", height, width); fprintf(stderr, "process height %d, process width %d\n", process_height, process_width); /** cameraや画像取得の用意(ここまで) ***/ /** 画像処理(赤色抽出)の準備 ***/ //fontの設定(しないとSegfaultで落ちる) float hscale = 1.0f; float vscale = 1.0f; float italicscale = 0.0f; int thickness = 3; cvInitFont(&font, CV_FONT_HERSHEY_COMPLEX, hscale, vscale, italicscale, thickness, CV_AA); //font設定ここまで // Set threshold rgb_thre[0] = R_MIN_THRE; rgb_thre[1] = R_MAX_THRE; rgb_thre[2] = G_MIN_THRE; rgb_thre[3] = G_MAX_THRE; rgb_thre[4] = B_MIN_THRE; rgb_thre[5] = B_MAX_THRE; //画像処理するイメージ領域を確保 frame_image = cvCreateImage(cvSize(process_width, process_height), IPL_DEPTH_8U, 3); processed_image = cvCreateImage(cvSize(process_width, process_height), IPL_DEPTH_8U, 3); /** 画像処理(赤色抽出)の準備(ここまで) ***/ /**** 面積を出すための2値化 ***/ grayImage = cvCreateImage(cvGetSize(frame_image), IPL_DEPTH_8U, 1); binaryImage = cvCreateImage(cvGetSize(frame_image), IPL_DEPTH_8U, 1); //Labeling init label_buf = (int*)malloc(sizeof(int)*frame_image->width*frame_image->height); /**** main loop(本体) ****/ while(1){ CvPoint centroid; //カメラ画像をcaptureする capture_image = cvQueryFrame(cap); if (capture_image==NULL) { fprintf(stderr, "capture_image is %p\n", capture_image); continue; } cvResize(capture_image, frame_image, CV_INTER_LINEAR); //カメラ画像を処理する maskRGB(frame_image, processed_image, rgb_thre); //赤色抽出 // Binarize myBinarize(processed_image, grayImage, binaryImage); cvDilate(binaryImage, grayImage, NULL, 10); //ぼうちょう cvErode(grayImage, binaryImage, NULL, 15); //収縮 // Labeling cvGetRawData(binaryImage, &binarydata, &step, &size); labeling(binarydata, frame_image->height, frame_image->width, label_buf, step); label_num = labeling_result(&linfo, label_buf, frame_image->height, frame_image->width); //処理結果を書き込む { int i,n; n=25; //fprintf(stderr, "num is %d\n", label_num); for(i=0; i<label_num; i++){ //fprintf(stderr, "area %d, x %d y %d\n", linfo[i].area, (int)linfo[i].xpos, (int)linfo[i].ypos); centroid.x = (int) linfo[i].xpos; centroid.y = (int) linfo[i].ypos; drawCross(processed_image, ¢roid, CV_RGB(0, 255, 0)); //×印をいれる sprintf(text, "X: %d Y: %d AREA: %d", centroid.x, centroid.y, linfo[i].area); //値をかく cvPutText(processed_image, text, cvPoint(n, (height-n*(i+1))), &font, CV_RGB(0, 255, 0)); // } } // image -> rawdata sema_wait(raw_semaphore); cvGetRawData(frame_image, &rawdata, &step, &size); // process image -> process data sema_wait(process_semaphore); cvGetRawData(processed_image, &processdata, &step, &size); //sleep usleep(30000); } //release the capture object cvReleaseCapture(&cap); return 0; }