bonanza-ruby-opencv 0.0.13.20140330211753

data/ext/opencv/curve.h

@@ -0,0 +1,34 @@
+/************************************************************
+
+   curve.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVSEQ_CURVE_H
+#define RUBY_OPENCV_CVSEQ_CURVE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CURVE namespace mCurve {
+#define __NAMESPACE_END_CURVE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CURVE
+
+VALUE rb_module();
+
+void init_ruby_module();
+
+VALUE rb_closed_q(VALUE self);
+VALUE rb_convex_q(VALUE self);
+VALUE rb_hole_q(VALUE self);
+VALUE rb_simple_q(VALUE self);
+VALUE rb_arc_length(int argc, VALUE *argv, VALUE self);
+
+__NAMESPACE_END_CURVE
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVSEQ_CURVE_H

data/ext/opencv/cvavgcomp.cpp

@@ -0,0 +1,64 @@
+/************************************************************
+
+   cvavgcomp.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvavgcomp.h"
+/*
+ * Document-class: OpenCV::CvAvgComp
+ *
+ * CvRect with parameter "neighbors"
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_AVGCOMP
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvAvgComp *ptr;
+  return Data_Make_Struct(klass, CvAvgComp, 0, -1, ptr);
+}
+
+/*
+ * Return neighbors
+ * @overload neighbors
+ * @return [Integer] neighbors
+ */
+VALUE
+rb_neighbors(VALUE self)
+{
+  return INT2NUM(CVAVGCOMP(self)->neighbors);
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+  VALUE cvrect = rb_define_class_under(opencv, "CvRect", rb_cObject);
+#endif
+
+  if (rb_klass)
+    return;
+
+  VALUE opencv = rb_module_opencv(), cvrect = cCvRect::rb_class();
+  rb_klass = rb_define_class_under(opencv, "CvAvgComp", cvrect);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "neighbors", RUBY_METHOD_FUNC(rb_neighbors), 0);
+}
+
+__NAMESPACE_END_AVGCOMP
+__NAMESPACE_END_OPENCV

data/ext/opencv/cvavgcomp.h

@@ -0,0 +1,39 @@
+/**********************************************************************
+
+   cvavgcomp.h
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+**********************************************************************/
+#ifndef RUBY_OPENCV_AVGCOMP_H
+#define RUBY_OPENCV_AVGCOMP_H
+
+#define __NAMESPACE_BEGIN_AVGCOMP namespace cCvAvgComp {
+#define __NAMESPACE_END_AVGCOMP }
+
+#include <opencv.h>
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_AVGCOMP
+
+VALUE rb_class();
+
+void init_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+VALUE rb_neighbors(VALUE self);
+
+__NAMESPACE_END_AVGCOMP
+
+inline CvAvgComp *CVAVGCOMP(VALUE object){
+  CvAvgComp *ptr;
+  Data_Get_Struct(object, CvAvgComp, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+
+#endif // RUBY_OPENCV_AVGCOMP_H

data/ext/opencv/cvbox2d.cpp

@@ -0,0 +1,195 @@
+/************************************************************
+
+   cvbox2d.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvbox2d.h"
+/*
+ * Document-class: OpenCV::CvBox2D
+ *
+ * Stores coordinates of a rotated rectangle.
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVBOX2D
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvBox2D *ptr;
+  return Data_Make_Struct(klass, CvBox2D, 0, -1, ptr);
+}
+
+/*
+ * Create a box
+ * @overload new(center=nil, size=nil, angle=nil)
+ *   @param center [CvPoint2D32f,nil] Center of the box
+ *   @param size [CvSize,nil] Size of the box
+ *   @param angle [Number,nil] Angle between the horizontal axis and the first side in degrees
+ * @return [CvBox2D] New box
+ */
+VALUE
+rb_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE center, size, angle;
+  CvBox2D* self_ptr = CVBOX2D(self);
+  rb_scan_args(argc, argv, "03", &center, &size, &angle);
+  
+  if (!NIL_P(center)) {
+    self_ptr->center = VALUE_TO_CVPOINT2D32F(center);
+  }
+  if (!NIL_P(size)) {
+    self_ptr->size = VALUE_TO_CVSIZE2D32F(size);
+    self_ptr->angle = NUM2DBL(angle);
+  }
+  
+  return self;
+}
+
+/*
+ * Returns center point of the box
+ * @overload center
+ * @return [CvPoint2D32f] Center of the box
+ */
+VALUE
+rb_center(VALUE self)
+{
+  return REFER_OBJECT(cCvPoint2D32f::rb_class(), &CVBOX2D(self)->center, self);
+}
+
+/*
+ * Set center point of the box
+ * @overload center=value
+ *   @param value [CvPoint2D32f] Center of the box
+ * @return [CvBox2D] self
+ */
+VALUE
+rb_set_center(VALUE self, VALUE value)
+{
+  CVBOX2D(self)->center = VALUE_TO_CVPOINT2D32F(value);
+  return self;
+}
+
+/*
+ * Returns size of the box
+ * @overload size
+ * @return [CvSize2D32f] Size of the box
+ */
+VALUE
+rb_size(VALUE self)
+{
+  return REFER_OBJECT(cCvSize2D32f::rb_class(), &CVBOX2D(self)->size, self);
+}
+
+/*
+ * Set size of the box
+ * @overload size=value
+ *   @param value [CvSize2D32f] Size of the box
+ * @return [CvBox2D] self
+ */
+VALUE
+rb_set_size(VALUE self, VALUE value)
+{
+  CVBOX2D(self)->size = VALUE_TO_CVSIZE2D32F(value);
+  return self;
+}
+
+/*
+ * Returns angle of the box
+ * @overload angle
+ * @return [Float] Angle of the box
+ */
+VALUE
+rb_angle(VALUE self)
+{
+  return rb_float_new(CVBOX2D(self)->angle);
+}
+
+/*
+ * Set angle of the box
+ * @overload angle=value
+ *   @param value [Number] Angle of the box
+ * @return [CvBox2D] self
+ */
+VALUE
+rb_set_angle(VALUE self, VALUE value)
+{
+  CVBOX2D(self)->angle = NUM2DBL(value);
+  return self;
+}
+
+/*
+ * Find box vertices
+ * @overload points
+ * @return [Array<CvPoint2D32f>] Vertices of the box
+ * @opencv_func cvBoxPoints
+ */
+VALUE
+rb_points(VALUE self)
+{
+  const int n = 4;
+  CvPoint2D32f p[n];
+  try {
+    cvBoxPoints(*CVBOX2D(self), p);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  VALUE points = rb_ary_new2(n);
+  for (int i = 0; i < n; ++i) {
+    rb_ary_store(points, i, cCvPoint2D32f::new_object(p[i]));
+  }
+  return points;
+}
+
+VALUE
+new_object()
+{
+  return rb_allocate(cCvBox2D::rb_class());
+}
+
+VALUE
+new_object(CvBox2D box)
+{
+  VALUE object = rb_allocate(rb_klass);
+  *CVBOX2D(object) = box;
+  return object;
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+#endif
+
+  if (rb_klass)
+    return;
+
+  VALUE opencv = rb_module_opencv();
+  rb_klass = rb_define_class_under(opencv, "CvBox2D", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), -1);
+  rb_define_method(rb_klass, "center", RUBY_METHOD_FUNC(rb_center), 0);
+  rb_define_method(rb_klass, "center=", RUBY_METHOD_FUNC(rb_set_center), 1);
+  rb_define_method(rb_klass, "size", RUBY_METHOD_FUNC(rb_size), 0);
+  rb_define_method(rb_klass, "size=", RUBY_METHOD_FUNC(rb_set_size), 1);
+  rb_define_method(rb_klass, "angle", RUBY_METHOD_FUNC(rb_angle), 0);
+  rb_define_method(rb_klass, "angle=", RUBY_METHOD_FUNC(rb_set_angle), 1);
+  rb_define_method(rb_klass, "points", RUBY_METHOD_FUNC(rb_points), 0);
+}
+
+__NAMESPACE_END_CVBOX2D
+__NAMESPACE_END_OPENCV

data/ext/opencv/cvbox2d.h

@@ -0,0 +1,61 @@
+/************************************************************
+
+   cvbox2d.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVBOX2D_H
+#define RUBY_OPENCV_CVBOX2D_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVBOX2D namespace cCvBox2D {
+#define __NAMESPACE_END_CVBOX2D }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVBOX2D
+
+VALUE rb_class();
+
+void init_ruby_class();
+
+VALUE rb_allocate(VALUE klass);
+
+VALUE rb_initialize(int argc, VALUE *argv, VALUE self);
+VALUE rb_center(VALUE self);
+VALUE rb_set_center(VALUE self, VALUE value);
+VALUE rb_size(VALUE self);
+VALUE rb_set_size(VALUE self, VALUE value);
+VALUE rb_angle(VALUE self);
+VALUE rb_set_angle(VALUE self, VALUE value);
+VALUE rb_points(VALUE self);
+
+VALUE new_object();
+VALUE new_object(CvBox2D box);
+
+__NAMESPACE_END_CVBOX2D
+
+inline CvBox2D*
+CVBOX2D(VALUE object){
+  CvBox2D *ptr;
+  Data_Get_Struct(object, CvBox2D, ptr);
+  return ptr;
+}
+
+inline CvBox2D
+VALUE_TO_CVBOX2D(VALUE object){
+  if (rb_obj_is_kind_of(object, cCvBox2D::rb_class())) {
+    return *CVBOX2D(object);
+  }
+  else {
+    raise_typeerror(object, cCvBox2D::rb_class());
+  }
+  throw "Should never reach here";
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVBOX2D_H

data/ext/opencv/cvcapture.cpp

@@ -0,0 +1,607 @@
+/************************************************************
+
+   cvcapture.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cvcapture.h"
+/*
+ * Document-class: OpenCV::CvCapture
+ *
+ * Class for video capturing from video files or cameras
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCAPTURE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+cvcapture_free(void *ptr)
+{ 
+  if (ptr)
+    cvReleaseCapture((CvCapture**)&ptr);
+}
+
+/*
+ * Open video file or a capturing device for video capturing
+ * @scope class
+ * @overload open(dev = nil)
+ *   @param dev [String,Fixnum,Simbol,nil] Video capturing device
+ *     * If dev is a string (i.e "stream.avi"), reads video stream from a file.
+ *     * If dev is a number or symbol (included in CvCapture::INTERFACE), reads video stream from a device.
+ *     * If dev is a nil, same as CvCapture.open(:any)
+ * @return [CvCapture] Opened CvCapture instance
+ * @opencv_func cvCaptureFromCAM
+ * @opencv_func cvCaptureFromFile
+ */
+VALUE
+rb_open(int argc, VALUE *argv, VALUE self)
+{
+  VALUE device;
+  rb_scan_args(argc, argv, "01", &device);
+  CvCapture *capture = 0;
+  try {
+    switch (TYPE(device)) {
+    case T_STRING:
+      capture = cvCaptureFromFile(StringValueCStr(device));
+      break;
+    case T_FIXNUM:
+      capture = cvCaptureFromCAM(FIX2INT(device));
+      break;
+    case T_SYMBOL: {
+      VALUE cap_index = rb_hash_lookup(rb_const_get(rb_class(), rb_intern("INTERFACE")), device);
+      if (NIL_P(cap_index))
+        rb_raise(rb_eArgError, "undefined interface.");
+      capture = cvCaptureFromCAM(NUM2INT(cap_index));
+      break;
+    }
+    case T_NIL:
+      capture = cvCaptureFromCAM(CV_CAP_ANY);
+      break;
+    }
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  if (!capture)
+    rb_raise(rb_eStandardError, "Invalid capture format.");
+  return Data_Wrap_Struct(rb_klass, 0, cvcapture_free, capture);
+}
+
+/*
+ * Grabs the next frame from video file or capturing device.
+ * @overload grab
+ * @return [Boolean] If grabbing a frame successed, returns true, otherwise returns false.
+ * @opencv_func cvGrabFrame
+ */
+VALUE
+rb_grab(VALUE self)
+{
+  int grab = 0;
+  try {
+    grab = cvGrabFrame(CVCAPTURE(self));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return grab ? Qtrue : Qfalse;
+}
+
+/*
+ * Decodes and returns the grabbed video frame.
+ * @overload retrieve
+ * @return [IplImage] Grabbed video frame
+ * @return [nil] Failed to grabbing a frame
+ * @opencv_func cvRetrieveFrame
+ */
+VALUE
+rb_retrieve(VALUE self)
+{
+  VALUE image = Qnil;
+  IplImage *frame = NULL;
+  try {
+    if (!(frame = cvRetrieveFrame(CVCAPTURE(self)))) {
+      return Qnil;
+    }
+    image = cIplImage::new_object(frame->width, frame->height,
+				  CV_MAKETYPE(IPL2CV_DEPTH(frame->depth), frame->nChannels));
+    if (frame->origin == IPL_ORIGIN_TL) {
+      cvCopy(frame, CVARR(image));
+    }
+    else {
+      cvFlip(frame, CVARR(image));
+    }
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return image;
+
+}
+
+/*
+ * Grabs, decodes and returns the next video frame.
+ * @overload query
+ * @return [IplImage] Next video frame
+ * @return [nil] Failed to read next video frame
+ * @opencv_func cvQueryFrame
+ */
+VALUE
+rb_query(VALUE self)
+{
+  VALUE image = Qnil;
+  IplImage *frame = NULL;
+  try {
+    if (!(frame = cvQueryFrame(CVCAPTURE(self)))) {
+      return Qnil;
+    }
+    image = cIplImage::new_object(frame->width, frame->height,
+				  CV_MAKETYPE(IPL2CV_DEPTH(frame->depth), frame->nChannels));
+    if (frame->origin == IPL_ORIGIN_TL) {
+      cvCopy(frame, CVARR(image));
+    }
+    else {
+      cvFlip(frame, CVARR(image));
+    }
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return image;
+}
+
+VALUE
+rb_get_capture_property(VALUE self, int id)
+{
+  double result = 0;
+  try {
+    result = cvGetCaptureProperty(CVCAPTURE(self), id);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return rb_float_new(result);
+}
+
+VALUE
+rb_set_capture_property(VALUE self, int id, VALUE value)
+{
+  double result = 0;
+  try {
+    result = cvSetCaptureProperty(CVCAPTURE(self), id, NUM2DBL(value));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return rb_float_new(result);
+}
+
+/*
+ * Get film current position in milliseconds or video capture timestamp.
+ * @overload millisecond
+ * @return [Number] Current position of the video file in milliseconds or video capture timestamp
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_POS_MSEC)
+ */
+VALUE
+rb_get_millisecond(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_POS_MSEC);
+}
+
+/*
+ * Set film current position in milliseconds or video capture timestamp.
+ * @overload millisecond=value
+ *   @param value [Number] Position in milliseconds or video capture timestamp.
+ * @return [Number]
+ * @opencv_func cvSetCaptureProperty (propId=CV_CAP_PROP_POS_MSEC)
+ */
+VALUE
+rb_set_millisecond(VALUE self, VALUE value)
+{
+  return rb_set_capture_property(self, CV_CAP_PROP_POS_MSEC, value);
+}
+
+/*
+ * Get 0-based index of the frame to be decoded/captured next
+ * @overload frames
+ * @return [Number] 0-based index of the frame to be decoded/captured next
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_POS_FRAMES)
+ */
+VALUE
+rb_get_frames(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_POS_FRAMES);
+}
+
+/*
+ * Set 0-based index of the frame to be decoded/captured next
+ * @overload frames=value
+ *   @param value [Number] 0-based index of the frame to be decoded/captured next
+ * @return [Number]
+ * @opencv_func cvSetCaptureProperty (propId=CV_CAP_PROP_POS_FRAMES)
+ */
+VALUE
+rb_set_frames(VALUE self, VALUE value)
+{
+  return rb_set_capture_property(self, CV_CAP_PROP_POS_FRAMES, value);
+}
+/*
+ * Get relative position of video file
+ * @overload avi_ratio
+ * @return [Number] Relative position of video file (0: Start of the film, 1: End of the film)
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_POS_AVI_RATIO)
+ */
+VALUE
+rb_get_avi_ratio(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_POS_AVI_RATIO);
+}
+/*
+ * Set relative position of video file
+ * @overload avi_ratio=value
+ *   @param value [Number] Relative position of video file (0: Start of the film, 1: End of the film)
+ * @return [Number]
+ * @opencv_func cvSetCaptureProperty (propId=CV_CAP_PROP_POS_AVI_RATIO)
+ */
+VALUE
+rb_set_avi_ratio(VALUE self, VALUE value)
+{
+  return rb_set_capture_property(self, CV_CAP_PROP_POS_AVI_RATIO, value);
+}
+
+/*
+ * Get size of frames in the video stream.
+ * @overload size
+ * @return [Size] Size of frames in the video stream.
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_FRAME_WIDTH,CV_CAP_PROP_FRAME_HEIGHT)
+ */
+VALUE
+rb_get_size(VALUE self)
+{
+  CvSize size;
+  try {
+    CvCapture* self_ptr = CVCAPTURE(self);
+    size = cvSize((int)cvGetCaptureProperty(self_ptr, CV_CAP_PROP_FRAME_WIDTH),
+		  (int)cvGetCaptureProperty(self_ptr, CV_CAP_PROP_FRAME_HEIGHT));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return cCvSize::new_object(size);
+}
+
+/*
+ * Set size of frames in the video stream.
+ * @overload size=value
+ *   @param value [CvSize] Size of frames
+ * @return [Number]
+ * @opencv_func cvSetCaptureProperty (propId=CV_CAP_PROP_FRAME_WIDTH,CV_CAP_PROP_FRAME_HEIGHT)
+ */
+VALUE
+rb_set_size(VALUE self, VALUE value)
+{
+  double result = 0;
+  CvSize size = VALUE_TO_CVSIZE(value);
+  try {
+    CvCapture* self_ptr = CVCAPTURE(self);
+    cvSetCaptureProperty(self_ptr, CV_CAP_PROP_FRAME_WIDTH, size.width);
+    result = cvSetCaptureProperty(self_ptr, CV_CAP_PROP_FRAME_HEIGHT, size.height);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return DBL2NUM(result);
+}
+
+/*
+ * Get width of frames in the video stream.
+ * @overload width
+ * @return [Number] Width of frames in the video stream.
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_FRAME_WIDTH)
+ */
+VALUE
+rb_get_width(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_FRAME_WIDTH);
+}
+
+/*
+ * Set width of frames in the video stream.
+ * @overload width=value
+ *   @param value [Number] Width of frames
+ * @return [Number]
+ * @opencv_func cvSetCaptureProperty (propId=CV_CAP_PROP_FRAME_WIDTH)
+ */
+VALUE
+rb_set_width(VALUE self, VALUE value)
+{
+  return rb_set_capture_property(self, CV_CAP_PROP_FRAME_WIDTH, value);
+}
+
+/*
+ * Get height of frames in the video stream.
+ * @overload height
+ * @return [Number] Height of frames in the video stream.
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_FRAME_HEIGHT)
+ */
+VALUE
+rb_get_height(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_FRAME_HEIGHT);
+}
+
+/*
+ * Set height of frames in the video stream.
+ * @overload height=value
+ *   @param value [Number] Height of frames
+ * @return [Number]
+ * @opencv_func cvSetCaptureProperty (propId=CV_CAP_PROP_FRAME_HEIGHT)
+ */
+VALUE
+rb_set_height(VALUE self, VALUE value)
+{
+  return rb_set_capture_property(self, CV_CAP_PROP_FRAME_HEIGHT, value);
+}
+
+/*
+ * Get frame rate
+ * @overload fps
+ * @return [Number] Frame rate
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_FPS)
+ */
+VALUE
+rb_get_fps(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_FPS);
+}
+
+/*
+ * Set frame rate
+ * @overload fps=value
+ *   @param value [Number] Frame rate
+ * @return [Number]
+ * @opencv_func cvSetCaptureProperty (propId=CV_CAP_PROP_FPS)
+ */
+VALUE
+rb_set_fps(VALUE self, VALUE value)
+{
+  return rb_set_capture_property(self, CV_CAP_PROP_FPS, value);
+}
+
+/*
+ * Get 4 character code of codec. see http://www.fourcc.org/
+ * @overload fourcc
+ * @return [Number] Codec code
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_FOURCC)
+ */
+VALUE
+rb_get_fourcc(VALUE self)
+{
+  char str[4];
+  double fourcc = cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FOURCC);
+  sprintf(str, "%s", (char*)&fourcc);
+  return rb_str_new2(str);
+}
+
+/*
+ * Get number of frames in video file.
+ * @overload frame_count
+ * @return [Number] Number of frames
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_FRAME_COUNT)
+ */
+VALUE
+rb_get_frame_count(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_FRAME_COUNT);
+}
+
+/*
+ * Get format of images returned by CvCapture#retrieve
+ * @overload format
+ * @return [Number] format
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_FORMAT)
+ */
+VALUE
+rb_get_format(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_FORMAT);
+}
+
+/*
+ * Get a backend-specific value indicating the current capture mode
+ * @overload mode
+ * @return [Number] Backend-specific value indicating the current capture mode
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_MODE)
+ */
+VALUE
+rb_get_mode(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_MODE);
+}
+
+/*
+ * Get brightness of the image (only for cameras)
+ * @overload brightness
+ * @return [Number] Brightness
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_BRIGHTNESS)
+ */
+VALUE
+rb_get_brightness(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_BRIGHTNESS);
+}
+
+/*
+ * Get contrast of the image (only for cameras)
+ * @overload contrast
+ * @return [Number] Contrast
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_CONTRAST)
+ */
+VALUE
+rb_get_contrast(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_CONTRAST);
+}
+
+/*
+ * Get saturation of the image (only for cameras)
+ * @overload saturation
+ * @return [Number] Saturation
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_SATURATION)
+ */
+VALUE
+rb_get_saturation(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_SATURATION);
+}
+/*
+ * Get hue of the image (only for cameras)
+ * @overload hue
+ * @return [Number] Hue
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_HUE)
+ */
+VALUE
+rb_get_hue(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_HUE);
+}
+
+/*
+ * Get gain of the image (only for cameras)
+ * @overload gain
+ * @return [Number] Gain
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_GAIN)
+ */
+VALUE
+rb_get_gain(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_GAIN);
+}
+
+/*
+ * Get exposure (only for cameras)
+ * @overload exposure
+ * @return [Number] Exposure
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_EXPOSURE)
+ */
+VALUE
+rb_get_exposure(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_EXPOSURE);
+}
+
+/*
+ * Get boolean flags indicating whether images should be converted to RGB
+ * @overload convert_rgb
+ * @return [Boolean] Whether images should be converted to RGB
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_CONVERT_RGB)
+ */
+VALUE
+rb_get_convert_rgb(VALUE self)
+{
+  int flag = 0;
+  try {
+    flag = (int)cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_CONVERT_RGB);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return flag ? Qtrue : Qfalse;
+}
+
+/*
+ * Get rectification flag for stereo cameras (note: only supported by DC1394 v 2.x backend currently)
+ * @overload rectification
+ * @return [Number] Rectification flag
+ * @opencv_func cvGetCaptureProperty (propId=CV_CAP_PROP_RECTIFICATION)
+ */
+VALUE
+rb_get_rectification(VALUE self)
+{
+  return rb_get_capture_property(self, CV_CAP_PROP_RECTIFICATION);
+}
+
+void
+init_ruby_class()
+{
+#if 0
+  // For documentation using YARD
+  VALUE opencv = rb_define_module("OpenCV");
+#endif
+
+  if (rb_klass)
+    return;
+
+  VALUE opencv = rb_module_opencv();
+  
+  rb_klass = rb_define_class_under(opencv, "CvCapture", rb_cData);
+  
+  VALUE video_interface = rb_hash_new();
+  /*
+   * :any, :mil, :vfw, :v4l, :v4l2, :fireware, :ieee1394, :dc1394, :cmu1394,
+   * :stereo, :tyzx, :tyzx_left, :tyzx_right, :tyzx_color, :tyzx_z, :qt, :qtuicktime
+   */
+  rb_define_const(rb_klass, "INTERFACE", video_interface);
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("any")), INT2FIX(CV_CAP_ANY));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("mil")), INT2FIX(CV_CAP_MIL));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("vfw")), INT2FIX(CV_CAP_VFW));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("v4l")), INT2FIX(CV_CAP_V4L));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("v4l2")), INT2FIX(CV_CAP_V4L2));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("fireware")), INT2FIX(CV_CAP_FIREWARE));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("ieee1394")), INT2FIX(CV_CAP_IEEE1394));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("dc1394")), INT2FIX(CV_CAP_DC1394));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("cmu1394")), INT2FIX(CV_CAP_CMU1394));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("stereo")), INT2FIX(CV_CAP_STEREO));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx")), INT2FIX(CV_CAP_TYZX));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_left")), INT2FIX(CV_TYZX_LEFT));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_right")), INT2FIX(CV_TYZX_RIGHT));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_color")), INT2FIX(CV_TYZX_COLOR));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("tyzx_z")), INT2FIX(CV_TYZX_Z));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("qt")), INT2FIX(CV_CAP_QT));
+  rb_hash_aset(video_interface, ID2SYM(rb_intern("quicktime")), INT2FIX(CV_CAP_QT));
+  
+  rb_define_singleton_method(rb_klass, "open", RUBY_METHOD_FUNC(rb_open), -1);
+  
+  rb_define_method(rb_klass, "grab", RUBY_METHOD_FUNC(rb_grab), 0);
+  rb_define_method(rb_klass, "retrieve", RUBY_METHOD_FUNC(rb_retrieve), 0);
+  rb_define_method(rb_klass, "query", RUBY_METHOD_FUNC(rb_query), 0);
+  rb_define_method(rb_klass, "millisecond", RUBY_METHOD_FUNC(rb_get_millisecond), 0);
+  rb_define_method(rb_klass, "millisecond=", RUBY_METHOD_FUNC(rb_set_millisecond), 1);
+  rb_define_method(rb_klass, "frames", RUBY_METHOD_FUNC(rb_get_frames), 0);
+  rb_define_method(rb_klass, "frames=", RUBY_METHOD_FUNC(rb_set_frames), 1);
+  rb_define_method(rb_klass, "avi_ratio", RUBY_METHOD_FUNC(rb_get_avi_ratio), 0);
+  rb_define_method(rb_klass, "avi_ratio=", RUBY_METHOD_FUNC(rb_set_avi_ratio), 1);
+  rb_define_method(rb_klass, "size", RUBY_METHOD_FUNC(rb_get_size), 0);
+  rb_define_method(rb_klass, "size=", RUBY_METHOD_FUNC(rb_set_size), 1);
+  rb_define_method(rb_klass, "width", RUBY_METHOD_FUNC(rb_get_width), 0);
+  rb_define_method(rb_klass, "width=", RUBY_METHOD_FUNC(rb_set_width), 1);
+  rb_define_method(rb_klass, "height", RUBY_METHOD_FUNC(rb_get_height), 0);
+  rb_define_method(rb_klass, "height=", RUBY_METHOD_FUNC(rb_set_height), 1);
+  rb_define_method(rb_klass, "fps", RUBY_METHOD_FUNC(rb_get_fps), 0);
+  rb_define_method(rb_klass, "fps=", RUBY_METHOD_FUNC(rb_set_fps), 1);
+  rb_define_method(rb_klass, "fourcc", RUBY_METHOD_FUNC(rb_get_fourcc), 0);
+  rb_define_method(rb_klass, "frame_count", RUBY_METHOD_FUNC(rb_get_frame_count), 0);
+  rb_define_method(rb_klass, "format", RUBY_METHOD_FUNC(rb_get_format), 0);
+  rb_define_method(rb_klass, "mode", RUBY_METHOD_FUNC(rb_get_mode), 0);
+  rb_define_method(rb_klass, "brightness", RUBY_METHOD_FUNC(rb_get_brightness), 0);
+  rb_define_method(rb_klass, "contrast", RUBY_METHOD_FUNC(rb_get_contrast), 0);
+  rb_define_method(rb_klass, "saturation", RUBY_METHOD_FUNC(rb_get_saturation), 0);
+  rb_define_method(rb_klass, "hue", RUBY_METHOD_FUNC(rb_get_hue), 0);
+  rb_define_method(rb_klass, "gain", RUBY_METHOD_FUNC(rb_get_gain), 0);
+  rb_define_method(rb_klass, "exposure", RUBY_METHOD_FUNC(rb_get_exposure), 0);
+  rb_define_method(rb_klass, "convert_rgb", RUBY_METHOD_FUNC(rb_get_convert_rgb), 0);
+  rb_define_method(rb_klass, "rectification", RUBY_METHOD_FUNC(rb_get_rectification), 0);
+}
+
+__NAMESPACE_END_CVCAPTURE
+__NAMESPACE_END_OPENCV
+