Added improved specs. No segfaults, but haven't tried Valgrind yet.

set_distance_type! is marked as pending.

Author: translunar

src/ruby/lib/flann.rb

@@ -52,23 +52,24 @@ class Parameters < FFI::Struct
   class << self
 
 
-    def dtype_to_c d
-      return :float if d == :float32
-      return :double if d == :float64
-      return d
+    DTYPE_TO_C = {:float32 => :float, :float64 => :double, :int32 => :int, :byte => :byte, :int8 => :byte}
+
+    def dtype_to_c d #:nodoc:
+      return DTYPE_TO_C[d] if DTYPE_TO_C.has_key?(d)
+      raise(NMatrix::DataTypeError, "FLANN does not support this dtype")
     end
 
 
     # Allocates index space and distance space for storing results from various searches. For a k-nearest neighbors
     # search, for example, you want trows (the number of rows in the testset) times k (the number of nearest neighbors
     # being searched for).
-    def allocate_results_space result_size
+    def allocate_results_space result_size #:nodoc:
       [FFI::MemoryPointer.new(:int, result_size), FFI::MemoryPointer.new(:float, result_size)]
     end
 
 
     # Don't know if these will be a hash, a static struct, or a pointer to a struct. Return the pointer and the struct.
-    def handle_parameters parameters
+    def handle_parameters parameters #:nodoc:
       parameters ||= DEFAULT_PARAMETERS unless block_given?
 
       if parameters.is_a?(FFI::MemoryPointer) # User supplies us with the necessary parameters already in the correct form.
@@ -94,38 +95,11 @@ def handle_parameters parameters
       [c_parameters_ptr, c_parameters]
     end
 
-    def handle_index index
-      return index.index_ptr if index.is_a?(Flann::Index)
-      index
-    end
-
-
-    # Find the k nearest neighbors with an index already built.
-    #
-    def nearest_neighbors_by_index index, testset, k, parameters: DEFAULT_PARAMETERS
-      parameters_ptr, parameters = handle_parameters(parameters)
-      result_size = testset.shape[0] * k
-      indices_int_ptr, distances_float_ptr = allocate_results_space(result_size)
-      index_ptr = handle_index(index)
-
-      raise(ArgumentError, "did you forget to call #build! on your index?") if index.index_ptr.nil?
-
-      Flann.flann_find_nearest_neighbors_index index_ptr,
-                                               FFI::Pointer.new_from_nmatrix(testset),
-                                               testset.shape[0],
-                                               indices_int_ptr, distances_float_ptr,
-                                               k,
-                                               parameters_ptr
-
-      [indices_int_ptr.read_array_of_int(result_size), distances_float_ptr.read_array_of_float(result_size)]
-    end
-
 
     # Find the k nearest neighbors.
     #
     # If no index parameters are given, FLANN_DEFAULT_PARAMETERS are used. A block is accepted as well.
     def nearest_neighbors dataset, testset, k, parameters: DEFAULT_PARAMETERS
-
       # Get a pointer and a struct regardless of how the arguments are supplied.
       parameters_ptr, parameters = handle_parameters(parameters)
       result_size = testset.shape[0] * k
@@ -147,20 +121,23 @@ def set_distance_type! distance_function, order = 0
     end
 
     # Perform hierarchical clustering of a set of points.
-    def compute_cluster_centers dataset, clusters, parameters: DEFAULT_PARAMETERS
+    def cluster dataset, clusters, parameters: DEFAULT_PARAMETERS
       c_method = "flann_compute_cluster_centers_#{Flann::dtype_to_c(dataset.dtype)}".to_sym
 
       result = dataset.clone_structure
       parameters_ptr, parameters = handle_parameters(parameters)
       Flann.send(c_method, FFI::Pointer.new_from_nmatrix(dataset), dataset.shape[0], dataset.shape[1], clusters, FFI::Pointer.new_from_nmatrix(result), parameters_ptr)
+
+      result
     end
+    alias :compute_cluster_centers :cluster
   end
 
 
 protected
 
-  # byte: unsigned char*dataset, int rows, int cols, float* speedup, FLANNParameters* flann_params
-  # only thing that changes is the pointer type for the first arg.
+    # byte: unsigned char*dataset, int rows, int cols, float* speedup, FLANNParameters* flann_params
+    # only thing that changes is the pointer type for the first arg.
   attach_function :flann_build_index_byte,   [:pointer, :int, :int, :pointer, :index_params_ptr], :index_ptr
   attach_function :flann_build_index_int,    [:pointer, :int, :int, :pointer, :index_params_ptr], :index_ptr
   attach_function :flann_build_index_float,  [:pointer, :int, :int, :pointer, :index_params_ptr], :index_ptr
@@ -178,26 +155,26 @@ def compute_cluster_centers dataset, clusters, parameters: DEFAULT_PARAMETERS
   attach_function :flann_radius_search_float,  [:index_ptr, :pointer, :pointer, :pointer, :int, :float, :index_params_ptr], :int
   attach_function :flann_radius_search_double, [:index_ptr, :pointer, :pointer, :pointer, :int, :float, :index_params_ptr], :int
 
-  attach_function :flann_save_index_byte, [:index_ptr, :pointer], :int
-  attach_function :flann_save_index_int, [:index_ptr, :pointer], :int
-  attach_function :flann_save_index_float, [:index_ptr, :pointer], :int
-  attach_function :flann_save_index_double, [:index_ptr, :pointer], :int
+  attach_function :flann_save_index_byte,   [:index_ptr, :string], :int
+  attach_function :flann_save_index_int,    [:index_ptr, :string], :int
+  attach_function :flann_save_index_float,  [:index_ptr, :string], :int
+  attach_function :flann_save_index_double, [:index_ptr, :string], :int
 
-  attach_function :flann_load_index_byte, [:pointer, :pointer, :int, :int], :index_ptr
-  attach_function :flann_load_index_int, [:pointer, :pointer, :int, :int], :index_ptr
-  attach_function :flann_load_index_float, [:pointer, :pointer, :int, :int], :index_ptr
-  attach_function :flann_load_index_double, [:pointer, :pointer, :int, :int], :index_ptr
+  attach_function :flann_load_index_byte,   [:string, :pointer, :int, :int], :index_ptr
+  attach_function :flann_load_index_int,    [:string, :pointer, :int, :int], :index_ptr
+  attach_function :flann_load_index_float,  [:string, :pointer, :int, :int], :index_ptr
+  attach_function :flann_load_index_double, [:string, :pointer, :int, :int], :index_ptr
 
-  attach_function :flann_free_index_byte, [:index_ptr, :index_params_ptr], :int
-  attach_function :flann_free_index_int, [:index_ptr, :index_params_ptr], :int
-  attach_function :flann_free_index_float, [:index_ptr, :index_params_ptr], :int
+  attach_function :flann_free_index_byte,   [:index_ptr, :index_params_ptr], :int
+  attach_function :flann_free_index_int,    [:index_ptr, :index_params_ptr], :int
+  attach_function :flann_free_index_float,  [:index_ptr, :index_params_ptr], :int
   attach_function :flann_free_index_double, [:index_ptr, :index_params_ptr], :int
 
   attach_function :flann_set_distance_type, [DistanceType, :int], :void
 
-  attach_function :flann_compute_cluster_centers_byte, [:pointer, :int, :int, :int, :pointer, :index_params_ptr], :int
-  attach_function :flann_compute_cluster_centers_int, [:pointer, :int, :int, :int, :pointer, :index_params_ptr], :int
-  attach_function :flann_compute_cluster_centers_float, [:pointer, :int, :int, :int, :pointer, :index_params_ptr], :int
-  attach_function :flann_compute_cluster_centers_double, [:pointer, :int, :int, :int, :pointer, :index_params_ptr], :int
+  attach_function :flann_compute_cluster_centers_byte,    [:pointer, :int, :int, :int, :pointer, :index_params_ptr], :int
+  attach_function :flann_compute_cluster_centers_int,     [:pointer, :int, :int, :int, :pointer, :index_params_ptr], :int
+  attach_function :flann_compute_cluster_centers_float,   [:pointer, :int, :int, :int, :pointer, :index_params_ptr], :int
+  attach_function :flann_compute_cluster_centers_double,  [:pointer, :int, :int, :int, :pointer, :index_params_ptr], :int
 
 end

src/ruby/lib/flann/index.rb

@@ -1,6 +1,7 @@
 class FFI::Pointer
   class << self
     def new_from_nmatrix nm
+      raise(StorageError, "dense storage expected") unless nm.dense?
       ::FFI::Pointer.new(nm.data_pointer).tap { |p| p.autorelease = false }
     end
   end
@@ -28,11 +29,11 @@ def initialize dataset: nil, dtype: :float64, parameters: Flann::DEFAULT_PARAMET
 
     # Build an index
     def build!
-      raise("no dataset specified") if @dataset.nil?
+      raise("no dataset specified") if dataset.nil?
 
       c_method = "flann_build_index_#{Flann::dtype_to_c(dtype)}".to_sym
       speedup_float_ptr = FFI::MemoryPointer.new(:float)
-      @index_ptr = Flann.send(c_method, FFI::Pointer.new_from_nmatrix(@dataset), @dataset.shape[0], @dataset.shape[1], speedup_float_ptr, parameters_ptr)
+      @index_ptr = Flann.send(c_method, FFI::Pointer.new_from_nmatrix(dataset), dataset.shape[0], dataset.shape[1], speedup_float_ptr, parameters_ptr)
 
       # Return the speedup
       speedup_float_ptr.read_float
@@ -41,47 +42,57 @@ def build!
     # Get the nearest neighbors based on this index. Forces a build of the index if one hasn't been done yet.
     def nearest_neighbors testset, k, parameters: DEFAULT_PARAMETERS
       self.build! if index_ptr.nil?
-      Flann::nearest_neighbors_by_index index_ptr, testset, k, parameters: parameters
+
+      parameters_ptr, parameters = Flann::handle_parameters(parameters)
+      result_size = testset.shape[0] * k
+      indices_int_ptr, distances_float_ptr = Flann::allocate_results_space(result_size)
+
+      Flann.flann_find_nearest_neighbors_index index_ptr,
+                                               FFI::Pointer.new_from_nmatrix(testset),
+                                               testset.shape[0],
+                                               indices_int_ptr, distances_float_ptr,
+                                               k,
+                                               parameters_ptr
+
+      [indices_int_ptr.read_array_of_int(result_size), distances_float_ptr.read_array_of_float(result_size)]
     end
 
     # Perform a radius search on a single query point
     def radius_search query, radius, max_k: dataset.shape[1], parameters: DEFAULT_PARAMETERS
       self.build! if index_ptr.nil?
-      parameters_ptr, parameters = handle_parameters(parameters)
-      indices_int_ptr, distances_float_ptr = allocate_results_space(max_k)
+      parameters_ptr, parameters = Flann::handle_parameters(parameters)
+      indices_int_ptr, distances_float_ptr = Flann::allocate_results_space(max_k)
 
       c_method = "flann_radius_search_#{Flann::dtype_to_c(dtype)}".to_sym
-      Flann.send(c_method, FFI::Pointer.new_from_nmatrix(query), indices_int_ptr, distances_float_ptr, max_k, radius, parameters_ptr)
+      Flann.send(c_method, index_ptr, FFI::Pointer.new_from_nmatrix(query), indices_int_ptr, distances_float_ptr, max_k, radius, parameters_ptr)
 
       # Return results: two arrays, one of indices and one of distances.
-      [indices_int_ptr.read_array_of_int(result_size), distances_float_ptr.read_array_of_float(result_size)]
+      [indices_int_ptr.read_array_of_int(max_k), distances_float_ptr.read_array_of_float(max_k)]
     end
 
     # Save an index to a file (without the dataset).
     def save filename
-      raise(IOError, "Cannot write an unbuilt index") if self.index_ptr.nil?
-      c_filename = FFI::MemoryPointer.from_string(filename)
+      raise(IOError, "Cannot write an unbuilt index") if index_ptr.nil?     # FIXME: This should probably have its own exception type.
       c_method = "flann_save_index_#{Flann::dtype_to_c(dtype)}".to_sym
-      Flann.send(c_method, c_filename)
+      Flann.send(c_method, index_ptr, filename)
       self
     end
 
     # Load an index from a file (with the dataset already known!).
     #
     # FIXME: This needs to free the previous dataset first.
     def load! filename
-      c_filename = FFI::MemoryPointer.from_string(filename)
       c_method = "flann_load_index_#{Flann::dtype_to_c(dtype)}".to_sym
 
-      @index_ptr = Flann.send(c_method, c_filename, FFI::Pointer.new_from_nmatrix(@dataset), @dataset.shape[0], @dataset.shape[1])
+      @index_ptr = Flann.send(c_method, filename, FFI::Pointer.new_from_nmatrix(dataset), dataset.shape[0], dataset.shape[1])
       self
     end
 
     # Free an index
     def free! parameters = DEFAULT_PARAMETERS
       c_method = "flann_free_index_#{Flann::dtype_to_c(dtype)}".to_sym
-      parameters_ptr, parameters = handle_parameters(parameters)
-      Flann.send(c_method, @index_ptr, parameters_ptr)
+      parameters_ptr, parameters = Flann::handle_parameters(parameters)
+      Flann.send(c_method, index_ptr, parameters_ptr)
       @index_ptr = nil
       self
     end

src/ruby/spec/basic_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/spec_helper.rb"
+
+describe Flann do
+  context "#set_distance_type!" do
+    it "sets the distance functor without error" do
+      pending "distance type unsupported in the C bindings, use the C++ bindings instead"
+      Flann.set_distance_type! :euclidean
+    end
+  end
+
+  [:byte, :int32, :float32, :float64].each do |dtype|
+    before :each do
+      @dataset = NMatrix.random([1000,128], dtype: dtype)
+      @testset = NMatrix.random([100,128],  dtype: dtype)
+    end
+
+    context "#nearest_neighbors" do
+      it "computes the nearest neighbors without an index" do
+        Flann.nearest_neighbors @dataset, @testset, 5
+      end
+    end
+
+    context "#cluster" do
+      it "calls flann_compute_cluster_centers_... properly" do
+        Flann.cluster(@dataset, 5)
+      end
+    end
+
+
+  end
+
+
+end

src/ruby/spec/flann_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + "/spec_helper.rb"
+
+
+describe Flann::Index do
+
+  before :each do
+    @dataset = NMatrix.random([1000,128])
+    @testset = NMatrix.random([100,128])
+    @index   = Flann::Index.new(dataset: @dataset) do |t|
+      t[:algorithm] = :kdtree
+      t[:trees]     = 4
+    end
+    @index.build!
+  end
+
+
+  context "#build!" do
+    it "builds a kdtree index with block parameters" do
+      # Empty: handled in :each, above
+    end
+  end
+
+
+  context "#nearest_neighbors" do
+    it "runs without error" do
+      @index.nearest_neighbors @testset, 5
+    end
+  end
+
+
+  context "#radius_search" do
+    it "runs without error" do
+      query = NMatrix.random([1,128])
+      @index.radius_search query, 0.4
+    end
+  end
+
+
+  context "#save" do
+    it "saves an index to a file which can be loaded again" do
+      FileUtils.rm("temp_index.save_file", :force => true)
+      @index.save("temp_index.save_file")
+
+      raise(IOError, "save failed") unless File.exists?("temp_index.save_file")
+
+      post_index = Flann::Index.new(dataset: @dataset)
+      post_index.load!("temp_index.save_file")
+      FileUtils.rm("temp_index.save_file", :force => true)
+    end
+  end
+
+
+  context "#free!" do
+    it "frees an index" do
+      @index.free!
+    end
+  end
+
+
+
+
+end