ropencv 0.0.2 → 0.0.3

data/.gitignore

@@ -2,11 +2,12 @@ build/*
 ext/CMakeFiles
 ext/CMakeCache.txt
 ext/Makefile
-ext/*.rbind
-ext/*.h
-ext/*.hpp
-ext/*.cc
-lib/ropencv/ropencv.rb
-lib/ropencv/ropencv_types.rb
-lib/ropencv/ropencv_types.so
-
+ext/src/*.rbind
+ext/src/*.h
+ext/src/*.hpp
+ext/src/*.cc
+lib/ruby/ropencv/ropencv.rb
+lib/ruby/ropencv/ropencv_types.rb
+lib/lib
+lib/include
+*.gem

data/CMakeLists.txt

@@ -1,19 +1,3 @@
 cmake_minimum_required(VERSION 2.6)
-
-SET(CMAKE_INSTALL TRUE)
 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/ropencv.rb
-        DESTINATION ${RUBY_LIBRARY_INSTALL_DIR})
-    INSTALL(DIRECTORY lib/ropencv
-        DESTINATION ${RUBY_LIBRARY_INSTALL_DIR})
-ENDIF(NOT RUBY_INCLUDE_PATH)
 

data/ext/CMakeLists.txt

@@ -1,38 +1,2 @@
 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")
-
-if(CMAKE_INSTALL)
-    add_custom_command(OUTPUT ${RBIND_SRC}
-       COMMAND ruby "${CMAKE_CURRENT_SOURCE_DIR}/extconf.rb")
-endif()
-
-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_ropencv.pc @ONLY)
-install(TARGETS rbind_opencv LIBRARY DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/../lib/ropencv)
-
-if(CMAKE_INSTALL)
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/rbind_ropencv.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()
-endif()
+add_subdirectory(src)

data/ext/extconf.rb

@@ -1,113 +1,5 @@
-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 .")
+Dir.chdir(File.dirname(__FILE__)) do
+    if !system("cmake . -DGEM_INSTALL=TRUE")
         raise "CMake Configure Error"
     end
 end

data/ext/rbind.rb

@@ -0,0 +1,108 @@
+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__),"src"),File.join(File.dirname(__FILE__),"..","lib","ruby","ropencv"))
+

data/ext/src/CMakeLists.txt

@@ -0,0 +1,50 @@
+cmake_minimum_required(VERSION 2.6)
+PROJECT(rbind_opencv CXX)
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+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_custom_command(OUTPUT ${RBIND_SRC}
+       COMMAND ruby "${CMAKE_CURRENT_SOURCE_DIR}/../rbind.rb")
+
+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
+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)
+else()
+    # global install
+    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})
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind DESTINATION include/${PROJECT_NAME})
+    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind DESTINATION include/${PROJECT_NAME})
+
+    FIND_PACKAGE(Ruby)
+    IF(NOT RUBY_INCLUDE_PATH)
+        MESSAGE(STATUS "Ruby library not found. Cannot install ruby extensions")
+    ELSEIF(NOT 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")
+    ENDIF(NOT RUBY_INCLUDE_PATH)
+endif()

data/ext/src/cmake/FindGem.cmake

@@ -0,0 +1,155 @@
+# Author thomas.roehr@dfki.de
+#
+# Version 0.3 2013-07-02
+#       - rely on `gem content` to find library and header
+#       - introduce GEM_OS_PKG to allow search via pkgconfig
+# Version 0.2 2010-01-14
+#       - add support for searching for multiple gems
+# Version 0.1 2010-12-15
+# 	- support basic search functionality 
+#       - tested to find rice
+#
+# OUTPUT:
+#
+# GEM_INCLUDE_DIRS	After successful search contains the include directores
+#
+# GEM_LIBRARIES		After successful search contains the full path of each found library
+#
+#
+# Usage: 
+# set(GEM_DEBUG TRUE)
+# find_package(Gem COMPONENTS rice hoe)
+# include_directories(${GEM_INCLUDE_DIRS})
+# target_link_libraries(${GEM_LIBRARIES}
+#
+# in case pkg-config should be used to search for the os pkg, set GEM_OS_PKG, i.e.
+# set(GEM_OS_PKG TRUE)
+#
+# Check for how 'gem' should be called
+find_program(GEM_EXECUTABLE
+    NAMES "gem${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}"
+        "gem${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}"
+        "gem-${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}"
+        "gem-${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}"
+        "gem${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}${RUBY_VERSION_PATCH}"
+        "gem${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}"
+        "gem-${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}${RUBY_VERSION_PATCH}"
+        "gem-${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}"
+        "gem")
+
+# Making backward compatible
+if(Gem_DEBUG)
+    set(GEM_DEBUG TRUE)
+endif()
+
+if(NOT GEM_EXECUTABLE)
+	MESSAGE(FATAL_ERROR "Could not find the gem executable - install 'gem' first")
+endif()
+
+if(NOT Gem_FIND_COMPONENTS)
+	MESSAGE(FATAL_ERROR "If searching for a Gem you have to provide COMPONENTS with the name of the gem")
+endif()
+
+set(GEM_FOUND TRUE)
+foreach(Gem_NAME ${Gem_FIND_COMPONENTS})
+    # If the gem is installed as a gem
+    if(NOT GEM_OS_PKG)
+	    set(GEM_HOME ENV{GEM_HOME})
+
+        # Use `gem content <gem-name>` to extract current information about installed gems
+        # Store the information into ${GEM_LOCAL_INFO}
+        EXECUTE_PROCESS(COMMAND ${GEM_EXECUTABLE} content ${Gem_NAME} OUTPUT_VARIABLE GEM_LOCAL_INFO)
+
+	    if("${GEM_LOCAL_INFO}" STREQUAL "")
+	    	MESSAGE(FATAL_ERROR "No local gem found. Check your GEM_HOME setting!")
+	    else()
+            set(_library_NAME_PATTERN lib${Gem_NAME}.a
+	        		   lib${Gem_NAME}.so
+	        		   lib${Gem_NAME}.dylib
+	        		   ${Gem_NAME}.a
+	        		   ${Gem_NAME}.so
+	        		   ${Gem_NAME}.dylib
+                       .*.a
+                       .*.so
+                       .*.dylib
+	        )
+
+            set(_header_SUFFIX_PATTERN
+                        .h
+                        .hh
+                        .hpp
+            )
+
+            # Create a list from the output results of the gem command
+            string(REPLACE "\n" ";" GEM_CONTENT_LIST ${GEM_LOCAL_INFO})
+            foreach(_gem_CONTENT_PATH ${GEM_CONTENT_LIST})
+                
+                # Convert so that only '/' Unix path separator are being using
+                # needed to do proper regex matching
+                FILE(TO_CMAKE_PATH ${_gem_CONTENT_PATH} gem_CONTENT_PATH)
+
+                # Identify library -- checking for a library in the gems 'lib' (sub)directory
+                # Search for an existing library, but only within the gems folder
+                foreach(_library_NAME ${_library_NAME_PATTERN})
+                    STRING(REGEX MATCH ".*${Gem_NAME}.*/lib/.*${_library_NAME}$" GEM_PATH_INFO "${gem_CONTENT_PATH}")
+                    if(NOT "${GEM_PATH_INFO}" STREQUAL "")
+                        list(APPEND GEM_LIBRARIES ${GEM_PATH_INFO})
+                        break()
+                    endif()
+                endforeach()
+
+                # Identify headers
+                # Checking for available headers in an include directory
+                foreach(_header_PATTERN ${_header_SUFFIX_PATTERN})
+                    STRING(REGEX MATCH ".*${Gem_NAME}.*/include/.*${_header_PATTERN}$" GEM_PATH_INFO "${gem_CONTENT_PATH}")
+                    if(NOT "${GEM_PATH_INFO}" STREQUAL "")
+                        STRING(REGEX REPLACE "(.*${Gem_NAME}.*/include/).*${_header_PATTERN}$" "\\1" GEM_PATH_INFO "${gem_CONTENT_PATH}")
+                        list(APPEND GEM_INCLUDE_DIRS ${GEM_PATH_INFO})
+                        break()
+                    endif()
+                endforeach()
+            endforeach()
+
+            # Compact the lists
+            if(${GEM_LIBRARIES})
+                LIST(REMOVE_DUPLICATES GEM_LIBRARIES)
+            endif()
+            if(${GEM_INCLUDE_DIRS})
+                LIST(REMOVE_DUPLICATES GEM_INCLUDE_DIRS)
+            endif()
+        endif()
+    else(NOT GEM_OS_PKG)
+        pkg_check_modules(GEM_PKG ${Gem_NAME})
+        set(GEM_INCLUDE_DIRS ${GEM_PKG_INCLUDE_DIRS})
+        set(GEM_LIBRARIES ${GEM_PKG_LIBRARIES} ${GEM_PKG_STATIC_LIBRARIES})
+        list(APPEND GEM_LIBRARIES ${GEM_PKG_LDFLAGS} ${GEM_PKG_STATIC_LDFLAGS})
+        list(APPEND GEM_LIBRARIES ${GEM_PKG_LDFLAGS_OTHER} ${GEM_PKG_STATIC_LDFLAGS_OTHER})
+
+        if(GEM_DEBUG)
+            message(STATUS "GEM_OS_PKG is defined")
+            message(STATUS "GEM_INCLUDE_DIRS ${GEM_INCLUDE_DIRS}")
+            message(STATUS "GEM_STATIC_LIBRARY_DIRS ${GEM_PKG_STATIC_LIBRARY_DIRS}")
+            message(STATUS "GEM_LIBRARY_DIRS ${GEM_PKG_STATIC_LIBRARY_DIRS}")
+            message(STATUS "GEM_STATIC_LIBRARIES ${GEM_PKG_STATIC_LIBRARIES}")
+            message(STATUS "GEM_LIBRARIES ${GEM_LIBRARIES}")
+        endif()
+    endif()
+
+	if("${GEM_LIBRARIES}" STREQUAL "")
+		set(GEM_FOUND FALSE)
+    else()
+        MESSAGE(STATUS "Gem: ${Gem_NAME} found")
+	endif()
+
+    if(GEM_DEBUG)
+		message(STATUS "${Gem_NAME} library dir: ${GEM_LIBRARIES}")
+		message(STATUS "${Gem_NAME} include dir: ${GEM_INCLUDE_DIRS}")
+    endif()
+		
+    if(Gem_FIND_REQUIRED)
+        if(NOT GEM_FOUND)
+		    MESSAGE(FATAL_ERROR "Gem: ${Gem_NAME} could not be found")
+        endif()
+	endif()
+endforeach()
+

data/ext/src/cmake/FindRuby.cmake

@@ -0,0 +1,260 @@
+# - Find Ruby
+# This module finds if Ruby is installed and determines where the include files
+# and libraries are. Ruby 1.8 and 1.9 are supported. The minimum required version 
+# specified in the find_package() command is honored.
+# It also determines what the name of the library is. This
+# code sets the following variables:
+#
+#  RUBY_EXECUTABLE   = full path to the ruby binary
+#  RUBY_INCLUDE_DIRS = include dirs to be used when using the ruby library
+#  RUBY_LIBRARY      = full path to the ruby library
+#  RUBY_VERSION      = the version of ruby which was found, e.g. "1.8.7"
+#  RUBY_FOUND        = set to true if ruby ws found successfully
+#
+#  RUBY_INCLUDE_PATH = same as RUBY_INCLUDE_DIRS, only provided for compatibility reasons, don't use it
+
+#=============================================================================
+# Copyright 2004-2009 Kitware, Inc.
+# Copyright 2008-2009 Alexander Neundorf <neundorf@kde.org>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distributed this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+#   RUBY_ARCHDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"archdir"@:>@)'`
+#   RUBY_SITEARCHDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"sitearchdir"@:>@)'`
+#   RUBY_SITEDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"sitelibdir"@:>@)'`
+#   RUBY_LIBDIR=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"libdir"@:>@)'`
+#   RUBY_LIBRUBYARG=`$RUBY -r rbconfig -e 'printf("%s",RbConfig::CONFIG@<:@"LIBRUBYARG_SHARED"@:>@)'`
+
+# uncomment the following line to get debug output for this file
+# SET(_RUBY_DEBUG_OUTPUT TRUE)
+
+# Determine the list of possible names of the ruby executable depending
+# on which version of ruby is required
+SET(_RUBY_POSSIBLE_EXECUTABLE_NAMES ${RUBY_PROGRAM_NAME} ruby)
+
+# if 1.9 is required, don't look for ruby18 and ruby1.8, default to version 1.8
+IF(Ruby_FIND_VERSION_MAJOR  AND  Ruby_FIND_VERSION_MINOR)
+   SET(Ruby_FIND_VERSION_SHORT_NODOT "${Ruby_FIND_VERSION_MAJOR}${RUBY_FIND_VERSION_MINOR}")
+ELSE(Ruby_FIND_VERSION_MAJOR  AND  Ruby_FIND_VERSION_MINOR)
+   SET(Ruby_FIND_VERSION_SHORT_NODOT "18")
+ENDIF(Ruby_FIND_VERSION_MAJOR  AND  Ruby_FIND_VERSION_MINOR)
+
+SET(_RUBY_POSSIBLE_EXECUTABLE_NAMES ${_RUBY_POSSIBLE_EXECUTABLE_NAMES} ruby1.9 ruby19)
+
+# if we want a version below 1.9, also look for ruby 1.8
+IF("${Ruby_FIND_VERSION_SHORT_NODOT}" VERSION_LESS "19")
+   SET(_RUBY_POSSIBLE_EXECUTABLE_NAMES ${_RUBY_POSSIBLE_EXECUTABLE_NAMES} ruby1.8 ruby18)
+ENDIF("${Ruby_FIND_VERSION_SHORT_NODOT}" VERSION_LESS "19")
+
+FIND_PROGRAM(RUBY_EXECUTABLE NAMES ${_RUBY_POSSIBLE_EXECUTABLE_NAMES})
+
+
+IF(RUBY_EXECUTABLE  AND NOT  RUBY_MAJOR_VERSION)
+  # query the ruby version
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['MAJOR']"
+      OUTPUT_VARIABLE RUBY_VERSION_MAJOR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['MINOR']"
+      OUTPUT_VARIABLE RUBY_VERSION_MINOR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['TEENY']"
+      OUTPUT_VARIABLE RUBY_VERSION_PATCH)
+
+   # query the different directories
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['archdir']"
+      OUTPUT_VARIABLE RUBY_ARCH_DIR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['arch']"
+      OUTPUT_VARIABLE RUBY_ARCH)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['rubyhdrdir']"
+      OUTPUT_VARIABLE RUBY_HDR_DIR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['libdir']"
+      OUTPUT_VARIABLE RUBY_POSSIBLE_LIB_DIR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['rubylibdir']"
+      OUTPUT_VARIABLE RUBY_RUBY_LIB_DIR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['LIBRUBY_SO']"
+      OUTPUT_VARIABLE RUBY_RUBY_LIBRARY)
+   STRING(REGEX REPLACE "^lib" "" RUBY_RUBY_LIBRARY "${RUBY_RUBY_LIBRARY}")
+   STRING(REGEX REPLACE "\\.so.*" "" RUBY_RUBY_LIBRARY "${RUBY_RUBY_LIBRARY}")
+
+   # site_ruby
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['sitearchdir']"
+      OUTPUT_VARIABLE RUBY_SITEARCH_DIR)
+
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['sitelibdir']"
+      OUTPUT_VARIABLE RUBY_SITELIB_DIR)
+
+   # vendor_ruby available ?
+   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r vendor-specific -e "print 'true'"
+      OUTPUT_VARIABLE RUBY_HAS_VENDOR_RUBY  ERROR_QUIET)
+
+   IF(RUBY_HAS_VENDOR_RUBY)
+       EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['vendorlibdir']"
+         OUTPUT_VARIABLE RUBY_VENDORLIB_DIR)
+
+     EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['vendorarchdir']"
+         OUTPUT_VARIABLE RUBY_VENDORARCH_DIR)
+   ENDIF(RUBY_HAS_VENDOR_RUBY)
+
+   # save the results in the cache so we don't have to run ruby the next time again
+   SET(RUBY_VERSION_MAJOR    ${RUBY_VERSION_MAJOR}    CACHE PATH "The Ruby major version" FORCE)
+   SET(RUBY_VERSION_MINOR    ${RUBY_VERSION_MINOR}    CACHE PATH "The Ruby minor version" FORCE)
+   SET(RUBY_VERSION_PATCH    ${RUBY_VERSION_PATCH}    CACHE PATH "The Ruby patch version" FORCE)
+   SET(RUBY_ARCH_DIR         ${RUBY_ARCH_DIR}         CACHE PATH "The Ruby arch dir" FORCE)
+   SET(RUBY_HDR_DIR          ${RUBY_HDR_DIR}          CACHE PATH "The Ruby header dir (1.9)" FORCE)
+   SET(RUBY_POSSIBLE_LIB_DIR ${RUBY_POSSIBLE_LIB_DIR} CACHE PATH "The Ruby lib dir" FORCE)
+   SET(RUBY_RUBY_LIB_DIR     ${RUBY_RUBY_LIB_DIR}     CACHE PATH "The Ruby ruby-lib dir" FORCE)
+   SET(RUBY_SITEARCH_DIR     ${RUBY_SITEARCH_DIR}     CACHE PATH "The Ruby site arch dir" FORCE)
+   SET(RUBY_SITELIB_DIR      ${RUBY_SITELIB_DIR}      CACHE PATH "The Ruby site lib dir" FORCE)
+   SET(RUBY_HAS_VENDOR_RUBY  ${RUBY_HAS_VENDOR_RUBY}  CACHE BOOL "Vendor Ruby is available" FORCE)
+   SET(RUBY_VENDORARCH_DIR   ${RUBY_VENDORARCH_DIR}   CACHE PATH "The Ruby vendor arch dir" FORCE)
+   SET(RUBY_VENDORLIB_DIR    ${RUBY_VENDORLIB_DIR}    CACHE PATH "The Ruby vendor lib dir" FORCE)
+
+   MARK_AS_ADVANCED(
+     RUBY_ARCH_DIR
+     RUBY_ARCH
+     RUBY_HDR_DIR
+     RUBY_POSSIBLE_LIB_DIR
+     RUBY_RUBY_LIB_DIR
+     RUBY_SITEARCH_DIR
+     RUBY_SITELIB_DIR
+     RUBY_HAS_VENDOR_RUBY
+     RUBY_VENDORARCH_DIR
+     RUBY_VENDORLIB_DIR
+     RUBY_VERSION_MAJOR
+     RUBY_VERSION_MINOR
+     RUBY_VERSION_PATCH
+     )
+ENDIF(RUBY_EXECUTABLE  AND NOT  RUBY_MAJOR_VERSION)
+
+# In case RUBY_EXECUTABLE could not be executed (e.g. cross compiling) 
+# try to detect which version we found. This is not too good.
+IF(NOT RUBY_VERSION_MAJOR)
+   # by default assume 1.8.0
+   SET(RUBY_VERSION_MAJOR 1)
+   SET(RUBY_VERSION_MINOR 8)
+   SET(RUBY_VERSION_PATCH 0)
+   # check whether we found 1.9.x
+   IF(${RUBY_EXECUTABLE} MATCHES "ruby1.?9"  OR  RUBY_HDR_DIR)
+      SET(RUBY_VERSION_MAJOR 1)
+      SET(RUBY_VERSION_MINOR 9)
+   ENDIF(${RUBY_EXECUTABLE} MATCHES "ruby1.?9"  OR  RUBY_HDR_DIR)
+ENDIF(NOT RUBY_VERSION_MAJOR)
+
+
+SET(RUBY_VERSION "${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}")
+SET(_RUBY_VERSION_SHORT "${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}")
+SET(_RUBY_VERSION_SHORT_NODOT "${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}")
+
+# Now we know which version we found
+IF(Ruby_FIND_VERSION)
+   IF(${RUBY_VERSION}  VERSION_LESS  ${Ruby_FIND_VERSION})
+      # force running ruby the next time again
+      SET(RUBY_VERSION_MAJOR    ""    CACHE PATH "The Ruby major version" FORCE)
+      IF(Ruby_FIND_REQUIRED)
+         MESSAGE(FATAL_ERROR "Ruby version ${Ruby_FIND_VERSION} required, but only version ${RUBY_VERSION} found.")
+      ELSE(Ruby_FIND_REQUIRED)
+         IF(NOT Ruby_FIND_QUIETLY)
+            MESSAGE(STATUS "Ruby version ${Ruby_FIND_VERSION} required, but only version ${RUBY_VERSION} found.")
+         ENDIF(NOT Ruby_FIND_QUIETLY)
+         RETURN()
+      ENDIF(Ruby_FIND_REQUIRED)
+   ENDIF(${RUBY_VERSION}  VERSION_LESS  ${Ruby_FIND_VERSION})
+ENDIF(Ruby_FIND_VERSION)
+
+FIND_PATH(RUBY_INCLUDE_DIR
+   NAMES ruby.h
+   HINTS
+   ${RUBY_HDR_DIR}
+   ${RUBY_ARCH_DIR}
+   /usr/lib/ruby/${_RUBY_VERSION_SHORT}/i586-linux-gnu/ )
+
+SET(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIR} )
+
+# if ruby > 1.8 is required or if ruby > 1.8 was found, search for the config.h dir
+IF( ${Ruby_FIND_VERSION_SHORT_NODOT} GREATER 18  OR  ${_RUBY_VERSION_SHORT_NODOT} GREATER 18  OR  RUBY_HDR_DIR)
+   message(STATUS "lookign for config.h")
+   FIND_PATH(RUBY_CONFIG_INCLUDE_DIR
+     NAMES ruby/config.h  config.h
+     HINTS 
+     ${RUBY_HDR_DIR}/${RUBY_ARCH}
+     ${RUBY_ARCH_DIR} 
+     )
+
+   SET(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIRS} ${RUBY_CONFIG_INCLUDE_DIR} )
+ENDIF( ${Ruby_FIND_VERSION_SHORT_NODOT} GREATER 18  OR  ${_RUBY_VERSION_SHORT_NODOT} GREATER 18  OR  RUBY_HDR_DIR)
+
+
+# Determine the list of possible names for the ruby library
+SET(_RUBY_POSSIBLE_LIB_NAMES ruby ruby-static ruby${_RUBY_VERSION_SHORT} ${RUBY_RUBY_LIBRARY})
+
+IF(WIN32)
+   SET( _RUBY_MSVC_RUNTIME "" )
+   IF( MSVC60 )
+     SET( _RUBY_MSVC_RUNTIME "60" )
+   ENDIF( MSVC60 )
+   IF( MSVC70 )
+     SET( _RUBY_MSVC_RUNTIME "70" )
+   ENDIF( MSVC70 )
+   IF( MSVC71 )
+     SET( _RUBY_MSVC_RUNTIME "71" )
+   ENDIF( MSVC71 )
+   IF( MSVC80 )
+     SET( _RUBY_MSVC_RUNTIME "80" )
+   ENDIF( MSVC80 )
+   IF( MSVC90 )
+     SET( _RUBY_MSVC_RUNTIME "90" )
+   ENDIF( MSVC90 )
+
+   LIST(APPEND _RUBY_POSSIBLE_LIB_NAMES
+               "msvcr${_RUBY_MSVC_RUNTIME}-ruby${RUBY_NODOT_VERSION}"
+               "msvcr${_RUBY_MSVC_RUNTIME}-ruby${RUBY_NODOT_VERSION}-static" 
+               "msvcrt-ruby${RUBY_NODOT_VERSION}"
+               "msvcrt-ruby${RUBY_NODOT_VERSION}-static" )
+ENDIF(WIN32)
+
+FIND_LIBRARY(RUBY_LIBRARY NAMES ${_RUBY_POSSIBLE_LIB_NAMES} HINTS ${RUBY_POSSIBLE_LIB_DIR} )
+
+INCLUDE(FindPackageHandleStandardArgs)
+SET(_RUBY_REQUIRED_VARS RUBY_EXECUTABLE RUBY_INCLUDE_DIR RUBY_LIBRARY)
+IF(_RUBY_VERSION_SHORT_NODOT GREATER 18)
+   LIST(APPEND _RUBY_REQUIRED_VARS RUBY_CONFIG_INCLUDE_DIR)
+ENDIF(_RUBY_VERSION_SHORT_NODOT GREATER 18)
+
+IF(_RUBY_DEBUG_OUTPUT)
+   MESSAGE(STATUS "--------FindRuby.cmake debug------------")
+   MESSAGE(STATUS "_RUBY_POSSIBLE_EXECUTABLE_NAMES: ${_RUBY_POSSIBLE_EXECUTABLE_NAMES}")
+   MESSAGE(STATUS "_RUBY_POSSIBLE_LIB_NAMES: ${_RUBY_POSSIBLE_LIB_NAMES}")
+   MESSAGE(STATUS "RUBY_ARCH_DIR: ${RUBY_ARCH_DIR}")
+   MESSAGE(STATUS "RUBY_HDR_DIR: ${RUBY_HDR_DIR}")
+   MESSAGE(STATUS "RUBY_POSSIBLE_LIB_DIR: ${RUBY_POSSIBLE_LIB_DIR}")
+   MESSAGE(STATUS "Found RUBY_VERSION: \"${RUBY_VERSION}\" , short: \"${_RUBY_VERSION_SHORT}\", nodot: \"${_RUBY_VERSION_SHORT_NODOT}\"")
+   MESSAGE(STATUS "_RUBY_REQUIRED_VARS: ${_RUBY_REQUIRED_VARS}")
+   MESSAGE(STATUS "--------------------")
+ENDIF(_RUBY_DEBUG_OUTPUT)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Ruby  DEFAULT_MSG  ${_RUBY_REQUIRED_VARS})
+
+MARK_AS_ADVANCED(
+  RUBY_EXECUTABLE
+  RUBY_LIBRARY
+  RUBY_INCLUDE_DIR
+  RUBY_CONFIG_INCLUDE_DIR
+  )
+
+# Set some variables for compatibility with previous version of this file
+SET(RUBY_POSSIBLE_LIB_PATH ${RUBY_POSSIBLE_LIB_DIR})
+SET(RUBY_RUBY_LIB_PATH ${RUBY_RUBY_LIB_DIR})
+SET(RUBY_INCLUDE_PATH ${RUBY_INCLUDE_DIRS})

data/ropencv.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
     s.name              = 'ropencv'
-    s.version           = '0.0.2'
-    s.date              = '2013-06-30'
+    s.version           = '0.0.3'
+    s.date              = '2013-07-02'
     s.platform          = Gem::Platform::RUBY
     s.authors           = ['Alexander Duda']
     s.email             = ['Alexander.Duda@dfki.de']
@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
     s.summary           = 'Automated ffi-bindings for opencv 2.4.4 and 2.4.9'
     s.description       = ''
     s.files             = `git ls-files`.split("\n")
-    s.require_path      = 'lib'
+    s.require_path      = 'lib/ruby'
     s.required_rubygems_version = ">= 1.3.6"
     s.add_runtime_dependency "rbind", "~> 0.0.8"
     s.add_runtime_dependency "ffi", "~> 1.9.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ropencv
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-30 00:00:00.000000000 Z
+date: 2013-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbind
@@ -64,17 +64,21 @@ files:
 - ext/post_opencv244.txt
 - ext/post_opencv249.txt
 - ext/pre_opencv244.txt
-- ext/rbind.pc.in
+- ext/rbind.rb
 - ext/specializing.rb
-- lib/ropencv.rb
-- lib/ropencv/ropencv_ruby.rb
+- ext/src/CMakeLists.txt
+- ext/src/cmake/FindGem.cmake
+- ext/src/cmake/FindRuby.cmake
+- ext/src/rbind.pc.in
+- lib/ruby/ropencv.rb
+- lib/ruby/ropencv/ropencv_ruby.rb
 - ropencv.gemspec
 homepage: http://github.com/
 licenses: []
 post_install_message: 
 rdoc_options: []
 require_paths:
-- lib
+- lib/ruby
 required_ruby_version: !ruby/object:Gem::Requirement
   none: false
   requirements: