librtree 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c35526142564e94d93f091e405467f2ee2df3d294b1a4b8e3a87db66f1229043
-  data.tar.gz: dffb928767c821a14460f21d06fc1c90e41a7a17a94a8e700fac0c409d65ca59
+  metadata.gz: 97e18073b1466bdc07ddba6d4b06cfa850c3531240920ab4bd391a1896def24f
+  data.tar.gz: 0a57abcf15c8dd21e3ec7ee26fdb2f5d98ae8ec06838297eb00b05f5ebaae70d
 SHA512:
-  metadata.gz: 0447a6e59546922ed8d227e0f3589aae7771243c4e16c24ae46cde5075dae4b1f7be2b1a8526d58adc6c3db379719201fcf370f1251e82773f488046ab66caff
-  data.tar.gz: 8ed4fd4e3982a4bfbffac9a53f92ae6dfd497ac4e684110d72591e7ec500a4ee2629a5b3a17dad5cc404383eb7aaccf333d7d15a8aeaa943d858a3e973a35d13
+  metadata.gz: e633393e0fc75958fae7ee302a0a1e51e42ce41f86ec887da9c41bf74c2bb1657b4c06d4e690939c83945092ba4531901050f537bef6c48c73ddeea28a272a69
+  data.tar.gz: 25b6456ab526e41afd095157c96715118cdadbb9a15c2c863197fda329a61f5d6f8adda1e78aeb8733f8e74d54faf4bba193103e81aff3db7bfebcc8e54c2052

data/CHANGELOG.md

@@ -1,7 +1,12 @@
 Changelog
 ---------
 
-### 1.0.2, pending
+### 1.0.3, 16-10-2023
+
+- Update to librtree 1.3.0
+- Remove workaround for "optional argument to #exit!" issue
+
+### 1.0.2, 06-04-2023
 
 - The `#serialise` method raises if the read from pipe returns
   nil (which it might), so the method (and other methods which
@@ -26,7 +31,7 @@ Changelog
 
 - Tidying
 - Fix warning "undefining the allocator of T_DATA class" on
-  Ruby 3,2
+  Ruby 3.2
 - No functional changes
 
 ### 0.9.0, 07-11-2021

data/README.md

@@ -54,12 +54,12 @@ this.
 If using [rbenv][4], then first set a local version of Ruby to use,
 then install the gems into your local cache
 
-    rbenv local 2.7.0
+    rbenv local 3.2.0
     bundle install
 
-The repository's `.gitignore` ignores **rbenv**'s `.ruby-version`
-file, since we don't want to mandate a particular Ruby version
-for the package.
+The repository's `.gitignore` ignores **rbenv**'s `.ruby-version` file,
+since we don't want to mandate a particular Ruby version for the package
+(although 3.0 is the minimal version for development at present).
 
 If not using **rbenv** then just
 

data/ext/rtree/lib/branch.c

@@ -2,7 +2,8 @@
 #include "config.h"
 #endif
 
-#include "rtree/branch.h"
+#include "branch.h"
+#include "state.h"
 
 #include <stddef.h>
 #include <stdalign.h>

data/ext/rtree/lib/branch.h

@@ -0,0 +1,97 @@
+/*
+  branch.h
+  Copyright (c) J.J. Green 2023
+*/
+
+#ifndef BRANCH_H
+#define BRANCH_H
+
+#include <stdlib.h>
+
+#include "rtree/branch.h"
+
+#include "rect.h"
+#include "rtree/types.h"
+#include "rtree/state.h"
+#include "rtree/node.h"
+
+/*
+  The union is either a pointer to the child-node in the tree, or
+  if we are at level zero, the id payload.  The latter may as well
+  be the size of a pointer.
+
+  The rect is big enough to hold 2 * dims floats, understood to be
+  [x0, y0, ..., x1, y1, ...] corresponding to the (hyper-)rectangle
+  x0 < x < x1, y0 < y < y1, ..., this must be at the end of the
+  struct (since variable).
+
+  For the sake of SSE, we would like the rect member to be 16-byte
+  aligned, and this could be done with
+
+    rtree_coord_t alignas(16) rect[];
+
+  but this would force the size of branch_t to be a multiple of 16,
+  so for the dimension 2 case with rtree_coord_t a float increases
+  branch size from 24 to 32 bytes, essentially increasing the size
+  of the tree by 20%.  So we don't do that, and use non-aligned
+  variants for SSE load/save (apparently on recent CPUs the penalty
+  is pretty small).
+*/
+
+struct branch_t
+{
+  union {
+    node_t *child;
+    rtree_id_t id;
+  };
+  rtree_coord_t rect[];
+};
+
+size_t branch_sizeof(size_t);
+int branch_init(const state_t*, branch_t*);
+branch_t* branch_copy(const state_t*, const branch_t*, branch_t*);
+
+/* inline accessors */
+
+inline void branch_set_child(branch_t *branch, node_t *child)
+{
+  branch->child = child;
+}
+
+inline const node_t* branch_get_child(const branch_t *branch)
+{
+  return branch->child;
+}
+
+inline node_t* branch_get_child_mutable(branch_t *branch)
+{
+  return branch->child;
+}
+
+inline void branch_set_id(branch_t *branch, rtree_id_t id)
+{
+  branch->id = id;
+}
+
+inline rtree_id_t branch_get_id(const branch_t *branch)
+{
+  return branch->id;
+}
+
+inline void branch_set_rect(const state_t *state, branch_t *branch,
+                            const rtree_coord_t *rect)
+{
+  rect_copy(state, rect, branch->rect);
+}
+
+inline const rtree_coord_t* branch_get_rect(const branch_t *branch)
+{
+  return branch->rect;
+}
+
+inline rtree_coord_t* branch_get_rect_mutable(branch_t *branch)
+{
+  return branch->rect;
+}
+
+#endif

data/ext/rtree/lib/branches.c

@@ -11,7 +11,7 @@
 #include "config.h"
 #endif
 
-#include "rtree/branches.h"
+#include "branches.h"
 
 extern branch_t* branches_get(const state_t*, void*, size_t);
 extern void branches_set(const state_t*, void*, size_t, const branch_t*);

data/ext/rtree/lib/{rtree/branches.h → branches.h}

@@ -1,10 +1,10 @@
 /*
-  rtree/branches.h
+  branches.h
   Copyright (c) J.J. Green 2020
 */
 
-#ifndef RTREE_BRANCHES_H
-#define RTREE_BRANCHES_H
+#ifndef BRANCHES_H
+#define BRANCHES_H
 
 #ifdef __cplusplus
 extern "C" {
@@ -14,9 +14,9 @@ extern "C" {
 #include <errno.h>
 #include <string.h>
 
-#include <rtree/state.h>
-#include <rtree/branch.h>
-#include <rtree/error.h>
+#include "state.h"
+#include "rtree/branch.h"
+#include "rtree/error.h"
 
 inline branch_t* branches_get(const state_t *state, void *buffer, size_t i)
 {

data/ext/rtree/lib/bsrt.c

@@ -4,8 +4,11 @@
 
 #include "bsrt.h"
 
+#include "node.h"
+#include "branch.h"
+#include "branches.h"
+
 #include "rtree/error.h"
-#include "rtree/branches.h"
 
 #include <errno.h>
 #include <string.h>
@@ -129,28 +132,18 @@ static int write_rect(const state_t *state,
 
   for (size_t i = 0 ; i < n ; i++)
     {
-      /*
-        The type-punning to/from char* here is legal (the standard
-        makes an explicit exception), but cppcheck warns anyway, so
-        we suppress those warnings
-      */
-
       char p[k];
 
-      /* cppcheck-suppress invalidPointerCast */
       *(rtree_coord_t*)p = rect[i];
 
 #if SIZEOF_RTREE_COORD_T == 4
-      /* cppcheck-suppress invalidPointerCast */
       *(uint32_t*)p = htole32(*(uint32_t*)p);
 #elif SIZEOF_RTREE_COORD_T == 8
-      /* cppcheck-suppress invalidPointerCast */
       *(uint64_t*)p = htole64(*(uint64_t*)p);
 #else
 #error rtree_coord_t size not handled
 #endif
 
-      /* cppcheck-suppress invalidPointerCast */
       buffer[i] = *(rtree_coord_t*)p;
     }
 
@@ -321,7 +314,7 @@ static int read_v1_header(FILE *stream, uint16_t v[5])
   return 0;
 }
 
-static bool read_v1_state_consistent(uint16_t v[5], const state_t *state)
+static bool read_v1_state_consistent(const uint16_t v[5], const state_t *state)
 {
   return
     (v[0] == state_dims(state)) &&
@@ -360,8 +353,6 @@ static int read_v1_rect(FILE *stream,
 #error rtree_coord_t size not handled
 #endif
 
-      /* cppcheck-suppress invalidPointerCast */
-
       rect[i] = *(rtree_coord_t*)p;
     }
 
@@ -592,7 +583,7 @@ static int read_v2_header(FILE *stream, uint16_t v[6])
   return 0;
 }
 
-static bool read_v2_state_consistent(uint16_t v[6], const state_t *state)
+static bool read_v2_state_consistent(const uint16_t v[6], const state_t *state)
 {
   return
     (v[0] == state_dims(state)) &&

data/ext/rtree/lib/bsrt.h

@@ -8,7 +8,7 @@
 
 #include <stdio.h>
 
-#include <rtree.h>
+#include "rtree.h"
 
 int bsrt_rtree_write(const rtree_t*, FILE*);
 rtree_t* bsrt_rtree_read(FILE*);

data/ext/rtree/lib/csv.c

@@ -3,6 +3,7 @@
 #endif
 
 #include "csv.h"
+#include "state.h"
 
 #include "rtree/error.h"
 #include "rtree/types.h"

data/ext/rtree/lib/csv.h

@@ -8,8 +8,8 @@
 
 #include <stdio.h>
 
-#include <rtree.h>
-#include <rtree/state.h>
+#include "rtree.h"
+#include "rtree/state.h"
 
 rtree_t* csv_rtree_read(FILE*, size_t, state_flags_t);
 

data/ext/rtree/lib/json.c

@@ -4,9 +4,11 @@
 
 #include "json.h"
 #include "bounds.h"
+#include "node.h"
+#include "branch.h"
+#include "branches.h"
 
 #include "rtree/error.h"
-#include "rtree/branches.h"
 
 #include <errno.h>
 

data/ext/rtree/lib/json.h

@@ -8,7 +8,7 @@
 
 #include <stdio.h>
 
-#include <rtree.h>
+#include "rtree.h"
 
 int json_rtree_write(const rtree_t*, FILE*);
 rtree_t* json_rtree_read(FILE*);

data/ext/rtree/lib/node.c

@@ -2,11 +2,13 @@
 #include "config.h"
 #endif
 
-#include "rtree/node.h"
-#include "rtree/branches.h"
-#include "rtree/rect.h"
+#include "node.h"
+
 #include "rtree/error.h"
 
+#include "branch.h"
+#include "branches.h"
+#include "rect.h"
 #include "split.h"
 
 #include <stdbool.h>
@@ -307,23 +309,27 @@ node_t* node_add_branch(const state_t *state, node_t *node, branch_t *branch)
   Pick a branch.  Pick the one that will need the smallest increase
   in volume to accomodate the new (hyper-)rectangle.  This will result
   in the least total volume for the covering rectangles in the current
-  node.  In case of a tie, pick the one which was smaller before, to
-  get the best resolution when searching.
+  node.
+
+  This is expensive but does not show up directly in the profile since
+  it is only called once so obviously inlined.
 */
 
 static int node_pick_branch(const state_t *state,
-                            node_t *node, const rtree_coord_t *rect,
+                            node_t *node,
+                            const rtree_coord_t *rect,
                             size_t *index)
 {
-  const size_t
-    dims = state_dims(state);
-  size_t
-    index_min = SIZE_MAX;
-  rtree_coord_t
-    dvol_min = INFINITY,
-    vol_min = INFINITY;
 
-  for (size_t i = 0 ; i < node_count(node) ; i++)
+  const size_t dims = state_dims(state);
+  assert(dims > 0);
+  rtree_coord_t rect2[2 * dims];
+
+  const size_t n = node_count(node);
+  assert(n > 0);
+  rtree_coord_t dvol[n];
+
+  for (size_t i = 0 ; i < n ; i++)
     {
       branch_t *branch;
 
@@ -331,34 +337,29 @@ static int node_pick_branch(const state_t *state,
         return RTREE_ERR_GETBRANCH;
 
       const rtree_coord_t *rect1 = branch_get_rect(branch);
-      rtree_coord_t rect2[2 * dims];
       rect_combine(state, rect, rect1, rect2);
 
       rtree_coord_t
         vol1 = rect_spherical_volume(state, rect1),
-        vol2 = rect_spherical_volume(state, rect2),
-        dvol = vol2 - vol1;
+        vol2 = rect_spherical_volume(state, rect2);
 
-      if ((dvol < dvol_min) || ((dvol == dvol_min) && (vol1 < vol_min)))
+      dvol[i] = vol2 - vol1;
+    }
+
+  rtree_coord_t dvol_min = dvol[0];
+  size_t index_min = 0;
+
+  for (size_t i = 1 ; i < n ; i++)
+    {
+      rtree_coord_t dvol_i = dvol[i];
+
+      if (dvol_i < dvol_min)
         {
+          dvol_min = dvol_i;
           index_min = i;
-          vol_min = vol1;
-          dvol_min = dvol;
         }
     }
 
-  /*
-    This can only happen if no branches are assigned in the above
-    block, on the first call of it, dvol_min == DBL_MAX, so either
-    the first case is called, or dvol == DBL_MAX, but dvol is equal
-    to vol2 - vol1, and vol1, vol2 are non-negative, so vol2 must
-    be DBL_MAX and vol1 zero, in particular vol1 < vol_min (DBL_MAX),
-    so the second condition is met.
-  */
-
-  if (index_min == SIZE_MAX)
-    return RTREE_ERR_PICKBRANCH;
-
   *index = index_min;
 
   return RTREE_OK;

data/ext/rtree/lib/node.h

@@ -0,0 +1,84 @@
+/*
+  node.h
+  Copyright (c) J.J. Green 2023
+*/
+
+#ifndef NODE_H
+#define NODE_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+typedef uint16_t node_level_t;
+typedef uint16_t node_count_t;
+typedef uint16_t node_height_t;
+
+#define NODE_LEVEL_MAX UINT16_MAX
+#define NODE_COUNT_MAX UINT16_MAX
+
+#include "rtree/node.h"
+
+#include "rtree/types.h"
+#include "rtree/state.h"
+#include "rtree/branch.h"
+
+struct node_t
+{
+  node_level_t level;
+  node_count_t count;
+  char branches[];
+};
+
+typedef int (nbe_cb_t)(const state_t*, const branch_t*, void*);
+
+int node_init(const state_t*, node_t*);
+node_t* node_new(const state_t*);
+void node_destroy(const state_t*, node_t*);
+node_t* node_clone(const state_t*, const node_t*);
+int node_branch_each(const state_t*, const node_t*, nbe_cb_t*, void*);
+int node_branch_each_level(const state_t*, const node_t*, node_level_t,
+                           nbe_cb_t*, void*);
+size_t node_num_branch(size_t, size_t);
+int node_detach_branch(const state_t*, node_t*, size_t);
+node_t* node_add_branch(const state_t*, node_t*, branch_t*);
+int node_envelope(const state_t*, const node_t*, rtree_coord_t*);
+node_t* node_add_rect(const state_t*, rtree_id_t, rtree_coord_t*,
+                      node_t*, node_level_t);
+int node_update(const state_t*, const node_t*, rtree_update_t*, void*);
+bool node_identical(const state_t*, const node_t*, const node_t*);
+node_height_t node_height(const state_t*, const node_t*);
+size_t node_bytes(const state_t*, const node_t*);
+bool node_nonempty(const state_t*, const node_t*);
+
+inline node_count_t node_count(const node_t *node)
+{
+  return node->count;
+}
+
+inline void node_count_increment(node_t *node)
+{
+  node->count++;
+}
+
+inline void node_count_decrement(node_t *node)
+{
+  node->count--;
+}
+
+inline node_level_t node_level(const node_t *node)
+{
+  return node->level;
+}
+
+inline void node_set_level(node_t *node, node_level_t level)
+{
+  node->level = level;
+}
+
+inline void* node_get_branches(node_t *node)
+{
+  return node->branches;
+}
+
+#endif

data/ext/rtree/lib/package.c

@@ -5,7 +5,7 @@
 
 #include "rtree/package.h"
 
-const char rtree_package_version[] = "1.1.4";
+const char rtree_package_version[] = "1.2.0";
 const char rtree_package_name[] = "librtree";
 const char rtree_package_url[] = "https://gitlab.com/jjg/librtree";
 const char rtree_package_bugreport[] = "j.j.green@gmx.co.uk";

data/ext/rtree/lib/postscript.c

@@ -3,6 +3,11 @@
 #endif
 
 #include "rtree/postscript.h"
+
+#include "node.h"
+#include "branch.h"
+#include "state.h"
+
 #include "rtree/package.h"
 #include "rtree/error.h"
 
@@ -32,7 +37,7 @@ typedef struct {
 typedef struct {
   const state_t *state;
   const node_t *root;
-  const style_t *style;
+  const postscript_style_t *style;
   page_t page;
 } ps_t;
 
@@ -45,7 +50,7 @@ static bool clamped(float value)
   return (value >= 0.0) && (value <= 1.0);
 }
 
-static int psr_colour(json_t *json, colour_t *colour)
+static int psr_colour(json_t *json, postscript_colour_t *colour)
 {
   json_t *json_colour;
 
@@ -127,7 +132,7 @@ static int psr_colour(json_t *json, colour_t *colour)
   return 1;
 }
 
-static int psr_style_level(json_t *json, style_level_t *style_level)
+static int psr_style_level(json_t *json, postscript_style_level_t *style_level)
 {
   if (! json_is_object(json))
     return 1;
@@ -169,7 +174,7 @@ static int psr_style_level(json_t *json, style_level_t *style_level)
   return 0;
 }
 
-static style_t* psr_style(json_t *json)
+static postscript_style_t* psr_style(json_t *json)
 {
   if (! json_is_array(json))
     return NULL;
@@ -179,16 +184,16 @@ static style_t* psr_style(json_t *json)
   if (n == 0)
     return NULL;
 
-  style_level_t *array;
+  postscript_style_level_t *array;
 
-  if ((array = calloc(n, sizeof(style_level_t))) != NULL)
+  if ((array = calloc(n, sizeof(postscript_style_level_t))) != NULL)
     {
       size_t i;
       json_t *json_style;
 
       json_array_foreach(json, i, json_style)
         {
-          style_level_t *style_level = array + i;
+          postscript_style_level_t *style_level = array + i;
 
           if (psr_style_level(json_style, style_level) != 0)
             {
@@ -197,9 +202,9 @@ static style_t* psr_style(json_t *json)
             }
         }
 
-      style_t *style;
+      postscript_style_t *style;
 
-      if ((style = malloc(sizeof(style_t))) != NULL)
+      if ((style = malloc(sizeof(postscript_style_t))) != NULL)
         {
           style->n = n;
           style->array = array;
@@ -212,14 +217,14 @@ static style_t* psr_style(json_t *json)
   return NULL;
 }
 
-style_t* postscript_style_read(FILE *stream)
+postscript_style_t* postscript_style_read(FILE *stream)
 {
   const size_t flags = JSON_REJECT_DUPLICATES;
   json_t *json;
 
   if ((json = json_loadf(stream, flags, NULL)) != NULL)
     {
-      style_t *style = psr_style(json);
+      postscript_style_t *style = psr_style(json);
       json_decref(json);
       return style;
     }
@@ -231,7 +236,7 @@ style_t* postscript_style_read(FILE *stream)
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-parameter"
-style_t* postscript_style_read(FILE *stream)
+postscript_style_t* postscript_style_read(FILE *stream)
 {
   errno = ENOSYS;
   return NULL;
@@ -240,7 +245,7 @@ style_t* postscript_style_read(FILE *stream)
 
 #endif
 
-void postscript_style_destroy(style_t *style)
+void postscript_style_destroy(postscript_style_t *style)
 {
   if (style != NULL)
     free(style->array);
@@ -473,7 +478,7 @@ int postscript_write(const state_t *state,
       if (i >= ps.style->n)
         break;
 
-      style_level_t style_level = ps.style->array[i];
+      postscript_style_level_t style_level = ps.style->array[i];
       node_level_t level = max_level - i;
 
       switch (style_level.fill.colour.model)

data/ext/rtree/lib/rect.c

@@ -2,7 +2,9 @@
 #include "config.h"
 #endif
 
-#include "rtree/rect.h"
+#include "rect.h"
+#include "state.h"
+
 #include "rtree/error.h"
 
 #ifdef HAVE_TGMATH_H

data/ext/rtree/lib/{rtree/rect.h → rect.h}

@@ -1,20 +1,16 @@
 /*
-  rtree/rect.h
+  rect.h
   Copyright (c) J.J. Green 2019
 */
 
-#ifndef RTREE_RECT_H
-#define RTREE_RECT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
+#ifndef RECT_H
+#define RECT_H
 
 #include <stdlib.h>
 #include <stdbool.h>
 
-#include <rtree/state.h>
-#include <rtree/types.h>
+#include "rtree/state.h"
+#include "rtree/types.h"
 
 int rect_init(const state_t*, rtree_coord_t*);
 
@@ -31,8 +27,4 @@ bool rect_identical(const state_t*, const rtree_coord_t*, const rtree_coord_t*);
 int rects_alloc(const state_t*, size_t, rtree_coord_t**);
 void rects_free(size_t, rtree_coord_t**);
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif