librtree 0.9.1 → 1.0.1

data/ext/rtree/lib/rtree/postscript.h

@@ -0,0 +1,66 @@
+/*
+  rtree/postscript.h
+  Copyright (c) J.J. Green 2020
+*/
+
+#ifndef RTREE_POSTSCRIPT_H
+#define RTREE_POSTSCRIPT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct rtree_postscript_t rtree_postscript_t;
+
+#include <stdio.h>
+#include <rtree/node.h>
+#include <rtree/extent.h>
+
+typedef enum
+  { model_none, model_grey, model_rgb, model_cmyk }
+  colour_model_t;
+
+typedef struct {
+  colour_model_t model;
+  union {
+    float grey[1];
+    float rgb[3];
+    float cmyk[4];
+  };
+} colour_t;
+
+typedef struct {
+  struct {
+    colour_t colour;
+  } fill;
+  struct {
+    colour_t colour;
+    float width;
+  } stroke;
+} style_level_t;
+
+typedef struct {
+  size_t n;
+  style_level_t *array;
+} style_t;
+
+style_t* postscript_style_read(FILE*);
+void postscript_style_destroy(style_t*);
+
+struct rtree_postscript_t
+{
+  const style_t *style;
+  extent_axis_t axis;
+  float extent;
+  float margin;
+  const char *title;
+};
+
+int postscript_write(const state_t*, const node_t*,
+                     const rtree_postscript_t*, FILE*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/rtree/lib/rtree/rect.h

@@ -0,0 +1,38 @@
+/*
+  rtree/rect.h
+  Copyright (c) J.J. Green 2019
+*/
+
+#ifndef RTREE_RECT_H
+#define RTREE_RECT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include <rtree/state.h>
+#include <rtree/types.h>
+
+int rect_init(const state_t*, rtree_coord_t*);
+
+rtree_coord_t rect_volume(const state_t*, const rtree_coord_t*);
+rtree_coord_t rect_spherical_volume(const state_t*, const rtree_coord_t*);
+void rect_combine(const state_t*,
+                  const rtree_coord_t *restrict,
+                  const rtree_coord_t *restrict,
+                  rtree_coord_t *restrict);
+bool rect_intersect(const state_t*, const rtree_coord_t*, const rtree_coord_t*);
+void rect_merge(const state_t*, const rtree_coord_t*, rtree_coord_t*);
+void rect_copy(const state_t*, const rtree_coord_t*, rtree_coord_t*);
+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

data/ext/rtree/lib/rtree/rectf.h

@@ -0,0 +1,34 @@
+/*
+  rtree/rectf.h
+  Copyright (c) J.J. Green 2022
+*/
+
+#ifndef RTREE_RECTF_H
+#define RTREE_RECTF_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtree/types.h>
+#include <stddef.h>
+
+/* rect-spherical-volume */
+
+typedef rtree_coord_t (rectf_rsv_t)(size_t, const rtree_coord_t*);
+
+rectf_rsv_t* rectf_spherical_volume(size_t);
+
+/* rect-combine */
+
+typedef void (rectf_rc_t)(size_t,
+                          const rtree_coord_t*,
+                          const rtree_coord_t*,
+                          rtree_coord_t*);
+
+rectf_rc_t* rectf_combine(size_t);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/rtree/lib/rtree/search.h

@@ -0,0 +1,27 @@
+/*
+  rtree/search.h
+  Copyright (c) J.J. Green 2020
+*/
+
+#ifndef RTREE_SEARCH_H
+#define RTREE_SEARCH_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rtree/node.h>
+#include <rtree/types.h>
+#include <rtree/state.h>
+
+typedef int (rtree_search_t)(rtree_id_t, void*);
+
+int search(const state_t*,
+           const rtree_coord_t*, const node_t*,
+           rtree_search_t*, void*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/rtree/lib/rtree/state.h

@@ -0,0 +1,113 @@
+/*
+  rtree/state.h
+
+  This structure is open, but we only access it via accessors,
+  often trivial; these are implemented as (C99 standard) inline
+  functions, so there's no performance penalty.
+
+  Copyright (c) J.J. Green 2019
+*/
+
+#ifndef RTREE_STATE_H
+#define RTREE_STATE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <rtree/types.h>
+#include <rtree/rectf.h>
+
+typedef uint32_t state_flags_t;
+
+typedef struct
+{
+  size_t dims, factor;
+  rtree_coord_t volume;
+  struct {
+    size_t page, branch, node;
+  } size;
+  struct {
+    rectf_rsv_t *spherical_volume;
+    rectf_rc_t *combine;
+  } rectf;
+  state_flags_t flags;
+} state_t;
+
+#define RTREE_DEFAULT 0
+
+#define RTREE_SPLIT_QUADRATIC 0
+#define RTREE_SPLIT_LINEAR 1
+#define RTREE_SPLIT_GREENE 2
+
+#define RTREE_NODE_PAGE(n) ((n) << 2)
+
+state_t* state_new(size_t, state_flags_t);
+state_t* state_clone(const state_t*);
+void state_destroy(state_t*);
+state_flags_t state_split(const state_t*);
+state_flags_t state_node_page(const state_t*);
+bool state_identical(const state_t*, const state_t*);
+
+inline rtree_coord_t state_rsv(const state_t *state, const rtree_coord_t *rect)
+{
+  return state->rectf.spherical_volume(state->dims, rect) * state->volume;
+}
+
+inline void state_rc(const state_t *state,
+                     const rtree_coord_t *rect0,
+                     const rtree_coord_t *rect1,
+                     rtree_coord_t *rect2)
+{
+  state->rectf.combine(state->dims, rect0, rect1, rect2);
+}
+
+inline size_t state_dims(const state_t *state)
+{
+  return state->dims;
+}
+
+inline size_t state_branch_size(const state_t *state)
+{
+  return state->size.branch;
+}
+
+inline size_t state_page_size(const state_t *state)
+{
+  return state->size.page;
+}
+
+inline size_t state_node_size(const state_t *state)
+{
+  return state->size.node;
+}
+
+inline size_t state_rect_size(const state_t *state)
+{
+  return state_dims(state) * 2 * sizeof(rtree_coord_t);
+}
+
+inline size_t state_branching_factor(const state_t *state)
+{
+  return state->factor;
+}
+
+inline double state_unit_sphere_volume(const state_t *state)
+{
+  return state->volume;
+}
+
+inline size_t state_bytes(const state_t *state)
+{
+  return (state ? sizeof(state_t) : 0);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/rtree/lib/rtree/types.h

@@ -0,0 +1,14 @@
+/*
+  rtree/types.h
+  Copyright (c) J.J. Green 2020
+*/
+
+#ifndef RTREE_TYPES_H
+#define RTREE_TYPES_H
+
+#include <stdint.h>
+
+typedef double rtree_coord_t;
+typedef uint64_t rtree_id_t;
+
+#endif

data/ext/rtree/lib/rtree-base.c

@@ -0,0 +1,197 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "rtree.h"
+#include "rtree/error.h"
+
+#include "csv.h"
+#include "json.h"
+#include "bsrt.h"
+
+#include <errno.h>
+#include <stdlib.h>
+
+rtree_t* rtree_alloc(void)
+{
+  rtree_t *rtree;
+
+  if ((rtree = malloc(sizeof(rtree_t))) == NULL)
+    errno = ENOMEM;
+  else
+    {
+      rtree->state = NULL;
+      rtree->root = NULL;
+    }
+
+  return rtree;
+}
+
+int rtree_init(rtree_t *rtree, size_t dims, state_flags_t flags)
+{
+  state_t *state;
+
+  if ((state = state_new(dims, flags)) != NULL)
+    {
+      node_t *root;
+
+      if ((root = node_new(state)) != NULL)
+        {
+          rtree->state = state;
+          rtree->root = root;
+
+          return 0;
+        }
+
+      state_destroy(state);
+    }
+
+  return 1;
+}
+
+rtree_t* rtree_new(size_t dims, state_flags_t flags)
+{
+  rtree_t *rtree;
+
+  if ((rtree = rtree_alloc()) != NULL)
+    {
+      if ((rtree_init(rtree, dims, flags)) == 0)
+        return rtree;
+
+      free(rtree);
+    }
+
+  return NULL;
+}
+
+rtree_t* rtree_clone(const rtree_t *src)
+{
+  node_t *dest_root;
+
+  if ((dest_root = node_clone(src->state, src->root)) != NULL)
+    {
+      state_t *dest_state;
+      if ((dest_state = state_clone(src->state)) != NULL)
+        {
+          rtree_t *dest;
+
+          if ((dest = rtree_alloc()) == NULL)
+            errno = ENOMEM;
+          else
+            {
+              dest->root = dest_root;
+              dest->state = dest_state;
+              return dest;
+            }
+          state_destroy(dest_state);
+        }
+      node_destroy(src->state, dest_root);
+    }
+  return NULL;
+}
+
+void rtree_destroy(rtree_t *rtree)
+{
+  if (rtree != NULL)
+    {
+      node_destroy(rtree->state, rtree->root);
+      state_destroy(rtree->state);
+    }
+  free(rtree);
+}
+
+rtree_height_t rtree_height(const rtree_t *rtree)
+{
+  return node_height(rtree->state, rtree->root);
+}
+
+rtree_t* rtree_csv_read(FILE *stream, size_t dim, state_flags_t flags)
+{
+  return csv_rtree_read(stream, dim, flags);
+}
+
+int rtree_json_write(const rtree_t *rtree, FILE *stream)
+{
+  return json_rtree_write(rtree, stream);
+}
+
+rtree_t* rtree_json_read(FILE *stream)
+{
+  return json_rtree_read(stream);
+}
+
+int rtree_bsrt_write(const rtree_t *rtree, FILE *stream)
+{
+  return bsrt_rtree_write(rtree, stream);
+}
+
+rtree_t* rtree_bsrt_read(FILE *stream)
+{
+  return bsrt_rtree_read(stream);
+}
+
+int rtree_add_rect(rtree_t *rtree, rtree_id_t id, rtree_coord_t *rect)
+{
+  node_t *node = node_add_rect(rtree->state, id, rect, rtree->root, 0);
+
+  if (node == NULL)
+    return RTREE_ERR_ADDRECT;
+
+  if (node != rtree->root)
+    rtree->root = node;
+
+  return RTREE_OK;
+}
+
+int rtree_update(rtree_t *rtree, rtree_update_t *f, void *context)
+{
+  return node_update(rtree->state, rtree->root, f, context);
+}
+
+bool rtree_identical(const rtree_t *a, const rtree_t *b)
+{
+  if (a && b)
+    {
+      return
+        state_identical(a->state, b->state) &&
+        node_identical(a->state, a->root, b->root);
+    }
+
+  return ! (a || b);
+}
+
+int rtree_search(const rtree_t *rtree, const rtree_coord_t *rect,
+                 rtree_search_t *f, void *arg)
+{
+  return search(rtree->state, rect, rtree->root, f, arg);
+}
+
+int rtree_postscript(const rtree_t *rtree,
+                     const rtree_postscript_t *options,
+                     FILE *stream)
+{
+  return postscript_write(rtree->state, rtree->root, options, stream);
+}
+
+const char* rtree_strerror(int err)
+{
+  return strerror_rtree(err);
+}
+
+size_t rtree_bytes(const rtree_t *rtree)
+{
+  if (rtree == NULL)
+    return 0;
+  else
+    return
+      sizeof(rtree_t) +
+      state_bytes(rtree->state) +
+      node_bytes(rtree->state, rtree->root);
+}
+
+bool rtree_empty(const rtree_t *rtree)
+{
+  return
+    (rtree == NULL) ||
+    (! node_nonempty(rtree->state, rtree->root));
+}

data/ext/rtree/lib/rtree.h

@@ -0,0 +1,62 @@
+/*
+  rtree.h
+
+  This is the bottom-level "public" header, it does not
+  include all of the rtree headers, just enough to define
+  the members of the (atypically) open structure rtree_t.
+
+  Copyright (c) J.J. Green 2020
+*/
+
+#ifndef RTREE_H
+#define RTREE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef struct rtree_t rtree_t;
+typedef uint16_t rtree_height_t;
+
+#include <rtree/types.h>
+#include <rtree/state.h>
+#include <rtree/node.h>
+#include <rtree/postscript.h>
+#include <rtree/search.h>
+#include <rtree/error.h>
+
+struct rtree_t
+{
+  state_t *state;
+  node_t *root;
+};
+
+rtree_t* rtree_alloc(void);
+int rtree_init(rtree_t*, size_t, state_flags_t);
+rtree_t* rtree_new(size_t, state_flags_t);
+rtree_t* rtree_clone(const rtree_t*);
+void rtree_destroy(rtree_t*);
+rtree_height_t rtree_height(const rtree_t*);
+int rtree_search(const rtree_t*, const rtree_coord_t*, rtree_search_t*, void*);
+int rtree_add_rect(rtree_t*, rtree_id_t, rtree_coord_t*);
+int rtree_update(rtree_t*, rtree_update_t*, void*);
+bool rtree_identical(const rtree_t*, const rtree_t*);
+rtree_t* rtree_csv_read(FILE*, size_t, state_flags_t);
+int rtree_json_write(const rtree_t*, FILE*);
+rtree_t* rtree_json_read(FILE*);
+int rtree_bsrt_write(const rtree_t*, FILE*);
+rtree_t* rtree_bsrt_read(FILE*);
+int rtree_postscript(const rtree_t*, const rtree_postscript_t*, FILE*);
+const char* rtree_strerror(int);
+size_t rtree_bytes(const rtree_t*);
+bool rtree_empty(const rtree_t*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/rtree/lib/search.c

@@ -0,0 +1,54 @@
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "rtree/search.h"
+
+#include "rtree/branch.h"
+#include "rtree/error.h"
+#include "rtree/rect.h"
+
+typedef struct
+{
+  rtree_search_t *callback;
+  void *context;
+  const rtree_coord_t *rect;
+} search_context_t;
+
+static int internal(const state_t *state,
+                    const branch_t *branch, void *arg)
+{
+  int err = RTREE_OK;
+  search_context_t *search_context = arg;
+  if (rect_intersect(state, branch_get_rect(branch), search_context->rect))
+    err = search(state, search_context->rect, branch_get_child(branch),
+                 search_context->callback, search_context->context);
+  return err;
+}
+
+static int leaf(const state_t *state,
+                const branch_t *branch, void *arg)
+{
+  int err = RTREE_OK;
+  search_context_t *search_context = arg;
+  if (rect_intersect(state, branch_get_rect(branch), search_context->rect))
+    err = search_context->callback(branch_get_id(branch),
+                                   search_context->context);
+  return err;
+}
+
+int search(const state_t *state,
+           const rtree_coord_t *rect, const node_t *node,
+           rtree_search_t *callback, void *context)
+{
+  search_context_t search_context = {
+    .callback = callback,
+    .context = context,
+    .rect = rect
+  };
+  node_level_t level = node_level(node);
+
+  return node_branch_each(state, node,
+                          level > 0 ? internal : leaf,
+                          &search_context);
+}