Image * USBCamera::takeImage()
 {
     // Update camera, call executor's functor.
     tryToUpdateCapture();
     
     // Take image
     try
     {
         // Delay camera for some time..
         usleep(m_delay*1000);
         
         // Get image from camera
         Image * image = new Image();
         cvGrabFrame(m_camera);
         cvGrabFrame(m_camera);
         cvGrabFrame(m_camera);
         cvGrabFrame(m_camera);
         cvGrabFrame(m_camera); // workaround for buffering
         image->setImage(cvRetrieveFrame(m_camera));
         
         // Check if need to rotate the image
         image->rotate(m_angle);
         
         return image;
     }
     catch(cv::Exception & ex)
     {
         throw OpenCVException(ex.msg.c_str());
     }
 }

//------------------------------------------------------------------------------
void OgreVideoTexture::_reinitCapture()
{
    cvSetCaptureProperty(mCvCapture, CV_CAP_PROP_POS_MSEC, 0.0);
    
    cvGrabFrame(mCvCapture);
    mCurrentFrameIndex = 1;
}

/* Tool function */
void motionDetection::accFrameFromVideo(CvCapture* capture){

	//cvNamedWindow( "Video", CV_WINDOW_AUTOSIZE ); // Create a window to display the video 

	while (mCount != mFrameNumber)
	{
		if (cvGrabFrame(capture))
		{
			mFrame = cvRetrieveFrame(capture);
			// convert rgb to gray 
			cvCvtColor(mFrame, mpFrame[mCount], CV_BGR2GRAY);
			// accumulate each frame
			cvAdd(mSum, mpFrame[mCount], mSum);
			//cvShowImage( "Video", mpFrame[mCount] );  // display current frame 

			++mCount;
			if (cvWaitKey(10) >= 0) {
				break;
			}
		}
		else {
			break;
		}
	}
	//cvDestroyWindow( "Video" );
}

int main(){
    
    //initialize
    IplImage *frame;
    CvCapture *video = cvCaptureFromFile("/Users/ihong-gyu/MyProject/OpenCVTest/video.mp4");
    
    //create window
    cvNamedWindow("Video",0);
    
    //show video
    while(1){
        cvGrabFrame(video);
        frame = cvRetrieveFrame(video);
        
        //null checker
        if(!frame)
            break;
        cvShowImage("Video", frame);
        
        //wait key input
        if(cvWaitKey(10)>=0)
            break;
    }
    
    //release memory
    cvReleaseCapture(&video);
    
    
    
    
    return 0;
}

void Capture::update()
{
    cvGrabFrame(m_capture);
    IplImage *frame = cvRetrieveFrame(m_capture); 

    TmpBufferImage btmp(CV_8UC3);
    
    if ( frame != NULL )
    {
        CvMat *mat = cvCreateMat(frame->height, frame->width, CV_8UC3);
        if ( m_invert )
        {
            CvMat *tmp = btmp.getImage(frame->width, frame->height);        
            
            cvConvertImage(frame, tmp, CV_CVTIMG_SWAP_RB);
            InvertImage(tmp, mat);            
        }
        else
        {
            
            cvConvertImage(frame, mat, CV_CVTIMG_SWAP_RB);
        }
        
        m_wpipe.write(mat);                                          
    }
}

/* read the next camera frame to R G and B chanel arrays to be then
 * used by an RVC-CAL actor compiled with Orcc */
void readCameraFrame(uchar *rArr, uchar *gArr, uchar *bArr){

  /* for loop initalisation variables */
  int h, w;

  /* try and grab the next frame */
  if(!cvGrabFrame(capture)){
    printf("Could not grab a camera frame\n");
    exit(0);
  }
  img=cvRetrieveFrame(capture,0);
  int nchannels = img->nChannels;
  int step      = img->widthStep;
  uchar *frame = ( uchar* )img->imageData;

  /* loop over all pixels, writing the R G and B channel uchar values
   * to its corresponding array */
  const int R = 2;
  const int G = 1;
  const int B = 0;
  int pixelCount=0;
  for (h=0; h < height; h++){
    for (w = 0; w < width; w++){
      char* rgb = frame + step * h + w * 3;
      bArr[pixelCount] = rgb[B];
      gArr[pixelCount] = rgb[G];
      rArr[pixelCount] = rgb[R];
      pixelCount++;
    }
  }
}

static u32 OCV_Run(void *par)
{
	IplImage* image;
	CvCapture *capture;
	GF_InputSensorDevice *ifce = (GF_InputSensorDevice *)par;
	GF_OpenCV *ocv = (GF_OpenCV *)ifce->udta;

	capture= cvCaptureFromCAM(0);
	cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH,640  );
	cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT, 480 );

	cvNamedWindow( "test", 0 );

	image = NULL;
	while (ocv->running) {
		if (cvGrabFrame(capture)) {
			CvHaarClassifierCascade* cascade;

			image = cvRetrieveFrame(capture);

			cascade = load_object_detector("haarcascade_frontalface_default.xml");
			detect_and_draw_objects(ifce, image, cascade, 1 );


			cvShowImage( "test", image );
			cvWaitKey(40);
		}
	}
	if (image) cvReleaseImage( &image);
	return 0;
}

int main()
{
	IplImage* image = 0;
	IplImage* reverse = 0;

	CvCapture* video = cvCaptureFromCAM(-1);

	cvNamedWindow("Original Video",0);
	cvNamedWindow("Reverse Video",0);

	while(1)
	{
		cvGrabFrame(video);
		image = cvRetrieveFrame(video);
		cvShowImage("Original Video",image);

		reverse = cvCreateImage(cvGetSize(image),image->depth,image->nChannels);

		cvNot(image,reverse);

		if(cvWaitKey(10) >=0)
			break;

		reverse->origin=image->origin;
		cvShowImage("Reverse Video",reverse);
	}

	cvReleaseImage(&reverse);
	cvReleaseCapture(&video);
	cvDestroyWindow("Reverse Video");
	cvDestroyWindow("Original Video");
	return 0;
}

void ImageGrabberStartLoop()
{
  // Allocate the memory storage for calculations and frame data
  CvMemStorage* storage = cvCreateMemStorage(0);
  CvCapture* capture = cvCaptureFromCAM(0);
  // Images to capture the frame from video or camera or from file
  IplImage *frame = 0;
  IplImage *frame_copy = 0;
  cvNamedWindow( "result", 1 );
  // If loaded succesfully, then:
  if( capture )
  {
    bool breakLoop = false;
    // Capture from the camera.
    for(;;)
    {
      if (breakLoop)
        break;
      // Capture the frame and load it in IplImage
      if( !cvGrabFrame( capture ))
        break;
      frame = cvRetrieveFrame( capture );

      // If the frame does not exist, quit the loop
      if( !frame )
        break;

      // Allocate framecopy as the same size of the frame
      if( !frame_copy )
        frame_copy = cvCreateImage( cvSize(frame->width,frame->height),
        IPL_DEPTH_8U, frame->nChannels );

      // Check the origin of image. If top left, copy the image frame to frame_copy. 
      if( frame->origin == IPL_ORIGIN_TL )
        cvCopy( frame, frame_copy, 0 );
      // Else flip and copy the image
      else
        cvFlip( frame, frame_copy, 0 );

      cvShowImage("result",frame_copy);

      // Wait for a while before proceeding to the next frame
      int key = cvWaitKey(1);
      switch(key)
      {					
      case -1:
        break;
      default:
        breakLoop = true;
      }            
    }			
  }
  // Destroy the window previously created with filename: "result"
  cvDestroyWindow("result");
  // Release the images, and capture memory
  cvReleaseCapture( &capture ); 
  cvReleaseImage( &frame_copy );

}

bool VideoCapture::grab()
{
    CV_INSTRUMENT_REGION();

    if (!icap.empty())
        return icap->grabFrame();
    return cvGrabFrame(cap) != 0;
}

int main()
{
	int x = 0, y = 0;
	char Cr = 0, Cb = 0;
	int width = 640, height = 320;
	
	IplImage* frame = 0;

	CvCapture* capture = cvCaptureFromCAM(-1);

	cvNamedWindow("Result",0);

	while(1)
	{
		cvGrabFrame(capture);
		frame = cvRetrieveFrame(capture);
		
		IplImage* YCrCb = cvCreateImage(cvGetSize(frame),8,3); // ycrcb 변환
		IplImage* Skin = cvCreateImage(cvGetSize(frame),8,1); // 피부 이진화

		height = frame->height;
		width = frame->width;
		
		cvCvtColor(frame,YCrCb,CV_RGB2YCrCb);
		for(y=0; y<height;y++)
		{
			for(x=0; x<width; x++)
			{
					Cr = (char)YCrCb->imageData[y*YCrCb->widthStep+3*x+1];
					Cb = (char)YCrCb->imageData[y*YCrCb->widthStep+3*x+2];

					if( (77<Cr && Cr<127) && (133<Cb && Cb<173) )
					{
						Skin->imageData[y*Skin->widthStep+x] = 0;
					}
					else
					{
						Skin->imageData[y*Skin->widthStep+x] = 255;
					}
			}
		
		}

		cvShowImage("Result",Skin);
		cvSetZero(frame);
		cvSetZero(YCrCb);
		cvSetZero(Skin);

		if(cvWaitKey(33)==27)
			break;
	}

	cvDestroyWindow("Result");
	cvReleaseCapture(&capture);

	return 0;
}

int main(int argc,char *argv[])
{
  gargc = argc;
  gargv = argv;

  int c;

  int stopit = 0;

  IplImage* color_img;

  double msec;
  CvCapture* cv_cap = cvCaptureFromFile(argv[1]);

  printf("height=%g\n", cvGetCaptureProperty(cv_cap, CV_CAP_PROP_FRAME_HEIGHT));
  printf("width=%g\n", cvGetCaptureProperty(cv_cap, CV_CAP_PROP_FRAME_WIDTH));
  printf("fps=%g\n", cvGetCaptureProperty(cv_cap, CV_CAP_PROP_FPS));
  printf("total frames=%g\n", cvGetCaptureProperty(cv_cap, CV_CAP_PROP_FRAME_COUNT));

  int frameid, frcount;
  sscanf(argv[2], "%d", &frameid); 

  cvGrabFrame(cv_cap); // get frame

  if(frameid>30) {
     cvSetCaptureProperty(cv_cap, CV_CAP_PROP_POS_FRAMES, frameid-20);
  }

  while(cvGetCaptureProperty(cv_cap, CV_CAP_PROP_POS_FRAMES)<(frameid-1)) {
    //for(frcount = 0;frcount < frameid;frcount++) {
    cvGrabFrame(cv_cap); // get frame
  }
//  cvGrabFrame(cv_cap); // get frame
//  printf("frameix=%g\n", cvGetCaptureProperty(cv_cap, CV_CAP_PROP_POS_FRAMES));
  color_img = cvQueryFrame(cv_cap); // get frame
  printf("frameix=%g\n", cvGetCaptureProperty(cv_cap, CV_CAP_PROP_POS_FRAMES));
  msec = cvGetCaptureProperty(cv_cap, CV_CAP_PROP_POS_MSEC);
  printf("msec=%g \n", msec);
  printf("sec=%g \n", msec/1000);
  cvSaveImage("extract.png",color_img);

  cvReleaseCapture( &cv_cap );
  return 0;
}

int EdgeTest::Run()
{
	CvCapture* capture;
    IplImage* frame;

	// Initialize the capture device
	capture = cvCaptureFromCAM(-1);

	if(!capture)
    {
		ShowError("Cannot find webcam");
		return -1;
	}
	
	cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_WIDTH, 700);
	cvSetCaptureProperty(capture, CV_CAP_PROP_FRAME_HEIGHT, 700);
	cvSetCaptureProperty(capture, CV_CAP_PROP_CONTRAST, 0);


	
	// Create windows to display results
    cvNamedWindow("Capture", 1);


	for(;;)
    {
		// Retrive data from webcam and copy the frame to frame_mod
		if(!cvGrabFrame(capture))
            break;

		frame = cvRetrieveFrame(capture);

        if(!frame)
            break;
			


		// Show image on capture screen
		cvFlip(frame, frame, -1);
		cvShowImage("Capture", frame);


			
		// Esc key
        if(cvWaitKey(10) >= 0)
            break;
    }

    cvReleaseCapture(&capture);
    
    cvDestroyWindow("EdgeTest");
    cvDestroyWindow("Capture");


    return 0;
}

/**
    Fonction toujours graber la derniére image
*/
void* grabCamB(void* data)
{
    while(1){
        pthread_mutex_lock (& mu);
        cvGrabFrame( captureCameraB );
        pthread_mutex_unlock (& mu);
        cvWaitKey(10);
    }
    return data;
}

int _tmain(int argc, _TCHAR* argv[])
{
	
	IplImage* pImg; //Án©úIplImage«ü°w
	IplImage* pImgcanny;
	IplImage* pImggray;

        cvNamedWindow( "Camera", 1 );
		cvNamedWindow( "gray", 1 );
		cvNamedWindow( "canny", 1 );

        CvCapture *capture;
	int c; 
    
	capture = cvCaptureFromCAM(0);
	if(!capture)
		return -1;
	else
        printf("Camera is OK! \n");
	
	while(true){	
            
			if(cvGrabFrame(capture)){

				pImg = cvRetrieveFrame(capture);
				pImggray = cvCreateImage( cvGetSize(pImg),
					  IPL_DEPTH_8U,
					  1);
				
				pImgcanny = cvCreateImage( cvGetSize(pImg),
					  IPL_DEPTH_8U,
					  1);

				cvCvtColor (pImg , pImggray ,CV_BGR2GRAY);
				cvCanny(pImggray, pImgcanny, 50, 150, 3);
				
				cvShowImage( "Camera", pImg );
				cvShowImage( "gray", pImggray );
				cvShowImage( "canny", pImgcanny );
			}
		
		//µ¥«ÝESC«öÁä«ö¤U«hµ²§ô
		if(cvWaitKey(10) == 27)
			break;
	} // end of while 
	   

	cvWaitKey(0);
        
	cvDestroyWindow( "Camera" );//¾P·´µøµ¡
        
	cvReleaseCapture( &capture );  
    
	return 0;
}

IplImage* CCamera::getImage()
{
  if(cam_type_ != CAM_SEQ)
  {
    if(cam_type_ == CAM_OPENNI)
    {
      cv::Mat bgrImage;

      if(!video_capture_.grab())
      {
        std::cerr << "Can not grab images." << std::endl;
        return NULL;
      }

      video_capture_.retrieve(bgrImage, CV_CAP_OPENNI_BGR_IMAGE);
      IplImage* frame = new IplImage(bgrImage);
      cvCopy(frame, img_input_);
    }
    else
    {
			// grab image from camera
			int res=cvGrabFrame (capture_);
			IplImage* frame = cvRetrieveFrame(capture_);

      assert(frame);
      cvCopy(frame, img_input_);
    }
		// check whether its a flea cam
    if(cam_type_ == CAM_FLEA)
      cvFlip(img_input_); // input from flea camera is upside down

    IplImage* t = cvCloneImage(img_input_);
    cvRemap(t, img_input_, img_mapx_, img_mapy_); // rectify
    cvReleaseImage(&t);
    return img_input_;
  }
  else // image sequence
  {
    std::stringstream ss;
    ss << m_strImgPath << "/" << /*"img" <<*/ std::setw(4) << std::setfill('0') << m_nImgIdx << "." << img_ext_;
    if(verbose_) std::cout << "Load image: " << ss.str() << std::endl;
    // Read an image from the saved image sequence
    IplImage* image = cvLoadImage(ss.str().c_str(), color_ ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE);

    // Read edge image if there are edge images in the same folder. (e.g. Berkeley edges, scale space edges)
    // If there are no edge images, 'img_edge_' would be NULL
    ss.str(std::string());
    ss << m_strImgPath << "/" << /*"img" <<*/ std::setw(4) << std::setfill('0') << m_nImgIdx << "bedges." << "png";
    img_edge_ = cvLoadImage(ss.str().c_str(), CV_LOAD_IMAGE_GRAYSCALE);

    // Increase the image index
    m_nImgIdx++;
    return image;
  }
}

bool open_camera(int index)
{
	c_capture = cvCaptureFromCAM(index);
	if(!c_capture)	return false;

	cvGrabFrame(c_capture );
	c_capimg = cvQueryFrame(c_capture);
	c_image = cvCreateImage(cvGetSize(c_capimg), c_capimg->depth, c_capimg->nChannels);

	return true;
}

/*
 * call-seq:
 *   grab -> true or false
 *
 * Grabbed frame is stored internally. To grab frame
 * <i>fast</i> that is important for syncronization in case of reading from
 * several cameras simultaneously. The grabbed frames are not exposed because
 * they may be stored in compressed format (as defined by camera/driver).
 * To retrieve the grabbed frame, retrieve should be used.
 *
 * If grabbed frame was success, return true. Otherwise return false.
 */
VALUE
rb_grab(VALUE self)
{
  int grab = 0;
  try {
    grab = cvGrabFrame(CVCAPTURE(self));
  }
  catch (cv::Exception& e) {
    raise_cverror(e);
  }
  return grab ? Qtrue : Qfalse;
}

//------------------------------------------------------------------------------
void OgreVideoTexture::_initCapture()
{
    
    mCvCapture = cvCreateFileCapture(mVideoFileName.c_str());
    mFrameCount = cvGetCaptureProperty(mCvCapture, CV_CAP_PROP_FRAME_COUNT);

    // skip first frame
    cvGrabFrame(mCvCapture);
    mCurrentFrameIndex++;

    _logMessage("openned " + mVideoFileName);
}

const IplImage* ImageGrabberGetCameraImage()
{
  // Allocate the memory storage for calculations and frame data
  CvMemStorage* storage = cvCreateMemStorage(0);
  CvCapture* capture = cvCaptureFromCAM(0);
  // Images to capture the frame from video or camera or from file
  IplImage *frame = 0;
  IplImage *frame_copy = 0;
  // If loaded succesfully, then:
  if( capture )
  {
    // Capture the frame and load it in IplImage
    if( !cvGrabFrame( capture ))
    {
      // Release the images, and capture memory
      cvReleaseCapture( &capture ); 
      return 0;
    }
    frame = cvRetrieveFrame( capture );

    // If the frame does not exist, quit
    if( !frame )
    {
      // Release the images, and capture memory
      cvReleaseCapture( &capture ); 
      return 0;
    }

    // Allocate framecopy as the same size of the frame
    if( !frame_copy )
      frame_copy = cvCreateImage( cvSize(frame->width,frame->height),
      IPL_DEPTH_8U, frame->nChannels );

    // Check the origin of image. If top left, copy the image frame to frame_copy. 
    if( frame->origin == IPL_ORIGIN_TL )
      cvCopy( frame, frame_copy, 0 );
    // Else flip and copy the image
    else
      cvFlip( frame, frame_copy, 0 );

    // Release the capture but not the image
    cvReleaseCapture( &capture ); 
    // return final image
    return frame_copy;
  }

  // Release the images, and capture memory
  cvReleaseCapture( &capture ); 
  cvReleaseImage( &frame_copy );
  return 0;
}