void OpenniGetColorPoints(CvCapture* capture, std::vector<ColorPoint>* points, IplImage* maskImg)
{
	IplImage* pcm = cvRetrieveFrame(capture, CV_CAP_OPENNI_POINT_CLOUD_MAP); //XYZ in meters (CV_32FC3)
	IplImage* bgr = cvRetrieveFrame(capture, CV_CAP_OPENNI_BGR_IMAGE); //CV_8UC3

	int ptCount = pcm->width * pcm->height;
	CvPoint3D32f* position = (CvPoint3D32f*)pcm->imageData;
	unsigned char* color = (unsigned char*)bgr->imageData;

	//int colorIdx = 0;
	ColorPoint cp;
	if (maskImg)
	{
		unsigned char* mask = (unsigned char*)maskImg->imageData;
		for (int i = 0; i < ptCount; i++, mask++, position++, color += 3)
			if (*mask)
			{
				memcpy(&cp.position, position, sizeof(CvPoint3D32f));
				memcpy(&cp.red, color, 3);
				points->push_back(cp);

			}
	}
	else
	{
		for (int i = 0; i < ptCount; i++, position++, color += 3)
		{
			memcpy(&cp.position, position, sizeof(CvPoint3D32f));
			memcpy(&cp.red, color, 3);
			points->push_back(cp);

		}
	}
}

void WebCam::captureImg()
{
	std::stringstream path;

	path<<"scan/capture/"<< saveCount <<".png";

	cvRetrieveFrame(capture);

	cvSaveImage(path.str().c_str(), cvRetrieveFrame(capture));
	saveCount++;

}

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;
}

 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());
     }
 }

/* 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" );
}

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;
}

void USBCamReader::readCurFrameGray(unsigned char* grayImgData) {
	assert(videoCap);
	IplImage* img = cvRetrieveFrame(videoCap);
	cv::Mat rawFrame(img);
	cv::Mat videoFrame(_h, _w, CV_8UC1, grayImgData);
	cv::cvtColor(rawFrame, videoFrame, CV_RGB2GRAY);
}

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++;
    }
  }
}

QImage* Camera::retrieveFrame()
{
    IplImage* image = cvRetrieveFrame(capture);
    int width = image->width;
    int height = image->height;
    int pixels = width * height;
    uchar* imageData = new unsigned char[4 * pixels];
    for(int i = 0; i < pixels; i++)
    {
        imageData[i * 4 + 3] = 0xFF; // alpha channel
    }

    uchar* src = (uchar*)(image->imageData);
    uchar* srcEnd = src + (3 * pixels);
    uchar* dest = imageData;

    do
    {
        memcpy(dest, src, 3);
        dest += 4;
        src += 3;
    }
    while(src < srcEnd);

    QImage* result = new QImage(imageData, width, height, QImage::Format_RGB32);
    return result;
}

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 );

}

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 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;
}

void AVIReader::readCurFrameGray(unsigned char* grayImgData) {
	assert(videoCap);
	IplImage* img = cvRetrieveFrame(videoCap);
	cv::Mat rawFrame(img);
	cv::Mat videoFrame(_h, _w, CV_8UC1, grayImgData);
	if(rawFrame.type() == CV_8UC1)
		rawFrame.copyTo(videoFrame);
	else
		cv::cvtColor(rawFrame, videoFrame, CV_RGB2GRAY);
}

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;
  }
}

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;
}

bool OpenCVCamera::captureFrame() {
    bool retVal = false;
    if (m_capture != NULL) {
        if (cvGrabFrame(m_capture)) {
            if (getBPP() == 1) {
                IplImage *tmpFrame = cvRetrieveFrame(m_capture);

                if (m_image == NULL) {
                    m_image = cvCreateImage(cvGetSize(tmpFrame), IPL_DEPTH_8U, 1);
                }

                cvCvtColor(tmpFrame, m_image, CV_BGR2GRAY);
            }
            else {
                m_image = cvRetrieveFrame(m_capture);
            }

            retVal = true;
        }
    }
    return retVal;
}

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;
}

/*
 * call-seq:
 *   retrieve -> IplImage or nil
 *
 * Gets the image grabbed with grab.
 */
VALUE
rb_retrieve(VALUE self)
{
  IplImage *frame = cvRetrieveFrame(CVCAPTURE(self));
  if(!frame)
    return Qnil;
  VALUE image = cIplImage::new_object(cvSize(frame->width, frame->height), CV_MAKETYPE(CV_8U, frame->nChannels));
  if (frame->origin == IPL_ORIGIN_TL) {
    cvCopy(frame, CVARR(image));
  } else {
    cvFlip(frame, CVARR(image));
  }
  return image;
}