ropencv 0.0.7 → 0.0.8

data/ext/rbind.rb

@@ -1,106 +1,79 @@
 require 'rbind'
 require 'pp'
-require File.join(File.dirname(__FILE__),'specializing.rb')
+require 'yaml'
+
+require File.join(File.dirname(__FILE__),'helper.rb')
+opencv_version,opencv_headers = find_opencv
 
 rbind = Rbind::Rbind.new("OpenCV")
 rbind.pkg_config << "opencv"
+rbind.includes = opencv_headers
 
-# 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" && opencv_version <= "2.4.6"
-    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"]
+# add some templates and alias
+rbind.parser.type_alias["const_c_string"] = rbind.c_string.to_const
+if opencv_version >= "2.4.9"
+    rbind.add_std_types
 else
-    raise "OpenCV version #{opencv_version} is not supported"
+    rbind.add_std_vector
 end
+rbind.parser.add_type OpenCVPtr.new
 
-# 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
+# add Vec types
+2.upto(6) do |idx|
+    next if idx == 5
+    rbind.parser.add_type Vec.new("cv::Vec#{idx}d",rbind.double,idx)
+    rbind.parser.add_type Vec.new("cv::Vec#{idx}f",rbind.float,idx)
+    rbind.parser.add_type Vec.new("cv::Vec#{idx}i",rbind.int,idx)
 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.use_namespace rbind.std
+rbind.cv.type_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.9"
     rbind.parse File.join(File.dirname(__FILE__),"post_opencv249.txt")
-    rbind.cv.randShuffle.parameter(2).add_flag(:IO)
+    rbind.cv.randShuffle.parameter(2).remove_const!
 end
 
-rbind.cv.CascadeClassifier.detectMultiScale[1].parameter(2).add_flag(:IO)
-rbind.cv.CascadeClassifier.detectMultiScale[1].parameter(3).add_flag(:IO)
+rbind.cv.CascadeClassifier.detectMultiScale[1].parameter(2).remove_const!
+rbind.cv.CascadeClassifier.detectMultiScale[1].parameter(3).remove_const!
 
-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.BRISK.generateKernel.parameter(0).remove_const!
+rbind.cv.BRISK.generateKernel.parameter(1).remove_const!
+rbind.cv.BRISK.operation("BRISK")[1].parameter(0).remove_const!
+rbind.cv.BRISK.operation("BRISK")[1].parameter(1).remove_const!
 
-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)
+rbind.cv.putText.parameter(0).remove_const!
+rbind.cv.chamerMatching.parameter(0).remove_const!
+rbind.cv.chamerMatching.parameter(1).remove_const!
+rbind.cv.chamerMatching.parameter(2).remove_const!
 
 # add some more vector types
-rbind.parser.find_type(rbind,"vector_Point3f")
-rbind.parser.find_type(rbind,"vector_Point3d")
+rbind.parser.type("std::vector<Point3f>")
+rbind.parser.type("std::vector<Point3d>")
+rbind.parser.type("std::vector<Vec4i>")
+
+# add opencv docu
+@doc = YAML.load(File.open(File.join(File.dirname(__FILE__),'opencv.yml')).read)
+rbind.parser.each_type do |t|
+    if @doc.has_key?(t.full_name)
+        t.doc = @doc[t.full_name]
+    end
+    next unless t.is_a?(Rbind::RNamespace)
+    t.each_operation do |op|
+        if @doc.has_key?(op.full_name)
+            op.doc = @doc[op.full_name]
+        end
+    end
+end
 
 # generate files
 rbind.generator_ruby.file_prefix = "ropencv"
-rbind.generate(File.join(File.dirname(__FILE__),"src"),File.join(File.dirname(__FILE__),"..","lib","ruby","ropencv"))
+rbind.generate(File.join(File.dirname(__FILE__),"src"),File.join(File.dirname(__FILE__),"..","lib","ropencv"))
 

data/ext/src/CMakeLists.txt

@@ -22,15 +22,14 @@ ADD_LIBRARY(rbind_opencv SHARED ${RBIND_SRC})
 TARGET_LINK_LIBRARIES(rbind_opencv ${OPENCV_LIBS} ${OPENCV_LDFLAGS}  ${GEM_LIBRARIES})
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/rbind.pc.in ${CMAKE_CURRENT_BINARY_DIR}/rbind_opencv.pc @ONLY)
-set(ROOT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/../..)
 
-# global install
+set(ROOT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/../..)
 if(GEM_INSTALL)
     # local install
-    install(TARGETS rbind_opencv LIBRARY DESTINATION ${ROOT_FOLDER}/lib/lib)
-    install(FILES types.h operations.h conversions.hpp DESTINATION ${ROOT_FOLDER}/lib/include)
-    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind DESTINATION ${ROOT_FOLDER}/lib/include)
-    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind DESTINATION ${ROOT_FOLDER}/lib/include)
+    install(TARGETS rbind_opencv LIBRARY DESTINATION ${ROOT_FOLDER}/lib)
+    install(FILES types.h operations.h conversions.hpp DESTINATION ${ROOT_FOLDER}/include)
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind DESTINATION ${ROOT_FOLDER}/include)
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind DESTINATION ${ROOT_FOLDER}/include)
 else()
     # global install
     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/rbind_opencv.pc DESTINATION lib/pkgconfig)
@@ -42,7 +41,7 @@ else()
     FIND_PACKAGE(Ruby)
     IF(NOT RUBY_INCLUDE_PATH)
         MESSAGE(STATUS "Ruby library not found. Cannot install ruby extensions")
-    ELSEIF(NOT RUBY_EXTENSIONS_AVAILABLE)
+    ELSEIF(RUBY_EXTENSIONS_AVAILABLE)
         STRING(REGEX REPLACE ".*lib(32|64)?/?" "lib/" RUBY_LIBRARY_INSTALL_DIR ${RUBY_RUBY_LIB_PATH})
         INSTALL(DIRECTORY ${ROOT_FOLDER}/lib/ruby/ DESTINATION ${RUBY_LIBRARY_INSTALL_DIR}
             FILES_MATCHING PATTERN "*.rb")

data/ext/src/cmake/FindGem.cmake

@@ -111,10 +111,10 @@ foreach(Gem_NAME ${Gem_FIND_COMPONENTS})
             endforeach()
 
             # Compact the lists
-            if(${GEM_LIBRARIES})
+            if(DEFINED GEM_LIBRARIES)
                 LIST(REMOVE_DUPLICATES GEM_LIBRARIES)
             endif()
-            if(${GEM_INCLUDE_DIRS})
+            if(DEFINED GEM_INCLUDE_DIRS)
                 LIST(REMOVE_DUPLICATES GEM_INCLUDE_DIRS)
             endif()
         endif()

data/lib/{ruby/ropencv → ropencv}/ropencv_ruby.rb

@@ -7,7 +7,39 @@ module OpenCV
         end
     end
 
+    class Std::Vector::Cv_Mat
+        def self.to_native(obj,context)
+            if obj.is_a?(Vector::Std_Vector_Cv_Point2f)
+                t = Vector::Cv_Mat.new
+                obj.each do |e|
+                    t << cv::Mat.new(e.size,2,cv::CV_32FC1,e.data,cv::Mat::AUTO_STEP)
+                end
+                t.__obj_ptr__
+            elsif obj.is_a?(Vector::Std_Vector_Cv_Point)
+                t = Vector::Cv_Mat.new
+                obj.each do |e|
+                    t << cv::Mat.new(e.size,2,cv::CV_32SC1,e.data,cv::Mat::AUTO_STEP)
+                end
+                t.__obj_ptr__
+            else
+                rbind_to_native(obj,context)
+            end
+        end
+    end
+    include Std
+
     module Cv
+        class Size
+            def *(val)
+                Size.new(width*val,height*val)
+            end
+            def +(val)
+                Size.new(width+val,height+val)
+            end
+            def -(val)
+                Size.new(width-val,height-val)
+            end
+        end
         class String
             def self.to_native(obj,context)
                 if obj.is_a? ::String
@@ -22,69 +54,76 @@ module OpenCV
             end
         end
 
-        class Scalar
-            def []=(i,value=nil)
-                raise "out of bound #{value}" if value < 0 || value > 3
-                val.put_float64(i*8,value)
-                value
-            end
-        end
-
-        class Vec2d
-            def [](i)
-                raise "Out of bound #{i}" if i < 0 || i > 1 
-                val.get_float64(i*8)
-            end
-            def []=(i,val0)
-                raise "Out of bound #{i}" if i < 0 || i > 1 
-                val.put_float64(i*8,val0)
+        class Point
+            def self.to_native(obj,context)
+                if obj.is_a? ::OpenCV::Cv::Point2f
+                    OpenCV::Cv::Point.new(obj.x,obj.y).__obj_ptr__
+                else
+                    rbind_to_native(obj,context)
+                end
             end
         end
 
-        class Vec3d
+        module Vecxd
             def [](i)
-                raise "Out of bound #{i}" if i < 0 || i > 2
+                raise "Out of bound #{i}" if i < 0 || i >= self.class::SIZE
                 val.get_float64(i*8)
             end
             def []=(i,val0)
-                raise "Out of bound #{i}" if i < 0 || i > 2
+                raise "Out of bound #{i}" if i < 0 || i >= self.class::SIZE
                 val.put_float64(i*8,val0)
             end
-        end
-
-        class Vec4d
-            def [](i)
-                raise "Out of bound #{i}" if i < 0 || i > 3
-                val.get_float64(i*8)
-            end
-            def []=(i,val0)
-                raise "Out of bound #{i}" if i < 0 || i > 3
-                val.put_float64(i*8,val0)
+            def to_a
+                val.get_array_of_float64(0,self.class::SIZE)
             end
         end
 
-        class Vec4f
+        module Vecxf
             def [](i)
-                raise "Out of bound #{i}" if i < 0 || i > 3
+                raise "Out of bound #{i}" if i < 0 || i >= self.class::SIZE
                 val.get_float32(i*4)
             end
             def []=(i,val0)
-                raise "Out of bound #{i}" if i < 0 || i > 3
+                raise "Out of bound #{i}" if i < 0 || i >= self.class::SIZE
                 val.put_float32(i*4,val0)
             end
+            def to_a
+                val.get_array_of_float32(0,self.class::SIZE)
+            end
         end
-        
-        class Vec6f
+
+        module Vecxi
             def [](i)
-                raise "Out of bound #{i}" if i < 0 || i > 5
-                val.get_float32(i*4)
+                raise "Out of bound #{i}" if i < 0 || i >= self.class::SIZE
+                val.get_int(i*FFI.type_size(FFI::Type::INT))
             end
             def []=(i,val0)
-                raise "Out of bound #{i}" if i < 0 || i > 5
-                val.put_float32(i*4,val0)
+                raise "Out of bound #{i}" if i < 0 || i >= self.class::SIZE
+                val.put_int(i*FFI.type_size(FFI::Type::INT),val0)
+            end
+            def to_a
+                val.get_array_of_int(0,self.class::SIZE)
             end
         end
 
+        class Vec2d;include Vecxd; SIZE=2;end
+        class Vec2f;include Vecxf; SIZE=2;end
+        class Vec2i;include Vecxi; SIZE=2;end
+
+        class Vec3d;include Vecxd; SIZE=3;end
+        class Vec3f;include Vecxf; SIZE=3;end
+        class Vec3i;include Vecxi; SIZE=3;end
+
+        class Vec4d;include Vecxd; SIZE=4;end
+        class Vec4f;include Vecxf; SIZE=4;end
+        class Vec4i;include Vecxi; SIZE=4;end
+
+        class Vec6d;include Vecxd; SIZE=6;end
+        class Vec6f;include Vecxf; SIZE=6;end
+        class Vec6i;include Vecxi; SIZE=6;end
+
+        class Scalar; include Vecxd; SIZE=4;end
+
         class Mat
             class << self
                 alias :rbind_new :new
@@ -100,9 +139,11 @@ module OpenCV
             end
 
             def self.to_native(obj,context)
-                if obj.is_a?(VectorPoint2f)
+                if obj.is_a?(Std::Vector::Cv_Point)
+                    cv::Mat.new(obj.size,2,cv::CV_32SC1,obj.data,cv::Mat::AUTO_STEP).__obj_ptr__
+                elsif obj.is_a?(Std::Vector::Cv_Point2f)
                     cv::Mat.new(obj.size,2,cv::CV_32FC1,obj.data,cv::Mat::AUTO_STEP).__obj_ptr__
-                elsif obj.is_a?(VectorPoint3f)
+                elsif obj.is_a?(Std::Vector::Cv_Point3f)
                     cv::Mat.new(obj.size,3,cv::CV_32FC1,obj.data,cv::Mat::AUTO_STEP).__obj_ptr__
                 elsif obj.is_a?(Array)
                     h,w,e= if obj.first.is_a? Array
@@ -151,17 +192,25 @@ module OpenCV
                           [i,j]
                       end
                 if i >= rows || i < 0 || j >= cols || j <0
-                    raise ArgumentError,"out of bound #{i}/#{j}"
+                    raise ArgumentError,"out of bound #{i}/#{j} #{rows}/#{cols}"
                 end
                 case type & 7
                 when CV_8U
                     data.get_uint8(i*step+j)
+                when CV_16U
+                    data.get_uint16(i*step+j*2)
+                when CV_16S
+                    data.get_int16(i*step+j*2)
+                when CV_32S
+                    data.get_int32(i*step+j*4)
+                when CV_32F
+                    data.get_float32(i*step+j*4)
                 when CV_32F
                     data.get_float32(i*step+j*4)
                 when CV_64F
                     data.get_float64(i*step+j*8)
                 else
-                    raise "cannot connvert #{self.class} to ruby"
+                    raise "cannot connvert #{self.class} of type #{type} to ruby"
                 end
             end
 
@@ -210,12 +259,18 @@ module OpenCV
                 case type & 7
                 when CV_8U
                     data.put_uint8(i*step+j,val)
+                when CV_16U
+                    data.put_uint16(i*step+j,val*2)
+                when CV_16S
+                    data.put_int16(i*step+j,val*2)
+                when CV_32S
+                    data.put_int32(i*step+j,val*4)
                 when CV_32F
                     data.put_float32(i*step+j*4,val)
                 when CV_64F
                     data.put_float64(i*step+j*8,val)
                 else
-                    raise "cannot connvert #{self.class} to ruby"
+                    raise "cannot connvert #{self.class} of type #{type} to ruby"
                 end
             end
 
@@ -274,12 +329,7 @@ module OpenCV
                          else
                              '%6.3f'
                          end
-                a = if cols == 1 || rows == 1
-                        [to_a]
-                    else
-                        to_a
-                    end
-                str = a.map do |r|
+                str = to_a.map do |r|
                     str = r.map do |e|
                         sprintf(format,e)
                     end.join(" ")
@@ -293,6 +343,12 @@ module OpenCV
                 getter = case type & 7
                          when CV_8U
                              ptr.method(:get_array_of_uint8)
+                         when CV_16U
+                             ptr.method(:get_array_of_uint16)
+                         when CV_16S
+                             ptr.method(:get_array_of_int16)
+                         when CV_32S
+                             ptr.method(:get_array_of_int32)
                          when CV_32F
                              ptr.method(:get_array_of_float32)
                          when CV_64F
@@ -300,15 +356,11 @@ module OpenCV
                          else
                              raise "cannot connvert #{self.class} to array"
                          end
-                if w  == 1 || h == 1
-                    getter.call(0,total)
-                else
-                    result = []
-                    0.upto(h-1) do |i|
-                        result << getter.call(s*i,w*c)
-                    end
-                    result
+                result = []
+                0.upto(h-1) do |i|
+                    result << getter.call(s*i,w*c)
                 end
+                result
             end
         end
     end