ruby-opencv 0.0.8.pre-x86-mingw32

data/ext/opencv/cvcontourtree.h

@@ -0,0 +1,41 @@
+/************************************************************
+
+  cvcontourtree.h -
+
+  $Author: lsxi $
+
+  Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCONTOURTREE_H
+#define RUBY_OPENCV_CVCONTOURTREE_H
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCONTOURTREE namespace cCvContourTree {
+#define __NAMESPACE_END_CVCONTOURTREE }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONTOURTREE
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_p1(VALUE self);
+VALUE rb_p2(VALUE self);
+VALUE rb_contour(VALUE self, VALUE criteria);
+
+VALUE new_object();
+
+__NAMESPACE_END_CVCONTOURTREE
+
+inline CvContourTree*
+CVCONTOURTREE(VALUE object){
+  CvContourTree *ptr;
+  Data_Get_Struct(object, CvContourTree, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCONTOUR_H

data/ext/opencv/cvconvexitydefect.cpp

@@ -0,0 +1,103 @@
+/************************************************************
+
+   cvconvexitydefect.cpp -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#include "cvconvexitydefect.h"
+/*
+ * Document-class: OpenCV::CvConvexityDefect
+ *
+ * Convexity.
+ * C structure is here.
+ *   typedef struct CvConvexityDefect {
+ *     CvPoint* start;
+ *     CvPoint* end;
+ *     CvPoint* depth_point;
+ *     float depth;
+ *   } CvConvexityDefect;
+ *
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONVEXITYDEFECT
+
+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, "CvConvexityDefect", rb_cObject);
+  rb_define_method(rb_klass, "start", RUBY_METHOD_FUNC(rb_start), 0);
+  rb_define_method(rb_klass, "end", RUBY_METHOD_FUNC(rb_end), 0);
+  rb_define_method(rb_klass, "depth_point", RUBY_METHOD_FUNC(rb_depth_point), 0);
+  rb_define_method(rb_klass, "depth", RUBY_METHOD_FUNC(rb_depth), 0);
+}
+
+/*
+ * call-seq:
+ *   start -> cvpoint
+ *
+ * Return start point as CvPoint.
+ */
+VALUE
+rb_start(VALUE self)
+{
+  return cCvPoint::new_object(*CVCONVEXITYDEFECT(self)->start);
+}
+
+/*
+ * call-seq:
+ *   end -> cvpoint
+ *
+ * Return end point as CvPoint.
+ */
+VALUE
+rb_end(VALUE self)
+{
+  return cCvPoint::new_object(*CVCONVEXITYDEFECT(self)->end);
+}
+
+/*
+ * call-seq:
+ *   depth_point -> cvpoint
+ *
+ * Return depth point as CvPoint.
+ */
+VALUE
+rb_depth_point(VALUE self)
+{
+  return cCvPoint::new_object(*CVCONVEXITYDEFECT(self)->depth_point);
+}
+
+/*
+ * call-seq:
+ *   depth -> float
+ *
+ * Return depth.
+ */
+VALUE
+rb_depth(VALUE self)
+{
+  return rb_float_new(CVCONVEXITYDEFECT(self)->depth);
+}
+
+__NAMESPACE_END_CVCONVEXITYDEFECT
+__NAMESPACE_END_OPENCV

data/ext/opencv/cvconvexitydefect.h

@@ -0,0 +1,42 @@
+/************************************************************
+
+   cvconvexitydefect.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2007 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVCONVEXITYDEFECT_H
+#define RUBY_OPENCV_CVCONVEXITYDEFECT_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVCONVEXITYDEFECT namespace cCvConvexityDefect {
+#define __NAMESPACE_END_CVCONVEXITYDEFECT }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVCONVEXITYDEFECT
+
+VALUE rb_class();
+
+void define_ruby_class();
+
+VALUE rb_start(VALUE self);
+VALUE rb_end(VALUE self);
+VALUE rb_depth_point(VALUE self);
+VALUE rb_depth(VALUE self);
+
+__NAMESPACE_END_CVCONVEXITYDEFECT
+
+inline CvConvexityDefect*
+CVCONVEXITYDEFECT(VALUE object)
+{
+  CvConvexityDefect *ptr;
+  Data_Get_Struct(object, CvConvexityDefect, ptr);
+  return ptr;
+}
+
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVCONVEXITYDEFECT_H

data/ext/opencv/cverror.cpp

@@ -0,0 +1,159 @@
+/************************************************************
+
+    cverror.cpp -
+
+    $Author: lsxi $
+
+    Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#include "cverror.h"
+/*
+ * Document-class: OpenCV::CvError
+ * 
+ * =Internal OpenCV errors
+ *
+ * This module collect OpenCV internal error wrapper classes.
+ * * CvStatusBackTrace
+ * * CvStatusError
+ * * CvStatusInternal
+ * * CvStatusNoMemory
+ * * CvStatusBadArgument
+ * * CvStatusNoConverge
+ * * CvStatusAutoTrace
+ *
+ * * CvHeaderIsNull
+ * * CvBadImageSize
+ * * CvBadOffset
+ * * CvBadDataPointer
+ * * CvBadStep
+ * * CvBadModelOrChannelSequence
+ * * CvBadNumChannels
+ * * CvBadAlphaChannel
+ * * CvBadOrder
+ * * CvBadOrigin
+ * * CvBadAlign
+ * * CvBadCallback
+ * * CvBadTileSize
+ * * CvBadCOI
+ * * CvBadROISize
+ * 
+ * * CvMaskIsTiled
+ *
+ * * CvStatusNullPointer
+ * * CvStatusVectorLengthError
+ * * CvStatusFilterStructContentError
+ * * CvStatusKernelStructContentError
+ * * CvStatusFilterOffsetError
+ * 
+ * * CvStatusBadSize
+ * * CvStatusDivByZero
+ * * CvStatusInplaceNotSupported
+ * * CvStatusObjectNotFound
+ * * CvStatusUnmatchedFormant
+ * * CvStatusUnsupportedFormats
+ * * CvStatusOutOfRange
+ * * CvStatusParseError
+ * * CvStatusNotImplemented
+ * * CvStsBadMemoryBlock
+ */
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVERROR
+
+st_table *cv_error = st_init_numtable();
+    
+VALUE rb_klass;
+
+void
+REGISTER_CVERROR(const char* object_name, int error_code)
+{
+  st_insert(cv_error, (st_data_t)error_code,
+	    (st_data_t)rb_define_class_under(rb_module_opencv(), object_name, 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, "CvError", rb_eStandardError);
+  REGISTER_CVERROR("CvStsBackTrace", CV_StsBackTrace);
+  REGISTER_CVERROR("CvStsError", CV_StsError);
+  REGISTER_CVERROR("CvStsInternal", CV_StsInternal);
+  REGISTER_CVERROR("CvStsNoMem", CV_StsNoMem);
+  REGISTER_CVERROR("CvStsBadArg", CV_StsBadArg);
+  REGISTER_CVERROR("CvStsBadFunc", CV_StsBadFunc);
+  REGISTER_CVERROR("CvStsNoConv", CV_StsNoConv);
+  REGISTER_CVERROR("CvStsAutoTrace", CV_StsAutoTrace);
+  REGISTER_CVERROR("CvHeaderIsNull", CV_HeaderIsNull);
+  REGISTER_CVERROR("CvBadImageSize", CV_BadImageSize);
+  REGISTER_CVERROR("CvBadOffset", CV_BadOffset);
+  REGISTER_CVERROR("CvBadDataPtr", CV_BadDataPtr);
+  REGISTER_CVERROR("CvBadStep", CV_BadStep);
+  REGISTER_CVERROR("CvBadModelOrChSeq", CV_BadModelOrChSeq);
+  REGISTER_CVERROR("CvBadNumChannels", CV_BadNumChannels);
+  REGISTER_CVERROR("CvBadNumChannel1U", CV_BadNumChannel1U);
+  REGISTER_CVERROR("CvBadDepth", CV_BadDepth);
+  REGISTER_CVERROR("CvBadAlphaChannel", CV_BadAlphaChannel);
+  REGISTER_CVERROR("CvBadOrder", CV_BadOrder);
+  REGISTER_CVERROR("CvBadOrigin", CV_BadOrigin);
+  REGISTER_CVERROR("CvBadAlign", CV_BadAlign);
+  REGISTER_CVERROR("CvBadCallBack", CV_BadCallBack);
+  REGISTER_CVERROR("CvBadTileSize", CV_BadTileSize);
+  REGISTER_CVERROR("CvBadCOI", CV_BadCOI);
+  REGISTER_CVERROR("CvBadROISize", CV_BadROISize);
+  REGISTER_CVERROR("CvMaskIsTiled", CV_MaskIsTiled);
+  REGISTER_CVERROR("CvStsNullPtr", CV_StsNullPtr);
+  REGISTER_CVERROR("CvStsVecLengthErr", CV_StsVecLengthErr);
+  REGISTER_CVERROR("CvStsFilterStructContentErr", CV_StsFilterStructContentErr);
+  REGISTER_CVERROR("CvStsKernelStructContentErr", CV_StsKernelStructContentErr);
+  REGISTER_CVERROR("CvStsFilterOffsetErr", CV_StsFilterOffsetErr);
+  REGISTER_CVERROR("CvStsBadSize", CV_StsBadSize);
+  REGISTER_CVERROR("CvStsDivByZero", CV_StsDivByZero);
+  REGISTER_CVERROR("CvStsInplaceNotSupported", CV_StsInplaceNotSupported);
+  REGISTER_CVERROR("CvStsObjectNotFound", CV_StsObjectNotFound);
+  REGISTER_CVERROR("CvStsUnmatchedFormats", CV_StsUnmatchedFormats);
+  REGISTER_CVERROR("CvStsBadFlag", CV_StsBadFlag);
+  REGISTER_CVERROR("CvStsBadPoint", CV_StsBadPoint);
+  REGISTER_CVERROR("CvStsBadMask", CV_StsBadMask);
+  REGISTER_CVERROR("CvStsUnmatchedSizes", CV_StsUnmatchedSizes);
+  REGISTER_CVERROR("CvStsUnsupportedFormat", CV_StsUnsupportedFormat);
+  REGISTER_CVERROR("CvStsOutOfRange", CV_StsOutOfRange);
+  REGISTER_CVERROR("CvStsParseError", CV_StsParseError);
+  REGISTER_CVERROR("CvStsNotImplemented", CV_StsNotImplemented);
+  REGISTER_CVERROR("CvStsBadMemBlock", CV_StsBadMemBlock);
+  REGISTER_CVERROR("CvStsAssert", CV_StsAssert);
+  REGISTER_CVERROR("CvGpuNotSupported", CV_GpuNotSupported);
+  REGISTER_CVERROR("CvGpuApiCallError", CV_GpuApiCallError);
+}
+    
+VALUE
+by_code(int error_code)
+{
+  VALUE klass = 0;
+  st_lookup(cv_error, (st_data_t)error_code, (st_data_t*)&klass);
+  return klass ? klass : rb_eStandardError;
+}
+
+void
+raise(cv::Exception e)
+{
+  rb_raise(by_code(e.code), "%s", e.what());
+}
+
+__NAMESPACE_END_CVERROR
+__NAMESPACE_END_OPENCV

data/ext/opencv/cverror.h

@@ -0,0 +1,28 @@
+/************************************************************
+
+   cverror.h -
+
+   $Author: lsxi $
+
+   Copyright (C) 2005-2006 Masakazu Yonekura
+
+************************************************************/
+#ifndef RUBY_OPENCV_CVERROR_H
+#define RUBY_OPENCV_CVERROR_H
+
+#include "opencv.h"
+
+#define __NAMESPACE_BEGIN_CVERROR namespace cCvError {
+#define __NAMESPACE_END_CVERROR }
+
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVERROR
+
+void define_ruby_class();
+VALUE by_code(int error_code);
+void raise(cv::Exception e);
+
+__NAMESPACE_END_CVERROR
+__NAMESPACE_END_OPENCV
+
+#endif // RUBY_OPENCV_CVERROR_H

data/ext/opencv/cvfeaturetree.cpp

@@ -0,0 +1,125 @@
+/************************************************************
+
+   cvfeaturetree.cpp -
+
+   $Author: ser1zw $
+
+   Copyright (C) 2011 ser1zw
+
+************************************************************/
+#include "cvfeaturetree.h"
+/*
+ * Document-class: OpenCV::CvFeatureTree
+ */
+__NAMESPACE_BEGIN_OPENCV
+__NAMESPACE_BEGIN_CVFEATURETREE
+
+VALUE rb_klass;
+
+VALUE
+rb_class()
+{
+  return rb_klass;
+}
+
+void
+mark_feature_tree(void *ptr)
+{
+  if (ptr) {
+    VALUE desc = ((CvFeatureTreeWrap*)ptr)->desc;
+    rb_gc_mark(desc);
+  }
+}
+
+void
+rb_release_feature_tree(void *ptr)
+{
+  if (ptr) {
+    CvFeatureTree* ft = ((CvFeatureTreeWrap*)ptr)->feature_tree;
+    cvReleaseFeatureTree(ft);
+  }
+}
+
+VALUE
+rb_allocate(VALUE klass)
+{
+  CvFeatureTreeWrap* ptr;
+  return Data_Make_Struct(klass, CvFeatureTreeWrap, mark_feature_tree,
+			  rb_release_feature_tree, ptr);
+}
+
+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, "CvFeatureTree", rb_cObject);
+  rb_define_alloc_func(rb_klass, rb_allocate);
+  rb_define_private_method(rb_klass, "initialize", RUBY_METHOD_FUNC(rb_initialize), 1);
+
+  rb_define_method(rb_klass, "find_features", RUBY_METHOD_FUNC(rb_find_features), 3);
+}
+
+/*
+ * call-seq:
+ *   new(desc)
+ *
+ * Create a new kd-tree
+ */
+VALUE
+rb_initialize(VALUE self, VALUE desc)
+{
+  CvMat* desc_mat = CVMAT_WITH_CHECK(desc);
+  CvFeatureTreeWrap* self_ptr = (CvFeatureTreeWrap*)DATA_PTR(self);
+  free(self_ptr);
+  self_ptr = ALLOC(CvFeatureTreeWrap);
+  try {
+    self_ptr->feature_tree = cvCreateKDTree(desc_mat);
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  self_ptr->desc = desc;
+  return self;
+}
+
+/*
+ * call-seq:
+ *   find_features(desc, rows, cols, k, emax) -> array(results, dist)
+ *
+ * Find features from kd-tree
+ *
+ * desc:  m x d matrix of (row-)vectors to find the nearest neighbors of.
+ * k: The number of neighbors to find.
+ * emax: The maximum number of leaves to visit.
+ *
+ * return
+ *    results: m x k set of row indices of matching vectors (referring to matrix passed to cvCreateFeatureTree). Contains -1 in some columns if fewer than k neighbors found.
+ *    dist: m x k matrix of distances to k nearest neighbors.
+ */
+VALUE
+rb_find_features(VALUE self, VALUE desc, VALUE k, VALUE emax)
+{
+  CvMat* desc_mat = CVMAT_WITH_CHECK(desc);
+  int _k = NUM2INT(k);
+  VALUE results = cCvMat::new_object(desc_mat->rows, _k, CV_32SC1);
+  VALUE dist = cCvMat::new_object(desc_mat->rows, _k, CV_64FC1);
+  try {
+    cvFindFeatures(CVFEATURETREE(self), desc_mat, CVMAT(results), CVMAT(dist), _k, NUM2INT(emax));
+  }
+  catch (cv::Exception& e) {
+    raise_cverror(e);
+  }
+  return rb_assoc_new(results, dist);
+}
+
+__NAMESPACE_END_OPENCV
+__NAMESPACE_END_CVFEATURETREE
+