C++ cvCreateCameraCapture函数代码示例

int main(int argc, char* argv[]) {

    int chessboard_search = 0;

    cvNamedWindow("leftimage",  CV_WINDOW_AUTOSIZE);
    cvNamedWindow("rightimage", CV_WINDOW_AUTOSIZE);
    CvCapture *capture_left, *capture_right;

    printf("Using webcam\n");
    capture_left  = cvCreateCameraCapture(CAM_LEFT );
    capture_right = cvCreateCameraCapture(CAM_RIGHT);
/*    cvSetCaptureProperty(capture_left, 
            CV_CAP_PROP_FRAME_WIDTH, SCREEN_WIDTH/2);
    cvSetCaptureProperty(capture_right, 
            CV_CAP_PROP_FRAME_WIDTH, SCREEN_WIDTH/2);
*/

    if (capture_left == NULL)
      fatal("can't find left webcam (seen from computers eyes)");
    if (capture_right == NULL)
      fatal("can't find right webcam (seen from computers eyes)");

    IplImage *frame_left, *frame_right;

    /* process frames */
    while (1) {
        /* get next frame */
        frame_left  = cvQueryFrame(capture_left);
        frame_right = cvQueryFrame(capture_right);

        if (!frame_left || !frame_right)
            break;

        /* search for chessboard */
        if (chessboard_search) {
            chessboard_finder(frame_left);
            chessboard_finder(frame_right);
        }

        /* show frames in window */
        cvShowImage("leftimage", frame_left);
        cvShowImage("rightimage", frame_right);

        char c = cvWaitKey(33);
        if (c == 27)
            break;
        if (c == 99) { /* pushed c */
            chessboard_search = !(chessboard_search);
            printf("Chessboard search is turned %s.\n",
                    (chessboard_search) ? "on" : "off");
        }
    }

    cvReleaseCapture(&capture_left);
    cvReleaseCapture(&capture_right);
    cvDestroyWindow("leftimage");
    cvDestroyWindow("rightimage");

    return 0;
}

//--------------------------------------------------------------------------------------
// Name: CVInit()
// Desc: Initializate OpenCV
//--------------------------------------------------------------------------------------
bool GLCVUtils::CVInit (int mode)
{
	if (mode == VIDEO_FILE)
	{
		capture = cvCreateFileCapture ("Ratatouille.avi");
		if (! capture) printf ("\n\n\nerror creating file capture\n\n\n");
			
	}
	
	else if (mode == CAMERA)
	{
		// create capture
		capture = cvCreateCameraCapture (0);
		if (! capture)
		{
			printf ("\nError creating capture");
			return false;
		}

		// sets camera (hardware) resolution
		cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_WIDTH,  TEXTURE_W);
		cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_HEIGHT, TEXTURE_H);
		
	}
	else
	{
		printf ("\nWrong Mode");
	}

	return true;
}

int _tmain(int argc, _TCHAR* argv[])
{
    
    CvCapture* kameraku;
	kameraku=cvCreateCameraCapture(1);
    assert(kameraku!=NULL);
    IplImage* framemurah;//=cvQueryFrame(kameraku);
    IplImage* framegray;//=cvCreateImage(cvSize( framemurah->width, framemurah->height ), IPL_DEPTH_8U, 1 );
	//cvCvtColor(framemurah,framegray,CV_RGB2GRAY );

    
    while(1){
        framemurah=cvQueryFrame(kameraku);
        //if(!framemurah) break;
		cvNamedWindow("Kamera1", CV_WINDOW_AUTOSIZE);
        cvShowImage("Kamera1", framemurah);
        char c = cvWaitKey(33);


		framegray=cvCreateImage(cvSize( framemurah->width, framemurah->height ), IPL_DEPTH_8U, 1 );
		cvCvtColor(framemurah,framegray,CV_RGB2GRAY);//konvert RGB to Gray
		//cvThreshold(framemurah,framegray, g_thresh, 255, CV_THRESH_BINARY);
		cvThreshold(framegray,framegray, 50, 255, CV_THRESH_BINARY);
		cvNamedWindow("Kamera2", CV_WINDOW_AUTOSIZE);
		cvShowImage("Kamera2", framegray);
		char v = cvWaitKey(33);
        //if(c==27) break;
    }
    cvReleaseCapture(&kameraku);
    cvDestroyWindow("Kamera1");
	cvDestroyWindow("Kamera2");
}

int main(int args,char *argv[]){
	// 视频结构
	CvCapture *capture = NULL;
	// 获得摄像头数据
	// CV_CAP_ANY 自动
	capture = cvCreateCameraCapture(CV_CAP_ANY);
	if (!capture) {
		exit(0);
	}
	cvNamedWindow("camera",CV_WINDOW_AUTOSIZE);
	// 图片结构
	IplImage *image = NULL;
	while(image = cvQueryFrame(capture)){
		// 反色处理
		cvNot(image,image);
		// 现实图像
		cvShowImage("camera",image);
		// 监听键盘输入，如果有输入则跳出while
		if( cvWaitKey(2) >= 0 )
			break;
	}
	// 释放视频
	cvReleaseCapture(&capture);
	return 0;
}

void ColibriMainWindow::on_camButton_toggled(bool checked)
{
	if(!checked) {
		if(m_timer.isActive())
			m_timer.stop();
		// Stop thread
		if(m_pColibriThread) {
			m_pColibriThread->stop();
			m_pColibriThread->setCapture(NULL);
		}
		cvReleaseCapture(&capture);
		capture = NULL;

		return;
	}

	if(!capture) {
		int retry = 0;
		do {
			capture = cvCreateCameraCapture (retry);
			fprintf(stderr, "[Colibri] %s:%d : capture #%d =%p\n", __func__, __LINE__,
					retry, capture);
			retry++;
		} while(!capture && retry < 5);
	}


	if(!capture) {
		QMessageBox::critical(NULL, tr("No webcam"),
							  tr("Unable to find webcam. Please try disconnect/reconnect."));
		return ; }

	startBackgroundThread();
}

// Get the resolutions of a device
void Cam::getDeviceInfo(int d){
    CvCapture *cap = cvCreateCameraCapture(d);
    num_resolutions = 0;

    for(int i=0; i<N_RESOLUTIONS; i++){
        // Set actual values of resolution
        cvSetCaptureProperty( cap, CV_CAP_PROP_FRAME_WIDTH, c_resolutions[i].x );
        cvSetCaptureProperty( cap, CV_CAP_PROP_FRAME_HEIGHT, c_resolutions[i].y );

        // Compare the actual resolution value with the last accepted value (Width and Height)
        if( c_resolutions[i].x == cvGetCaptureProperty(cap, CV_CAP_PROP_FRAME_WIDTH)
            && c_resolutions[i].y == cvGetCaptureProperty(cap, CV_CAP_PROP_FRAME_HEIGHT) ){
            resolutions[num_resolutions].x = cvGetCaptureProperty(cap, CV_CAP_PROP_FRAME_WIDTH);
            resolutions[num_resolutions].y = cvGetCaptureProperty(cap, CV_CAP_PROP_FRAME_HEIGHT);
            num_resolutions++;
        }

    }
    cvReleaseCapture(&cap);

    /*
    for(int i=0; i<num_resolutions; i++){
        std::cout << i << ": " << resolutions[i].x << ", " << resolutions[i].y << std::endl;
    }
    */
}

int main()
{
	int thresh=25;
	CvCapture* capture;
	capture = cvCreateCameraCapture(-1);
	IplImage *frame,*res;
	char win[]="video_stream";
	char win2[]="outline_feed";
	cvNamedWindow(win,CV_WINDOW_AUTOSIZE);
	cvNamedWindow(win2,CV_WINDOW_AUTOSIZE);
	cvCreateTrackbar("Threshold",win2,&thresh,128);

	while(1)
	{
		frame=cvQueryFrame(capture);
		res = findedge(frame,thresh);
		clearnoise(res,0, 3);
		clearnoise(res,1, 3);
		cvShowImage(win,frame);
		cvShowImage(win2,res);
		
		if(cvWaitKey(50)==27)
			break;
	}
	cvReleaseImage(&frame);
	cvReleaseImage(&res);
	cvReleaseCapture(&capture);
	cvDestroyWindow(win);
	cvDestroyWindow(win2);
	return 0;
}

////////////////////////////////////////////////////////////////////////////
// MAIN ////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///
/// Main program.
///
int main( int argc, char *argv[] )
{

    CvCapture *video;
    IplImage *frame;
    char *win_name = "Captured Frame";
    char key = 0;

    video = cvCreateCameraCapture( -1 );
//    video = cvCreateFileCapture( argv[1] ); 
    if ( !video ) {
        fprintf( stderr, "unable to capture source\n" );
        exit( 1 );
    } else {
        printf( "capture source opened.\n" );
    }

    printCaptureProperties( video );

    printf( "Press 'q' to quit.\n" );

    while ( ( frame = cvQueryFrame( video ) ) && ( char ) key != 'q' ) {
        cvNamedWindow( win_name, 1 );
        cvShowImage( win_name, frame );
        key = cvWaitKey( 5 );
    }

    cvDestroyWindow( win_name );
    cvReleaseCapture( &video );

    return 0;
}

int main() {
 
	// Image & hsvImage
	//IplImage *hsv;
	// Video Capture
	CvCapture *capture;
	// Key for keyboard event
	char key;
 
	// Number of tracked pixels
	int nbPixels;
	// Next position of the object we overlay
	CvPoint objectNextPos;
 
	// Initialize the video Capture (200 => CV_CAP_V4L2)
 	capture = cvCreateCameraCapture(200);
 
	// Check if the capture is ok
    	if (!capture) {
		printf("Can't initialize the video capture.\n");
        	return -1;
 	}
 
	// Create the windows
   	cvNamedWindow("Test Color Tracking", CV_WINDOW_AUTOSIZE);
   	cvNamedWindow("Test Mask", CV_WINDOW_AUTOSIZE);
	cvMoveWindow("Test Color Tracking", 0, 100);
	cvMoveWindow("Test Mask", 650, 100);
 
	// Mouse event to select the tracked color on the original image
	cvSetMouseCallback("Test Color Tracking", getObjectColor);
 
	// While we don't want to quit
	while(key != 'Q' && key != 'q') {
 
		// We get the current image
		image = cvQueryFrame(capture);
 
		// If there is no image, we exit the loop
		if(!image)
			continue;
 
		objectNextPos = binarisation(image, &nbPixels);
		addObjectToVideo(image, objectNextPos, nbPixels);
 
		// We wait 10 ms
		key = cvWaitKey(10);
 
	}
 
	// Destroy the windows we have created
	cvDestroyWindow("Test Color Tracking");
	cvDestroyWindow("Test Mask");
 
	// Destroy the capture
	cvReleaseCapture(&capture);
 
	return 0;
 
}

int main(int argc, char *argv[]) {
	// Face detection
	if (initFacedetect() < 0)
		exit(-1);

	numImgs = argc - 1;
	imgPaths = argv + 1;

	if (numImgs == 0) {
		// Camera input
		//capture = cvCaptureFromCAM(-1);
		capture = cvCreateCameraCapture(-1);
		if (capture == NULL) {
			printf("Couldn't start camera\n");
			exit(-1);
		}
	}

	cvNamedWindow("preview", 1);

	videoFunc();

	cvDestroyWindow("preview");

	if (numImgs == 0)
		cvReleaseCapture(&capture);

	deinit_opt_flow();

	SDL_Quit();
	return 0;
}

int Qt_Gui_by_ABK (int a,char *b[])
{
 CvCapture *capture ;
 IplImage *frame=0;
 capture = cvCreateCameraCapture(0);
 int n = 0;
 //resoulution
// cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_WIDTH,1024);
 //cvSetCaptureProperty(capture,CV_CAP_PROP_FRAME_HEIGHT,768);

 
 QApplication app(a,b,true);
 QLabel label ;
 QSplashScreen * splash = new QSplashScreen;
 
 while(1)
 {
 frame = cvQueryFrame(capture);
 printf("the camera resoulution is %dx%d\n",frame->width,frame->height);
 cvCvtColor(frame,frame,CV_BGR2RGB);
 QImage image =QImage((uchar*)frame->imageData,frame->width,frame->height,QImage::Format_RGB888);

 splash->setPixmap(QPixmap::fromImage(image));
 splash->show();
 //label.update();
 n++;
 }
 return app.exec();


}

int main( int argc, char** argv )
{
	cvNamedWindow( "Press Any Key to Quit", CV_WINDOW_AUTOSIZE );
	CvCapture *capture = cvCreateCameraCapture(0);
	if( capture == NULL )
	{
		printf( "\n!ERROR! - Could not open camera at /dev/video0\n\n" );
		printf( "\nIf you are using VMWare, verify that the camera is connected" );
		printf( "\nto the VMWare image by selecting 'Virtual Machine' in the" );
		printf( "\nVMWare player window header above. " );
		printf( "\nThen select 'removable devices' and verify your camera is connected.\n\n\n" );
		assert(0);
	}

	IplImage *frame;

	while(1)
	{
		frame = cvQueryFrame( capture );
		if( !frame ) break;
		cvShowImage( "Press Any Key to Quit", frame );
		char c = cvWaitKey(33);
		if( c != -1 ) break;
	}

	cvReleaseCapture( &capture );
	cvDestroyWindow( "Press Any Key to Quit" );
}

void VideoReader::useCamera(int idCamera)
{
    auto tmp = cvCreateCameraCapture(idCamera);
    if( ! tmp )
        throw Exception::buildException("Can't use this camera as source", "VideoReader", "useCamera", EPC);
    m_video = tmp;
}

int main(int argc, char** argv) {
  CvCapture* capture = 0;
  IplImage* input = 0;
  IplImage* output = 0;
  int tick = 0, prev_tick = 0;
  double now = 0.0;
  CvFont font;
  char buffer[256];
  const char* windowName = "median";

  if (argc == 1 || (argc == 2 && strlen(argv[1]) == 1 && isdigit(argv[1][0]))) {
    capture = cvCreateCameraCapture(argc == 2 ? argv[1][0] - '0' : 0);
  } else if (argc == 2) {
    capture = cvCreateFileCapture(argv[1]);
  }
  if (!capture) {
    fprintf(stderr, "ERROR: capture is NULL \n");
    return (-1);
  }

  cvNamedWindow(windowName, CV_WINDOW_AUTOSIZE);
  cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 1.0, 1.0, 0.0, 1, 0);
  input = cvQueryFrame(capture);
  if (!input) {
    fprintf(stderr, "Could not query frame...\n");
    return (-1);
  }
  output = cvCreateImage(cvSize(input->width, input->height), IPL_DEPTH_8U, 3);

  while (1) {
    input = cvQueryFrame(capture);
    if (!input) {
      fprintf(stderr, "Could not query frame...\n");
      break;
    }

    process(input, output);

    sprintf(buffer, "%3.1lfms", now / 1000);
    cvPutText(output, buffer, cvPoint(50, 150), &font, CV_RGB(255, 0, 0));

    cvShowImage(windowName, output);

    //If a certain key pressed
    if (cvWaitKey(10) >= 0) {
      break;
    }

    tick = cvGetTickCount();
    now = (tick - prev_tick) / cvGetTickFrequency();
    prev_tick = tick;
  }

  cvReleaseImage(&output);

  cvReleaseCapture(&capture);
  cvDestroyWindow(windowName);

  return 0;
}

void MyDisplay::camera_negatif()
{
    capture = cvCreateCameraCapture(CV_CAP_ANY);
    while (1){
        frame = cvQueryFrame(capture);
        img_nvg = cvCreateImage(cvGetSize(frame), frame->depth, 1);

        //conversion en niveau de gris
        cvConvertImage(frame, img_nvg, 0);

        stretch_histogram_NVG(img_nvg);
        negatif(img_nvg);

        //frame = negatif(frame);
        cvShowImage("test", img_nvg);
        int key = cvWaitKey(1);
        if (key == 'q')
        {
            break;
        }
        else {
            //nothing to do
        }
    }
    cvReleaseCapture(&capture);

}