opencv 0.0.6

data/ext/cvcapture.cpp

@@ -0,0 +1,276 @@
+/************************************************************
+
+   cvcapture.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include"cvcapture.h"
+/*
+ * Document-class: OpenCV::CvCapture
+ *
+ * Capture image from video stream.
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCAPTURE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * 
+   * note: this comment is used by rdoc.
+   */
+  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}: video source */
+  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_millisecond), 0);
+  rb_define_method(rb_klass, "frames", RUBY_METHOD_FUNC(rb_frames), 0);
+  rb_define_method(rb_klass, "size", RUBY_METHOD_FUNC(rb_size), 0);
+  rb_define_method(rb_klass, "width", RUBY_METHOD_FUNC(rb_width), 0);
+  rb_define_method(rb_klass, "height", RUBY_METHOD_FUNC(rb_height), 0);
+  rb_define_method(rb_klass, "fps", RUBY_METHOD_FUNC(rb_fps), 0);
+  rb_define_method(rb_klass, "fourcc", RUBY_METHOD_FUNC(rb_fourcc), 0);
+  rb_define_method(rb_klass, "frame_count", RUBY_METHOD_FUNC(rb_frame_count), 0);
+}
+
+void
+free(void *ptr)
+{ 
+  if(ptr)
+    cvReleaseCapture((CvCapture**)&ptr);
+}
+
+/*
+ * call-seq:
+ *   CvCapture.open(<i>[dev = -1]</i>)
+ *
+ * Reading video stream from the specified file or camera device.
+ * If <i>dev</i> is string (i.e "stream.avi"), reading video stream from file.
+ * If <i>dev</i> is number or symbol(include CvCapture::INTERFACE),
+ * reading video stream from camera. 
+ * Currently two camera interfaces can be used on Windows:
+ * * Video for Windows(VFW)
+ * * Matrox Imaging Library(MIL)
+ * and two on Linux
+ * * V4L
+ * * FireWire(IEEE1394).
+ * If there is only one camera or it does not matter what camera to use <i>nil</i> may be passed.
+ */
+VALUE
+rb_open(int argc, VALUE *argv, VALUE self)
+{
+  VALUE device, i;
+  rb_scan_args(argc, argv, "01", &device);
+  CvCapture *capture = 0;
+  switch (TYPE(device)) {
+  case T_STRING:
+    capture = cvCaptureFromFile(StringValueCStr(device));
+    break;
+  case T_FIXNUM:
+    capture = cvCaptureFromCAM(FIX2INT(device));
+    break;
+  case T_SYMBOL:    
+    i = rb_hash_aref(rb_const_get(rb_class(), rb_intern("INTERFACE")), device);
+    if (NIL_P(i))
+      rb_raise(rb_eArgError, "undefined interface.");
+    capture = cvCaptureFromCAM(NUM2INT(i));
+    break;
+  case T_NIL:
+    capture = cvCaptureFromCAM(CV_CAP_ANY);
+    break;
+  }
+  if (!capture)
+    rb_raise(rb_eStandardError, "Invalid capture format.");
+  return Data_Wrap_Struct(rb_klass, 0, free, capture);
+}
+
+
+/*
+ * 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)
+{
+  return cvGrabFrame(CVCAPTURE(self)) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   retrieve -> CvMat 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;
+}
+
+/*
+ * call-seq:
+ *   query -> CvMat or nil
+ *
+ * Grabs and returns a frame camera or file. Just a combination of grab and retrieve in one call.
+ */
+VALUE
+rb_query(VALUE self)
+{
+  IplImage *frame = cvQueryFrame(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;
+}
+
+/*
+ * Film current position in milliseconds or video capture timestamp.
+ */
+VALUE
+rb_millisecond(VALUE self)
+{
+  return rb_dbl2big(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_POS_MSEC));
+}
+
+/*
+ * 0-based index of the frame to be decoded/captured next
+ */
+VALUE
+rb_frames(VALUE self)
+{
+  return rb_float_new(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_POS_FRAMES));
+}
+
+/*
+ * Relative position of video file (0 - start of the film, 1 - end of the film)
+ */
+VALUE
+rb_avi_ratio(VALUE self)
+{
+  return rb_float_new(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_POS_AVI_RATIO));  
+}
+
+/*
+ * Size of frames in the video stream.
+ */
+VALUE
+rb_size(VALUE self)
+{
+  return cCvSize::new_object(cvSize((int)cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FRAME_WIDTH), (int)cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FRAME_HEIGHT))); 
+}
+
+/*
+ * Width of frames in the video stream.
+ */
+VALUE
+rb_width(VALUE self)
+{
+  return rb_dbl2big(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FRAME_WIDTH));
+}
+
+/*
+ * Height of frames in the video stream.
+ */
+VALUE
+rb_height(VALUE self)
+{
+  return rb_dbl2big(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FRAME_HEIGHT));
+}
+
+/*
+ * Frame rate
+ */
+VALUE
+rb_fps(VALUE self)
+{
+  return rb_dbl2big(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FPS));
+}
+
+/*
+ * 4character code of codec. see http://www.fourcc.org/
+ */
+VALUE
+rb_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);
+}
+
+/*
+ * Number of frames in video file.
+ */
+VALUE
+rb_frame_count(VALUE self)
+{
+  return rb_dbl2big(cvGetCaptureProperty(CVCAPTURE(self), CV_CAP_PROP_FRAME_COUNT));
+}
+
+
+__NAMESPACE_END_CVCAPTURE
+__NAMESPACE_END_OPENCV

data/ext/cvcapture.h

@@ -0,0 +1,54 @@
+/************************************************************
+
+   cvcapture.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCAPTURE_H
+#define RUBY_OPENCV_CVCAPTURE_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCAPTURE namespace cCvCapture{
+#define __NAMESPACE_END_CVCAPTURE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCAPTURE
+
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+void free(void *ptr);
+VALUE rb_open(int argc, VALUE *argv, VALUE klass);
+
+VALUE rb_grab(VALUE self);
+VALUE rb_retrieve(VALUE self);
+VALUE rb_query(VALUE self);
+
+VALUE rb_millisecond(VALUE self);
+VALUE rb_frames(VALUE self);
+VALUE rb_avi_ratio(VALUE self);
+VALUE rb_size(VALUE self);
+VALUE rb_width(VALUE self);
+VALUE rb_height(VALUE self);
+VALUE rb_fps(VALUE self);
+VALUE rb_fourcc(VALUE self);
+VALUE rb_frame_count(VALUE self);
+
+__NAMESPACE_END_CVCAPTURE
+
+
+inline CvCapture *CVCAPTURE(VALUE object){
+  CvCapture *ptr;
+  Data_Get_Struct(object, CvCapture, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCAPTURE_H

data/ext/cvchain.cpp

@@ -0,0 +1,184 @@
+/************************************************************
+
+   cvchain.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvchain.h"
+/*
+ * Document-class: OpenCV::CvChain
+ *
+ * Freeman chain code.
+ * CvMat#find_contours(:method => :code)
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCHAIN
+
+#define APPROX_CHAIN_OPTION(op) NIL_P(op) ? rb_const_get(rb_class(), rb_intern("APPROX_CHAIN_OPTION")) : rb_funcall(rb_const_get(rb_class(), rb_intern("APPROX_CHAIN_OPTION")), rb_intern("merge"), 1, op)
+#define APPROX_CHAIN_METHOD(op) CVMETHOD("APPROX_CHAIN_METHOD", rb_hash_aref(op, ID2SYM(rb_intern("method"))), CV_CHAIN_APPROX_SIMPLE)
+#define APPROX_CHAIN_PARAMETER(op) NUM2INT(rb_hash_aref(op, ID2SYM(rb_intern("parameter"))))
+#define APPROX_CHAIN_MINIMAL_PARAMETER(op) NUM2INT(rb_hash_aref(op, ID2SYM(rb_intern("minimal_parameter"))))
+#define APPROX_CHAIN_RECURSIVE(op) ({VALUE _recursive = rb_hash_aref(op, ID2SYM(rb_intern("recursive"))); NIL_P(_recursive) ? 0 : _recursive == Qfalse ? 0 : 1;})
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+define_ruby_class()
+{
+  if (rb_klass)
+    return;
+  /* 
+   * opencv = rb_define_module("OpenCV");
+   * cvseq = rb_define_class_under(opencv, "CvSeq");
+   * curve = rb_define_module_under(opencv, "Curve");
+   * note: this comment is used by rdoc.
+   */
+  VALUE opencv = rb_module_opencv();
+  VALUE cvseq = cCvSeq::rb_class();
+  VALUE curve = mCurve::rb_module();
+
+  rb_klass = rb_define_class_under(opencv, "CvChain", cvseq);
+  rb_include_module(rb_klass, curve);
+  VALUE approx_chain_option = rb_hash_new();
+  rb_define_const(rb_klass, "APPROX_CHAIN_OPTION", approx_chain_option); 
+  rb_hash_aset(approx_chain_option, ID2SYM(rb_intern("method")), ID2SYM(rb_intern("approx_simple")));
+  rb_hash_aset(approx_chain_option, ID2SYM(rb_intern("parameter")), rb_float_new(0));
+  rb_hash_aset(approx_chain_option, ID2SYM(rb_intern("minimal_parameter")), INT2FIX(0));
+  rb_hash_aset(approx_chain_option, ID2SYM(rb_intern("recursive")), Qfalse);
+
+  rb_define_method(rb_klass, "origin", RUBY_METHOD_FUNC(rb_origin), 0);
+  rb_define_method(rb_klass, "origin=", RUBY_METHOD_FUNC(rb_set_origin), 0);
+  rb_define_method(rb_klass, "codes", RUBY_METHOD_FUNC(rb_codes), 0);
+  rb_define_method(rb_klass, "points", RUBY_METHOD_FUNC(rb_points), 0);
+  rb_define_method(rb_klass, "approx_chain", RUBY_METHOD_FUNC(rb_approx_chain), -1);
+  rb_define_alias(rb_klass, "approx", "approx_chain");
+}
+
+/*
+ * call-seq:
+ *   origin -> cvpoint
+ *
+ * Return Freeman chain code origin.
+ */
+VALUE
+rb_origin(VALUE self)
+{
+  return cCvPoint::new_object(CVCHAIN(self)->origin);
+}
+
+/*
+ * call-seq:
+ *   origin = point -> self
+ *
+ * Set Freeman chain code origin.
+ */
+VALUE
+rb_set_origin(VALUE self, VALUE origin)
+{
+  CVCHAIN(self)->origin = VALUE_TO_CVPOINT(origin);  
+  return self;
+}
+
+/*
+ * call-seq:
+ *   codes -> array(contain fixnum)
+ *
+ * Return Freeman chain codes.
+ */
+VALUE
+rb_codes(VALUE self)
+{
+  CvChain *chain = CVCHAIN(self);
+  CvChainPtReader reader;
+  CvPoint p = chain->origin;
+  VALUE ary = rb_ary_new2(chain->total);
+  cvStartReadChainPoints(chain, &reader);
+  for (int i = 0; i < chain->total; i++) {
+    CV_READ_SEQ_ELEM(reader.code, (*((CvSeqReader*)&(reader))));
+    rb_ary_store(ary, i, CHR2FIX(reader.code));
+  }
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   points -> array(contain cvpoint)
+ *
+ * Return points that represent by Freeman chain code.
+ */
+VALUE
+rb_points(VALUE self)
+{
+  CvChain *chain = CVCHAIN(self);
+  CvChainPtReader reader;
+  CvPoint p = chain->origin;
+  VALUE ary = rb_ary_new2(chain->total);
+  cvStartReadChainPoints(chain, &reader);
+  for (int i = 0; i < chain->total; i++) {
+    CV_READ_CHAIN_POINT(p, reader);
+    rb_ary_store(ary, i, cCvPoint::new_object(p));
+  }
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   approx_chain(<i>[approx_chain_option]</i>) -> cvcontour
+ *
+ * Approximates Freeman chain(s) with polygonal curve.
+ * <i>approx_chain_option</i> should be Hash include these keys.
+ *   :method - Approximation method.
+ *      :approx_none - translate all the points from the chain code into points;
+ *      :approx_simple(default) - compress horizontal, vertical, and diagonal segments, that is,
+ *                                the function leaves only their ending points.
+ *      :approx_tc89_l1
+ *      :approx_tc89_kcos - apply one of the flavors of Teh-Chin chain approximation algorithm.
+ *      If set the difference between the current pixel and seed pixel is considered,
+ *      otherwise difference between neighbor pixels is considered (the range is floating).
+ *   :parameter - Method parameter (not used now).
+ *   :minimal_perimeter (default 0)
+ *      Approximates only those contours whose perimeters are not less than minimal_perimeter. Other chains are removed from the resulting structure.
+ *   :recursive (default false)
+ *      If not nil or false, the function approximates all chains that access can be obtained to
+ *      from self by h_next or v_next links. If 0, the single chain is approximated.
+ *
+ */
+VALUE
+rb_approx_chain(int argc, VALUE *argv, VALUE self)
+{
+  VALUE approx_chain_option, storage;
+  rb_scan_args(argc, argv, "01", &approx_chain_option);
+  approx_chain_option = APPROX_CHAIN_OPTION(approx_chain_option);
+  /* can't compile VC
+  storage = cCvMemStorage::new_object();
+  CvSeq *seq = cvApproxChains(CVSEQ(self), CVMEMSTORAGE(storage),			      
+			      APPROX_CHAIN_METHOD(approx_chain_option),
+			      APPROX_CHAIN_PARAMETER(approx_chain_option),			    
+			      APPROX_CHAIN_MINIMAL_PARAMETER(approx_chain_option),			      
+			      APPROX_CHAIN_RECURSIVE(approx_chain_option));
+  
+  return cCvSeq::new_sequence(cCvContour::rb_class(), seq, cCvPoint::rb_class(), storage);
+  */
+  return Qnil;
+}
+
+VALUE
+new_object()
+{
+  VALUE storage = cCvMemStorage::new_object();
+  CvSeq *seq = cvCreateSeq(CV_SEQ_CHAIN_CONTOUR, sizeof(CvChain), sizeof(CvChainCode), CVMEMSTORAGE(storage));
+  VALUE object = cCvSeq::new_sequence(cCvChain::rb_class(), seq, cCvChainCode::rb_class(), storage);
+  return object;
+}
+
+__NAMESPACE_END_CVCHAIN
+__NAMESPACE_END_OPENCV