C++ VideoCapture::grab方法代码示例

	bool update(void) {
		bool result;
		if(useVideo == 0) {
			result = cap.grab();
			cap.retrieve(rgbImg, CV_CAP_OPENNI_BGR_IMAGE);
			cap.retrieve(depthMap, CV_CAP_OPENNI_DEPTH_MAP);
		}
		else if(useVideo == 1) {
			result = cap.grab();
			cap.retrieve(rgbImg);
			depthMap = Mat();
		}
		else if(useVideo == 2) {
			result = (cap.grab() && cap1.grab());
			if(result) {
				cap.retrieve(rgbImg);
				cap1.retrieve(depthImg);
				for(int i=0; i<depthImg.rows; i++) {
					for(int j=0; j<depthImg.cols; j++) {
						depthMap.at<ushort>(i,j) = (int(depthImg.at<Vec3b>(i,j)[0])*256 + int(depthImg.at<Vec3b>(i,j)[1]));
					}
				}
			}
		}
		return result;
	}

int grab_frame(VideoCapture& capture, Mat& img, char* filename) {

  // camera/image setup
  if (!cv_init_) {
    if (filename != NULL) {
      capture.open(filename);
    } else {
      float scale = 0.52;//0.606;
      int w = 640 * scale;
      int h = 480 * scale;
      capture.open(0); //try to open
      capture.set(CV_CAP_PROP_FRAME_WIDTH, w);  capture.set(CV_CAP_PROP_FRAME_HEIGHT, h);
    }
    if (!capture.isOpened()) { cerr << "open video device fail\n" << endl; return 0; }
    capture.grab();
    capture.retrieve(img);
    if (img.empty()) { cout << "load image fail " << endl; return 0; }
    printf(" img = %d x %d \n", img.rows, img.cols);
    cv_init_ = 1;
  }

  // get frames
  capture.grab();
  capture.retrieve(img);

  if (waitKey(10) >= 0) { return 0; }
  else { return 1; }
}

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

  ros::init(argc,argv,"aruco_test");
  ros::NodeHandle nh;

  namedWindow("detection_result");
  startWindowThread();
  namedWindow("board");
  startWindowThread();

  /*  Mat distCoeffs = (Mat_<float>(1,5) << 0.182276,-0.533582,0.000520,-0.001682,0.000000);
  Mat camMatrix  = (Mat_<float>(3,3) << 
		    743.023418,0.000000,329.117496,
		    0.000000,745.126083,235.748102,
		    0.000000,0.000000,1.000000);*/

  
  VideoCapture input;
  input.open(0);
  Mat boardImg;
  createBoard(boardImg);

  imshow("board",boardImg);


  while(input.grab() && ros::ok()){
    Mat image,result;
    input.retrieve(image);
    process(image,result);
    imshow("detection_result",result);
  } 
  return 0;
}

int main( /*int argc, char* argv[]*/ ){
    VideoCapture capture;
    capture.open(CV_CAP_OPENNI);
    capture.set( CV_CAP_PROP_OPENNI_REGISTRATION , 0);

    if( !capture.isOpened() ){
        cout << "Can not open a capture object." << endl;
        return -1;
    }

    namedWindow( "depth", 1 );
    setMouseCallback( "depth", onMouse, 0 );
    for(;;){
        if( !capture.grab() ){
            cout << "Can not grab images." << endl;
            return -1;
        }else{
            Mat depthMap,show;
            capture.retrieve(world, CV_CAP_OPENNI_POINT_CLOUD_MAP);
            if( capture.retrieve( depthMap, CV_CAP_OPENNI_DEPTH_MAP ) ) depthMap.convertTo( show, CV_8UC1, 0.05f);
            line(show,startPt,endPt,Scalar(255));
            putText(show,format("distance: %f m",dist),Point(5,15),FONT_HERSHEY_PLAIN,1,Scalar(255));
            imshow("depth",show);
        }
        if( waitKey( 30 ) >= 0 )    break;
    }
}

int main(int argc, char* argv[])
{
  VideoCapture cap; //
  cap.open("http://192.168.1.139:1234/?action=stream");
  if (!cap.isOpened())  // if not success, exit program
  {
    cout << "Cannot open the video cam" << endl;
    return -1;
  }

  clientSocket = socket(PF_INET, SOCK_DGRAM, 0);
  serverAddr.sin_family = AF_INET;
  serverAddr.sin_port = htons(33333);
  serverAddr.sin_addr.s_addr = inet_addr("192.168.1.139");
  memset(serverAddr.sin_zero, '\0', sizeof serverAddr.sin_zero);
  addr_size = sizeof serverAddr;

  while (1)
  {
    cap.grab();
    cap.retrieve(frame);
    adjusted_color_img = brightness_and_contrast(frame);
    color_detection(adjusted_color_img);
    imshow("view", frame);
    waitKey(20);
    usleep(2000);
  }
}

int getDepthImage(VideoCapture capture, Mat &depth_image){

	//depth image

	if( !capture.grab() )
	{
		cout << "Can not grab images." << endl;
		return -1;
	}
	else
	{

		if( capture.retrieve( depth_image, CAP_OPENNI_DEPTH_MAP ) )
		{
			const float scaleFactor = 0.05f;
			//Mat show;
			depth_image.convertTo( depth_image, CV_8UC1, scaleFactor );

			//imshow( "depth map", depth_image );

		}

	}

	return 0;
}

void vIdle() {
    if (TheCaptureFlag) {
        // capture image
        TheVideoCapturer.grab();
        TheVideoCapturer.retrieve(TheInputImage);
        TheUndInputImage.create(TheInputImage.size(), CV_8UC3);
        // by deafult, opencv works in BGR, so we must convert to RGB because OpenGL in windows preffer
        cv::cvtColor(TheInputImage, TheInputImage, CV_BGR2RGB);
        // remove distorion in image
        cv::undistort(TheInputImage, TheUndInputImage, TheCameraParams.CameraMatrix,
                      TheCameraParams.Distorsion);
        // detect markers
        MDetector.detect(TheUndInputImage, TheMarkers);
        // Detection of the board
        TheBoardDetected.second = TheBoardDetector.detect(
            TheMarkers, TheBoardConfig, TheBoardDetected.first, TheCameraParams, TheMarkerSize);
        // chekc the speed by calculating the mean speed of all iterations
        // resize the image to the size of the GL window
        cv::resize(TheUndInputImage, TheResizedImage, TheGlWindowSize);
        // create mask. It is a syntetic mask consisting of a simple rectangle, just to show a example of
        // opengl with mask
        TheMask = createSyntheticMask(TheResizedImage); // lets create with the same size of the resized
                                                        // image, i.e. the size of the opengl window
    }
    glutPostRedisplay();
}

    JNIEXPORT jboolean JNICALL Java_org_opencv_highgui_VideoCapture_n_1grab
    (JNIEnv* env, jclass, jlong self)
    {
        try {
#ifdef DEBUG
            LOGD("highgui::VideoCapture_n_1grab()");
#endif // DEBUG
            VideoCapture* me = (VideoCapture*) self; //TODO: check for NULL
            bool _retval_ = me->grab(  );

            return _retval_;
        } catch(cv::Exception e) {
#ifdef DEBUG
            LOGD("highgui::VideoCapture_n_1grab() catched cv::Exception: %s", e.what());
#endif // DEBUG
            jclass je = env->FindClass("org/opencv/core/CvException");
            if(!je) je = env->FindClass("java/lang/Exception");
            env->ThrowNew(je, e.what());
            return 0;
        } catch (...) {
#ifdef DEBUG
            LOGD("highgui::VideoCapture_n_1grab() catched unknown exception (...)");
#endif // DEBUG
            jclass je = env->FindClass("java/lang/Exception");
            env->ThrowNew(je, "Unknown exception in JNI code {highgui::VideoCapture_n_1grab()}");
            return 0;
        }
    }

void video_thread_CL(void* pParams)
{
	FaceDetector *faceDetector;
	if (threadUseCL){
		faceDetector = (FaceDetectorCL*)pParams;
	}
	else{
		faceDetector = (FaceDetectorCpu*)pParams;
	}
	
	std::string name = faceDetector->name();

	//HAAR_EYE_TREE_EYEGLASSES_DATA
	//HAAR_EYE_DATA
	//HAAR_FRONT_FACE_DEFAULT_DATA
	//LBP_FRONTAL_FACE
	//LBP_PROFILE_FACE
	faceDetector->load(HAAR_FRONT_FACE_DEFAULT_DATA);

	VideoCapture videoCapture;
	cv::Mat frame, frameCopy, image;

	videoCapture.open(faceDetector->videoFile().c_str());
	if (!videoCapture.isOpened()) { cout << "No video detected" << endl; return; }

	if (imshowFlag) { cv::namedWindow(name.c_str(), 1); }

	if (videoCapture.isOpened())
	{
		cout << "In capture ..." << name.c_str() << endl;
		while (videoCapture.grab())
		{
			if (!videoCapture.retrieve(frame, 0)) { break; }

			faceDetector->setSrcImg(frame, 1);
			faceDetector->doWork();
			if (imshowFlag){ cv::imshow(name.c_str(), faceDetector->resultMat()); }
			
			std::vector<cv::Rect> &faces_result = faceDetector->getResultFaces();
			std::cout << "face --" << name.c_str() << std::endl;
			for (int i = 0; i < faces_result.size(); ++i){
				std::cout << faces_result.at(i).x << ", " << faces_result.at(i).y << std::endl;
			}
			
			if (waitKey(10) >= 0){
				videoCapture.release();
				break;
			}

			Sleep(1);
		}
	}
	
	if (imshowFlag) { cvDestroyWindow(name.c_str()); }
	finishTaskFlag++;
	_endthread();
	return;

}

void* imageTakingThread(void* parameters) {
    vidCap.set(CV_CAP_PROP_FRAME_WIDTH, 160);
    vidCap.set(CV_CAP_PROP_FRAME_HEIGHT, 120);
    while(1)
    {
        vidCap.grab();
    }
}

void threadGrab1(){
        cap1.grab();
        cap1.retrieve(img1);
        Mat Tmp = img1.t(); //Rotate Image
        flip(Tmp,img1,1);
        rightImgs.push_back(img1);
        //outputVideocap1.write(img1);
}

void threadGrab0(){
        cap0.grab();
        cap0.retrieve(img0);
        Mat Tmp = img0.t(); //Rotate Image
        flip(Tmp,img0,0);
        leftImgs.push_back(img0);
        //outputVideocap0.write(img0);
}

/**
 * parameter cam - Camera that will be used
 * parameter src  - Source matrix that will be shown
 */
void checkFeed(VideoCapture cam, Mat src){
    if(!cam.isOpened()){
        cout << "Camera not detected.";
    }
    if (cam.grab()){
        if (!cam.retrieve(src)){
            cout << "Could not retrieve.";
        }
    }
}

 bool grab()
 {
    bool bSuccess = camera_.grab(); // grab a new frame from video
   if (!bSuccess) //if not success, break loop
   {
        printf("Cannot grab a frame from video stream in camera %d \n", camNum_);
        return false;
   }
   printf("Grabbed a frame from video stream in camera %d \n", camNum_);
   return true;
 }

bool getNextFrame(VideoCapture& video, Mat& frame, int& framenum, int jump = 1)
{
	// firstGot should regulate itself so it'll reset when a video runs out of frames
	
	bool moreFrames = true;
	if(firstGot) // not first frame
	{
		bool val1 = true;
		for(int i = 0; i < jump; i++)
			if(!video.grab())
				val1 = false;
		bool val2 = video.retrieve(frame);
		framenum += jump;
		if(!val1 || !val2)
		{
			firstGot = false; // this means video ended
			moreFrames = false;
		}
	}
	else // first frame
	{
		bool val = video.grab();
		firstGot = true;
		if(!val)
		{
			printf("first frame val failed on grab\n");
			firstGot = false;
			moreFrames = false;
		}
		val = video.retrieve(frame);
		if(!val)
		{
			printf("first frame failed on retreive\n");
			firstGot = false;
			moreFrames = false;
		}
		framenum++;
	}
	return moreFrames;
}