librtree 0.8.1 → 0.8.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 126a8974cacf26f7c8603d161d4d7de0c121abdf5a0bc45b8244178156cbdca7
-  data.tar.gz: 1dd3115fb8a2eb08dd5a8968ad201978b2a956dde48e210cf648027365d91fa9
+  metadata.gz: ad62e4e446f6fb4571d33f6498bf9df26d5b360a0325cde40ead187ebcb0be04
+  data.tar.gz: d462f690013c36933961206659026af7fe9b50ea6d23198f15a0965247390192
 SHA512:
-  metadata.gz: 148bffff79b038c562620bd583f6437bced0426af7210a3a289023162634f681ef1579b523cab78a6ef057be07075868b3e49b06cc48bc4747fdedfd2d0380d8
-  data.tar.gz: 375703fbd60f42cf8722188c6fd654bcbc7ceec5886b19705c5993140fb0973a7c68c14df89e8255cef467e13c586579e94691557847ad5b6168bbfb80075eb5
+  metadata.gz: 19e997efe8519f2db02e10f69f8d60af57c376e9a6de7f38bc8f3613cbd8287800e096816f1c37361c122c0a7c99e41bd97f7842ddebdf0357395e31a666739b
+  data.tar.gz: bf1911bade3fcba763aee1f4a451dd9638f8e9c3b06577482b09bc134942282d031538d8a436ee161ec4334c7f2dfdadfcf8ac1349dc3d32b053c69390e5eb7f

data/ext/rtree/extconf.rb

@@ -20,11 +20,9 @@ puts LIB_DIRS.inspect
 
 dir_config('librtree', HEADER_DIRS, LIB_DIRS)
 
-abort 'missing csv.h' unless find_header('csv.h')
 abort 'missing jansson.h' unless find_header('jansson.h')
 abort 'missing rtree.h' unless find_header('rtree.h')
 
-abort "libcsv is missing" unless find_library('csv', 'csv_init')
 abort "libjansson is missing" unless find_library('jansson', 'json_pack')
 abort "librtree is missing" unless find_library('rtree', 'rtree_new')
 

data/ext/rtree/rtree.c

@@ -1,35 +1,48 @@
 #include <ruby.h>
 #include <ruby/io.h>
+#include <ruby/version.h>
 
 #include <rtree.h>
+#include <rtree/package.h>
 
 #include <errno.h>
 #include <stdint.h>
 
-typedef struct
-{
-  void *rtree;
-} lrt_t;
 
-static void lrt_free(void *p)
+static void lrt_dfree(void *p)
 {
-  lrt_t *lrt = p;
-
-  if (lrt->rtree)
-    {
-      rtree_destroy(lrt->rtree);
-      lrt->rtree = NULL;
-    }
+  rtree_destroy((rtree_t*)p);
 }
 
-static VALUE lrt_alloc(VALUE cls)
+static size_t lrt_dsize(const void *p)
 {
-  lrt_t *lrt;
-  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt);
+  return rtree_bytes((const rtree_t*)p);
+}
 
-  lrt->rtree = NULL;
+static rb_data_type_t type = {
+  .wrap_struct_name = "rtree-wrap",
+  .function = {
+    .dmark = NULL,
+    .dfree = lrt_dfree,
+    .dsize = lrt_dsize,
+#if RUBY_API_VERSION_CODE < 20700
+    .reserved = { NULL, NULL }
+#else
+    .dcompact = NULL,
+    .reserved = { NULL }
+#endif
+  },
+  .parent = NULL,
+  .data = NULL,
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
 
-  return obj;
+static VALUE lrt_alloc(VALUE cls)
+{
+  rtree_t *rtree;;
+  if ((rtree = rtree_alloc()) == NULL)
+    rb_raise(rb_eNoMemError, "failed to alloc rtree");
+  return TypedData_Wrap_Struct(cls, &type, rtree);
 }
 
 static VALUE lrt_init(VALUE self, VALUE dim_obj, VALUE flags_obj)
@@ -40,31 +53,28 @@ static VALUE lrt_init(VALUE self, VALUE dim_obj, VALUE flags_obj)
   Check_Type(dim_obj, T_FIXNUM);
   state_flags_t flags = FIX2UINT(flags_obj);
 
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
-  if ((lrt->rtree = rtree_new(dim, flags)) == NULL)
-    rb_raise(rb_eNoMemError, "failed to create rtree");
+  if ((rtree_init(rtree, dim, flags)) != 0)
+    rb_raise(rb_eNoMemError, "failed to init rtree");
 
   return self;
 }
 
 static VALUE lrt_release(VALUE self)
 {
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
-
-  free(lrt->rtree);
-
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
+  rtree_destroy(rtree);
   return self;
 }
 
 static VALUE lrt_height(VALUE self)
 {
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
-
-  return INT2NUM(rtree_height(lrt->rtree));
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
+  return INT2NUM(rtree_height(rtree));
 }
 
 static VALUE lrt_add_rect(VALUE self, VALUE id_obj, VALUE coord_obj)
@@ -72,11 +82,9 @@ static VALUE lrt_add_rect(VALUE self, VALUE id_obj, VALUE coord_obj)
   Check_Type(coord_obj, T_ARRAY);
   Check_Type(id_obj, T_FIXNUM);
 
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
-  rtree_t
-    *rtree = lrt->rtree;
   rtree_id_t
     id = FIX2ULONG(id_obj);
   size_t
@@ -132,11 +140,10 @@ static VALUE lrt_update(VALUE self)
   if (!rb_block_given_p())
     rb_raise(rb_eArgError, "Expected block");
 
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
-  rtree_t *rtree = lrt->rtree;
-  size_t len = 2 * state_dims(rtree->state);
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
+  size_t len = 2 * state_dims(rtree->state);
   int err = rtree_update(rtree, update_cb, &len);
 
   if (err != 0)
@@ -169,11 +176,9 @@ static VALUE lrt_search(VALUE self, VALUE coord_obj)
 
   Check_Type(coord_obj, T_ARRAY);
 
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
-  rtree_t
-    *rtree = lrt->rtree;
   size_t
     len = RARRAY_LEN(coord_obj),
     dim = state_dims(rtree->state);
@@ -215,12 +220,7 @@ static VALUE deserialise(VALUE cls, VALUE io_obj, deserialise_t *f)
         rb_raise(rb_eRuntimeError, "Failed read from stream");
     }
 
-  lrt_t *lrt;
-  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt);
-
-  lrt->rtree = rtree;
-
-  return obj;
+  return TypedData_Wrap_Struct(cls, &type, rtree);
 }
 
 static VALUE lrt_json_read(VALUE cls, VALUE io_obj)
@@ -259,12 +259,7 @@ static VALUE lrt_csv_read(VALUE cls,
         rb_raise(rb_eRuntimeError, "Failed read from stream");
     }
 
-  lrt_t *lrt;
-  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt);
-
-  lrt->rtree = rtree;
-
-  return obj;
+  return TypedData_Wrap_Struct(cls, &type, rtree);
 }
 
 /* serialisation */
@@ -281,9 +276,8 @@ static VALUE serialise(VALUE self, VALUE io_obj, serialise_t *f)
   rb_io_check_writable(io);
   FILE *fp = rb_io_stdio_file(io);
 
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
-  rtree_t *rtree = lrt->rtree;
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
   int err = f(rtree, fp);
   if (err != 0)
@@ -304,12 +298,10 @@ static VALUE lrt_bsrt_write(VALUE self, VALUE io_obj)
 
 static VALUE lrt_identical(VALUE self, VALUE other)
 {
-  lrt_t *lrt_self, *lrt_other;
-  Data_Get_Struct(self, lrt_t, lrt_self);
-  Data_Get_Struct(other, lrt_t, lrt_other);
-  rtree_t
-    *rtree_self = lrt_self->rtree,
-    *rtree_other = lrt_other->rtree;
+  rtree_t *rtree_self, *rtree_other;
+
+  TypedData_Get_Struct(self, rtree_t, &type, rtree_self);
+  TypedData_Get_Struct(other, rtree_t, &type, rtree_other);
 
   if (rtree_identical(rtree_self, rtree_other))
     return Qtrue;
@@ -319,12 +311,12 @@ static VALUE lrt_identical(VALUE self, VALUE other)
 
 static VALUE lrt_clone(VALUE self)
 {
-  lrt_t *lrt;
-  Data_Get_Struct(self, lrt_t, lrt);
   rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
 
+  rtree_t *clone;
   errno = 0;
-  if ((rtree = rtree_clone(lrt->rtree)) == NULL)
+  if ((clone = rtree_clone(rtree)) == NULL)
     {
       if (errno)
         rb_sys_fail(__func__);
@@ -332,13 +324,73 @@ static VALUE lrt_clone(VALUE self)
         rb_raise(rb_eRuntimeError, "Failed clone");
     }
 
-  lrt_t *lrt_cloned;
-  VALUE cls = CLASS_OF(self);
-  VALUE obj = Data_Make_Struct(cls, lrt_t, NULL, lrt_free, lrt_cloned);
+  return TypedData_Wrap_Struct(CLASS_OF(self), &type, clone);
+}
+
+static VALUE state_size_access(VALUE self, size_t (*f)(const state_t*))
+{
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
+  return INT2NUM(f(rtree->state));
+}
+
+static VALUE lrt_dim(VALUE self)
+{
+  return state_size_access(self, state_dims);
+}
+
+static VALUE lrt_page_size(VALUE self)
+{
+  return state_size_access(self, state_page_size);
+}
+
+static VALUE lrt_node_size(VALUE self)
+{
+  return state_size_access(self, state_node_size);
+}
 
-  lrt_cloned->rtree = rtree;
+static VALUE lrt_rect_size(VALUE self)
+{
+  return state_size_access(self, state_rect_size);
+}
+
+static VALUE lrt_branch_size(VALUE self)
+{
+  return state_size_access(self, state_branch_size);
+}
+
+static VALUE lrt_branching_factor(VALUE self)
+{
+  return state_size_access(self, state_branching_factor);
+}
 
-  return obj;
+static VALUE lrt_unit_sphere_volume(VALUE self)
+{
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
+  return DBL2NUM(state_unit_sphere_volume(rtree->state));
+}
+
+static VALUE lrt_size(VALUE self)
+{
+  rtree_t *rtree;
+  TypedData_Get_Struct(self, rtree_t, &type, rtree);
+  return INT2NUM(rtree_bytes(rtree));
+}
+
+static VALUE lrt_version(VALUE self)
+{
+  return rb_str_new_cstr(rtree_package_version);
+}
+
+static VALUE lrt_bugreport(VALUE self)
+{
+  return rb_str_new_cstr(rtree_package_bugreport);
+}
+
+static VALUE lrt_url(VALUE self)
+{
+  return rb_str_new_cstr(rtree_package_url);
 }
 
 void Init_rtree(void)
@@ -356,7 +408,21 @@ void Init_rtree(void)
   rb_define_method(cls, "json_write", lrt_json_write, 1);
   rb_define_method(cls, "bsrt_write", lrt_bsrt_write, 1);
   rb_define_method(cls, "eq?", lrt_identical, 1);
+  rb_define_method(cls, "dim", lrt_dim, 0);
+  rb_define_method(cls, "size", lrt_size, 0);
+  rb_define_method(cls, "page_size", lrt_page_size, 0);
+  rb_define_method(cls, "node_size", lrt_node_size, 0);
+  rb_define_method(cls, "rect_size", lrt_rect_size, 0);
+  rb_define_method(cls, "branch_size", lrt_branch_size, 0);
+  rb_define_method(cls, "branching_factor", lrt_branching_factor, 0);
+  rb_define_method(cls, "unit_sphere_volume", lrt_unit_sphere_volume, 0);
+  rb_define_singleton_method(cls, "version", lrt_version, 0);
+  rb_define_singleton_method(cls, "bugreport", lrt_bugreport, 0);
+  rb_define_singleton_method(cls, "url", lrt_url, 0);
   rb_define_singleton_method(cls, "json_read", lrt_json_read, 1);
   rb_define_singleton_method(cls, "bsrt_read", lrt_bsrt_read, 1);
   rb_define_singleton_method(cls, "csv_read", lrt_csv_read, 3);
+  rb_define_const(cls, "SPLIT_QUADRATIC", INT2NUM(RTREE_SPLIT_QUADRATIC));
+  rb_define_const(cls, "SPLIT_LINEAR", INT2NUM(RTREE_SPLIT_LINEAR));
+  rb_define_const(cls, "SPLIT_GREENE", INT2NUM(RTREE_SPLIT_GREENE));
 }

data/lib/rtree.rb

@@ -1,4 +1,4 @@
-# The C extension
+# The Ruby/C interface, which is not documented in YARD.
 class RTreeC ; end
 
 # @author RTree J. J. Green
@@ -96,7 +96,7 @@ class RTree < RTreeC
     # Build a new RTree instance from CSV stream
     # @param io [IO] a readable stream object
     # @param dim [Integer] the dimension of the tree
-    # @param split [:linear, :quadratic] See {#initialize}
+    # @param split [:linear, :quadratic, :greene] See {#initialize}
     # @param node_page [Integer] See {#initialize}
     # @return [RTree] the newly built RTree
     # @note The CSV file (without header) should have the id in the
@@ -120,13 +120,30 @@ class RTree < RTreeC
       end
     end
 
+    # @return [Array<Integer>] version of librtree
+    def version
+      @version ||= super.split('.').map(&:to_i)
+    end
+
+    # @return [String] email address for librtree bug reports
+    def bugreport
+      super
+    end
+
+    # @return [String] librtree homepage
+    def url
+      super
+    end
+
     # @!visibility private
     def split_flag(split)
       case split
       when :quadratic
-        0
+        self::SPLIT_QUADRATIC
       when :linear
-        1
+        self::SPLIT_LINEAR
+      when :greene
+        self::SPLIT_GREENE
       else
         raise ArgumentError, "bad split value: #{split}"
       end
@@ -165,9 +182,10 @@ class RTree < RTreeC
 
   # Initialize a new (empty) RTree
   # @param dim [Integer] the dimension of the tree
-  # @param split [:linear, :quadratic] determines the splitting strategy,
-  #   the linear strategy is faster to build, the quadratic produces a
-  #   better-quality R-tree which is faster to query.
+  # @param split [:linear, :quadratic, :greene] determines the splitting
+  #   strategy, the linear strategy is faster to build, the quadratic
+  #   and greene strategies produces a better-quality R-trees which is
+  #   faster to query.
   # @param node_page [Integer] the nodes-per-page value. This value can
   #   affect performance quite dramatically, particularly build time. A
   #   value which is too large would result in an infeasible branching
@@ -233,7 +251,7 @@ class RTree < RTreeC
   #   is much faster than rebuilding the R-tree; in this Ruby interface
   #   the callback must convert C floats to Ruby, yield them to the
   #   block and then convert the returned Ruby Floats to C; so we would
-  #   expect that it loses much of its competetive advantage when
+  #   expect that it loses much of its competitive advantage when
   #   compared to an R-tree rebuild.
   def update!
     super
@@ -252,7 +270,7 @@ class RTree < RTreeC
   end
 
   # Serialise to JSON stream
-  # @param io [IO] a writeable stream
+  # @param io [IO] a writable stream
   # @return [self]
   # @see .json_read
   # @example Write to file
@@ -262,7 +280,7 @@ class RTree < RTreeC
   end
 
   # Serialise to BSRT (binary serialised R-tree) stream
-  # @param io [IO] a writeable stream
+  # @param io [IO] a writable stream
   # @return [self]
   # @see .bsrt_read
   # @example Write to file
@@ -292,7 +310,7 @@ class RTree < RTreeC
   end
 
   # Equality of RTrees.  This is a rather strict equality,
-  # not only must the tree have the same rectangkes, they
+  # not only must the tree have the same rectangles, they
   # must be in the same order. Certainly {#clone} will produce
   # an instance which is equal in this sense.
   # @return [Boolean] true if the instances are identical
@@ -302,6 +320,52 @@ class RTree < RTreeC
 
   alias_method(:==, :eq?)
 
+  # @return [Integer] the dimension of the R-tree
+  def dim
+    super
+  end
+
+  # @return [Integer] the total bytes allocated for the instance
+  # @note This method traverses the entire tree summing the
+  #   contributions for each node (rather than maintaining a
+  #   running count).  Performance-minded users may wish to
+  #   cache this value (invalidating the cache when calling
+  #   {#add_rect} of course).
+  def size
+    super
+  end
+
+  # @return [Integer] the bytes in a page of memory
+  def page_size
+    super
+  end
+
+  # @return [Integer] the size in bytes of a node
+  def node_size
+    super
+  end
+
+  # @return [Integer] the size in bytes of a rectangle
+  def rect_size
+    super
+  end
+
+  # @return [Integer] the size in bytes of a branch
+  def branch_size
+    super
+  end
+
+  # @return [Integer] the number of branches from each node
+  def branching_factor
+    super
+  end
+
+  # @return [Float] the volume of the unit sphere in the R-tree's
+  #   dimension
+  def unit_sphere_volume
+    super
+  end
+
   private
 
   attr_reader :split, :node_page
@@ -334,6 +398,7 @@ class RTree < RTreeC
     result
   end
 
+
 end
 
 require 'rtree/rtree'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: librtree
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.6
 platform: ruby
 authors:
 - J.J. Green
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-19 00:00:00.000000000 Z
+date: 2021-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -95,8 +95,8 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1'
 description: |
-  A Ruby extension for librtree implementing the R-tree
-  spatial-index of Guttman-Green.
+  A Ruby extension implementing the R-tree spatial-index of
+  Guttman-Green.
 email: j.j.green@gmx.co.uk
 executables: []
 extensions:
@@ -119,14 +119,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- The librtree library
+- The librtree library (1.0.6 or later)
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4