rgeo-dschee 0.5.4

data/ext/geos_c_impl/polygon.h

@@ -0,0 +1,43 @@
+/*
+  Polygon methods for GEOS wrapper
+*/
+
+
+#ifndef RGEO_GEOS_POLYGON_INCLUDED
+#define RGEO_GEOS_POLYGON_INCLUDED
+
+#include <ruby.h>
+#include <geos_c.h>
+
+#include "factory.h"
+
+RGEO_BEGIN_C
+
+
+/*
+  Initializes the polygon module. This should be called after
+  the geometry module is initialized.
+*/
+void rgeo_init_geos_polygon(RGeo_Globals* globals);
+
+/*
+  Comopares the values of two GEOS polygons. The two given geometries MUST
+  be polygon types.
+  Returns Qtrue if the polygons are equal, Qfalse if they are inequal, or
+  Qnil if an error occurs.
+*/
+VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z);
+
+/*
+  A tool for building up hash values.
+  You must pass in the context, a geos geometry, and a seed hash.
+  Returns an updated hash.
+  This call is useful in sequence, and should be bracketed by calls to
+  rb_hash_start and rb_hash_end.
+*/
+st_index_t rgeo_geos_polygon_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash);
+
+
+RGEO_END_C
+
+#endif

data/ext/geos_c_impl/preface.h

@@ -0,0 +1,38 @@
+/*
+  Preface header for GEOS wrapper
+*/
+
+
+#ifdef HAVE_GEOS_C_H
+#ifdef HAVE_GEOSSETSRID_R
+#define RGEO_GEOS_SUPPORTED
+#endif
+#endif
+
+#ifdef HAVE_GEOSPREPAREDCONTAINS_R
+#define RGEO_GEOS_SUPPORTS_PREPARED1
+#endif
+#ifdef HAVE_GEOSPREPAREDDISJOINT_R
+#define RGEO_GEOS_SUPPORTS_PREPARED2
+#endif
+#ifdef HAVE_GEOSWKTWWRITER_SETOUTPUTDIMENSION_R
+#define RGEO_GEOS_SUPPORTS_SETOUTPUTDIMENSION
+#endif
+#ifdef HAVE_RB_MEMHASH
+#define RGEO_SUPPORTS_NEW_HASHING
+#endif
+
+#ifndef RGEO_SUPPORTS_NEW_HASHING
+#define st_index_t int
+#define rb_memhash(x,y) rgeo_internal_memhash(x,y)
+#define rb_hash_start(x) ((st_index_t)(x ^ 0xdeadbeef))
+#define rb_hash_end(x) ((st_index_t)(x ^ 0xbeefdead))
+#endif
+
+#ifdef __cplusplus
+#define RGEO_BEGIN_C extern "C" {
+#define RGEO_END_C }
+#else
+#define RGEO_BEGIN_C
+#define RGEO_END_C
+#endif

data/ext/proj4_c_impl/extconf.rb

@@ -0,0 +1,62 @@
+# -----------------------------------------------------------------------------
+#
+# Makefile builder for Proj4 wrapper
+#
+# -----------------------------------------------------------------------------
+
+if ::RUBY_DESCRIPTION =~ /^jruby\s/
+
+  ::File.open("Makefile", "w") { |f_| f_.write(".PHONY: install\ninstall:\n") }
+
+else
+
+  require "mkmf"
+
+  header_dirs_ =
+    [
+      ::RbConfig::CONFIG["includedir"],
+      "/usr/local/include",
+      "/usr/local/proj/include",
+      "/usr/local/proj4/include",
+      "/opt/local/include",
+      "/opt/proj/include",
+      "/opt/proj4/include",
+      "/opt/include",
+      "/Library/Frameworks/PROJ.framework/unix/include",
+      "/usr/include"
+    ]
+  lib_dirs_ =
+    [
+      ::RbConfig::CONFIG["libdir"],
+      "/usr/local/lib",
+      "/usr/local/lib64",
+      "/usr/local/proj/lib",
+      "/usr/local/proj4/lib",
+      "/opt/local/lib",
+      "/opt/proj/lib",
+      "/opt/proj4/lib",
+      "/opt/lib",
+      "/Library/Frameworks/PROJ.framework/unix/lib",
+      "/usr/lib",
+      "/usr/lib64"
+    ]
+  header_dirs_.delete_if { |path_| !::File.directory?(path_) }
+  lib_dirs_.delete_if { |path_| !::File.directory?(path_) }
+
+  found_proj_ = false
+  header_dirs_, lib_dirs_ = dir_config("proj", header_dirs_, lib_dirs_)
+  if have_header("proj_api.h")
+    $libs << " -lproj"
+    if have_func("pj_init_plus", "proj_api.h")
+      found_proj_ = true
+    else
+      $libs.gsub!(" -lproj", "")
+    end
+  end
+  unless found_proj_
+    puts "**** WARNING: Unable to find Proj headers or Proj version is too old."
+    puts "**** Compiling without Proj support."
+  end
+  create_makefile("rgeo/coord_sys/proj4_c_impl")
+
+end

data/ext/proj4_c_impl/main.c

@@ -0,0 +1,315 @@
+/*
+  Main initializer for Proj4 wrapper
+*/
+
+#ifdef HAVE_PROJ_API_H
+#ifdef HAVE_PJ_INIT_PLUS
+#define RGEO_PROJ4_SUPPORTED
+#endif
+#endif
+
+#ifdef __cplusplus
+#define RGEO_BEGIN_C extern "C" {
+#define RGEO_END_C }
+#else
+#define RGEO_BEGIN_C
+#define RGEO_END_C
+#endif
+
+
+#ifdef RGEO_PROJ4_SUPPORTED
+
+#include <ruby.h>
+#include <proj_api.h>
+
+#endif
+
+
+RGEO_BEGIN_C
+
+
+#ifdef RGEO_PROJ4_SUPPORTED
+
+
+typedef struct {
+  projPJ pj;
+  VALUE original_str;
+  char uses_radians;
+} RGeo_Proj4Data;
+
+
+#define RGEO_PROJ4_DATA_PTR(obj) ((RGeo_Proj4Data*)DATA_PTR(obj))
+
+
+// Destroy function for proj data.
+
+static void destroy_proj4_func(RGeo_Proj4Data* data)
+{
+  if (data->pj) {
+    pj_free(data->pj);
+  }
+  free(data);
+}
+
+
+static void mark_proj4_func(RGeo_Proj4Data* data)
+{
+  if (!NIL_P(data->original_str)) {
+    rb_gc_mark(data->original_str);
+  }
+}
+
+
+static VALUE alloc_proj4(VALUE klass)
+{
+  VALUE result;
+  RGeo_Proj4Data* data;
+
+  result = Qnil;
+  data = ALLOC(RGeo_Proj4Data);
+  if (data) {
+    data->pj = NULL;
+    data->original_str = Qnil;
+    data->uses_radians = 0;
+    result = Data_Wrap_Struct(klass, mark_proj4_func, destroy_proj4_func, data);
+  }
+  return result;
+}
+
+
+static VALUE method_proj4_initialize_copy(VALUE self, VALUE orig)
+{
+  RGeo_Proj4Data* self_data;
+  projPJ pj;
+  RGeo_Proj4Data* orig_data;
+  char* str;
+
+  // Clear out any existing value
+  self_data = RGEO_PROJ4_DATA_PTR(self);
+  pj = self_data->pj;
+  if (pj) {
+    pj_free(pj);
+    self_data->pj = NULL;
+    self_data->original_str = Qnil;
+  }
+
+  // Copy value from orig
+  orig_data = RGEO_PROJ4_DATA_PTR(orig);
+  if (!NIL_P(orig_data->original_str)) {
+    self_data->pj = pj_init_plus(RSTRING_PTR(orig_data->original_str));
+  }
+  else {
+    str = pj_get_def(orig_data->pj, 0);
+    self_data->pj = pj_init_plus(str);
+    pj_dalloc(str);
+  }
+  self_data->original_str = orig_data->original_str;
+  self_data->uses_radians = orig_data->uses_radians;
+
+  return self;
+}
+
+
+static VALUE method_proj4_set_value(VALUE self, VALUE str, VALUE uses_radians)
+{
+  RGeo_Proj4Data* self_data;
+  projPJ pj;
+
+  Check_Type(str, T_STRING);
+
+  // Clear out any existing value
+  self_data = RGEO_PROJ4_DATA_PTR(self);
+  pj = self_data->pj;
+  if (pj) {
+    pj_free(pj);
+    self_data->pj = NULL;
+    self_data->original_str = Qnil;
+  }
+
+  // Set new data
+  self_data->pj = pj_init_plus(RSTRING_PTR(str));
+  self_data->original_str = str;
+  self_data->uses_radians = RTEST(uses_radians) ? 1 : 0;
+
+  return self;
+}
+
+
+static VALUE method_proj4_get_geographic(VALUE self)
+{
+  VALUE result;
+  RGeo_Proj4Data* new_data;
+  RGeo_Proj4Data* self_data;
+
+  result = Qnil;
+  new_data = ALLOC(RGeo_Proj4Data);
+  if (new_data) {
+    self_data = RGEO_PROJ4_DATA_PTR(self);
+    new_data->pj = pj_latlong_from_proj(self_data->pj);
+    new_data->original_str = Qnil;
+    new_data->uses_radians = self_data->uses_radians;
+    result = Data_Wrap_Struct(CLASS_OF(self), mark_proj4_func, destroy_proj4_func, new_data);
+  }
+  return result;
+}
+
+
+static VALUE method_proj4_original_str(VALUE self)
+{
+  return RGEO_PROJ4_DATA_PTR(self)->original_str;
+}
+
+
+static VALUE method_proj4_uses_radians(VALUE self)
+{
+  return RGEO_PROJ4_DATA_PTR(self)->uses_radians ? Qtrue : Qfalse;
+}
+
+
+static VALUE method_proj4_canonical_str(VALUE self)
+{
+  VALUE result;
+  projPJ pj;
+  char* str;
+
+  result = Qnil;
+  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  if (pj) {
+    str = pj_get_def(pj, 0);
+    if (str) {
+      result = rb_str_new2(str);
+      pj_dalloc(str);
+    }
+  }
+  return result;
+}
+
+
+static VALUE method_proj4_is_geographic(VALUE self)
+{
+  VALUE result;
+  projPJ pj;
+
+  result = Qnil;
+  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  if (pj) {
+    result = pj_is_latlong(pj) ? Qtrue : Qfalse;
+  }
+  return result;
+}
+
+
+static VALUE method_proj4_is_geocentric(VALUE self)
+{
+  VALUE result;
+  projPJ pj;
+
+  result = Qnil;
+  pj = RGEO_PROJ4_DATA_PTR(self)->pj;
+  if (pj) {
+    result = pj_is_geocent(pj) ? Qtrue : Qfalse;
+  }
+  return result;
+}
+
+
+static VALUE method_proj4_is_valid(VALUE self)
+{
+  return RGEO_PROJ4_DATA_PTR(self)->pj ? Qtrue : Qfalse;
+}
+
+
+static VALUE cmethod_proj4_version(VALUE module)
+{
+  return INT2NUM(PJ_VERSION);
+}
+
+
+static VALUE cmethod_proj4_transform(VALUE module, VALUE from, VALUE to, VALUE x, VALUE y, VALUE z)
+{
+  VALUE result;
+  projPJ from_pj;
+  projPJ to_pj;
+  double xval, yval, zval;
+  int err;
+
+  result = Qnil;
+  from_pj = RGEO_PROJ4_DATA_PTR(from)->pj;
+  to_pj = RGEO_PROJ4_DATA_PTR(to)->pj;
+  if (from_pj && to_pj) {
+    xval = rb_num2dbl(x);
+    yval = rb_num2dbl(y);
+    zval = 0.0;
+    if (!NIL_P(z)) {
+      zval = rb_num2dbl(z);
+    }
+    err = pj_transform(from_pj, to_pj, 1, 1, &xval, &yval, NIL_P(z) ? NULL : &zval);
+    if (!err && xval != HUGE_VAL && yval != HUGE_VAL && (NIL_P(z) || zval != HUGE_VAL)) {
+      result = rb_ary_new2(NIL_P(z) ? 2 : 3);
+      rb_ary_push(result, rb_float_new(xval));
+      rb_ary_push(result, rb_float_new(yval));
+      if (!NIL_P(z)) {
+        rb_ary_push(result, rb_float_new(zval));
+      }
+    }
+  }
+  return result;
+}
+
+
+static VALUE cmethod_proj4_create(VALUE klass, VALUE str, VALUE uses_radians)
+{
+  VALUE result;
+  RGeo_Proj4Data* data;
+
+  result = Qnil;
+  Check_Type(str, T_STRING);
+  data = ALLOC(RGeo_Proj4Data);
+  if (data) {
+    data->pj = pj_init_plus(RSTRING_PTR(str));
+    data->original_str = str;
+    data->uses_radians = RTEST(uses_radians) ? 1 : 0;
+    result = Data_Wrap_Struct(klass, mark_proj4_func, destroy_proj4_func, data);
+  }
+  return result;
+}
+
+
+static void rgeo_init_proj4()
+{
+  VALUE rgeo_module;
+  VALUE coordsys_module;
+  VALUE proj4_class;
+
+  rgeo_module = rb_define_module("RGeo");
+  coordsys_module = rb_define_module_under(rgeo_module, "CoordSys");
+  proj4_class = rb_define_class_under(coordsys_module, "Proj4", rb_cObject);
+
+  rb_define_alloc_func(proj4_class, alloc_proj4);
+  rb_define_module_function(proj4_class, "_create", cmethod_proj4_create, 2);
+  rb_define_method(proj4_class, "initialize_copy", method_proj4_initialize_copy, 1);
+  rb_define_method(proj4_class, "_set_value", method_proj4_set_value, 2);
+  rb_define_method(proj4_class, "_original_str", method_proj4_original_str, 0);
+  rb_define_method(proj4_class, "_canonical_str", method_proj4_canonical_str, 0);
+  rb_define_method(proj4_class, "_valid?", method_proj4_is_valid, 0);
+  rb_define_method(proj4_class, "_geographic?", method_proj4_is_geographic, 0);
+  rb_define_method(proj4_class, "_geocentric?", method_proj4_is_geocentric, 0);
+  rb_define_method(proj4_class, "_radians?", method_proj4_uses_radians, 0);
+  rb_define_method(proj4_class, "_get_geographic", method_proj4_get_geographic, 0);
+  rb_define_module_function(proj4_class, "_transform_coords", cmethod_proj4_transform, 5);
+  rb_define_module_function(proj4_class, "_proj_version", cmethod_proj4_version, 0);
+}
+
+
+#endif
+
+
+void Init_proj4_c_impl()
+{
+#ifdef RGEO_PROJ4_SUPPORTED
+  rgeo_init_proj4();
+#endif
+}
+
+
+RGEO_END_C