ropencv 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+build/*

data/CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 2.6)
+
+add_subdirectory(ext)
+
+FIND_PACKAGE(Ruby)
+IF(NOT RUBY_INCLUDE_PATH)
+    MESSAGE(STATUS "Ruby library not found. Cannot install OpenCV ruby extensions")
+ELSEIF(NOT RUBY_EXTENSIONS_AVAILABLE)
+    STRING(REGEX REPLACE ".*lib(32|64)?/?" "lib/" RUBY_LIBRARY_INSTALL_DIR ${RUBY_RUBY_LIB_PATH})
+
+    FIND_PROGRAM(RDOC_EXECUTABLE NAMES rdoc1.9 rdoc1.8 rdoc)
+    FIND_PROGRAM(YARD_EXECUTABLE NAMES yard)
+
+    INSTALL(FILES lib/opencv.rb
+        DESTINATION ${RUBY_LIBRARY_INSTALL_DIR})
+    INSTALL(DIRECTORY lib/opencv
+        DESTINATION ${RUBY_LIBRARY_INSTALL_DIR})
+ENDIF(NOT RUBY_INCLUDE_PATH)
+

data/README.md

@@ -0,0 +1,61 @@
+# ffi ruby wrapper for opencv 2.4.4 and 2.4.9
+This is the first draft for automated ffi ruby bindings using rbind for opencv 2.4.4 and 2.4.9
+
+# Installation 
+You have to install opencv 2.4.4 or 2.4.9 first. After this you can install the opencv ruby bindings via:
+- gem install ropencv
+
+# Additional methods 
+The following methods not available for python or java are automatically wrapped by this package:
+- drawMatches
+- findEssentialMat (OpenCV 2.4.9)
+- recoverPose (OpenCV 2.4.9)
+
+# Example1
+
+    require 'ropencv'
+    include OpenCV
+
+    mat = cv::imread("logo.png")
+    cv.blur(mat,mat,cv::Size.new(10,10))
+
+    detector = cv::FeatureDetector::create("SURF")
+    keypoints = Vector::KeyPoint.new
+    detector.detect(mat,keypoints)
+
+    puts "found #{keypoints.size} keypoints"
+    puts "first keypoint is at #{keypoints[0].pt.x}/#{keypoints[0].pt.y}"
+
+    cv::draw_keypoints(mat,keypoints,mat)
+    cv::imshow("key_points",mat)
+    cv::wait_key(-1)
+
+# Example2
+
+    require 'ropencv'
+    include OpenCV
+
+    mat1 = cv::imread("image1.png")
+    mat2 = cv::imread("image2.png")
+
+    detector = cv::FeatureDetector::create("SURF")
+    extractor = cv::DescriptorExtractor::create("SURF")
+    matcher = cv::DescriptorMatcher::create("BruteForce")
+
+    features1 = Vector::KeyPoint.new
+    features2 = Vector::KeyPoint.new
+    detector.detect mat1,features1
+    detector.detect mat2,features2
+
+    descriptor1 = cv::Mat.new
+    descriptor2 = cv::Mat.new
+    extractor.compute(mat1,features1,descriptor1)
+    extractor.compute(mat2,features2,descriptor2)
+
+    matches = Vector::DMatch.new
+    matcher.match(descriptor1,descriptor2,matches)
+
+    result = cv::Mat.new
+    cv::draw_matches(mat_last,features1,mat,features2,matches,result)
+    cv::imshow("result",result)
+    cv::wait_key(-1)

data/examples/test.rb

@@ -0,0 +1,16 @@
+require './../lib/opencv'
+include OpenCV
+
+mat = cv::imread("logo.png")
+cv.blur(mat,mat,cv::Size.new(10,10))
+
+detector = cv::FeatureDetector::create("SURF")
+keypoints = Vector::KeyPoint.new
+detector.detect(mat,keypoints)
+
+puts "found #{keypoints.size} keypoints"
+puts "first keypoint is at #{keypoints[0].pt.x}/#{keypoints[0].pt.y}"
+
+cv::draw_keypoints(mat,keypoints,mat)
+cv::imshow("key_points",mat)
+cv::wait_key(-1)

data/ext/CMakeLists.txt

@@ -0,0 +1,32 @@
+cmake_minimum_required(VERSION 2.6)
+PROJECT(rbind_opencv CXX)
+
+include(FindPkgConfig)
+pkg_check_modules(OPENCV REQUIRED opencv)
+add_definitions(${OPENCV_CFLAGS})
+include_directories(${OPENCV_INCLUDE_DIRS})
+link_directories(${OPENCV_LIBRARY_DIRS})
+
+
+
+SET(RBIND_SRC
+    "${CMAKE_CURRENT_SOURCE_DIR}/types.cc"
+    "${CMAKE_CURRENT_SOURCE_DIR}/operations.cc"
+    "${CMAKE_CURRENT_SOURCE_DIR}/conversions.cc")
+ADD_LIBRARY(rbind_opencv SHARED ${RBIND_SRC})
+
+TARGET_LINK_LIBRARIES(rbind_opencv ${OPENCV_LIBS} ${OPENCV_LDFLAGS} )
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/rbind.pc.in ${CMAKE_CURRENT_BINARY_DIR}/rbind_opencv.pc @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/rbind_opencv.pc DESTINATION lib/pkgconfig)
+
+install(TARGETS rbind_opencv LIBRARY DESTINATION lib)
+install(FILES types.h operations.h conversions.hpp DESTINATION include/${PROJECT_NAME}/${DIR})
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind)
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind DESTINATION include/${PROJECT_NAME}/${DIR})
+endif()
+
+if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind)
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind DESTINATION include/${PROJECT_NAME}/${DIR})
+endif()

data/ext/extconf.rb

@@ -0,0 +1,113 @@
+require 'rbind'
+require 'pp'
+require File.join(File.dirname(__FILE__),'specializing.rb')
+
+rbind = Rbind::Rbind.new("OpenCV")
+rbind.pkg_config << "opencv"
+
+# find opencv header path
+out = IO.popen("pkg-config --cflags-only-I opencv")
+paths = out.read.split("-I").delete_if(&:empty?).map do |i|
+    i.gsub("\n","").gsub(" ","").gsub("opencv","")
+end
+raise "Cannot find OpenCV" if paths.empty?
+
+#check opencv version
+out = IO.popen("pkg-config --modversion opencv")
+opencv_version = out.read.chomp
+
+##add opencv headers
+if opencv_version == "2.4.4"
+    rbind.includes =   ["opencv2/core/core_c.h", "opencv2/core/types_c.h",
+                        "opencv2/core/core.hpp", "opencv2/flann/miniflann.hpp",
+                        "opencv2/imgproc/imgproc_c.h", "opencv2/imgproc/types_c.h",
+                        "opencv2/imgproc/imgproc.hpp", "opencv2/photo/photo_c.h",
+                        "opencv2/photo/photo.hpp", "opencv2/video/video.hpp",
+                        "opencv2/features2d/features2d.hpp", "opencv2/objdetect/objdetect.hpp",
+                        "opencv2/calib3d/calib3d.hpp", "opencv2/ml/ml.hpp",
+                        "opencv2/highgui/highgui_c.h", "opencv2/highgui/highgui.hpp",
+                        "opencv2/contrib/contrib.hpp", "opencv2/nonfree/nonfree.hpp",
+                        "opencv2/nonfree/features2d.hpp"]
+elsif opencv_version >= "2.4.9"
+    rbind.includes =   ["opencv2/core.hpp", "opencv2/core/types.hpp",
+                        "opencv2/core/utility.hpp", "opencv2/core/base.hpp",
+                        "opencv2/contrib.hpp", "opencv2/calib3d.hpp",
+                        "opencv2/features2d.hpp", "opencv2/flann.hpp",
+                        "opencv2/highgui.hpp", "opencv2/imgproc.hpp",
+                        "opencv2/ml.hpp", "opencv2/nonfree.hpp",
+                        "opencv2/nonfree/features2d.hpp", "opencv2/objdetect.hpp",
+                        "opencv2/photo.hpp", "opencv2/softcascade.hpp",
+                        "opencv2/stitching.hpp", "opencv2/superres.hpp",
+                        "opencv2/video.hpp", "opencv2/legacy.hpp",
+                        "opencv2/videostab.hpp"]
+else
+    raise "OpenCV version #{opencv_version} is not supported"
+end
+
+# check that all headers are available
+rbind.includes = rbind.includes.map do |i|
+    path = File.join(paths[0],i)
+    if !File.exist?(path)
+        ::Rbind.log.info "OpenCV version does not support #{path}"
+        nil
+    else
+        path
+    end
+end.compact
+Rbind.log.info "found opencv #{opencv_version}: #{paths[0]}"
+
+# auto add vector and ptr types if missing
+rbind.on_type_not_found do |owner,type|
+    if type =~ /Ptr_(.*)/
+        t = rbind.parser.find_type(owner,$1)
+        t2 = Rbind::RPtr.new(type,rbind,t).typedef("cv::Ptr<#{t.full_name} >")
+        rbind.parser.add_type t2
+    elsif type =~ /vector_(.*)/
+        t = rbind.parser.find_type(owner,$1)
+        t2 = Rbind::RVector.new(type,rbind,t).typedef("std::vector<#{t.full_name} >")
+        rbind.parser.add_type t2
+    end
+end
+
+# parsing
+rbind.parse File.join(File.dirname(__FILE__),"pre_opencv244.txt")
+rbind.parse File.join(File.dirname(__FILE__),"opencv.txt")
+rbind.use_namespace rbind.cv
+rbind.cv.types_alias["string"] = rbind.cv.String
+rbind.parse_headers
+rbind.parse File.join(File.dirname(__FILE__),"post_opencv244.txt")
+
+# post parsing + patching wrong signatures
+if opencv_version == "2.4.4"
+    rbind.cv.CascadeClassifier.detectMultiScale[1].parameter(2).add_flag(:IO)
+    rbind.cv.CascadeClassifier.detectMultiScale[1].parameter(3).add_flag(:IO)
+elsif opencv_version >= "2.4.9"
+    rbind.parse File.join(File.dirname(__FILE__),"post_opencv249.txt")
+    rbind.cv.randShuffle.parameter(2).add_flag(:IO)
+else
+    raise "not supported opencv version"
+end
+
+rbind.cv.BRISK.generateKernel.parameter(0).add_flag(:IO)
+rbind.cv.BRISK.generateKernel.parameter(1).add_flag(:IO)
+rbind.cv.BRISK.operation("BRISK")[1].parameter(0).add_flag(:IO)
+rbind.cv.BRISK.operation("BRISK")[1].parameter(1).add_flag(:IO)
+
+rbind.cv.putText.parameter(0).add_flag(:IO)
+rbind.cv.chamerMatching.parameter(0).add_flag(:IO)
+rbind.cv.chamerMatching.parameter(1).add_flag(:IO)
+rbind.cv.chamerMatching.parameter(2).add_flag(:IO)
+
+# add some more vector types
+rbind.parser.find_type(rbind,"vector_Point3f")
+rbind.parser.find_type(rbind,"vector_Point3d")
+
+# generate files
+rbind.generator_ruby.file_prefix = "ropencv"
+rbind.generate(File.join(File.dirname(__FILE__)),File.join(File.dirname(__FILE__),"..","lib","ropencv"))
+
+Dir.chdir(rbind.generator_c.output_path) do
+    if !system("cmake .")
+        raise "CMake Configure Error"
+    end
+end

data/ext/opencv.txt

@@ -0,0 +1,442 @@
+const cv.CV_8U 0
+const cv.CV_8S 1
+const cv.CV_16U 2
+const cv.CV_16S 3
+const cv.CV_32S 4
+const cv.CV_32F 5
+const cv.CV_64F 6
+const cv.CV_8UC1 (1-1)*8 + CV_8U
+const cv.CV_8UC2 (2-1)*8 + CV_8U
+const cv.CV_8UC3 (3-1)*8 + CV_8U
+const cv.CV_8UC4 (4-1)*8 + CV_8U
+const cv.CV_8SC1 (1-1)*8 + CV_8S
+const cv.CV_8SC2 (2-1)*8 + CV_8S
+const cv.CV_8SC3 (3-1)*8 + CV_8S
+const cv.CV_8SC4 (4-1)*8 + CV_8S
+const cv.CV_16UC1 (1-1)*8 + CV_16U
+const cv.CV_16UC2 (2-1)*8 + CV_16U
+const cv.CV_16UC3 (3-1)*8 + CV_16U
+const cv.CV_16UC4 (4-1)*8 + CV_16U
+const cv.CV_16SC1 (1-1)*8 + CV_16S
+const cv.CV_16SC2 (2-1)*8 + CV_16S
+const cv.CV_16SC3 (3-1)*8 + CV_16S
+const cv.CV_16SC4 (4-1)*8 + CV_16S
+const cv.CV_32SC1 (1-1)*8 + CV_32S
+const cv.CV_32SC2 (2-1)*8 + CV_32S
+const cv.CV_32SC3 (3-1)*8 + CV_32S
+const cv.CV_32SC4 (4-1)*8 + CV_32S
+const cv.CV_32FC1 (1-1)*8 + CV_32F
+const cv.CV_32FC2 (2-1)*8 + CV_32F
+const cv.CV_32FC3 (3-1)*8 + CV_32F
+const cv.CV_32FC4 (4-1)*8 + CV_32F
+const cv.CV_64FC1 (1-1)*8 + CV_64F
+const cv.CV_64FC2 (2-1)*8 + CV_64F
+const cv.CV_64FC3 (3-1)*8 + CV_64F
+const cv.CV_64FC4 (4-1)*8 + CV_64F
+const cv.CV_CN_MAX 512
+const cv.CV_CN_SHIFT 3
+const cv.CV_DEPTH_MAX (1 << CV_CN_SHIFT)
+const cv.CV_MAT_CN_MASK ((CV_CN_MAX - 1) << CV_CN_SHIFT)
+const cv.CV_MAT_TYPE_MASK (CV_DEPTH_MAX*CV_CN_MAX - 1)
+const cv.CV_MAT_CONT_FLAG_SHIFT 14
+const cv.CV_MAT_CONT_FLAG (1 << CV_MAT_CONT_FLAG_SHIFT)
+const cv.CV_SUBMAT_FLAG_SHIFT 15
+const cv.CV_SUBMAT_FLAG (1 << CV_SUBMAT_FLAG_SHIFT)
+class cv.Range
+    int start /RW
+    int end   /RW
+cv.Range.Range
+    int start
+    int end
+cv.Range.size int
+cv.Range.size bool
+cv.Range.all Range
+cv.Range.all Range
+cv.Range.operator== bool
+    Range r
+cv.Range.operator!= bool
+    Range r
+cv.Range.operator& Range
+    Range r
+cv.Range.operator+ Range
+    int delta
+cv.Range.operator- Range
+    int delta
+class cv.String
+cv.String.String
+cv.String.String
+    c_string str
+    size_t length
+cv.String.String
+    String other
+cv.String.size size_t
+cv.String.length size_t
+cv.String.operator[] char
+    size_t idx
+cv.String.c_str const_c_string
+cv.String.empty bool
+cv.String.clear void
+cv.String.compare int
+    String str
+cv.String.swap void
+    String str /IO
+class cv.Scalar
+    double* val
+cv.Scalar.Scalar
+cv.Scalar.Scalar
+    double v0
+cv.Scalar.Scalar
+    double v0
+    double v1
+    double v2 0
+    double v3 0
+cv.Scalar.all Scalar /S
+    double v0
+cv.Scalar.mul Scalar
+    Scalar other
+    double scale 1
+cv.Scalar.conj Scalar
+cv.Scalar.isReal bool
+cv.Scalar.operator[] double
+    size_t elem
+class cv.Point
+    int x /RW
+    int y /RW
+class cv.Rect
+    int x /RW
+    int y /RW
+    int width /RW
+    int height /RW
+cv.Point.Point
+    int x
+    int y
+cv.Point.Point
+    Point pt
+cv.Point.dot int
+    Point pt
+cv.Point.dot double
+    Point pt
+cv.Point.cross double
+    Point pt
+cv.Point.inside bool
+    Rect rect
+cv.Point.operator+ void
+    Point pt
+class cv.Point2f
+    float x /RW
+    float y /RW
+cv.Point2f.Point2f
+    float x
+    float y
+cv.Point2f.Point2f
+    Point2f pt
+cv.Point2f.dot float
+    Point2f pt
+cv.Point2f.dot double
+    Point2f pt
+cv.Point2f.cross double
+    Point2f pt
+cv.Point2f.operator+ void
+    Point2f pt
+class cv.Point2d
+    double x /RW
+    double y /RW
+cv.Point2d.Point2d
+    double x
+    double y
+cv.Point2d.operator+ void
+    Point2d pt
+cv.Point2d.Point2d
+    Point2d pt
+cv.Point2d.dot double
+    Point2d pt
+cv.Point2d.dot double
+    Point2d pt
+cv.Point2d.cross double
+    Point2d pt
+class cv.Point3f
+    float x /RW
+    float y /RW
+    float z /RW
+cv.Point3f.Point3f
+    float x
+    float y
+    float z
+cv.Point3f.Point3f
+    Point3f pt
+cv.Point3f.dot float
+    Point3f pt
+cv.Point3f.ddot double
+    Point3f pt
+cv.Point3f.cross Point3f
+    Point3f pt
+cv.Point3f.operator+ void
+    Point3f pt
+class cv.Point3d
+    double x /RW
+    double y /RW
+    double z /RW
+cv.Point3d.Point3d
+    double x
+    double y
+    double z
+cv.Point3d.Point3d
+    Point3d pt
+cv.Point3d.dot double
+    Point3d pt
+cv.Point3d.ddot double
+    Point3d pt
+cv.Point3d.cross Point3d
+    Point3d pt
+cv.Point3d.operator+ void
+    Point3d pt
+class cv.Size
+    int width  /RW
+    int height /RW
+cv.Size.Size
+cv.Size.Size
+    Size sz
+cv.Size.Size
+    Point  pt
+cv.Size.Size
+    int width
+    int height
+cv.Size.area int
+class cv.Size2f
+    int width  /RW
+    int height /RW
+cv.Size2f.Size2f
+cv.Size2f.Size2f
+    Size2f sz
+cv.Size2f.Size2f
+    Point2f  pt
+cv.Size2f.Size2f
+    int width
+    int height
+cv.Size2f.area int
+cv.Rect.Rect
+cv.Rect.Rect
+    Rect rect
+cv.Rect.Rect
+    int x
+    int y
+    int width
+    int height
+cv.Rect.tl Point
+cv.Rect.br Point
+cv.Rect.size Size
+cv.Rect.area int
+cv.Rect.contains bool
+    Point point
+class CvTermCriteria
+class CvDTreeNode
+class CvSlice
+class cvflann.flann_algorithm_t
+class cvflann.flann_distance_t
+class cv.RotatedRect
+    Point2f center /RW
+    Size2f size    /RW
+    float angle    /RW
+cv.RotatedRect.RotatedRect
+cv.RotatedRect.RotatedRect
+    Point2f center
+    Size2f size
+    float angle
+cv.RotatedRect.boundingRect Rect
+class cv.FileNode
+class cv.Vec2d
+cv.Vec2d.Vec2d
+cv.Vec2d.Vec2d
+    Vec2d vec
+cv.Vec2d.Vec2d
+    double t1
+    double t2
+cv.Vec2d.all Vec2d /S
+    double alpha
+cv.Vec2d.mul Vec2d
+    Vec2d other
+cv.Vec2d.conj Vec2d
+cv.Vec2d.operator[] double
+    int i
+class cv.Vec3d
+class cv.Vec4d
+class cv.Vec4f
+class cv.Vec6f
+class cv.TermCriteria
+class cv.flann::IndexParams
+class cv.flann::SearchParams
+class cv.FeatureDetector
+class cv.Mat
+    int flags
+    int rows
+    int cols
+    size_t step
+    uchar* data
+cv.Mat.Mat
+cv.Mat.Mat
+    Mat m
+cv.Mat.Mat
+    Size size
+    int type
+cv.Mat.Mat
+    int rows
+    int cols
+    int type
+cv.Mat.Mat
+    int rows
+    int cols
+    int type
+    void* data 
+    size_t step AUTO_STEP
+cv.Mat.operator+ Mat
+    Mat mat
+cv.Mat.operator+ Mat
+    double val
+cv.Mat.operator+ Mat
+    int val
+cv.Mat.operator- Mat
+    Mat mat
+cv.Mat.operator- Mat
+    double val
+cv.Mat.operator- Mat
+    int val
+cv.Mat.operator* Mat
+    Mat mat
+cv.Mat.operator* Mat
+    double val
+cv.Mat.operator* Mat
+    int val
+cv.Mat.operator/ Mat
+    Mat mat
+cv.Mat.operator/ Mat
+    double val
+cv.Mat.operator/ Mat
+    int val
+cv.Mat.row Mat
+    int y
+cv.Mat.col Mat
+    int c
+cv.Mat.rowRange Mat
+    int startrow
+    int endrow
+cv.Mat.rowRange Mat
+        Range r
+cv.Mat.colRange Mat
+    int startcol
+    int endcol
+cv.Mat.colRange Mat
+    Range r
+cv.Mat.diag Mat
+    int d 0
+cv.Mat.clone Mat
+cv.Mat.copyTo void
+    Mat m /O
+cv.Mat.copyTo void
+    Mat m /O
+    Mat mask /IO
+cv.Mat.convertTo void
+    Mat m /O
+    int rtype
+    double alpha 1
+    double beta 0
+cv.Mat.assignTo void
+    Mat m /O
+    int type -1
+cv.Mat.reshape Mat
+    int cn
+    int rows 0
+cv.Mat.t Mat
+cv.Mat.inv Mat
+    int method DECOMP_LU
+cv.Mat.mul Mat
+    Mat m
+    double scale 1
+cv.Mat.cross Mat
+    Mat m
+cv.Mat.dot double
+    Mat m
+cv.Mat.zeros Mat /S
+    int rows
+    int cols
+    int type
+cv.Mat.zeros Mat /S
+    Size size
+    int type
+cv.Mat.ones Mat /S
+    int rows
+    int cols
+    int type
+cv.Mat.ones Mat /S
+    Size size
+    int type
+cv.Mat.eye Mat /S
+    int rows
+    int cols
+    int type
+cv.Mat.eye Mat /S
+    Size size
+    int type
+cv.Mat.create void
+    int rows
+    int cols
+    int type
+cv.Mat.create void
+    Size size
+    int type
+cv.Mat.isContinuous bool
+cv.Mat.isSubmatrix bool
+cv.Mat.elemSize size_t
+cv.Mat.elemSize1 size_t
+cv.Mat.size Size
+cv.Mat.type int
+cv.Mat.depth int
+cv.Mat.channels int
+cv.Mat.step1 size_t
+    int i 0
+cv.Mat.empty bool
+cv.Mat.total size_t
+cv.Mat.checkVector int
+    int elemChannels
+    int depth -1
+    bool requireContinuous true
+cv.Mat.ptr uchar*
+    int i0 0
+cv.Mat.ptr uchar*
+    int i0
+    int i1
+cv.Mat.ptr uchar*
+    int i0
+    int i1
+    int i2
+cv.Mat.operator () Mat =block
+    Rect rect
+const cv.Mat.MAGIC_VAL 0x42FF0000
+const cv.Mat.AUTO_STEP 0
+const cv.Mat.CONTINUOUS_FLAG CV_MAT_CONT_FLAG
+const cv.Mat.SUBMATRIX_FLAG CV_SUBMAT_FLAG
+const cv.Mat.MAGIC_MASK 0xFFFF0000
+const cv.Mat.TYPE_MASK 0x00000FFF
+const cv.Mat.DEPTH_MASK 7
+class cv.RNG
+    uint64 state
+cv.RNG.RNG
+cv.RNG.RNG
+    uint64 state
+cv.RNG.uniform int
+    int a
+    int b
+cv.RNG.uniform float 
+    float a
+    float b
+cv.RNG.uniform double 
+    double a
+    double b
+cv.RNG.fill void
+    Mat mat /IO
+    int distType
+    Mat a
+    Mat b
+    bool saturateRange false
+cv.RNG.gaussian double
+    double sigma
+